Lines Matching refs:smc
19 #include "h/smc.h"
64 int pcm_status_twisted(struct s_smc *smc);
72 static int mac_index(struct s_smc *smc, int mac);
73 static int phy_index(struct s_smc *smc, int phy);
74 static int mac_con_resource_index(struct s_smc *smc, int mac);
75 static int phy_con_resource_index(struct s_smc *smc, int phy);
76 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
78 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
80 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
82 static void smt_echo_test(struct s_smc *smc, int dna);
83 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
85 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
91 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una);
92 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde);
93 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state);
94 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts);
95 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy);
96 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency);
97 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor);
98 static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path);
99 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st);
100 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy);
101 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers);
102 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc);
103 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc);
104 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc);
105 static void smt_fill_manufacturer(struct s_smc *smc,
107 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user);
108 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount);
109 static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
112 static void smt_clear_una_dna(struct s_smc *smc);
113 static void smt_clear_old_una_dna(struct s_smc *smc);
117 static void update_dac(struct s_smc *smc, int report);
120 static void hwm_conv_can(struct s_smc *smc, char *data, int len);
122 #define hwm_conv_can(smc,data,len)
126 static inline int is_my_addr(const struct s_smc *smc,
130 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[0])
132 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[2])
134 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[4])) ;
165 void smt_agent_init(struct s_smc *smc)
172 smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
177 smc->mib.fddiSMTStationId.sid_oem[0] = 0 ;
178 smc->mib.fddiSMTStationId.sid_oem[1] = 0 ;
179 driver_get_bia(smc,&smc->mib.fddiSMTStationId.sid_node) ;
181 smc->mib.fddiSMTStationId.sid_node.a[i] =
182 bitrev8(smc->mib.fddiSMTStationId.sid_node.a[i]);
184 smc->mib.fddiSMTManufacturerData[0] =
185 smc->mib.fddiSMTStationId.sid_node.a[0] ;
186 smc->mib.fddiSMTManufacturerData[1] =
187 smc->mib.fddiSMTStationId.sid_node.a[1] ;
188 smc->mib.fddiSMTManufacturerData[2] =
189 smc->mib.fddiSMTStationId.sid_node.a[2] ;
190 smc->sm.smt_tid = 0 ;
191 smc->mib.m[MAC0].fddiMACDupAddressTest = DA_NONE ;
192 smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
194 smt_clear_una_dna(smc) ;
195 smt_clear_old_una_dna(smc) ;
198 smc->sm.pend[i] = 0 ;
199 smc->sm.please_reconnect = 0 ;
200 smc->sm.uniq_ticks = 0 ;
211 void smt_agent_task(struct s_smc *smc)
213 smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
219 void smt_emulate_token_ct(struct s_smc *smc, int mac_index)
226 count = ((time - smc->sm.last_tok_time[mac_index]) *
235 if (smc->hw.mac_ring_is_up){
236 smc->mib.m[mac_index].fddiMACToken_Ct += count;
240 smc->sm.last_tok_time[mac_index] = time;
246 void smt_event(struct s_smc *smc, int event)
254 if (smc->sm.please_reconnect) {
255 smc->sm.please_reconnect -- ;
256 if (smc->sm.please_reconnect == 0) {
258 queue_event(smc,EVENT_ECM,EC_CONNECT) ;
271 smt_timer_poll(smc) ;
272 smt_start_watchdog(smc) ;
276 ess_timer_poll(smc) ;
280 sba_timer_poll(smc) ;
283 smt_srf_event(smc,0,0,0) ;
289 if (time - smc->sm.smt_last_lem >= TICKS_PER_SECOND*8) {
303 sm_lem_evaluate(smc) ;
304 smc->sm.smt_last_lem = time ;
310 mac_update_counter(smc) ;
311 mib = smc->mib.m ;
327 smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
345 smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
361 phy = &smc->y[port] ;
373 smt_srf_event(smc,SMT_COND_PORT_EB_ERROR,
388 if (time - smc->sm.smt_last_notify >= (u_long)
389 (smc->mib.fddiSMTTT_Notify * TICKS_PER_SECOND) ) {
396 if (!smc->sm.pend[SMT_TID_NIF])
397 smc->sm.pend[SMT_TID_NIF] = smt_get_tid(smc) ;
398 smt_send_nif(smc,&fddi_broadcast, FC_SMT_NSA,
399 smc->sm.pend[SMT_TID_NIF], SMT_REQUEST,0) ;
400 smc->sm.smt_last_notify = time ;
406 if (smc->sm.smt_tvu &&
407 time - smc->sm.smt_tvu > 228*TICKS_PER_SECOND) {
409 smc->sm.smt_tvu = 0 ;
411 if (!is_equal(&smc->mib.m[MAC0].fddiMACUpstreamNbr,
414 smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
415 smc->mib.m[MAC0].fddiMACUpstreamNbr ;
417 smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
418 smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
425 update_dac(smc,0) ;
426 smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
429 if (smc->sm.smt_tvd &&
430 time - smc->sm.smt_tvd > 228*TICKS_PER_SECOND) {
432 smc->sm.smt_tvd = 0 ;
433 if (!is_equal(&smc->mib.m[MAC0].fddiMACDownstreamNbr,
436 smc->mib.m[MAC0].fddiMACOldDownstreamNbr=
437 smc->mib.m[MAC0].fddiMACDownstreamNbr ;
439 smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
440 smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
452 if (time - smc->sm.last_tok_time[i] > 2*TICKS_PER_SECOND ){
453 smt_emulate_token_ct( smc, i );
458 smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
478 void smt_received_pack(struct s_smc *smc, SMbuf *mb, int fs)
493 smt_free_mbuf(smc,mb) ;
497 smc->mib.m[MAC0].fddiMACSMTCopied_Ct++ ;
500 hwm_conv_can(smc,(char *)sm,12) ;
503 if (is_individual(&sm->smt_dest) && !is_my_addr(smc,&sm->smt_dest)) {
504 smt_free_mbuf(smc,mb) ;
520 smc->sba.sm = sm ;
521 sba(smc,NIF) ;
531 smt_free_mbuf(smc,mb) ;
540 smt_free_mbuf(smc,mb) ;
563 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_VERSION,local) ;
564 smt_free_mbuf(smc,mb) ;
570 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,local) ;
571 smt_free_mbuf(smc,mb) ;
576 if (smt_check_para(smc,sm,plist_nif)) {
589 &smc->mib.m[MAC0].fddiMACUpstreamNbr,
593 if (!is_equal(&smc->mib.m[MAC0].
596 smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
597 smc->mib.m[MAC0].fddiMACUpstreamNbr ;
600 smc->mib.m[MAC0].fddiMACUpstreamNbr =
602 smt_srf_event(smc,
605 smt_echo_test(smc,0) ;
607 smc->sm.smt_tvu = smt_get_time() ;
609 sm_to_para(smc,sm,SMT_P_STATE) ;
611 smc->mib.m[MAC0].fddiMACUNDA_Flag =
614 update_dac(smc,1) ;
623 smt_send_nif(smc,&sm->smt_source,
633 smc->sm.pend[SMT_TID_NIF] = 0 ;
635 smc->mib.m[MAC0].fddiMACDupAddressTest =
637 smc->r.dup_addr_test = DA_FAILED ;
638 queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
639 smc->mib.m[MAC0].fddiMACDA_Flag = TRUE ;
640 update_dac(smc,1) ;
643 if (sm->smt_tid == smc->sm.pend[SMT_TID_NIF]) {
644 smc->sm.pend[SMT_TID_NIF] = 0 ;
647 &smc->mib.m[MAC0].fddiMACDownstreamNbr,
650 if (!is_equal(&smc->mib.m[MAC0].
653 smc->mib.m[MAC0].fddiMACOldDownstreamNbr =
654 smc->mib.m[MAC0].fddiMACDownstreamNbr ;
657 smc->mib.m[MAC0].fddiMACDownstreamNbr =
659 smt_srf_event(smc,
662 smt_echo_test(smc,1) ;
664 smc->mib.m[MAC0].fddiMACDA_Flag = FALSE ;
665 update_dac(smc,1) ;
666 smc->sm.smt_tvd = smt_get_time() ;
667 smc->mib.m[MAC0].fddiMACDupAddressTest =
669 if (smc->r.dup_addr_test != DA_PASSED) {
670 smc->r.dup_addr_test = DA_PASSED ;
671 queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
675 smc->sm.pend[SMT_TID_NIF_TEST]) {
680 smc->sm.pend[SMT_TID_NIF],sm->smt_tid) ;
693 smt_send_sif_config(smc,&sm->smt_source,sm->smt_tid,local) ;
700 smt_send_sif_operation(smc,&sm->smt_source,sm->smt_tid,local) ;
705 smc->mib.priv.fddiPRIVECF_Reply_Rx++ ;
708 if (sm_to_para(smc,sm,SMT_P_ECHODATA) == 0) {
712 if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
715 else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
718 else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
723 smc->sm.pend[SMT_TID_ECF],
728 smc->mib.priv.fddiPRIVECF_Req_Rx++ ;
730 if (sm->smt_len && !sm_to_para(smc,sm,SMT_P_ECHODATA)) {
732 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,
742 dump_smt(smc,sm,"ECF REPLY") ;
743 smc->mib.priv.fddiPRIVECF_Reply_Tx++ ;
744 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
756 fs = ess_raf_received_pack(smc,mb,sm,fs) ;
761 sba_raf_received_pack(smc,sm,fs) ;
765 smc->mib.priv.fddiPRIVRDF_Rx++ ;
770 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
779 smc->mib.priv.fddiPRIVPMF_Get_Rx++ ;
781 smc->mib.priv.fddiPRIVPMF_Set_Rx++ ;
790 smt_pmf_received_pack(smc,mb, local) ;
793 dump_smt(smc,sm,"SRF received") ;
806 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
814 smt_free_mbuf(smc,mb) ;
817 static void update_dac(struct s_smc *smc, int report)
821 cond = ( smc->mib.m[MAC0].fddiMACUNDA_Flag |
822 smc->mib.m[MAC0].fddiMACDA_Flag) != 0 ;
823 if (report && (cond != smc->mib.m[MAC0].fddiMACDuplicateAddressCond))
824 smt_srf_event(smc, SMT_COND_MAC_DUP_ADDR,INDEX_MAC,cond) ;
826 smc->mib.m[MAC0].fddiMACDuplicateAddressCond = cond ;
835 void smt_send_frame(struct s_smc *smc, SMbuf *mb, int fc, int local)
841 if (!smc->r.sm_ma_avail && !local) {
842 smt_free_mbuf(smc,mb) ;
846 sm->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
847 sm->smt_sid = smc->mib.fddiSMTStationId ;
850 hwm_conv_can(smc,(char *)sm,12) ; /* convert SA and DA */
851 smc->mib.m[MAC0].fddiMACSMTTransmit_Ct++ ;
852 smt_send_mbuf(smc,mb,local ? FC_SMT_LOC : fc) ;
858 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
884 if (!(mb=smt_build_frame(smc,SMT_RDF,SMT_REPLY,sizeof(struct smt_rdf))))
927 dump_smt(smc,(struct smt_header *)rdf,"RDF") ;
928 smc->mib.priv.fddiPRIVRDF_Tx++ ;
929 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
935 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
945 if (!(mb = smt_build_frame(smc,SMT_NIF,type,sizeof(struct smt_nif))))
948 smt_fill_una(smc,&nif->una) ; /* set UNA */
949 smt_fill_sde(smc,&nif->sde) ; /* set station descriptor */
950 smt_fill_state(smc,&nif->state) ; /* set state information */
952 smt_fill_fsc(smc,&nif->fsc) ; /* set frame status cap. */
956 dump_smt(smc,(struct smt_header *)nif,"NIF") ;
957 smt_send_frame(smc,mb,fc,local) ;
964 static void smt_send_nif_request(struct s_smc *smc, struct fddi_addr *dest)
966 smc->sm.pend[SMT_TID_NIF_TEST] = smt_get_tid(smc) ;
967 smt_send_nif(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_NIF_TEST],
974 static void smt_send_ecf_request(struct s_smc *smc, struct fddi_addr *dest,
977 smc->sm.pend[SMT_TID_ECF] = smt_get_tid(smc) ;
978 smt_send_ecf(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_ECF],
986 static void smt_echo_test(struct s_smc *smc, int dna)
990 smc->sm.pend[dna ? SMT_TID_ECF_DNA : SMT_TID_ECF_UNA] =
991 tid = smt_get_tid(smc) ;
992 smt_send_ecf(smc, dna ?
993 &smc->mib.m[MAC0].fddiMACDownstreamNbr :
994 &smc->mib.m[MAC0].fddiMACUpstreamNbr,
1001 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
1012 if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
1016 smt_fill_echo(smc,&ecf->ec_echo,tid,len) ; /* set ECHO */
1019 smc->mib.priv.fddiPRIVECF_Req_Tx++ ;
1020 smt_send_frame(smc,mb,fc,0) ;
1027 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
1035 if (!(mb = smt_build_frame(smc,SMT_SIF_CONFIG,SMT_REPLY,
1040 smt_fill_timestamp(smc,&sif->ts) ; /* set time stamp */
1041 smt_fill_sde(smc,&sif->sde) ; /* set station descriptor */
1042 smt_fill_version(smc,&sif->version) ; /* set version information */
1043 smt_fill_state(smc,&sif->state) ; /* set state information */
1044 smt_fill_policy(smc,&sif->policy) ; /* set station policy */
1045 smt_fill_latency(smc,&sif->latency); /* set station latency */
1046 smt_fill_neighbor(smc,&sif->neighbor); /* set station neighbor */
1047 smt_fill_setcount(smc,&sif->setcount) ; /* set count */
1048 len = smt_fill_path(smc,&sif->path); /* set station path descriptor*/
1052 dump_smt(smc,(struct smt_header *)sif,"SIF Configuration Reply") ;
1053 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1060 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
1072 if (smc->s.sas == SMT_SAS)
1076 if (!(mb = smt_build_frame(smc,SMT_SIF_OPER,SMT_REPLY,
1080 smt_fill_timestamp(smc,&sif->ts) ; /* set time stamp */
1081 smt_fill_mac_status(smc,&sif->status) ; /* set mac status */
1082 smt_fill_mac_counter(smc,&sif->mc) ; /* set mac counter field */
1083 smt_fill_mac_fnc(smc,&sif->fnc) ; /* set frame not copied counter */
1084 smt_fill_manufacturer(smc,&sif->man) ; /* set manufacturer field */
1085 smt_fill_user(smc,&sif->user) ; /* set user field */
1086 smt_fill_setcount(smc,&sif->setcount) ; /* set count */
1091 smt_fill_lem(smc,sif->lem,PS) ;
1095 smt_fill_lem(smc,&sif->lem[i],i) ;
1101 dump_smt(smc,(struct smt_header *)sif,"SIF Operation Reply") ;
1102 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1108 SMbuf *smt_build_frame(struct s_smc *smc, int class, int type,
1114 if (!(mb = smt_get_mbuf(smc)))
1133 smt->smt_tid = smt_get_tid(smc) ; /* set transaction ID */
1153 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una)
1157 una->una_node = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1163 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde)
1166 sde->sde_non_master = smc->mib.fddiSMTNonMaster_Ct ;
1167 sde->sde_master = smc->mib.fddiSMTMaster_Ct ;
1179 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state)
1189 if (smc->mib.fddiSMTPeerWrapFlag) {
1193 if (cfm_status_unattached(smc)) {
1197 if ((twist = pcm_status_twisted(smc)) & 1) {
1206 if (pcm_rooted_station(smc))
1208 if (smc->mib.a[0].fddiPATHSbaPayload != 0)
1212 ((smc->mib.m[MAC0].fddiMACDA_Flag ? SMT_ST_MY_DUPA : 0 ) |
1213 (smc->mib.m[MAC0].fddiMACUNDA_Flag ? SMT_ST_UNA_DUPA : 0)) ;
1219 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts)
1223 smt_set_timestamp(smc,ts->ts_time) ;
1226 void smt_set_timestamp(struct s_smc *smc, u_char *p)
1245 p[6] = (u_char)(smc->sm.uniq_ticks>>8) ;
1246 p[7] = (u_char)smc->sm.uniq_ticks ;
1250 if (utime != smc->sm.uniq_time) {
1251 smc->sm.uniq_ticks = 0 ;
1253 smc->sm.uniq_ticks++ ;
1254 smc->sm.uniq_time = utime ;
1260 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy)
1277 in = smc->mib.fddiSMTConnectionPolicy ;
1284 policy->pl_config = smc->mib.fddiSMTConfigPolicy ;
1291 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency)
1295 latency->lt_phyout_idx1 = phy_index(smc,0) ;
1301 if (smc->s.sas == SMT_DAS) {
1302 latency->lt_phyout_idx2 = phy_index(smc,1) ;
1314 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor)
1319 neighbor->nb_mac_index = mac_index(smc,1) ;
1320 neighbor->nb_una = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1321 neighbor->nb_dna = smc->mib.m[MAC0].fddiMACDownstreamNbr ;
1330 #define ALLPHYS ((smc->s.sas == SMT_SAS) ? 1 : 2)
1333 static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path)
1355 if (smc->s.sas == SMT_SAS)
1358 pcm_status_state(smc,physp,&type,&state,&remote,&mac) ;
1368 phy->phy_resource_idx = phy_con_resource_index(smc,p) ;
1373 pd_mac->mac_addr = smc->mib.m[MAC0].fddiMACSMTAddress ;
1374 pd_mac->mac_resource_idx = mac_con_resource_index(smc,1) ;
1381 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st)
1386 st->st_mac_index = mac_index(smc,1) ;
1388 mac_update_counter(smc) ;
1393 st->st_t_req = smc->mib.m[MAC0].fddiMACT_Req ;
1394 st->st_t_neg = smc->mib.m[MAC0].fddiMACT_Neg ;
1395 st->st_t_max = smc->mib.m[MAC0].fddiMACT_Max ;
1396 st->st_tvx_value = smc->mib.m[MAC0].fddiMACTvxValue ;
1397 st->st_t_min = smc->mib.m[MAC0].fddiMACT_Min ;
1399 st->st_sba = smc->mib.a[PATH0].fddiPATHSbaPayload ;
1400 st->st_frame_ct = smc->mib.m[MAC0].fddiMACFrame_Ct ;
1401 st->st_error_ct = smc->mib.m[MAC0].fddiMACError_Ct ;
1402 st->st_lost_ct = smc->mib.m[MAC0].fddiMACLost_Ct ;
1408 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy)
1412 mib = smc->y[phy].mib ;
1416 lem->lem_phy_index = phy_index(smc,phy) ;
1430 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers)
1432 SK_UNUSED(smc) ;
1449 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc)
1451 SK_UNUSED(smc) ;
1469 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc)
1473 mc->mc_index = mac_index(smc,1) ;
1474 mc->mc_receive_ct = smc->mib.m[MAC0].fddiMACCopied_Ct ;
1475 mc->mc_transmit_ct = smc->mib.m[MAC0].fddiMACTransmit_Ct ;
1481 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc)
1485 fnc->nc_index = mac_index(smc,1) ;
1486 fnc->nc_counter = smc->mib.m[MAC0].fddiMACNotCopied_Ct ;
1493 static void smt_fill_manufacturer(struct s_smc *smc,
1498 (char *) smc->mib.fddiSMTManufacturerData,
1505 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user)
1509 (char *) smc->mib.fddiSMTUserData,
1516 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount)
1518 SK_UNUSED(smc) ;
1520 setcount->count = smc->mib.fddiSMTSetCount.count ;
1522 (char *)smc->mib.fddiSMTSetCount.timestamp,8) ;
1528 static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
1533 SK_UNUSED(smc) ;
1546 static void smt_clear_una_dna(struct s_smc *smc)
1548 smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
1549 smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
1552 static void smt_clear_old_una_dna(struct s_smc *smc)
1554 smc->mib.m[MAC0].fddiMACOldUpstreamNbr = SMT_Unknown ;
1555 smc->mib.m[MAC0].fddiMACOldDownstreamNbr = SMT_Unknown ;
1558 u_long smt_get_tid(struct s_smc *smc)
1561 while ((tid = ++(smc->sm.smt_tid) ^ SMT_TID_MAGIC) == 0)
1643 int smt_check_para(struct s_smc *smc, struct smt_header *sm,
1648 if (!sm_to_para(smc,sm,(int) *p)) {
1657 void *sm_to_para(struct s_smc *smc, struct smt_header *sm, int para)
1664 SK_UNUSED(smc) ;
1712 smc->mib.fddiSMTBypassPresent = 1 ;
1722 static int mac_index(struct s_smc *smc, int mac)
1726 SK_UNUSED(smc) ;
1729 return((smc->s.sas == SMT_SAS) ? 2 : 3) ;
1736 static int phy_index(struct s_smc *smc, int phy)
1738 SK_UNUSED(smc) ;
1745 static int mac_con_resource_index(struct s_smc *smc, int mac)
1748 SK_UNUSED(smc) ;
1750 return(entity_to_index(smc,cem_get_downstream(smc,ENTITY_MAC))) ;
1753 switch (smc->mib.fddiSMTCF_State) {
1762 return(smc->s.sas == SMT_SAS ? 2 : 3) ;
1769 static int phy_con_resource_index(struct s_smc *smc, int phy)
1772 return(entity_to_index(smc,cem_get_downstream(smc,ENTITY_PHY(phy)))) ;
1774 switch (smc->mib.fddiSMTCF_State) {
1791 static int entity_to_index(struct s_smc *smc, int e)
1794 return(mac_index(smc,1)) ;
1796 return(phy_index(smc,e - ENTITY_PHY(0))) ;
1916 int smt_action(struct s_smc *smc, int class, int code, int index)
1925 smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
1926 queue_event(smc,EVENT_ECM,EC_CONNECT) ;
1929 queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
1930 smc->mib.fddiSMTRemoteDisconnectFlag = TRUE ;
1931 RS_SET(smc,RS_DISCONNECT) ;
1932 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1934 smt_get_event_word(smc));
1937 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1939 smt_get_event_word(smc));
1942 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1944 smt_get_event_word(smc));
1947 if (smc->y[PA].pc_mode == PM_PEER) {
1948 RS_SET(smc,RS_EVENT) ;
1949 queue_event(smc,EVENT_PCM+PA,PC_DISABLE) ;
1953 if (smc->y[PB].pc_mode == PM_PEER) {
1954 RS_SET(smc,RS_EVENT) ;
1955 queue_event(smc,EVENT_PCM+PB,PC_DISABLE) ;
1960 if (smc->mib.p[port].fddiPORTMy_Type != TM)
1962 RS_SET(smc,RS_EVENT) ;
1963 queue_event(smc,EVENT_PCM+port,PC_DISABLE) ;
1990 queue_event(smc,EVENT_PCM+index,event) ;
2002 static void hwm_conv_can(struct s_smc *smc, char *data, int len)
2006 SK_UNUSED(smc) ;