1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /******************************************************************************
4 * (C)Copyright 1998,1999 SysKonnect,
5 * a business unit of Schneider & Koch & Co. Datensysteme GmbH.
7 * See the file "skfddi.c" for further information.
9 * The information in this file is provided "AS IS" without warranty.
11 ******************************************************************************/
17 #include <linux/bitrev.h>
18 #include <linux/kernel.h>
21 #include "h/smtstate.h"
26 #define m_fc(mb) ((mb)->sm_data[0])
28 #define SMT_TID_MAGIC 0x1f0a7b3c
30 static const char *const smt_type_name[] = {
31 "SMT_00??", "SMT_INFO", "SMT_02??", "SMT_03??",
32 "SMT_04??", "SMT_05??", "SMT_06??", "SMT_07??",
33 "SMT_08??", "SMT_09??", "SMT_0A??", "SMT_0B??",
34 "SMT_0C??", "SMT_0D??", "SMT_0E??", "SMT_NSA"
37 static const char *const smt_class_name[] = {
38 "UNKNOWN","NIF","SIF_CONFIG","SIF_OPER","ECF","RAF","RDF",
39 "SRF","PMF_GET","PMF_SET","ESF"
42 #define LAST_CLASS (SMT_PMF_SET)
44 static const struct fddi_addr SMT_Unknown = {
52 static int smt_swap_short(u_short s);
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,
61 int fc, u_long tid, int type, int local);
62 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
63 u_long tid, int type, int len);
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,
66 u_long tid, int local);
67 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
68 u_long tid, int local);
70 static void smt_string_swap(char *data, const char *format, int len);
72 static void smt_add_frame_len(SMbuf *mb, int len);
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,
88 struct smp_p_manufacturer *man);
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);
97 static int entity_to_index(void);
99 static void update_dac(struct s_smc *smc, int report);
100 static int div_ratio(u_long upper, u_long lower);
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,
109 const struct fddi_addr *addr)
111 return(*(short *)(&addr->a[0]) ==
112 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[0])
113 && *(short *)(&addr->a[2]) ==
114 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[2])
115 && *(short *)(&addr->a[4]) ==
116 *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[4])) ;
119 static inline int is_broadcast(const struct fddi_addr *addr)
121 return *(u_short *)(&addr->a[0]) == 0xffff &&
122 *(u_short *)(&addr->a[2]) == 0xffff &&
123 *(u_short *)(&addr->a[4]) == 0xffff;
126 static inline int is_individual(const struct fddi_addr *addr)
128 return !(addr->a[0] & GROUP_ADDR);
131 static inline int is_equal(const struct fddi_addr *addr1,
132 const struct fddi_addr *addr2)
134 return *(u_short *)(&addr1->a[0]) == *(u_short *)(&addr2->a[0]) &&
135 *(u_short *)(&addr1->a[2]) == *(u_short *)(&addr2->a[2]) &&
136 *(u_short *)(&addr1->a[4]) == *(u_short *)(&addr2->a[4]);
140 * list of mandatory paras in frames
142 static const u_short plist_nif[] = { SMT_P_UNA,SMT_P_SDE,SMT_P_STATE,0 } ;
147 void smt_agent_init(struct s_smc *smc)
154 smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
157 * get OUI address from driver (bia == built-in-address)
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) ;
162 for (i = 0 ; i < 6 ; i ++) {
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) ;
179 for (i = 0 ; i < SMT_MAX_TEST ; i++)
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,
196 EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
197 DB_SMT("SMT agent task");
200 #ifndef SMT_REAL_TOKEN_CT
201 void smt_emulate_token_ct(struct s_smc *smc, int mac_index)
207 time = smt_get_time();
208 count = ((time - smc->sm.last_tok_time[mac_index]) *
209 100)/TICKS_PER_SECOND;
212 * Only when ring is up we will have a token count. The
213 * flag is unfortunately a single instance value. This
214 * doesn't matter now, because we currently have only
217 if (smc->hw.mac_ring_is_up){
218 smc->mib.m[mac_index].fddiMACToken_Ct += count;
221 /* Remember current time */
222 smc->sm.last_tok_time[mac_index] = time;
228 void smt_event(struct s_smc *smc, int event)
231 #ifndef SMT_REAL_TOKEN_CT
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) ;
244 if (event == SM_FAST)
248 * timer for periodic cleanup in driver
249 * reset and start the watchdog (FM2)
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) ;
267 #endif /* no SLIM_SMT */
269 time = smt_get_time() ;
271 if (time - smc->sm.smt_last_lem >= TICKS_PER_SECOND*8) {
273 * Use 8 sec. for the time intervall, it simplifies the
276 struct fddi_mib_m *mib ;
283 * calculate LEM bit error rate
285 sm_lem_evaluate(smc) ;
286 smc->sm.smt_last_lem = time ;
292 mac_update_counter(smc) ;
295 (mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) +
296 (mib->fddiMACError_Ct - mib->fddiMACOld_Error_Ct) ;
298 (mib->fddiMACFrame_Ct - mib->fddiMACOld_Frame_Ct) +
299 (mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) ;
300 mib->fddiMACFrameErrorRatio = div_ratio(upper,lower) ;
303 ((!mib->fddiMACFrameErrorThreshold &&
304 mib->fddiMACError_Ct != mib->fddiMACOld_Error_Ct) ||
305 (mib->fddiMACFrameErrorRatio >
306 mib->fddiMACFrameErrorThreshold)) ;
308 if (cond != mib->fddiMACFrameErrorFlag)
309 smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
313 (mib->fddiMACNotCopied_Ct - mib->fddiMACOld_NotCopied_Ct) ;
316 (mib->fddiMACCopied_Ct - mib->fddiMACOld_Copied_Ct) ;
317 mib->fddiMACNotCopiedRatio = div_ratio(upper,lower) ;
320 ((!mib->fddiMACNotCopiedThreshold &&
321 mib->fddiMACNotCopied_Ct !=
322 mib->fddiMACOld_NotCopied_Ct)||
323 (mib->fddiMACNotCopiedRatio >
324 mib->fddiMACNotCopiedThreshold)) ;
326 if (cond != mib->fddiMACNotCopiedFlag)
327 smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
333 mib->fddiMACOld_Frame_Ct = mib->fddiMACFrame_Ct ;
334 mib->fddiMACOld_Copied_Ct = mib->fddiMACCopied_Ct ;
335 mib->fddiMACOld_Error_Ct = mib->fddiMACError_Ct ;
336 mib->fddiMACOld_Lost_Ct = mib->fddiMACLost_Ct ;
337 mib->fddiMACOld_NotCopied_Ct = mib->fddiMACNotCopied_Ct ;
340 * Check port EBError Condition
342 for (port = 0; port < NUMPHYS; port ++) {
343 phy = &smc->y[port] ;
345 if (!phy->mib->fddiPORTHardwarePresent) {
349 cond = (phy->mib->fddiPORTEBError_Ct -
350 phy->mib->fddiPORTOldEBError_Ct > 5) ;
352 /* If ratio is more than 5 in 8 seconds
355 smt_srf_event(smc,SMT_COND_PORT_EB_ERROR,
356 (int) (INDEX_PORT+ phy->np) ,cond) ;
361 phy->mib->fddiPORTOldEBError_Ct =
362 phy->mib->fddiPORTEBError_Ct ;
365 #endif /* no SLIM_SMT */
370 if (time - smc->sm.smt_last_notify >= (u_long)
371 (smc->mib.fddiSMTTT_Notify * TICKS_PER_SECOND) ) {
373 * we can either send an announcement or a request
374 * a request will trigger a reply so that we can update
376 * note: same tid must be used until reply is received
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) {
390 DB_SMT("SMT : UNA expired");
391 smc->sm.smt_tvu = 0 ;
393 if (!is_equal(&smc->mib.m[MAC0].fddiMACUpstreamNbr,
395 /* Do not update unknown address */
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 ;
402 * Make sure the fddiMACUNDA_Flag = FALSE is
403 * included in the SRF so we don't generate
404 * a separate SRF for the deassertion of this
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) {
413 DB_SMT("SMT : DNA expired");
414 smc->sm.smt_tvd = 0 ;
415 if (!is_equal(&smc->mib.m[MAC0].fddiMACDownstreamNbr,
417 /* Do not update unknown address */
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,
426 #endif /* no SLIM_SMT */
428 #ifndef SMT_REAL_TOKEN_CT
430 * Token counter emulation section. If hardware supports the token
431 * count, the token counter will be updated in mac_update_counter.
433 for (i = MAC0; i < NUMMACS; i++ ){
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,
441 EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
444 static int div_ratio(u_long upper, u_long lower)
446 if ((upper<<16L) < upper)
447 upper = 0xffff0000L ;
452 return (int)(upper/lower) ;
458 * receive packet handler
460 void smt_received_pack(struct s_smc *smc, SMbuf *mb, int fs)
461 /* int fs; frame status */
463 struct smt_header *sm ;
470 case FC_SMT_LAN_LOC :
475 smt_free_mbuf(smc,mb) ;
479 smc->mib.m[MAC0].fddiMACSMTCopied_Ct++ ;
480 sm = smtod(mb,struct smt_header *) ;
481 local = ((fs & L_INDICATOR) != 0) ;
482 hwm_conv_can(smc,(char *)sm,12) ;
484 /* check destination address */
485 if (is_individual(&sm->smt_dest) && !is_my_addr(smc,&sm->smt_dest)) {
486 smt_free_mbuf(smc,mb) ;
489 #if 0 /* for DUP recognition, do NOT filter them */
490 /* ignore loop back packets */
491 if (is_my_addr(smc,&sm->smt_source) && !local) {
492 smt_free_mbuf(smc,mb) ;
497 smt_swap_para(sm,(int) mb->sm_len,1) ;
498 DB_SMT("SMT : received packet [%s] at 0x%p",
499 smt_type_name[m_fc(mb) & 0xf], sm);
500 DB_SMT("SMT : version %d, class %s",
502 smt_class_name[sm->smt_class > LAST_CLASS ? 0 : sm->smt_class]);
508 if (m_fc(mb) == FC_SMT_NSA && sm->smt_class == SMT_NIF &&
509 (sm->smt_type == SMT_ANNOUNCE || sm->smt_type == SMT_REQUEST)) {
516 * ignore any packet with NSA and A-indicator set
518 if ( (fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) {
519 DB_SMT("SMT : ignoring NSA with A-indicator set from %pM",
521 smt_free_mbuf(smc,mb) ;
526 * ignore frames with illegal length
528 if (((sm->smt_class == SMT_ECF) && (sm->smt_len > SMT_MAX_ECHO_LEN)) ||
529 ((sm->smt_class != SMT_ECF) && (sm->smt_len > SMT_MAX_INFO_LEN))) {
530 smt_free_mbuf(smc,mb) ;
537 switch (sm->smt_class) {
539 case SMT_SIF_CONFIG :
542 if (sm->smt_version != SMT_VID)
546 if (sm->smt_version != SMT_VID_2)
551 DB_SMT("SMT : version = %d, dest = %pM",
552 sm->smt_version, &sm->smt_source);
553 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_VERSION,local) ;
554 smt_free_mbuf(smc,mb) ;
557 if ((sm->smt_len > mb->sm_len - sizeof(struct smt_header)) ||
558 ((sm->smt_len & 3) && (sm->smt_class != SMT_ECF))) {
559 DB_SMT("SMT: info length error, len = %d", sm->smt_len);
560 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,local) ;
561 smt_free_mbuf(smc,mb) ;
564 switch (sm->smt_class) {
566 if (smt_check_para(smc,sm,plist_nif)) {
567 DB_SMT("SMT: NIF with para problem, ignoring");
570 switch (sm->smt_type) {
573 if (!(fs & C_INDICATOR) && m_fc(mb) == FC_SMT_NSA
574 && is_broadcast(&sm->smt_dest)) {
575 struct smt_p_state *st ;
579 &smc->mib.m[MAC0].fddiMACUpstreamNbr,
581 DB_SMT("SMT : updated my UNA = %pM",
583 if (!is_equal(&smc->mib.m[MAC0].
584 fddiMACUpstreamNbr,&SMT_Unknown)){
585 /* Do not update unknown address */
586 smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
587 smc->mib.m[MAC0].fddiMACUpstreamNbr ;
590 smc->mib.m[MAC0].fddiMACUpstreamNbr =
593 SMT_EVENT_MAC_NEIGHBOR_CHANGE,
595 smt_echo_test(smc,0) ;
597 smc->sm.smt_tvu = smt_get_time() ;
598 st = (struct smt_p_state *)
599 sm_to_para(smc,sm,SMT_P_STATE) ;
601 smc->mib.m[MAC0].fddiMACUNDA_Flag =
602 (st->st_dupl_addr & SMT_ST_MY_DUPA) ?
607 if ((sm->smt_type == SMT_REQUEST) &&
608 is_individual(&sm->smt_source) &&
609 ((!(fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) ||
610 (m_fc(mb) != FC_SMT_NSA))) {
611 DB_SMT("SMT : replying to NIF request %pM",
613 smt_send_nif(smc,&sm->smt_source,
620 DB_SMT("SMT : received NIF response from %pM",
622 if (fs & A_INDICATOR) {
623 smc->sm.pend[SMT_TID_NIF] = 0 ;
624 DB_SMT("SMT : duplicate address");
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 ;
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,
639 DB_SMT("SMT : updated my DNA");
640 if (!is_equal(&smc->mib.m[MAC0].
641 fddiMACDownstreamNbr, &SMT_Unknown)){
642 /* Do not update unknown address */
643 smc->mib.m[MAC0].fddiMACOldDownstreamNbr =
644 smc->mib.m[MAC0].fddiMACDownstreamNbr ;
647 smc->mib.m[MAC0].fddiMACDownstreamNbr =
650 SMT_EVENT_MAC_NEIGHBOR_CHANGE,
652 smt_echo_test(smc,1) ;
654 smc->mib.m[MAC0].fddiMACDA_Flag = FALSE ;
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) ;
664 else if (sm->smt_tid ==
665 smc->sm.pend[SMT_TID_NIF_TEST]) {
666 DB_SMT("SMT : NIF test TID ok");
669 DB_SMT("SMT : expected TID %lx, got %x",
670 smc->sm.pend[SMT_TID_NIF], sm->smt_tid);
678 case SMT_SIF_CONFIG : /* station information */
679 if (sm->smt_type != SMT_REQUEST)
681 DB_SMT("SMT : replying to SIF Config request from %pM",
683 smt_send_sif_config(smc,&sm->smt_source,sm->smt_tid,local) ;
685 case SMT_SIF_OPER : /* station information */
686 if (sm->smt_type != SMT_REQUEST)
688 DB_SMT("SMT : replying to SIF Operation request from %pM",
690 smt_send_sif_operation(smc,&sm->smt_source,sm->smt_tid,local) ;
692 case SMT_ECF : /* echo frame */
693 switch (sm->smt_type) {
695 smc->mib.priv.fddiPRIVECF_Reply_Rx++ ;
696 DB_SMT("SMT: received ECF reply from %pM",
698 if (sm_to_para(smc,sm,SMT_P_ECHODATA) == NULL) {
699 DB_SMT("SMT: ECHODATA missing");
702 if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
703 DB_SMT("SMT : ECF test TID ok");
705 else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
706 DB_SMT("SMT : ECF test UNA ok");
708 else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
709 DB_SMT("SMT : ECF test DNA ok");
712 DB_SMT("SMT : expected TID %lx, got %x",
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)) {
721 DB_SMT("SMT: ECF with para problem,sending RDF");
722 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,
726 DB_SMT("SMT - sending ECF reply to %pM",
729 /* set destination addr. & reply */
730 sm->smt_dest = sm->smt_source ;
731 sm->smt_type = SMT_REPLY ;
732 dump_smt(smc,sm,"ECF REPLY") ;
733 smc->mib.priv.fddiPRIVECF_Reply_Tx++ ;
734 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
735 return ; /* DON'T free mbuf */
743 case SMT_RAF : /* resource allocation */
745 DB_ESSN(2, "ESS: RAF frame received");
746 fs = ess_raf_received_pack(smc,mb,sm,fs) ;
750 DB_SBAN(2,"SBA: RAF frame received\n",0,0) ;
751 sba_raf_received_pack(smc,sm,fs) ;
754 case SMT_RDF : /* request denied */
755 smc->mib.priv.fddiPRIVRDF_Rx++ ;
757 case SMT_ESF : /* extended service - not supported */
758 if (sm->smt_type == SMT_REQUEST) {
759 DB_SMT("SMT - received ESF, sending RDF");
760 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
765 if (sm->smt_type != SMT_REQUEST)
767 /* update statistics */
768 if (sm->smt_class == SMT_PMF_GET)
769 smc->mib.priv.fddiPRIVPMF_Get_Rx++ ;
771 smc->mib.priv.fddiPRIVPMF_Set_Rx++ ;
773 * ignore PMF SET with I/G set
775 if ((sm->smt_class == SMT_PMF_SET) &&
776 !is_individual(&sm->smt_dest)) {
777 DB_SMT("SMT: ignoring PMF-SET with I/G set");
780 smt_pmf_received_pack(smc,mb, local) ;
783 dump_smt(smc,sm,"SRF received") ;
786 if (sm->smt_type != SMT_REQUEST)
789 * For frames with unknown class:
790 * we need to send a RDF frame according to 8.1.3.1.1,
791 * only if it is a REQUEST.
793 DB_SMT("SMT : class = %d, send RDF to %pM",
794 sm->smt_class, &sm->smt_source);
796 smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
801 DB_SMT("SMT: discarding invalid frame, reason = %d", illegal);
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)
825 /* SMbuf *mb; buffer to send */
826 /* int fc; FC value */
828 struct smt_header *sm ;
830 if (!smc->r.sm_ma_avail && !local) {
831 smt_free_mbuf(smc,mb) ;
834 sm = smtod(mb,struct smt_header *) ;
835 sm->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
836 sm->smt_sid = smc->mib.fddiSMTStationId ;
838 smt_swap_para(sm,(int) mb->sm_len,0) ; /* swap para & header */
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) ;
845 * generate and send RDF
847 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
849 /* SMbuf *rej; mbuf of offending frame */
850 /* int fc; FC of denied frame */
851 /* int reason; reason code */
854 struct smt_header *sm ; /* header of offending frame */
855 struct smt_rdf *rdf ;
859 sm = smtod(rej,struct smt_header *) ;
860 if (sm->smt_type != SMT_REQUEST)
863 DB_SMT("SMT: sending RDF to %pM,reason = 0x%x",
864 &sm->smt_source, reason);
868 * note: get framelength from MAC length, NOT from SMT header
869 * smt header length is included in sm_len
871 frame_len = rej->sm_len ;
873 if (!(mb=smt_build_frame(smc,SMT_RDF,SMT_REPLY,sizeof(struct smt_rdf))))
875 rdf = smtod(mb,struct smt_rdf *) ;
876 rdf->smt.smt_tid = sm->smt_tid ; /* use TID from sm */
877 rdf->smt.smt_dest = sm->smt_source ; /* set dest = source */
880 rdf->reason.para.p_type = SMT_P_REASON ;
881 rdf->reason.para.p_len = sizeof(struct smt_p_reason) - PARA_LEN ;
882 rdf->reason.rdf_reason = reason ;
885 rdf->version.para.p_type = SMT_P_VERSION ;
886 rdf->version.para.p_len = sizeof(struct smt_p_version) - PARA_LEN ;
887 rdf->version.v_pad = 0 ;
888 rdf->version.v_n = 1 ;
889 rdf->version.v_index = 1 ;
890 rdf->version.v_version[0] = SMT_VID_2 ;
891 rdf->version.v_pad2 = 0 ;
894 if ((unsigned int) frame_len <= SMT_MAX_INFO_LEN - sizeof(*rdf) +
895 2*sizeof(struct smt_header))
898 len = SMT_MAX_INFO_LEN - sizeof(*rdf) +
899 2*sizeof(struct smt_header) ;
900 /* make length multiple of 4 */
902 rdf->refused.para.p_type = SMT_P_REFUSED ;
903 /* length of para is smt_frame + ref_fc */
904 rdf->refused.para.p_len = len + 4 ;
905 rdf->refused.ref_fc = fc ;
908 smt_swap_para(sm,frame_len,0) ;
910 memcpy((char *) &rdf->refused.ref_header,(char *) sm,len) ;
912 len -= sizeof(struct smt_header) ;
914 rdf->smt.smt_len += len ;
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) ;
922 * generate and send NIF
924 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
925 int fc, u_long tid, int type, int local)
926 /* struct fddi_addr *dest; dest address */
927 /* int fc; frame control */
928 /* u_long tid; transaction id */
929 /* int type; frame type */
931 struct smt_nif *nif ;
934 if (!(mb = smt_build_frame(smc,SMT_NIF,type,sizeof(struct smt_nif))))
936 nif = smtod(mb, 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. */
943 nif->smt.smt_dest = *dest ; /* destination address */
944 nif->smt.smt_tid = tid ; /* transaction ID */
945 dump_smt(smc,(struct smt_header *)nif,"NIF") ;
946 smt_send_frame(smc,mb,fc,local) ;
951 * send NIF request (test purpose)
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],
961 * send ECF request (test purpose)
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,
984 FC_SMT_INFO,tid, SMT_REQUEST, (SMT_TEST_ECHO_LEN & ~3)-8) ;
988 * generate and send ECF
990 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
991 u_long tid, int type, int len)
992 /* struct fddi_addr *dest; dest address */
993 /* int fc; frame control */
994 /* u_long tid; transaction id */
995 /* int type; frame type */
996 /* int len; frame length */
998 struct smt_ecf *ecf ;
1001 if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
1003 ecf = smtod(mb, struct smt_ecf *) ;
1005 smt_fill_echo(smc,&ecf->ec_echo,tid,len) ; /* set ECHO */
1006 ecf->smt.smt_dest = *dest ; /* destination address */
1007 ecf->smt.smt_tid = tid ; /* transaction ID */
1008 smc->mib.priv.fddiPRIVECF_Req_Tx++ ;
1009 smt_send_frame(smc,mb,fc,0) ;
1013 * generate and send SIF config response
1016 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
1017 u_long tid, int local)
1018 /* struct fddi_addr *dest; dest address */
1019 /* u_long tid; transaction id */
1021 struct smt_sif_config *sif ;
1024 if (!(mb = smt_build_frame(smc,SMT_SIF_CONFIG,SMT_REPLY,
1025 SIZEOF_SMT_SIF_CONFIG)))
1028 sif = smtod(mb, struct smt_sif_config *) ;
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*/
1038 sif->smt.smt_dest = *dest ; /* destination address */
1039 sif->smt.smt_tid = tid ; /* transaction ID */
1040 smt_add_frame_len(mb,len) ; /* adjust length fields */
1041 dump_smt(smc,(struct smt_header *)sif,"SIF Configuration Reply") ;
1042 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1046 * generate and send SIF operation response
1049 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
1050 u_long tid, int local)
1051 /* struct fddi_addr *dest; dest address */
1052 /* u_long tid; transaction id */
1054 struct smt_sif_operation *sif ;
1060 #ifndef CONCENTRATOR
1061 if (smc->s.sas == SMT_SAS)
1065 if (!(mb = smt_build_frame(smc,SMT_SIF_OPER,SMT_REPLY,
1066 struct_size(sif, lem, ports))))
1068 sif = smtod(mb, typeof(sif));
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 */
1077 * set link error mon information
1080 smt_fill_lem(smc,sif->lem,PS) ;
1083 for (i = 0 ; i < ports ; i++) {
1084 smt_fill_lem(smc,&sif->lem[i],i) ;
1088 sif->smt.smt_dest = *dest ; /* destination address */
1089 sif->smt.smt_tid = tid ; /* transaction ID */
1090 dump_smt(smc,(struct smt_header *)sif,"SIF Operation Reply") ;
1091 smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1095 * get and initialize SMT frame
1097 SMbuf *smt_build_frame(struct s_smc *smc, int class, int type,
1101 struct smt_header *smt ;
1104 if (!smc->r.sm_ma_avail) {
1108 if (!(mb = smt_get_mbuf(smc)))
1111 mb->sm_len = length ;
1112 smt = smtod(mb, struct smt_header *) ;
1113 smt->smt_dest = fddi_broadcast ; /* set dest = broadcast */
1114 smt->smt_class = class ;
1115 smt->smt_type = type ;
1118 case SMT_SIF_CONFIG :
1121 smt->smt_version = SMT_VID ;
1124 smt->smt_version = SMT_VID_2 ;
1127 smt->smt_tid = smt_get_tid(smc) ; /* set transaction ID */
1129 smt->smt_len = length - sizeof(struct smt_header) ;
1133 static void smt_add_frame_len(SMbuf *mb, int len)
1135 struct smt_header *smt ;
1137 smt = smtod(mb, struct smt_header *) ;
1138 smt->smt_len += len ;
1145 * fill values in UNA parameter
1147 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una)
1149 SMTSETPARA(una,SMT_P_UNA) ;
1151 una->una_node = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1155 * fill values in SDE parameter
1157 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde)
1159 SMTSETPARA(sde,SMT_P_SDE) ;
1160 sde->sde_non_master = smc->mib.fddiSMTNonMaster_Ct ;
1161 sde->sde_master = smc->mib.fddiSMTMaster_Ct ;
1162 sde->sde_mac_count = NUMMACS ; /* only 1 MAC */
1164 sde->sde_type = SMT_SDE_CONCENTRATOR ;
1166 sde->sde_type = SMT_SDE_STATION ;
1171 * fill in values in station state parameter
1173 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state)
1178 SMTSETPARA(state,SMT_P_STATE) ;
1181 /* determine topology */
1183 if (smc->mib.fddiSMTPeerWrapFlag) {
1184 top |= SMT_ST_WRAPPED ; /* state wrapped */
1187 if (cfm_status_unattached(smc)) {
1188 top |= SMT_ST_UNATTACHED ; /* unattached concentrator */
1191 if ((twist = pcm_status_twisted(smc)) & 1) {
1192 top |= SMT_ST_TWISTED_A ; /* twisted cable */
1195 top |= SMT_ST_TWISTED_B ; /* twisted cable */
1200 if (pcm_rooted_station(smc))
1201 top |= SMT_ST_ROOTED_S ;
1202 if (smc->mib.a[0].fddiPATHSbaPayload != 0)
1203 top |= SMT_ST_SYNC_SERVICE ;
1204 state->st_topology = top ;
1205 state->st_dupl_addr =
1206 ((smc->mib.m[MAC0].fddiMACDA_Flag ? SMT_ST_MY_DUPA : 0 ) |
1207 (smc->mib.m[MAC0].fddiMACUNDA_Flag ? SMT_ST_UNA_DUPA : 0)) ;
1211 * fill values in timestamp parameter
1213 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts)
1216 SMTSETPARA(ts,SMT_P_TIMESTAMP) ;
1217 smt_set_timestamp(smc,ts->ts_time) ;
1220 void smt_set_timestamp(struct s_smc *smc, u_char *p)
1226 * timestamp is 64 bits long ; resolution is 80 nS
1227 * our clock resolution is 10mS
1228 * 10mS/80ns = 125000 ~ 2^17 = 131072
1230 utime = smt_get_time() ;
1231 time = utime * 100 ;
1232 time /= TICKS_PER_SECOND ;
1234 p[1] = (u_char)((time>>(8+8+8+8-1)) & 1) ;
1235 p[2] = (u_char)(time>>(8+8+8-1)) ;
1236 p[3] = (u_char)(time>>(8+8-1)) ;
1237 p[4] = (u_char)(time>>(8-1)) ;
1238 p[5] = (u_char)(time<<1) ;
1239 p[6] = (u_char)(smc->sm.uniq_ticks>>8) ;
1240 p[7] = (u_char)smc->sm.uniq_ticks ;
1242 * make sure we don't wrap: restart whenever the upper digits change
1244 if (utime != smc->sm.uniq_time) {
1245 smc->sm.uniq_ticks = 0 ;
1247 smc->sm.uniq_ticks++ ;
1248 smc->sm.uniq_time = utime ;
1252 * fill values in station policy parameter
1254 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy)
1262 * MIB para 101b (fddiSMTConnectionPolicy) coding
1263 * is different from 0005 coding
1265 static const u_char ansi_weirdness[16] = {
1266 0,7,5,3,8,1,6,4,9,10,2,11,12,13,14,15
1268 SMTSETPARA(policy,SMT_P_POLICY) ;
1271 in = smc->mib.fddiSMTConnectionPolicy ;
1272 for (i = 0, map = ansi_weirdness ; i < 16 ; i++) {
1278 policy->pl_config = smc->mib.fddiSMTConfigPolicy ;
1279 policy->pl_connect = out ;
1283 * fill values in latency equivalent parameter
1285 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency)
1287 SMTSETPARA(latency,SMT_P_LATENCY) ;
1289 latency->lt_phyout_idx1 = phy_index(smc,0) ;
1290 latency->lt_latency1 = 10 ; /* in octets (byte clock) */
1292 * note: latency has two phy entries by definition
1293 * for a SAS, the 2nd one is null
1295 if (smc->s.sas == SMT_DAS) {
1296 latency->lt_phyout_idx2 = phy_index(smc,1) ;
1297 latency->lt_latency2 = 10 ; /* in octets (byte clock) */
1300 latency->lt_phyout_idx2 = 0 ;
1301 latency->lt_latency2 = 0 ;
1306 * fill values in MAC neighbors parameter
1308 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor)
1310 SMTSETPARA(neighbor,SMT_P_NEIGHBORS) ;
1312 neighbor->nb_mib_index = INDEX_MAC ;
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 ;
1319 * fill values in path descriptor
1322 #define ALLPHYS NUMPHYS
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)
1329 SK_LOC_DECL(int,type) ;
1330 SK_LOC_DECL(int,state) ;
1331 SK_LOC_DECL(int,remote) ;
1332 SK_LOC_DECL(int,mac) ;
1336 struct smt_phy_rec *phy ;
1337 struct smt_mac_rec *pd_mac ;
1340 sizeof(struct smt_mac_rec) * NUMMACS +
1341 sizeof(struct smt_phy_rec) * ALLPHYS ;
1342 path->para.p_type = SMT_P_PATH ;
1343 path->para.p_len = len - PARA_LEN ;
1346 for (p = 0,phy = path->pd_phy ; p < ALLPHYS ; p++, phy++) {
1348 #ifndef CONCENTRATOR
1349 if (smc->s.sas == SMT_SAS)
1352 pcm_status_state(smc,physp,&type,&state,&remote,&mac) ;
1353 #ifdef LITTLE_ENDIAN
1354 phy->phy_mib_index = smt_swap_short((u_short)p+INDEX_PORT) ;
1356 phy->phy_mib_index = p+INDEX_PORT ;
1358 phy->phy_type = type ;
1359 phy->phy_connect_state = state ;
1360 phy->phy_remote_type = remote ;
1361 phy->phy_remote_mac = mac ;
1362 phy->phy_resource_idx = phy_con_resource_index(smc,p) ;
1366 pd_mac = (struct smt_mac_rec *) phy ;
1367 pd_mac->mac_addr = smc->mib.m[MAC0].fddiMACSMTAddress ;
1368 pd_mac->mac_resource_idx = mac_con_resource_index(smc,1) ;
1373 * fill values in mac status
1375 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st)
1377 SMTSETPARA(st,SMT_P_MAC_STATUS) ;
1379 st->st_mib_index = INDEX_MAC ;
1380 st->st_mac_index = mac_index(smc,1) ;
1382 mac_update_counter(smc) ;
1384 * timer values are represented in SMT as 2's complement numbers
1385 * units : internal : 2's complement BCLK
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 ;
1400 * fill values in LEM status
1402 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy)
1404 struct fddi_mib_p *mib ;
1406 mib = smc->y[phy].mib ;
1408 SMTSETPARA(lem,SMT_P_LEM) ;
1409 lem->lem_mib_index = phy+INDEX_PORT ;
1410 lem->lem_phy_index = phy_index(smc,phy) ;
1412 lem->lem_cutoff = mib->fddiPORTLer_Cutoff ;
1413 lem->lem_alarm = mib->fddiPORTLer_Alarm ;
1414 /* long term bit error rate */
1415 lem->lem_estimate = mib->fddiPORTLer_Estimate ;
1416 /* # of rejected connections */
1417 lem->lem_reject_ct = mib->fddiPORTLem_Reject_Ct ;
1418 lem->lem_ct = mib->fddiPORTLem_Ct ; /* total number of errors */
1422 * fill version parameter
1424 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers)
1427 SMTSETPARA(vers,SMT_P_VERSION) ;
1429 vers->v_n = 1 ; /* one version is enough .. */
1431 vers->v_version[0] = SMT_VID_2 ;
1437 * fill frame status capabilities
1440 * note: this para 200B is NOT in swap table, because it's also set in
1443 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc)
1446 SMTSETPARA(fsc,SMT_P_FSC) ;
1448 fsc->fsc_mac_index = INDEX_MAC ; /* this is MIB ; MIB is NOT
1452 fsc->fsc_value = FSC_TYPE0 ; /* "normal" node */
1453 #ifdef LITTLE_ENDIAN
1454 fsc->fsc_mac_index = smt_swap_short(INDEX_MAC) ;
1455 fsc->fsc_value = smt_swap_short(FSC_TYPE0) ;
1461 * fill mac counter field
1463 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc)
1465 SMTSETPARA(mc,SMT_P_MAC_COUNTER) ;
1466 mc->mc_mib_index = INDEX_MAC ;
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 ;
1473 * fill mac frame not copied counter
1475 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc)
1477 SMTSETPARA(fnc,SMT_P_MAC_FNC) ;
1478 fnc->nc_mib_index = INDEX_MAC ;
1479 fnc->nc_index = mac_index(smc,1) ;
1480 fnc->nc_counter = smc->mib.m[MAC0].fddiMACNotCopied_Ct ;
1485 * fill manufacturer field
1487 static void smt_fill_manufacturer(struct s_smc *smc,
1488 struct smp_p_manufacturer *man)
1490 SMTSETPARA(man,SMT_P_MANUFACTURER) ;
1491 memcpy((char *) man->mf_data,
1492 (char *) smc->mib.fddiSMTManufacturerData,
1493 sizeof(man->mf_data)) ;
1499 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user)
1501 SMTSETPARA(user,SMT_P_USER) ;
1502 memcpy((char *) user->us_data,
1503 (char *) smc->mib.fddiSMTUserData,
1504 sizeof(user->us_data)) ;
1510 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount)
1513 SMTSETPARA(setcount,SMT_P_SETCOUNT) ;
1514 setcount->count = smc->mib.fddiSMTSetCount.count ;
1515 memcpy((char *)setcount->timestamp,
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,
1528 SMTSETPARA(echo,SMT_P_ECHODATA) ;
1529 echo->para.p_len = len ;
1530 for (p = echo->ec_data ; len ; len--) {
1531 *p++ = (u_char) seed ;
1538 * called from CFM if configuration changes
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)
1557 return tid & 0x3fffffffL;
1560 #ifdef LITTLE_ENDIAN
1562 * table of parameter lengths
1564 static const struct smt_pdef {
1569 { SMT_P_UNA, sizeof(struct smt_p_una) ,
1571 { SMT_P_SDE, sizeof(struct smt_p_sde) ,
1573 { SMT_P_STATE, sizeof(struct smt_p_state) ,
1574 SWAP_SMT_P_STATE } ,
1575 { SMT_P_TIMESTAMP,sizeof(struct smt_p_timestamp) ,
1576 SWAP_SMT_P_TIMESTAMP } ,
1577 { SMT_P_POLICY, sizeof(struct smt_p_policy) ,
1578 SWAP_SMT_P_POLICY } ,
1579 { SMT_P_LATENCY, sizeof(struct smt_p_latency) ,
1580 SWAP_SMT_P_LATENCY } ,
1581 { SMT_P_NEIGHBORS,sizeof(struct smt_p_neighbor) ,
1582 SWAP_SMT_P_NEIGHBORS } ,
1583 { SMT_P_PATH, sizeof(struct smt_p_path) ,
1585 { SMT_P_MAC_STATUS,sizeof(struct smt_p_mac_status) ,
1586 SWAP_SMT_P_MAC_STATUS } ,
1587 { SMT_P_LEM, sizeof(struct smt_p_lem) ,
1589 { SMT_P_MAC_COUNTER,sizeof(struct smt_p_mac_counter) ,
1590 SWAP_SMT_P_MAC_COUNTER } ,
1591 { SMT_P_MAC_FNC,sizeof(struct smt_p_mac_fnc) ,
1592 SWAP_SMT_P_MAC_FNC } ,
1593 { SMT_P_PRIORITY,sizeof(struct smt_p_priority) ,
1594 SWAP_SMT_P_PRIORITY } ,
1595 { SMT_P_EB,sizeof(struct smt_p_eb) ,
1597 { SMT_P_MANUFACTURER,sizeof(struct smp_p_manufacturer) ,
1598 SWAP_SMT_P_MANUFACTURER } ,
1599 { SMT_P_REASON, sizeof(struct smt_p_reason) ,
1600 SWAP_SMT_P_REASON } ,
1601 { SMT_P_REFUSED, sizeof(struct smt_p_refused) ,
1602 SWAP_SMT_P_REFUSED } ,
1603 { SMT_P_VERSION, sizeof(struct smt_p_version) ,
1604 SWAP_SMT_P_VERSION } ,
1606 { SMT_P0015, sizeof(struct smt_p_0015) , SWAP_SMT_P0015 } ,
1607 { SMT_P0016, sizeof(struct smt_p_0016) , SWAP_SMT_P0016 } ,
1608 { SMT_P0017, sizeof(struct smt_p_0017) , SWAP_SMT_P0017 } ,
1609 { SMT_P0018, sizeof(struct smt_p_0018) , SWAP_SMT_P0018 } ,
1610 { SMT_P0019, sizeof(struct smt_p_0019) , SWAP_SMT_P0019 } ,
1611 { SMT_P001A, sizeof(struct smt_p_001a) , SWAP_SMT_P001A } ,
1612 { SMT_P001B, sizeof(struct smt_p_001b) , SWAP_SMT_P001B } ,
1613 { SMT_P001C, sizeof(struct smt_p_001c) , SWAP_SMT_P001C } ,
1614 { SMT_P001D, sizeof(struct smt_p_001d) , SWAP_SMT_P001D } ,
1617 { SMT_P_FSC, sizeof(struct smt_p_fsc) ,
1621 { SMT_P_SETCOUNT,0, SWAP_SMT_P_SETCOUNT } ,
1622 { SMT_P1048, 0, SWAP_SMT_P1048 } ,
1623 { SMT_P208C, 0, SWAP_SMT_P208C } ,
1624 { SMT_P208D, 0, SWAP_SMT_P208D } ,
1625 { SMT_P208E, 0, SWAP_SMT_P208E } ,
1626 { SMT_P208F, 0, SWAP_SMT_P208F } ,
1627 { SMT_P2090, 0, SWAP_SMT_P2090 } ,
1629 { SMT_P320B, sizeof(struct smt_p_320b) , SWAP_SMT_P320B } ,
1630 { SMT_P320F, sizeof(struct smt_p_320f) , SWAP_SMT_P320F } ,
1631 { SMT_P3210, sizeof(struct smt_p_3210) , SWAP_SMT_P3210 } ,
1633 { SMT_P4050, 0, SWAP_SMT_P4050 } ,
1634 { SMT_P4051, 0, SWAP_SMT_P4051 } ,
1635 { SMT_P4052, 0, SWAP_SMT_P4052 } ,
1636 { SMT_P4053, 0, SWAP_SMT_P4053 } ,
1639 #define N_SMT_PLEN ARRAY_SIZE(smt_pdef)
1642 int smt_check_para(struct s_smc *smc, struct smt_header *sm,
1643 const u_short list[])
1645 const u_short *p = list ;
1647 if (!sm_to_para(smc,sm,(int) *p)) {
1648 DB_SMT("SMT: smt_check_para - missing para %hx", *p);
1656 void *sm_to_para(struct s_smc *smc, struct smt_header *sm, int para)
1666 p = (char *)(sm+1) ; /* pointer to info */
1668 if (((struct smt_para *)p)->p_type == para)
1669 found = (void *) p ;
1670 plen = ((struct smt_para *)p)->p_len + PARA_LEN ;
1674 DB_SMT("SMT : sm_to_para - length error %d", plen);
1677 if ((plen & 3) && (para != SMT_P_ECHODATA)) {
1678 DB_SMT("SMT : sm_to_para - odd length %d", plen);
1689 * send ANTC data test frame
1691 void fddi_send_antc(struct s_smc *smc, struct fddi_addr *dest)
1697 struct smt_header *smt ;
1701 mb = smt_get_mbuf() ;
1702 mb->sm_len = 3000+12 ;
1703 p = smtod(mb, char *) + 12 ;
1704 for (i = 0 ; i < 3000 ; i++)
1707 smt = smtod(mb, struct smt_header *) ;
1708 smt->smt_dest = *dest ;
1709 smt->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
1710 smt_send_mbuf(smc,mb,FC_ASYNC_LLC) ;
1716 * return static mac index
1718 static int mac_index(struct s_smc *smc, int mac)
1725 return (smc->s.sas == SMT_SAS) ? 2 : 3;
1730 * return static phy index
1732 static int phy_index(struct s_smc *smc, int phy)
1739 * return dynamic mac connection resource index
1741 static int mac_con_resource_index(struct s_smc *smc, int mac)
1746 return entity_to_index(smc, cem_get_downstream(smc, ENTITY_MAC));
1749 switch (smc->mib.fddiSMTCF_State) {
1752 case SC11_C_WRAP_S :
1754 case SC10_C_WRAP_B :
1758 return smc->s.sas == SMT_SAS ? 2 : 3;
1763 * return dynamic phy connection resource index
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) {
1772 return phy == PA ? 3 : 2;
1773 case SC10_C_WRAP_B :
1774 return phy == PA ? 1 : 3;
1776 return phy == PA ? 3 : 1;
1778 return phy == PA ? 2 : 3;
1779 case SC11_C_WRAP_S :
1787 static int entity_to_index(struct s_smc *smc, int e)
1789 if (e == ENTITY_MAC)
1790 return mac_index(smc, 1);
1792 return phy_index(smc, e - ENTITY_PHY(0));
1796 #ifdef LITTLE_ENDIAN
1797 static int smt_swap_short(u_short s)
1799 return ((s>>8)&0xff) | ((s&0xff)<<8);
1802 void smt_swap_para(struct smt_header *sm, int len, int direction)
1803 /* int direction; 0 encode 1 decode */
1805 struct smt_para *pa ;
1806 const struct smt_pdef *pd ;
1812 /* printf("smt_swap_para sm %x len %d dir %d\n",
1815 smt_string_swap((char *)sm,SWAP_SMTHEADER,len) ;
1818 len -= sizeof(struct smt_header) ;
1820 p = (char *) (sm + 1) ;
1822 pa = (struct smt_para *) p ;
1825 pa->p_type = smt_swap_short(pa->p_type) ;
1826 pa->p_len = smt_swap_short(pa->p_len) ;
1832 * note: paras can have 0 length !
1837 for (i = N_SMT_PLEN, pd = smt_pdef; i ; i--,pd++) {
1838 if (pd->ptype == type)
1841 if (i && pd->pswap) {
1842 smt_string_swap(p+PARA_LEN,pd->pswap,len) ;
1849 static void smt_string_swap(char *data, const char *format, int len)
1851 const char *open_paren = NULL ;
1854 while (len > 0 && *format) {
1857 open_paren = format ;
1860 format = open_paren ;
1871 data += *format - '0' ;
1872 len -= *format - '0' ;
1900 void smt_swap_para(struct smt_header *sm, int len, int direction)
1901 /* int direction; 0 encode 1 decode */
1905 SK_UNUSED(direction) ;
1912 int smt_action(struct s_smc *smc, int class, int code, int index)
1916 DB_SMT("SMT: action %d code %d", class, code);
1918 case SMT_STATION_ACTION :
1920 case SMT_STATION_ACTION_CONNECT :
1921 smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
1922 queue_event(smc,EVENT_ECM,EC_CONNECT) ;
1924 case SMT_STATION_ACTION_DISCONNECT :
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)
1929 FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_DISCONNECT,
1930 smt_get_event_word(smc));
1932 case SMT_STATION_ACTION_PATHTEST :
1933 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1934 FDDI_SMT_EVENT, (u_long) FDDI_PATH_TEST,
1935 smt_get_event_word(smc));
1937 case SMT_STATION_ACTION_SELFTEST :
1938 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1939 FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_SELF_TEST,
1940 smt_get_event_word(smc));
1942 case SMT_STATION_ACTION_DISABLE_A :
1943 if (smc->y[PA].pc_mode == PM_PEER) {
1944 RS_SET(smc,RS_EVENT) ;
1945 queue_event(smc,EVENT_PCM+PA,PC_DISABLE) ;
1948 case SMT_STATION_ACTION_DISABLE_B :
1949 if (smc->y[PB].pc_mode == PM_PEER) {
1950 RS_SET(smc,RS_EVENT) ;
1951 queue_event(smc,EVENT_PCM+PB,PC_DISABLE) ;
1954 case SMT_STATION_ACTION_DISABLE_M :
1955 for (port = 0 ; port < NUMPHYS ; port++) {
1956 if (smc->mib.p[port].fddiPORTMy_Type != TM)
1958 RS_SET(smc,RS_EVENT) ;
1959 queue_event(smc,EVENT_PCM+port,PC_DISABLE) ;
1966 case SMT_PORT_ACTION :
1968 case SMT_PORT_ACTION_ENABLE :
1971 case SMT_PORT_ACTION_DISABLE :
1972 event = PC_DISABLE ;
1974 case SMT_PORT_ACTION_MAINT :
1977 case SMT_PORT_ACTION_START :
1980 case SMT_PORT_ACTION_STOP :
1986 queue_event(smc,EVENT_PCM+index,event) ;
1995 * canonical conversion of <len> bytes beginning form *data
1998 static void hwm_conv_can(struct s_smc *smc, char *data, int len)
2004 for (i = len; i ; i--, data++)
2005 *data = bitrev8(*data);
2009 #endif /* no SLIM_SMT */