Lines Matching defs:smc
15 #include "h/smc.h"
54 static int mac_index(struct s_smc *smc, int mac);
55 static int phy_index(struct s_smc *smc, int phy);
56 static int mac_con_resource_index(struct s_smc *smc, int mac);
57 static int phy_con_resource_index(struct s_smc *smc, int phy);
58 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
60 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
62 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
64 static void smt_echo_test(struct s_smc *smc, int dna);
65 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
67 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
73 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una);
74 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde);
75 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state);
76 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts);
77 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy);
78 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency);
79 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor);
80 static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path);
81 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st);
82 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy);
83 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers);
84 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc);
85 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc);
86 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc);
87 static void smt_fill_manufacturer(struct s_smc *smc,
89 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user);
90 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount);
91 static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
94 static void smt_clear_una_dna(struct s_smc *smc);
95 static void smt_clear_old_una_dna(struct s_smc *smc);
99 static void update_dac(struct s_smc *smc, int report);
102 static void hwm_conv_can(struct s_smc *smc, char *data, int len);
104 #define hwm_conv_can(smc,data,len)
108 static inline int is_my_addr(const struct s_smc *smc,
112 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[0])
114 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[2])
116 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[4])) ;
147 void smt_agent_init(struct s_smc *smc)
154 smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
159 smc->mib.fddiSMTStationId.sid_oem[0] = 0 ;
160 smc->mib.fddiSMTStationId.sid_oem[1] = 0 ;
161 driver_get_bia(smc,&smc->mib.fddiSMTStationId.sid_node) ;
163 smc->mib.fddiSMTStationId.sid_node.a[i] =
164 bitrev8(smc->mib.fddiSMTStationId.sid_node.a[i]);
166 smc->mib.fddiSMTManufacturerData[0] =
167 smc->mib.fddiSMTStationId.sid_node.a[0] ;
168 smc->mib.fddiSMTManufacturerData[1] =
169 smc->mib.fddiSMTStationId.sid_node.a[1] ;
170 smc->mib.fddiSMTManufacturerData[2] =
171 smc->mib.fddiSMTStationId.sid_node.a[2] ;
172 smc->sm.smt_tid = 0 ;
173 smc->mib.m[MAC0].fddiMACDupAddressTest = DA_NONE ;
174 smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
176 smt_clear_una_dna(smc) ;
177 smt_clear_old_una_dna(smc) ;
180 smc->sm.pend[i] = 0 ;
181 smc->sm.please_reconnect = 0 ;
182 smc->sm.uniq_ticks = 0 ;
193 void smt_agent_task(struct s_smc *smc)
195 smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
201 void smt_emulate_token_ct(struct s_smc *smc, int mac_index)
208 count = ((time - smc->sm.last_tok_time[mac_index]) *
217 if (smc->hw.mac_ring_is_up){
218 smc->mib.m[mac_index].fddiMACToken_Ct += count;
222 smc->sm.last_tok_time[mac_index] = time;
228 void smt_event(struct s_smc *smc, int event)
236 if (smc->sm.please_reconnect) {
237 smc->sm.please_reconnect -- ;
238 if (smc->sm.please_reconnect == 0) {
240 queue_event(smc,EVENT_ECM,EC_CONNECT) ;
253 smt_timer_poll(smc) ;
254 smt_start_watchdog(smc) ;
258 ess_timer_poll(smc) ;
262 sba_timer_poll(smc) ;
265 smt_srf_event(smc,0,0,0) ;
271 if (time - smc->sm.smt_last_lem >= TICKS_PER_SECOND*8) {
285 sm_lem_evaluate(smc) ;
286 smc->sm.smt_last_lem = time ;
292 mac_update_counter(smc) ;
293 mib = smc->mib.m ;
309 smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
327 smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
343 phy = &smc->y[port] ;
355 smt_srf_event(smc,SMT_COND_PORT_EB_ERROR,
370 if (time - smc->sm.smt_last_notify >= (u_long)
371 (smc->mib.fddiSMTTT_Notify * TICKS_PER_SECOND) ) {
378 if (!smc->sm.pend[SMT_TID_NIF])
379 smc->sm.pend[SMT_TID_NIF] = smt_get_tid(smc) ;
380 smt_send_nif(smc,&fddi_broadcast, FC_SMT_NSA,
381 smc->sm.pend[SMT_TID_NIF], SMT_REQUEST,0) ;
382 smc->sm.smt_last_notify = time ;
388 if (smc->sm.smt_tvu &&
389 time - smc->sm.smt_tvu > 228*TICKS_PER_SECOND) {
391 smc->sm.smt_tvu = 0 ;
393 if (!is_equal(&smc->mib.m[MAC0].fddiMACUpstreamNbr,
396 smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
397 smc->mib.m[MAC0].fddiMACUpstreamNbr ;
399 smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
400 smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
407 update_dac(smc,0) ;
408 smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
411 if (smc->sm.smt_tvd &&
412 time - smc->sm.smt_tvd > 228*TICKS_PER_SECOND) {
414 smc->sm.smt_tvd = 0 ;
415 if (!is_equal(&smc->mib.m[MAC0].fddiMACDownstreamNbr,
418 smc->mib.m[MAC0].fddiMACOldDownstreamNbr=
419 smc->mib.m[MAC0].fddiMACDownstreamNbr ;
421 smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
422 smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
434 if (time - smc->sm.last_tok_time[i] > 2*TICKS_PER_SECOND ){
435 smt_emulate_token_ct( smc, i );
440 smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
460 void smt_received_pack(struct s_smc *smc, SMbuf *mb, int fs)
475 smt_free_mbuf(smc,mb) ;
479 smc->mib.m[MAC0].fddiMACSMTCopied_Ct++ ;
482 hwm_conv_can(smc,(char *)sm,12) ;
485 if (is_individual(&sm->smt_dest) && !is_my_addr(smc,&sm->smt_dest)) {
486 smt_free_mbuf(smc,mb) ;
491 if (is_my_addr(smc,&sm->smt_source) && !local) {
492 smt_free_mbuf(smc,mb) ;
510 smc->sba.sm = sm ;
511 sba(smc,NIF) ;
521 smt_free_mbuf(smc,mb) ;
530 smt_free_mbuf(smc,mb) ;
553 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_VERSION,local) ;
554 smt_free_mbuf(smc,mb) ;
560 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,local) ;
561 smt_free_mbuf(smc,mb) ;
566 if (smt_check_para(smc,sm,plist_nif)) {
579 &smc->mib.m[MAC0].fddiMACUpstreamNbr,
583 if (!is_equal(&smc->mib.m[MAC0].
586 smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
587 smc->mib.m[MAC0].fddiMACUpstreamNbr ;
590 smc->mib.m[MAC0].fddiMACUpstreamNbr =
592 smt_srf_event(smc,
595 smt_echo_test(smc,0) ;
597 smc->sm.smt_tvu = smt_get_time() ;
599 sm_to_para(smc,sm,SMT_P_STATE) ;
601 smc->mib.m[MAC0].fddiMACUNDA_Flag =
604 update_dac(smc,1) ;
613 smt_send_nif(smc,&sm->smt_source,
623 smc->sm.pend[SMT_TID_NIF] = 0 ;
625 smc->mib.m[MAC0].fddiMACDupAddressTest =
627 smc->r.dup_addr_test = DA_FAILED ;
628 queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
629 smc->mib.m[MAC0].fddiMACDA_Flag = TRUE ;
630 update_dac(smc,1) ;
633 if (sm->smt_tid == smc->sm.pend[SMT_TID_NIF]) {
634 smc->sm.pend[SMT_TID_NIF] = 0 ;
637 &smc->mib.m[MAC0].fddiMACDownstreamNbr,
640 if (!is_equal(&smc->mib.m[MAC0].
643 smc->mib.m[MAC0].fddiMACOldDownstreamNbr =
644 smc->mib.m[MAC0].fddiMACDownstreamNbr ;
647 smc->mib.m[MAC0].fddiMACDownstreamNbr =
649 smt_srf_event(smc,
652 smt_echo_test(smc,1) ;
654 smc->mib.m[MAC0].fddiMACDA_Flag = FALSE ;
655 update_dac(smc,1) ;
656 smc->sm.smt_tvd = smt_get_time() ;
657 smc->mib.m[MAC0].fddiMACDupAddressTest =
659 if (smc->r.dup_addr_test != DA_PASSED) {
660 smc->r.dup_addr_test = DA_PASSED ;
661 queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
665 smc->sm.pend[SMT_TID_NIF_TEST]) {
670 smc->sm.pend[SMT_TID_NIF], sm->smt_tid);
683 smt_send_sif_config(smc,&sm->smt_source,sm->smt_tid,local) ;
690 smt_send_sif_operation(smc,&sm->smt_source,sm->smt_tid,local) ;
695 smc->mib.priv.fddiPRIVECF_Reply_Rx++ ;
698 if (sm_to_para(smc,sm,SMT_P_ECHODATA) == NULL) {
702 if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
705 else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
708 else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
713 smc->sm.pend[SMT_TID_ECF],
718 smc->mib.priv.fddiPRIVECF_Req_Rx++ ;
720 if (sm->smt_len && !sm_to_para(smc,sm,SMT_P_ECHODATA)) {
722 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,
732 dump_smt(smc,sm,"ECF REPLY") ;
733 smc->mib.priv.fddiPRIVECF_Reply_Tx++ ;
734 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
746 fs = ess_raf_received_pack(smc,mb,sm,fs) ;
751 sba_raf_received_pack(smc,sm,fs) ;
755 smc->mib.priv.fddiPRIVRDF_Rx++ ;
760 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
769 smc->mib.priv.fddiPRIVPMF_Get_Rx++ ;
771 smc->mib.priv.fddiPRIVPMF_Set_Rx++ ;
780 smt_pmf_received_pack(smc,mb, local) ;
783 dump_smt(smc,sm,"SRF received") ;
796 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
803 smt_free_mbuf(smc,mb) ;
806 static void update_dac(struct s_smc *smc, int report)
810 cond = ( smc->mib.m[MAC0].fddiMACUNDA_Flag |
811 smc->mib.m[MAC0].fddiMACDA_Flag) != 0 ;
812 if (report && (cond != smc->mib.m[MAC0].fddiMACDuplicateAddressCond))
813 smt_srf_event(smc, SMT_COND_MAC_DUP_ADDR,INDEX_MAC,cond) ;
815 smc->mib.m[MAC0].fddiMACDuplicateAddressCond = cond ;
824 void smt_send_frame(struct s_smc *smc, SMbuf *mb, int fc, int local)
830 if (!smc->r.sm_ma_avail && !local) {
831 smt_free_mbuf(smc,mb) ;
835 sm->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
836 sm->smt_sid = smc->mib.fddiSMTStationId ;
839 hwm_conv_can(smc,(char *)sm,12) ; /* convert SA and DA */
840 smc->mib.m[MAC0].fddiMACSMTTransmit_Ct++ ;
841 smt_send_mbuf(smc,mb,local ? FC_SMT_LOC : fc) ;
847 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
873 if (!(mb=smt_build_frame(smc,SMT_RDF,SMT_REPLY,sizeof(struct smt_rdf))))
916 dump_smt(smc,(struct smt_header *)rdf,"RDF") ;
917 smc->mib.priv.fddiPRIVRDF_Tx++ ;
918 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
924 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
934 if (!(mb = smt_build_frame(smc,SMT_NIF,type,sizeof(struct smt_nif))))
937 smt_fill_una(smc,&nif->una) ; /* set UNA */
938 smt_fill_sde(smc,&nif->sde) ; /* set station descriptor */
939 smt_fill_state(smc,&nif->state) ; /* set state information */
941 smt_fill_fsc(smc,&nif->fsc) ; /* set frame status cap. */
945 dump_smt(smc,(struct smt_header *)nif,"NIF") ;
946 smt_send_frame(smc,mb,fc,local) ;
953 static void smt_send_nif_request(struct s_smc *smc, struct fddi_addr *dest)
955 smc->sm.pend[SMT_TID_NIF_TEST] = smt_get_tid(smc) ;
956 smt_send_nif(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_NIF_TEST],
963 static void smt_send_ecf_request(struct s_smc *smc, struct fddi_addr *dest,
966 smc->sm.pend[SMT_TID_ECF] = smt_get_tid(smc) ;
967 smt_send_ecf(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_ECF],
975 static void smt_echo_test(struct s_smc *smc, int dna)
979 smc->sm.pend[dna ? SMT_TID_ECF_DNA : SMT_TID_ECF_UNA] =
980 tid = smt_get_tid(smc) ;
981 smt_send_ecf(smc, dna ?
982 &smc->mib.m[MAC0].fddiMACDownstreamNbr :
983 &smc->mib.m[MAC0].fddiMACUpstreamNbr,
990 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
1001 if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
1005 smt_fill_echo(smc,&ecf->ec_echo,tid,len) ; /* set ECHO */
1008 smc->mib.priv.fddiPRIVECF_Req_Tx++ ;
1009 smt_send_frame(smc,mb,fc,0) ;
1016 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
1024 if (!(mb = smt_build_frame(smc,SMT_SIF_CONFIG,SMT_REPLY,
1029 smt_fill_timestamp(smc,&sif->ts) ; /* set time stamp */
1030 smt_fill_sde(smc,&sif->sde) ; /* set station descriptor */
1031 smt_fill_version(smc,&sif->version) ; /* set version information */
1032 smt_fill_state(smc,&sif->state) ; /* set state information */
1033 smt_fill_policy(smc,&sif->policy) ; /* set station policy */
1034 smt_fill_latency(smc,&sif->latency); /* set station latency */
1035 smt_fill_neighbor(smc,&sif->neighbor); /* set station neighbor */
1036 smt_fill_setcount(smc,&sif->setcount) ; /* set count */
1037 len = smt_fill_path(smc,&sif->path); /* set station path descriptor*/
1041 dump_smt(smc,(struct smt_header *)sif,"SIF Configuration Reply") ;
1042 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1049 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
1061 if (smc->s.sas == SMT_SAS)
1065 if (!(mb = smt_build_frame(smc,SMT_SIF_OPER,SMT_REPLY,
1069 smt_fill_timestamp(smc,&sif->ts) ; /* set time stamp */
1070 smt_fill_mac_status(smc,&sif->status) ; /* set mac status */
1071 smt_fill_mac_counter(smc,&sif->mc) ; /* set mac counter field */
1072 smt_fill_mac_fnc(smc,&sif->fnc) ; /* set frame not copied counter */
1073 smt_fill_manufacturer(smc,&sif->man) ; /* set manufacturer field */
1074 smt_fill_user(smc,&sif->user) ; /* set user field */
1075 smt_fill_setcount(smc,&sif->setcount) ; /* set count */
1080 smt_fill_lem(smc,sif->lem,PS) ;
1084 smt_fill_lem(smc,&sif->lem[i],i) ;
1090 dump_smt(smc,(struct smt_header *)sif,"SIF Operation Reply") ;
1091 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1097 SMbuf *smt_build_frame(struct s_smc *smc, int class, int type,
1104 if (!smc->r.sm_ma_avail) {
1108 if (!(mb = smt_get_mbuf(smc)))
1127 smt->smt_tid = smt_get_tid(smc) ; /* set transaction ID */
1147 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una)
1151 una->una_node = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1157 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde)
1160 sde->sde_non_master = smc->mib.fddiSMTNonMaster_Ct ;
1161 sde->sde_master = smc->mib.fddiSMTMaster_Ct ;
1173 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state)
1183 if (smc->mib.fddiSMTPeerWrapFlag) {
1187 if (cfm_status_unattached(smc)) {
1191 if ((twist = pcm_status_twisted(smc)) & 1) {
1200 if (pcm_rooted_station(smc))
1202 if (smc->mib.a[0].fddiPATHSbaPayload != 0)
1206 ((smc->mib.m[MAC0].fddiMACDA_Flag ? SMT_ST_MY_DUPA : 0 ) |
1207 (smc->mib.m[MAC0].fddiMACUNDA_Flag ? SMT_ST_UNA_DUPA : 0)) ;
1213 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts)
1217 smt_set_timestamp(smc,ts->ts_time) ;
1220 void smt_set_timestamp(struct s_smc *smc, u_char *p)
1239 p[6] = (u_char)(smc->sm.uniq_ticks>>8) ;
1240 p[7] = (u_char)smc->sm.uniq_ticks ;
1244 if (utime != smc->sm.uniq_time) {
1245 smc->sm.uniq_ticks = 0 ;
1247 smc->sm.uniq_ticks++ ;
1248 smc->sm.uniq_time = utime ;
1254 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy)
1271 in = smc->mib.fddiSMTConnectionPolicy ;
1278 policy->pl_config = smc->mib.fddiSMTConfigPolicy ;
1285 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency)
1289 latency->lt_phyout_idx1 = phy_index(smc,0) ;
1295 if (smc->s.sas == SMT_DAS) {
1296 latency->lt_phyout_idx2 = phy_index(smc,1) ;
1308 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor)
1313 neighbor->nb_mac_index = mac_index(smc,1) ;
1314 neighbor->nb_una = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1315 neighbor->nb_dna = smc->mib.m[MAC0].fddiMACDownstreamNbr ;
1324 #define ALLPHYS ((smc->s.sas == SMT_SAS) ? 1 : 2)
1327 static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path)
1349 if (smc->s.sas == SMT_SAS)
1352 pcm_status_state(smc,physp,&type,&state,&remote,&mac) ;
1362 phy->phy_resource_idx = phy_con_resource_index(smc,p) ;
1367 pd_mac->mac_addr = smc->mib.m[MAC0].fddiMACSMTAddress ;
1368 pd_mac->mac_resource_idx = mac_con_resource_index(smc,1) ;
1375 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st)
1380 st->st_mac_index = mac_index(smc,1) ;
1382 mac_update_counter(smc) ;
1387 st->st_t_req = smc->mib.m[MAC0].fddiMACT_Req ;
1388 st->st_t_neg = smc->mib.m[MAC0].fddiMACT_Neg ;
1389 st->st_t_max = smc->mib.m[MAC0].fddiMACT_Max ;
1390 st->st_tvx_value = smc->mib.m[MAC0].fddiMACTvxValue ;
1391 st->st_t_min = smc->mib.m[MAC0].fddiMACT_Min ;
1393 st->st_sba = smc->mib.a[PATH0].fddiPATHSbaPayload ;
1394 st->st_frame_ct = smc->mib.m[MAC0].fddiMACFrame_Ct ;
1395 st->st_error_ct = smc->mib.m[MAC0].fddiMACError_Ct ;
1396 st->st_lost_ct = smc->mib.m[MAC0].fddiMACLost_Ct ;
1402 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy)
1406 mib = smc->y[phy].mib ;
1410 lem->lem_phy_index = phy_index(smc,phy) ;
1424 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers)
1426 SK_UNUSED(smc) ;
1443 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc)
1445 SK_UNUSED(smc) ;
1463 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc)
1467 mc->mc_index = mac_index(smc,1) ;
1468 mc->mc_receive_ct = smc->mib.m[MAC0].fddiMACCopied_Ct ;
1469 mc->mc_transmit_ct = smc->mib.m[MAC0].fddiMACTransmit_Ct ;
1475 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc)
1479 fnc->nc_index = mac_index(smc,1) ;
1480 fnc->nc_counter = smc->mib.m[MAC0].fddiMACNotCopied_Ct ;
1487 static void smt_fill_manufacturer(struct s_smc *smc,
1492 (char *) smc->mib.fddiSMTManufacturerData,
1499 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user)
1503 (char *) smc->mib.fddiSMTUserData,
1510 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount)
1512 SK_UNUSED(smc) ;
1514 setcount->count = smc->mib.fddiSMTSetCount.count ;
1516 (char *)smc->mib.fddiSMTSetCount.timestamp,8) ;
1522 static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
1527 SK_UNUSED(smc) ;
1540 static void smt_clear_una_dna(struct s_smc *smc)
1542 smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
1543 smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
1546 static void smt_clear_old_una_dna(struct s_smc *smc)
1548 smc->mib.m[MAC0].fddiMACOldUpstreamNbr = SMT_Unknown ;
1549 smc->mib.m[MAC0].fddiMACOldDownstreamNbr = SMT_Unknown ;
1552 u_long smt_get_tid(struct s_smc *smc)
1555 while ((tid = ++(smc->sm.smt_tid) ^ SMT_TID_MAGIC) == 0)
1642 int smt_check_para(struct s_smc *smc, struct smt_header *sm,
1647 if (!sm_to_para(smc,sm,(int) *p)) {
1656 void *sm_to_para(struct s_smc *smc, struct smt_header *sm, int para)
1663 SK_UNUSED(smc) ;
1691 void fddi_send_antc(struct s_smc *smc, struct fddi_addr *dest)
1693 SK_UNUSED(smc) ;
1709 smt->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
1710 smt_send_mbuf(smc,mb,FC_ASYNC_LLC) ;
1718 static int mac_index(struct s_smc *smc, int mac)
1722 SK_UNUSED(smc) ;
1725 return (smc->s.sas == SMT_SAS) ? 2 : 3;
1732 static int phy_index(struct s_smc *smc, int phy)
1734 SK_UNUSED(smc) ;
1741 static int mac_con_resource_index(struct s_smc *smc, int mac)
1744 SK_UNUSED(smc) ;
1746 return entity_to_index(smc, cem_get_downstream(smc, ENTITY_MAC));
1749 switch (smc->mib.fddiSMTCF_State) {
1758 return smc->s.sas == SMT_SAS ? 2 : 3;
1765 static int phy_con_resource_index(struct s_smc *smc, int phy)
1768 return entity_to_index(smc, cem_get_downstream(smc, ENTITY_PHY(phy))) ;
1770 switch (smc->mib.fddiSMTCF_State) {
1787 static int entity_to_index(struct s_smc *smc, int e)
1790 return mac_index(smc, 1);
1792 return phy_index(smc, e - ENTITY_PHY(0));
1912 int smt_action(struct s_smc *smc, int class, int code, int index)
1921 smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
1922 queue_event(smc,EVENT_ECM,EC_CONNECT) ;
1925 queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
1926 smc->mib.fddiSMTRemoteDisconnectFlag = TRUE ;
1927 RS_SET(smc,RS_DISCONNECT) ;
1928 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1930 smt_get_event_word(smc));
1933 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1935 smt_get_event_word(smc));
1938 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1940 smt_get_event_word(smc));
1943 if (smc->y[PA].pc_mode == PM_PEER) {
1944 RS_SET(smc,RS_EVENT) ;
1945 queue_event(smc,EVENT_PCM+PA,PC_DISABLE) ;
1949 if (smc->y[PB].pc_mode == PM_PEER) {
1950 RS_SET(smc,RS_EVENT) ;
1951 queue_event(smc,EVENT_PCM+PB,PC_DISABLE) ;
1956 if (smc->mib.p[port].fddiPORTMy_Type != TM)
1958 RS_SET(smc,RS_EVENT) ;
1959 queue_event(smc,EVENT_PCM+port,PC_DISABLE) ;
1986 queue_event(smc,EVENT_PCM+index,event) ;
1998 static void hwm_conv_can(struct s_smc *smc, char *data, int len)
2002 SK_UNUSED(smc) ;