1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /******************************************************************************
3   *
4   *	(C)Copyright 1998,1999 SysKonnect,
5   *	a business unit of Schneider & Koch & Co. Datensysteme GmbH.
6   *
7   *	See the file "skfddi.c" for further information.
8   *
9   *	The information in this file is provided "AS IS" without warranty.
10   *
11   ******************************************************************************/
12  
13  #include "h/types.h"
14  #include "h/fddi.h"
15  #include "h/smc.h"
16  #include "h/smt_p.h"
17  #include <linux/bitrev.h>
18  #include <linux/kernel.h>
19  
20  #define KERNEL
21  #include "h/smtstate.h"
22  
23  /*
24   * FC in SMbuf
25   */
26  #define m_fc(mb)	((mb)->sm_data[0])
27  
28  #define SMT_TID_MAGIC	0x1f0a7b3c
29  
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"
35  } ;
36  
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"
40  } ;
41  
42  #define LAST_CLASS	(SMT_PMF_SET)
43  
44  static const struct fddi_addr SMT_Unknown = {
45  	{ 0,0,0x1f,0,0,0 }
46  } ;
47  
48  /*
49   * function prototypes
50   */
51  #ifdef	LITTLE_ENDIAN
52  static int smt_swap_short(u_short s);
53  #endif
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,
59  			 int local);
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);
69  #ifdef LITTLE_ENDIAN
70  static void smt_string_swap(char *data, const char *format, int len);
71  #endif
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,
92  			  int len);
93  
94  static void smt_clear_una_dna(struct s_smc *smc);
95  static void smt_clear_old_una_dna(struct s_smc *smc);
96  #ifdef	CONCENTRATOR
97  static int entity_to_index(void);
98  #endif
99  static void update_dac(struct s_smc *smc, int report);
100  static int div_ratio(u_long upper, u_long lower);
101  #ifdef  USE_CAN_ADDR
102  static void	hwm_conv_can(struct s_smc *smc, char *data, int len);
103  #else
104  #define		hwm_conv_can(smc,data,len)
105  #endif
106  
107  
is_my_addr(const struct s_smc * smc,const struct fddi_addr * addr)108  static inline int is_my_addr(const struct s_smc *smc,
109  			     const struct fddi_addr *addr)
110  {
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])) ;
117  }
118  
is_broadcast(const struct fddi_addr * addr)119  static inline int is_broadcast(const struct fddi_addr *addr)
120  {
121  	return *(u_short *)(&addr->a[0]) == 0xffff &&
122  	       *(u_short *)(&addr->a[2]) == 0xffff &&
123  	       *(u_short *)(&addr->a[4]) == 0xffff;
124  }
125  
is_individual(const struct fddi_addr * addr)126  static inline int is_individual(const struct fddi_addr *addr)
127  {
128  	return !(addr->a[0] & GROUP_ADDR);
129  }
130  
is_equal(const struct fddi_addr * addr1,const struct fddi_addr * addr2)131  static inline int is_equal(const struct fddi_addr *addr1,
132  			   const struct fddi_addr *addr2)
133  {
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]);
137  }
138  
139  /*
140   * list of mandatory paras in frames
141   */
142  static const u_short plist_nif[] = { SMT_P_UNA,SMT_P_SDE,SMT_P_STATE,0 } ;
143  
144  /*
145   * init SMT agent
146   */
smt_agent_init(struct s_smc * smc)147  void smt_agent_init(struct s_smc *smc)
148  {
149  	int		i ;
150  
151  	/*
152  	 * get MAC address
153  	 */
154  	smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
155  
156  	/*
157  	 * get OUI address from driver (bia == built-in-address)
158  	 */
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]);
165  	}
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 ;
175  #ifndef	SLIM_SMT
176  	smt_clear_una_dna(smc) ;
177  	smt_clear_old_una_dna(smc) ;
178  #endif
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 ;
183  }
184  
185  /*
186   * SMT task
187   * forever
188   *	delay 30 seconds
189   *	send NIF
190   *	check tvu & tvd
191   * end
192   */
smt_agent_task(struct s_smc * smc)193  void smt_agent_task(struct s_smc *smc)
194  {
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");
198  }
199  
200  #ifndef SMT_REAL_TOKEN_CT
smt_emulate_token_ct(struct s_smc * smc,int mac_index)201  void smt_emulate_token_ct(struct s_smc *smc, int mac_index)
202  {
203  	u_long	count;
204  	u_long	time;
205  
206  
207  	time = smt_get_time();
208  	count =	((time - smc->sm.last_tok_time[mac_index]) *
209  					100)/TICKS_PER_SECOND;
210  
211  	/*
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
215  	 * one MAC instance.
216  	 */
217  	if (smc->hw.mac_ring_is_up){
218  		smc->mib.m[mac_index].fddiMACToken_Ct += count;
219  	}
220  
221  	/* Remember current time */
222  	smc->sm.last_tok_time[mac_index] = time;
223  
224  }
225  #endif
226  
227  /*ARGSUSED1*/
smt_event(struct s_smc * smc,int event)228  void smt_event(struct s_smc *smc, int event)
229  {
230  	u_long		time ;
231  #ifndef SMT_REAL_TOKEN_CT
232  	int		i ;
233  #endif
234  
235  
236  	if (smc->sm.please_reconnect) {
237  		smc->sm.please_reconnect -- ;
238  		if (smc->sm.please_reconnect == 0) {
239  			/* Counted down */
240  			queue_event(smc,EVENT_ECM,EC_CONNECT) ;
241  		}
242  	}
243  
244  	if (event == SM_FAST)
245  		return ;
246  
247  	/*
248  	 * timer for periodic cleanup in driver
249  	 * reset and start the watchdog (FM2)
250  	 * ESS timer
251  	 * SBA timer
252  	 */
253  	smt_timer_poll(smc) ;
254  	smt_start_watchdog(smc) ;
255  #ifndef	SLIM_SMT
256  #ifndef BOOT
257  #ifdef	ESS
258  	ess_timer_poll(smc) ;
259  #endif
260  #endif
261  #ifdef	SBA
262  	sba_timer_poll(smc) ;
263  #endif
264  
265  	smt_srf_event(smc,0,0,0) ;
266  
267  #endif	/* no SLIM_SMT */
268  
269  	time = smt_get_time() ;
270  
271  	if (time - smc->sm.smt_last_lem >= TICKS_PER_SECOND*8) {
272  		/*
273  		 * Use 8 sec. for the time intervall, it simplifies the
274  		 * LER estimation.
275  		 */
276  		struct fddi_mib_m	*mib ;
277  		u_long			upper ;
278  		u_long			lower ;
279  		int			cond ;
280  		int			port;
281  		struct s_phy		*phy ;
282  		/*
283  		 * calculate LEM bit error rate
284  		 */
285  		sm_lem_evaluate(smc) ;
286  		smc->sm.smt_last_lem = time ;
287  
288  		/*
289  		 * check conditions
290  		 */
291  #ifndef	SLIM_SMT
292  		mac_update_counter(smc) ;
293  		mib = smc->mib.m ;
294  		upper =
295  		(mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) +
296  		(mib->fddiMACError_Ct - mib->fddiMACOld_Error_Ct) ;
297  		lower =
298  		(mib->fddiMACFrame_Ct - mib->fddiMACOld_Frame_Ct) +
299  		(mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) ;
300  		mib->fddiMACFrameErrorRatio = div_ratio(upper,lower) ;
301  
302  		cond =
303  			((!mib->fddiMACFrameErrorThreshold &&
304  			mib->fddiMACError_Ct != mib->fddiMACOld_Error_Ct) ||
305  			(mib->fddiMACFrameErrorRatio >
306  			mib->fddiMACFrameErrorThreshold)) ;
307  
308  		if (cond != mib->fddiMACFrameErrorFlag)
309  			smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
310  				INDEX_MAC,cond) ;
311  
312  		upper =
313  		(mib->fddiMACNotCopied_Ct - mib->fddiMACOld_NotCopied_Ct) ;
314  		lower =
315  		upper +
316  		(mib->fddiMACCopied_Ct - mib->fddiMACOld_Copied_Ct) ;
317  		mib->fddiMACNotCopiedRatio = div_ratio(upper,lower) ;
318  
319  		cond =
320  			((!mib->fddiMACNotCopiedThreshold &&
321  			mib->fddiMACNotCopied_Ct !=
322  				mib->fddiMACOld_NotCopied_Ct)||
323  			(mib->fddiMACNotCopiedRatio >
324  			mib->fddiMACNotCopiedThreshold)) ;
325  
326  		if (cond != mib->fddiMACNotCopiedFlag)
327  			smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
328  				INDEX_MAC,cond) ;
329  
330  		/*
331  		 * set old values
332  		 */
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 ;
338  
339  		/*
340  		 * Check port EBError Condition
341  		 */
342  		for (port = 0; port < NUMPHYS; port ++) {
343  			phy = &smc->y[port] ;
344  
345  			if (!phy->mib->fddiPORTHardwarePresent) {
346  				continue;
347  			}
348  
349  			cond = (phy->mib->fddiPORTEBError_Ct -
350  				phy->mib->fddiPORTOldEBError_Ct > 5) ;
351  
352  			/* If ratio is more than 5 in 8 seconds
353  			 * Set the condition.
354  			 */
355  			smt_srf_event(smc,SMT_COND_PORT_EB_ERROR,
356  				(int) (INDEX_PORT+ phy->np) ,cond) ;
357  
358  			/*
359  			 * set old values
360  			 */
361  			phy->mib->fddiPORTOldEBError_Ct =
362  				phy->mib->fddiPORTEBError_Ct ;
363  		}
364  
365  #endif	/* no SLIM_SMT */
366  	}
367  
368  #ifndef	SLIM_SMT
369  
370  	if (time - smc->sm.smt_last_notify >= (u_long)
371  		(smc->mib.fddiSMTTT_Notify * TICKS_PER_SECOND) ) {
372  		/*
373  		 * we can either send an announcement or a request
374  		 * a request will trigger a reply so that we can update
375  		 * our dna
376  		 * note: same tid must be used until reply is received
377  		 */
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 ;
383  	}
384  
385  	/*
386  	 * check timer
387  	 */
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 ;
392  
393  		if (!is_equal(&smc->mib.m[MAC0].fddiMACUpstreamNbr,
394  			&SMT_Unknown)){
395  			/* Do not update unknown address */
396  			smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
397  				smc->mib.m[MAC0].fddiMACUpstreamNbr ;
398  		}
399  		smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
400  		smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
401  		/*
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
405  		 * condition
406  		 */
407  		update_dac(smc,0) ;
408  		smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
409  			INDEX_MAC,0) ;
410  	}
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,
416  			&SMT_Unknown)){
417  			/* Do not update unknown address */
418  			smc->mib.m[MAC0].fddiMACOldDownstreamNbr=
419  				smc->mib.m[MAC0].fddiMACDownstreamNbr ;
420  		}
421  		smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
422  		smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
423  			INDEX_MAC,0) ;
424  	}
425  
426  #endif	/* no SLIM_SMT */
427  
428  #ifndef SMT_REAL_TOKEN_CT
429  	/*
430  	 * Token counter emulation section. If hardware supports the token
431  	 * count, the token counter will be updated in mac_update_counter.
432  	 */
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 );
436  		}
437  	}
438  #endif
439  
440  	smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
441  		EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
442  }
443  
div_ratio(u_long upper,u_long lower)444  static int div_ratio(u_long upper, u_long lower)
445  {
446  	if ((upper<<16L) < upper)
447  		upper = 0xffff0000L ;
448  	else
449  		upper <<= 16L ;
450  	if (!lower)
451  		return 0;
452  	return (int)(upper/lower) ;
453  }
454  
455  #ifndef	SLIM_SMT
456  
457  /*
458   * receive packet handler
459   */
smt_received_pack(struct s_smc * smc,SMbuf * mb,int fs)460  void smt_received_pack(struct s_smc *smc, SMbuf *mb, int fs)
461  /* int fs;  frame status */
462  {
463  	struct smt_header	*sm ;
464  	int			local ;
465  
466  	int			illegal = 0 ;
467  
468  	switch (m_fc(mb)) {
469  	case FC_SMT_INFO :
470  	case FC_SMT_LAN_LOC :
471  	case FC_SMT_LOC :
472  	case FC_SMT_NSA :
473  		break ;
474  	default :
475  		smt_free_mbuf(smc,mb) ;
476  		return ;
477  	}
478  
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) ;
483  
484  	/* check destination address */
485  	if (is_individual(&sm->smt_dest) && !is_my_addr(smc,&sm->smt_dest)) {
486  		smt_free_mbuf(smc,mb) ;
487  		return ;
488  	}
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) ;
493  		return ;
494  	}
495  #endif
496  
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",
501  	       sm->smt_version,
502  	       smt_class_name[sm->smt_class > LAST_CLASS ? 0 : sm->smt_class]);
503  
504  #ifdef	SBA
505  	/*
506  	 * check if NSA frame
507  	 */
508  	if (m_fc(mb) == FC_SMT_NSA && sm->smt_class == SMT_NIF &&
509  		(sm->smt_type == SMT_ANNOUNCE || sm->smt_type == SMT_REQUEST)) {
510  			smc->sba.sm = sm ;
511  			sba(smc,NIF) ;
512  	}
513  #endif
514  
515  	/*
516  	 * ignore any packet with NSA and A-indicator set
517  	 */
518  	if ( (fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) {
519  		DB_SMT("SMT : ignoring NSA with A-indicator set from %pM",
520  		       &sm->smt_source);
521  		smt_free_mbuf(smc,mb) ;
522  		return ;
523  	}
524  
525  	/*
526  	 * ignore frames with illegal length
527  	 */
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) ;
531  		return ;
532  	}
533  
534  	/*
535  	 * check SMT version
536  	 */
537  	switch (sm->smt_class) {
538  	case SMT_NIF :
539  	case SMT_SIF_CONFIG :
540  	case SMT_SIF_OPER :
541  	case SMT_ECF :
542  		if (sm->smt_version != SMT_VID)
543  			illegal = 1;
544  		break ;
545  	default :
546  		if (sm->smt_version != SMT_VID_2)
547  			illegal = 1;
548  		break ;
549  	}
550  	if (illegal) {
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) ;
555  		return ;
556  	}
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) ;
562  		return ;
563  	}
564  	switch (sm->smt_class) {
565  	case SMT_NIF :
566  		if (smt_check_para(smc,sm,plist_nif)) {
567  			DB_SMT("SMT: NIF with para problem, ignoring");
568  			break ;
569  		}
570  		switch (sm->smt_type) {
571  		case SMT_ANNOUNCE :
572  		case SMT_REQUEST :
573  			if (!(fs & C_INDICATOR) && m_fc(mb) == FC_SMT_NSA
574  				&& is_broadcast(&sm->smt_dest)) {
575  				struct smt_p_state	*st ;
576  
577  				/* set my UNA */
578  				if (!is_equal(
579  					&smc->mib.m[MAC0].fddiMACUpstreamNbr,
580  					&sm->smt_source)) {
581  					DB_SMT("SMT : updated my UNA = %pM",
582  					       &sm->smt_source);
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 ;
588  					}
589  
590  					smc->mib.m[MAC0].fddiMACUpstreamNbr =
591  						sm->smt_source ;
592  					smt_srf_event(smc,
593  						SMT_EVENT_MAC_NEIGHBOR_CHANGE,
594  						INDEX_MAC,0) ;
595  					smt_echo_test(smc,0) ;
596  				}
597  				smc->sm.smt_tvu = smt_get_time() ;
598  				st = (struct smt_p_state *)
599  					sm_to_para(smc,sm,SMT_P_STATE) ;
600  				if (st) {
601  					smc->mib.m[MAC0].fddiMACUNDA_Flag =
602  					(st->st_dupl_addr & SMT_ST_MY_DUPA) ?
603  					TRUE : FALSE ;
604  					update_dac(smc,1) ;
605  				}
606  			}
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",
612  				       &sm->smt_source);
613  				smt_send_nif(smc,&sm->smt_source,
614  					FC_SMT_INFO,
615  					sm->smt_tid,
616  					SMT_REPLY,local) ;
617  			}
618  			break ;
619  		case SMT_REPLY :
620  			DB_SMT("SMT : received NIF response from %pM",
621  			       &sm->smt_source);
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 =
626  					DA_FAILED ;
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) ;
631  				break ;
632  			}
633  			if (sm->smt_tid == smc->sm.pend[SMT_TID_NIF]) {
634  				smc->sm.pend[SMT_TID_NIF] = 0 ;
635  				/* set my DNA */
636  				if (!is_equal(
637  					&smc->mib.m[MAC0].fddiMACDownstreamNbr,
638  					&sm->smt_source)) {
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 ;
645  					}
646  
647  					smc->mib.m[MAC0].fddiMACDownstreamNbr =
648  						sm->smt_source ;
649  					smt_srf_event(smc,
650  						SMT_EVENT_MAC_NEIGHBOR_CHANGE,
651  						INDEX_MAC,0) ;
652  					smt_echo_test(smc,1) ;
653  				}
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 =
658  					DA_PASSED ;
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) ;
662  				}
663  			}
664  			else if (sm->smt_tid ==
665  				smc->sm.pend[SMT_TID_NIF_TEST]) {
666  				DB_SMT("SMT : NIF test TID ok");
667  			}
668  			else {
669  				DB_SMT("SMT : expected TID %lx, got %x",
670  				       smc->sm.pend[SMT_TID_NIF], sm->smt_tid);
671  			}
672  			break ;
673  		default :
674  			illegal = 2 ;
675  			break ;
676  		}
677  		break ;
678  	case SMT_SIF_CONFIG :	/* station information */
679  		if (sm->smt_type != SMT_REQUEST)
680  			break ;
681  		DB_SMT("SMT : replying to SIF Config request from %pM",
682  		       &sm->smt_source);
683  		smt_send_sif_config(smc,&sm->smt_source,sm->smt_tid,local) ;
684  		break ;
685  	case SMT_SIF_OPER :	/* station information */
686  		if (sm->smt_type != SMT_REQUEST)
687  			break ;
688  		DB_SMT("SMT : replying to SIF Operation request from %pM",
689  		       &sm->smt_source);
690  		smt_send_sif_operation(smc,&sm->smt_source,sm->smt_tid,local) ;
691  		break ;
692  	case SMT_ECF :		/* echo frame */
693  		switch (sm->smt_type) {
694  		case SMT_REPLY :
695  			smc->mib.priv.fddiPRIVECF_Reply_Rx++ ;
696  			DB_SMT("SMT: received ECF reply from %pM",
697  			       &sm->smt_source);
698  			if (sm_to_para(smc,sm,SMT_P_ECHODATA) == NULL) {
699  				DB_SMT("SMT: ECHODATA missing");
700  				break ;
701  			}
702  			if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
703  				DB_SMT("SMT : ECF test TID ok");
704  			}
705  			else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
706  				DB_SMT("SMT : ECF test UNA ok");
707  			}
708  			else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
709  				DB_SMT("SMT : ECF test DNA ok");
710  			}
711  			else {
712  				DB_SMT("SMT : expected TID %lx, got %x",
713  				       smc->sm.pend[SMT_TID_ECF],
714  				       sm->smt_tid);
715  			}
716  			break ;
717  		case SMT_REQUEST :
718  			smc->mib.priv.fddiPRIVECF_Req_Rx++ ;
719  			{
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,
723  					local) ;
724  				break ;
725  			}
726  			DB_SMT("SMT - sending ECF reply to %pM",
727  			       &sm->smt_source);
728  
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 */
736  			}
737  		default :
738  			illegal = 1 ;
739  			break ;
740  		}
741  		break ;
742  #ifndef	BOOT
743  	case SMT_RAF :		/* resource allocation */
744  #ifdef	ESS
745  		DB_ESSN(2, "ESS: RAF frame received");
746  		fs = ess_raf_received_pack(smc,mb,sm,fs) ;
747  #endif
748  
749  #ifdef	SBA
750  		DB_SBAN(2, "SBA: RAF frame received") ;
751  		sba_raf_received_pack(smc,sm,fs) ;
752  #endif
753  		break ;
754  	case SMT_RDF :		/* request denied */
755  		smc->mib.priv.fddiPRIVRDF_Rx++ ;
756  		break ;
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) ;
761  		}
762  		break ;
763  	case SMT_PMF_GET :
764  	case SMT_PMF_SET :
765  		if (sm->smt_type != SMT_REQUEST)
766  			break ;
767  		/* update statistics */
768  		if (sm->smt_class == SMT_PMF_GET)
769  			smc->mib.priv.fddiPRIVPMF_Get_Rx++ ;
770  		else
771  			smc->mib.priv.fddiPRIVPMF_Set_Rx++ ;
772  		/*
773  		 * ignore PMF SET with I/G set
774  		 */
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");
778  			break ;
779  		}
780  		smt_pmf_received_pack(smc,mb, local) ;
781  		break ;
782  	case SMT_SRF :
783  		dump_smt(smc,sm,"SRF received") ;
784  		break ;
785  	default :
786  		if (sm->smt_type != SMT_REQUEST)
787  			break ;
788  		/*
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.
792  		 */
793  		DB_SMT("SMT : class = %d, send RDF to %pM",
794  		       sm->smt_class, &sm->smt_source);
795  
796  		smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
797  		break ;
798  #endif
799  	}
800  	if (illegal) {
801  		DB_SMT("SMT: discarding invalid frame, reason = %d", illegal);
802  	}
803  	smt_free_mbuf(smc,mb) ;
804  }
805  
update_dac(struct s_smc * smc,int report)806  static void update_dac(struct s_smc *smc, int report)
807  {
808  	int	cond ;
809  
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) ;
814  	else
815  		smc->mib.m[MAC0].fddiMACDuplicateAddressCond = cond ;
816  }
817  
818  /*
819   * send SMT frame
820   *	set source address
821   *	set station ID
822   *	send frame
823   */
smt_send_frame(struct s_smc * smc,SMbuf * mb,int fc,int local)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 */
827  {
828  	struct smt_header	*sm ;
829  
830  	if (!smc->r.sm_ma_avail && !local) {
831  		smt_free_mbuf(smc,mb) ;
832  		return ;
833  	}
834  	sm = smtod(mb,struct smt_header *) ;
835  	sm->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
836  	sm->smt_sid = smc->mib.fddiSMTStationId ;
837  
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) ;
842  }
843  
844  /*
845   * generate and send RDF
846   */
smt_send_rdf(struct s_smc * smc,SMbuf * rej,int fc,int reason,int local)847  static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
848  			 int local)
849  /* SMbuf *rej;	mbuf of offending frame */
850  /* int fc;	FC of denied frame */
851  /* int reason;	reason code */
852  {
853  	SMbuf	*mb ;
854  	struct smt_header	*sm ;	/* header of offending frame */
855  	struct smt_rdf	*rdf ;
856  	int		len ;
857  	int		frame_len ;
858  
859  	sm = smtod(rej,struct smt_header *) ;
860  	if (sm->smt_type != SMT_REQUEST)
861  		return ;
862  
863  	DB_SMT("SMT: sending RDF to %pM,reason = 0x%x",
864  	       &sm->smt_source, reason);
865  
866  
867  	/*
868  	 * note: get framelength from MAC length, NOT from SMT header
869  	 * smt header length is included in sm_len
870  	 */
871  	frame_len = rej->sm_len ;
872  
873  	if (!(mb=smt_build_frame(smc,SMT_RDF,SMT_REPLY,sizeof(struct smt_rdf))))
874  		return ;
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 */
878  
879  	/* set P12 */
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 ;
883  
884  	/* set P14 */
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 ;
892  
893  	/* set P13 */
894  	if ((unsigned int) frame_len <= SMT_MAX_INFO_LEN - sizeof(*rdf) +
895  		2*sizeof(struct smt_header))
896  		len = frame_len ;
897  	else
898  		len = SMT_MAX_INFO_LEN - sizeof(*rdf) +
899  			2*sizeof(struct smt_header) ;
900  	/* make length multiple of 4 */
901  	len &= ~3 ;
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 ;
906  
907  	/* swap it back */
908  	smt_swap_para(sm,frame_len,0) ;
909  
910  	memcpy((char *) &rdf->refused.ref_header,(char *) sm,len) ;
911  
912  	len -= sizeof(struct smt_header) ;
913  	mb->sm_len += len ;
914  	rdf->smt.smt_len += len ;
915  
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) ;
919  }
920  
921  /*
922   * generate and send NIF
923   */
smt_send_nif(struct s_smc * smc,const struct fddi_addr * dest,int fc,u_long tid,int type,int local)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 */
930  {
931  	struct smt_nif	*nif ;
932  	SMbuf		*mb ;
933  
934  	if (!(mb = smt_build_frame(smc,SMT_NIF,type,sizeof(struct smt_nif))))
935  		return ;
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 */
940  #ifdef	SMT6_10
941  	smt_fill_fsc(smc,&nif->fsc) ;	/* set frame status cap. */
942  #endif
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) ;
947  }
948  
949  #ifdef	DEBUG
950  /*
951   * send NIF request (test purpose)
952   */
smt_send_nif_request(struct s_smc * smc,struct fddi_addr * dest)953  static void smt_send_nif_request(struct s_smc *smc, struct fddi_addr *dest)
954  {
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],
957  		SMT_REQUEST,0) ;
958  }
959  
960  /*
961   * send ECF request (test purpose)
962   */
smt_send_ecf_request(struct s_smc * smc,struct fddi_addr * dest,int len)963  static void smt_send_ecf_request(struct s_smc *smc, struct fddi_addr *dest,
964  				 int len)
965  {
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],
968  		SMT_REQUEST,len) ;
969  }
970  #endif
971  
972  /*
973   * echo test
974   */
smt_echo_test(struct s_smc * smc,int dna)975  static void smt_echo_test(struct s_smc *smc, int dna)
976  {
977  	u_long	tid ;
978  
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) ;
985  }
986  
987  /*
988   * generate and send ECF
989   */
smt_send_ecf(struct s_smc * smc,struct fddi_addr * dest,int fc,u_long tid,int type,int len)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 */
997  {
998  	struct smt_ecf	*ecf ;
999  	SMbuf		*mb ;
1000  
1001  	if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
1002  		return ;
1003  	ecf = smtod(mb, struct smt_ecf *) ;
1004  
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) ;
1010  }
1011  
1012  /*
1013   * generate and send SIF config response
1014   */
1015  
smt_send_sif_config(struct s_smc * smc,struct fddi_addr * dest,u_long tid,int local)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 */
1020  {
1021  	struct smt_sif_config	*sif ;
1022  	SMbuf			*mb ;
1023  	int			len ;
1024  	if (!(mb = smt_build_frame(smc,SMT_SIF_CONFIG,SMT_REPLY,
1025  		SIZEOF_SMT_SIF_CONFIG)))
1026  		return ;
1027  
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) ;
1043  }
1044  
1045  /*
1046   * generate and send SIF operation response
1047   */
1048  
smt_send_sif_operation(struct s_smc * smc,struct fddi_addr * dest,u_long tid,int local)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 */
1053  {
1054  	struct smt_sif_operation *sif ;
1055  	SMbuf			*mb ;
1056  	int			ports ;
1057  	int			i ;
1058  
1059  	ports = NUMPHYS ;
1060  #ifndef	CONCENTRATOR
1061  	if (smc->s.sas == SMT_SAS)
1062  		ports = 1 ;
1063  #endif
1064  
1065  	if (!(mb = smt_build_frame(smc,SMT_SIF_OPER,SMT_REPLY,
1066  				   struct_size(sif, lem, ports))))
1067  		return ;
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 */
1076  	/*
1077  	 * set link error mon information
1078  	 */
1079  	if (ports == 1) {
1080  		smt_fill_lem(smc,sif->lem,PS) ;
1081  	}
1082  	else {
1083  		for (i = 0 ; i < ports ; i++) {
1084  			smt_fill_lem(smc,&sif->lem[i],i) ;
1085  		}
1086  	}
1087  
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) ;
1092  }
1093  
1094  /*
1095   * get and initialize SMT frame
1096   */
smt_build_frame(struct s_smc * smc,int class,int type,int length)1097  SMbuf *smt_build_frame(struct s_smc *smc, int class, int type,
1098  				  int length)
1099  {
1100  	SMbuf			*mb ;
1101  	struct smt_header	*smt ;
1102  
1103  #if	0
1104  	if (!smc->r.sm_ma_avail) {
1105  		return 0;
1106  	}
1107  #endif
1108  	if (!(mb = smt_get_mbuf(smc)))
1109  		return mb;
1110  
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 ;
1116  	switch (class) {
1117  	case SMT_NIF :
1118  	case SMT_SIF_CONFIG :
1119  	case SMT_SIF_OPER :
1120  	case SMT_ECF :
1121  		smt->smt_version = SMT_VID ;
1122  		break ;
1123  	default :
1124  		smt->smt_version = SMT_VID_2 ;
1125  		break ;
1126  	}
1127  	smt->smt_tid = smt_get_tid(smc) ;	/* set transaction ID */
1128  	smt->smt_pad = 0 ;
1129  	smt->smt_len = length - sizeof(struct smt_header) ;
1130  	return mb;
1131  }
1132  
smt_add_frame_len(SMbuf * mb,int len)1133  static void smt_add_frame_len(SMbuf *mb, int len)
1134  {
1135  	struct smt_header	*smt ;
1136  
1137  	smt = smtod(mb, struct smt_header *) ;
1138  	smt->smt_len += len ;
1139  	mb->sm_len += len ;
1140  }
1141  
1142  
1143  
1144  /*
1145   * fill values in UNA parameter
1146   */
smt_fill_una(struct s_smc * smc,struct smt_p_una * una)1147  static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una)
1148  {
1149  	SMTSETPARA(una,SMT_P_UNA) ;
1150  	una->una_pad = 0 ;
1151  	una->una_node = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1152  }
1153  
1154  /*
1155   * fill values in SDE parameter
1156   */
smt_fill_sde(struct s_smc * smc,struct smt_p_sde * sde)1157  static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde)
1158  {
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 */
1163  #ifdef	CONCENTRATOR
1164  	sde->sde_type = SMT_SDE_CONCENTRATOR ;
1165  #else
1166  	sde->sde_type = SMT_SDE_STATION ;
1167  #endif
1168  }
1169  
1170  /*
1171   * fill in values in station state parameter
1172   */
smt_fill_state(struct s_smc * smc,struct smt_p_state * state)1173  static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state)
1174  {
1175  	int	top ;
1176  	int	twist ;
1177  
1178  	SMTSETPARA(state,SMT_P_STATE) ;
1179  	state->st_pad = 0 ;
1180  
1181  	/* determine topology */
1182  	top = 0 ;
1183  	if (smc->mib.fddiSMTPeerWrapFlag) {
1184  		top |= SMT_ST_WRAPPED ;		/* state wrapped */
1185  	}
1186  #ifdef	CONCENTRATOR
1187  	if (cfm_status_unattached(smc)) {
1188  		top |= SMT_ST_UNATTACHED ;	/* unattached concentrator */
1189  	}
1190  #endif
1191  	if ((twist = pcm_status_twisted(smc)) & 1) {
1192  		top |= SMT_ST_TWISTED_A ;	/* twisted cable */
1193  	}
1194  	if (twist & 2) {
1195  		top |= SMT_ST_TWISTED_B ;	/* twisted cable */
1196  	}
1197  #ifdef	OPT_SRF
1198  	top |= SMT_ST_SRF ;
1199  #endif
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)) ;
1208  }
1209  
1210  /*
1211   * fill values in timestamp parameter
1212   */
smt_fill_timestamp(struct s_smc * smc,struct smt_p_timestamp * ts)1213  static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts)
1214  {
1215  
1216  	SMTSETPARA(ts,SMT_P_TIMESTAMP) ;
1217  	smt_set_timestamp(smc,ts->ts_time) ;
1218  }
1219  
smt_set_timestamp(struct s_smc * smc,u_char * p)1220  void smt_set_timestamp(struct s_smc *smc, u_char *p)
1221  {
1222  	u_long	time ;
1223  	u_long	utime ;
1224  
1225  	/*
1226  	 * timestamp is 64 bits long ; resolution is 80 nS
1227  	 * our clock resolution is 10mS
1228  	 * 10mS/80ns = 125000 ~ 2^17 = 131072
1229  	 */
1230  	utime = smt_get_time() ;
1231  	time = utime * 100 ;
1232  	time /= TICKS_PER_SECOND ;
1233  	p[0] = 0 ;
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 ;
1241  	/*
1242  	 * make sure we don't wrap: restart whenever the upper digits change
1243  	 */
1244  	if (utime != smc->sm.uniq_time) {
1245  		smc->sm.uniq_ticks = 0 ;
1246  	}
1247  	smc->sm.uniq_ticks++ ;
1248  	smc->sm.uniq_time = utime ;
1249  }
1250  
1251  /*
1252   * fill values in station policy parameter
1253   */
smt_fill_policy(struct s_smc * smc,struct smt_p_policy * policy)1254  static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy)
1255  {
1256  	int	i ;
1257  	const u_char *map ;
1258  	u_short	in ;
1259  	u_short	out ;
1260  
1261  	/*
1262  	 * MIB para 101b (fddiSMTConnectionPolicy) coding
1263  	 * is different from 0005 coding
1264  	 */
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
1267  	} ;
1268  	SMTSETPARA(policy,SMT_P_POLICY) ;
1269  
1270  	out = 0 ;
1271  	in = smc->mib.fddiSMTConnectionPolicy ;
1272  	for (i = 0, map = ansi_weirdness ; i < 16 ; i++) {
1273  		if (in & 1)
1274  			out |= (1<<*map) ;
1275  		in >>= 1 ;
1276  		map++ ;
1277  	}
1278  	policy->pl_config = smc->mib.fddiSMTConfigPolicy ;
1279  	policy->pl_connect = out ;
1280  }
1281  
1282  /*
1283   * fill values in latency equivalent parameter
1284   */
smt_fill_latency(struct s_smc * smc,struct smt_p_latency * latency)1285  static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency)
1286  {
1287  	SMTSETPARA(latency,SMT_P_LATENCY) ;
1288  
1289  	latency->lt_phyout_idx1 = phy_index(smc,0) ;
1290  	latency->lt_latency1 = 10 ;	/* in octets (byte clock) */
1291  	/*
1292  	 * note: latency has two phy entries by definition
1293  	 * for a SAS, the 2nd one is null
1294  	 */
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) */
1298  	}
1299  	else {
1300  		latency->lt_phyout_idx2 = 0 ;
1301  		latency->lt_latency2 = 0 ;
1302  	}
1303  }
1304  
1305  /*
1306   * fill values in MAC neighbors parameter
1307   */
smt_fill_neighbor(struct s_smc * smc,struct smt_p_neighbor * neighbor)1308  static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor)
1309  {
1310  	SMTSETPARA(neighbor,SMT_P_NEIGHBORS) ;
1311  
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 ;
1316  }
1317  
1318  /*
1319   * fill values in path descriptor
1320   */
1321  #ifdef	CONCENTRATOR
1322  #define ALLPHYS	NUMPHYS
1323  #else
1324  #define ALLPHYS	((smc->s.sas == SMT_SAS) ? 1 : 2)
1325  #endif
1326  
smt_fill_path(struct s_smc * smc,struct smt_p_path * path)1327  static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path)
1328  {
1329  	SK_LOC_DECL(int,type) ;
1330  	SK_LOC_DECL(int,state) ;
1331  	SK_LOC_DECL(int,remote) ;
1332  	SK_LOC_DECL(int,mac) ;
1333  	int	len ;
1334  	int	p ;
1335  	int	physp ;
1336  	struct smt_phy_rec	*phy ;
1337  	struct smt_mac_rec	*pd_mac ;
1338  
1339  	len =	PARA_LEN +
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 ;
1344  
1345  	/* PHYs */
1346  	for (p = 0,phy = path->pd_phy ; p < ALLPHYS ; p++, phy++) {
1347  		physp = p ;
1348  #ifndef	CONCENTRATOR
1349  		if (smc->s.sas == SMT_SAS)
1350  			physp = PS ;
1351  #endif
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) ;
1355  #else
1356  		phy->phy_mib_index = p+INDEX_PORT ;
1357  #endif
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) ;
1363  	}
1364  
1365  	/* MAC */
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) ;
1369  	return len;
1370  }
1371  
1372  /*
1373   * fill values in mac status
1374   */
smt_fill_mac_status(struct s_smc * smc,struct smt_p_mac_status * st)1375  static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st)
1376  {
1377  	SMTSETPARA(st,SMT_P_MAC_STATUS) ;
1378  
1379  	st->st_mib_index = INDEX_MAC ;
1380  	st->st_mac_index = mac_index(smc,1) ;
1381  
1382  	mac_update_counter(smc) ;
1383  	/*
1384  	 * timer values are represented in SMT as 2's complement numbers
1385  	 * units :	internal :  2's complement BCLK
1386  	 */
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 ;
1392  
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 ;
1397  }
1398  
1399  /*
1400   * fill values in LEM status
1401   */
smt_fill_lem(struct s_smc * smc,struct smt_p_lem * lem,int phy)1402  static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy)
1403  {
1404  	struct fddi_mib_p	*mib ;
1405  
1406  	mib = smc->y[phy].mib ;
1407  
1408  	SMTSETPARA(lem,SMT_P_LEM) ;
1409  	lem->lem_mib_index = phy+INDEX_PORT ;
1410  	lem->lem_phy_index = phy_index(smc,phy) ;
1411  	lem->lem_pad2 = 0 ;
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 */
1419  }
1420  
1421  /*
1422   * fill version parameter
1423   */
smt_fill_version(struct s_smc * smc,struct smt_p_version * vers)1424  static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers)
1425  {
1426  	SK_UNUSED(smc) ;
1427  	SMTSETPARA(vers,SMT_P_VERSION) ;
1428  	vers->v_pad = 0 ;
1429  	vers->v_n = 1 ;				/* one version is enough .. */
1430  	vers->v_index = 1 ;
1431  	vers->v_version[0] = SMT_VID_2 ;
1432  	vers->v_pad2 = 0 ;
1433  }
1434  
1435  #ifdef	SMT6_10
1436  /*
1437   * fill frame status capabilities
1438   */
1439  /*
1440   * note: this para 200B is NOT in swap table, because it's also set in
1441   * PMF add_para
1442   */
smt_fill_fsc(struct s_smc * smc,struct smt_p_fsc * fsc)1443  static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc)
1444  {
1445  	SK_UNUSED(smc) ;
1446  	SMTSETPARA(fsc,SMT_P_FSC) ;
1447  	fsc->fsc_pad0 = 0 ;
1448  	fsc->fsc_mac_index = INDEX_MAC ;	/* this is MIB ; MIB is NOT
1449  						 * mac_index ()i !
1450  						 */
1451  	fsc->fsc_pad1 = 0 ;
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) ;
1456  #endif
1457  }
1458  #endif
1459  
1460  /*
1461   * fill mac counter field
1462   */
smt_fill_mac_counter(struct s_smc * smc,struct smt_p_mac_counter * mc)1463  static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc)
1464  {
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 ;
1470  }
1471  
1472  /*
1473   * fill mac frame not copied counter
1474   */
smt_fill_mac_fnc(struct s_smc * smc,struct smt_p_mac_fnc * fnc)1475  static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc)
1476  {
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 ;
1481  }
1482  
1483  
1484  /*
1485   * fill manufacturer field
1486   */
smt_fill_manufacturer(struct s_smc * smc,struct smp_p_manufacturer * man)1487  static void smt_fill_manufacturer(struct s_smc *smc,
1488  				  struct smp_p_manufacturer *man)
1489  {
1490  	SMTSETPARA(man,SMT_P_MANUFACTURER) ;
1491  	memcpy((char *) man->mf_data,
1492  		(char *) smc->mib.fddiSMTManufacturerData,
1493  		sizeof(man->mf_data)) ;
1494  }
1495  
1496  /*
1497   * fill user field
1498   */
smt_fill_user(struct s_smc * smc,struct smp_p_user * user)1499  static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user)
1500  {
1501  	SMTSETPARA(user,SMT_P_USER) ;
1502  	memcpy((char *) user->us_data,
1503  		(char *) smc->mib.fddiSMTUserData,
1504  		sizeof(user->us_data)) ;
1505  }
1506  
1507  /*
1508   * fill set count
1509   */
smt_fill_setcount(struct s_smc * smc,struct smt_p_setcount * setcount)1510  static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount)
1511  {
1512  	SK_UNUSED(smc) ;
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) ;
1517  }
1518  
1519  /*
1520   * fill echo data
1521   */
smt_fill_echo(struct s_smc * smc,struct smt_p_echo * echo,u_long seed,int len)1522  static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
1523  			  int len)
1524  {
1525  	u_char	*p ;
1526  
1527  	SK_UNUSED(smc) ;
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 ;
1532  		seed += 13 ;
1533  	}
1534  }
1535  
1536  /*
1537   * clear DNA and UNA
1538   * called from CFM if configuration changes
1539   */
smt_clear_una_dna(struct s_smc * smc)1540  static void smt_clear_una_dna(struct s_smc *smc)
1541  {
1542  	smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
1543  	smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
1544  }
1545  
smt_clear_old_una_dna(struct s_smc * smc)1546  static void smt_clear_old_una_dna(struct s_smc *smc)
1547  {
1548  	smc->mib.m[MAC0].fddiMACOldUpstreamNbr = SMT_Unknown ;
1549  	smc->mib.m[MAC0].fddiMACOldDownstreamNbr = SMT_Unknown ;
1550  }
1551  
smt_get_tid(struct s_smc * smc)1552  u_long smt_get_tid(struct s_smc *smc)
1553  {
1554  	u_long	tid ;
1555  	while ((tid = ++(smc->sm.smt_tid) ^ SMT_TID_MAGIC) == 0)
1556  		;
1557  	return tid & 0x3fffffffL;
1558  }
1559  
1560  #ifdef	LITTLE_ENDIAN
1561  /*
1562   * table of parameter lengths
1563   */
1564  static const struct smt_pdef {
1565  	int	ptype ;
1566  	int	plen ;
1567  	const char	*pswap ;
1568  } smt_pdef[] = {
1569  	{ SMT_P_UNA,	sizeof(struct smt_p_una) ,
1570  		SWAP_SMT_P_UNA					} ,
1571  	{ SMT_P_SDE,	sizeof(struct smt_p_sde) ,
1572  		SWAP_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) ,
1584  		SWAP_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) ,
1588  		SWAP_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) ,
1596  		SWAP_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				} ,
1605  #ifdef ESS
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 } ,
1615  #endif
1616  #if	0
1617  	{ SMT_P_FSC,	sizeof(struct smt_p_fsc) ,
1618  		SWAP_SMT_P_FSC					} ,
1619  #endif
1620  
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			} ,
1628  #ifdef	ESS
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 } ,
1632  #endif
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			} ,
1637  } ;
1638  
1639  #define N_SMT_PLEN	ARRAY_SIZE(smt_pdef)
1640  #endif
1641  
smt_check_para(struct s_smc * smc,struct smt_header * sm,const u_short list[])1642  int smt_check_para(struct s_smc *smc, struct smt_header	*sm,
1643  		   const u_short list[])
1644  {
1645  	const u_short		*p = list ;
1646  	while (*p) {
1647  		if (!sm_to_para(smc,sm,(int) *p)) {
1648  			DB_SMT("SMT: smt_check_para - missing para %hx", *p);
1649  			return -1;
1650  		}
1651  		p++ ;
1652  	}
1653  	return 0;
1654  }
1655  
sm_to_para(struct s_smc * smc,struct smt_header * sm,int para)1656  void *sm_to_para(struct s_smc *smc, struct smt_header *sm, int para)
1657  {
1658  	char	*p ;
1659  	int	len ;
1660  	int	plen ;
1661  	void	*found = NULL;
1662  
1663  	SK_UNUSED(smc) ;
1664  
1665  	len = sm->smt_len ;
1666  	p = (char *)(sm+1) ;		/* pointer to info */
1667  	while (len > 0 ) {
1668  		if (((struct smt_para *)p)->p_type == para)
1669  			found = (void *) p ;
1670  		plen = ((struct smt_para *)p)->p_len + PARA_LEN ;
1671  		p += plen ;
1672  		len -= plen ;
1673  		if (len < 0) {
1674  			DB_SMT("SMT : sm_to_para - length error %d", plen);
1675  			return NULL;
1676  		}
1677  		if ((plen & 3) && (para != SMT_P_ECHODATA)) {
1678  			DB_SMT("SMT : sm_to_para - odd length %d", plen);
1679  			return NULL;
1680  		}
1681  		if (found)
1682  			return found;
1683  	}
1684  	return NULL;
1685  }
1686  
1687  #if	0
1688  /*
1689   * send ANTC data test frame
1690   */
1691  void fddi_send_antc(struct s_smc *smc, struct fddi_addr *dest)
1692  {
1693  	SK_UNUSED(smc) ;
1694  	SK_UNUSED(dest) ;
1695  #if	0
1696  	SMbuf			*mb ;
1697  	struct smt_header	*smt ;
1698  	int			i ;
1699  	char			*p ;
1700  
1701  	mb = smt_get_mbuf() ;
1702  	mb->sm_len = 3000+12 ;
1703  	p = smtod(mb, char *) + 12 ;
1704  	for (i = 0 ; i < 3000 ; i++)
1705  		*p++ = 1 << (i&7) ;
1706  
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) ;
1711  #endif
1712  }
1713  #endif
1714  
1715  /*
1716   * return static mac index
1717   */
mac_index(struct s_smc * smc,int mac)1718  static int mac_index(struct s_smc *smc, int mac)
1719  {
1720  	SK_UNUSED(mac) ;
1721  #ifdef	CONCENTRATOR
1722  	SK_UNUSED(smc) ;
1723  	return NUMPHYS + 1;
1724  #else
1725  	return (smc->s.sas == SMT_SAS) ? 2 : 3;
1726  #endif
1727  }
1728  
1729  /*
1730   * return static phy index
1731   */
phy_index(struct s_smc * smc,int phy)1732  static int phy_index(struct s_smc *smc, int phy)
1733  {
1734  	SK_UNUSED(smc) ;
1735  	return phy + 1;
1736  }
1737  
1738  /*
1739   * return dynamic mac connection resource index
1740   */
mac_con_resource_index(struct s_smc * smc,int mac)1741  static int mac_con_resource_index(struct s_smc *smc, int mac)
1742  {
1743  #ifdef	CONCENTRATOR
1744  	SK_UNUSED(smc) ;
1745  	SK_UNUSED(mac) ;
1746  	return entity_to_index(smc, cem_get_downstream(smc, ENTITY_MAC));
1747  #else
1748  	SK_UNUSED(mac) ;
1749  	switch (smc->mib.fddiSMTCF_State) {
1750  	case SC9_C_WRAP_A :
1751  	case SC5_THRU_B :
1752  	case SC11_C_WRAP_S :
1753  		return 1;
1754  	case SC10_C_WRAP_B :
1755  	case SC4_THRU_A :
1756  		return 2;
1757  	}
1758  	return smc->s.sas == SMT_SAS ? 2 : 3;
1759  #endif
1760  }
1761  
1762  /*
1763   * return dynamic phy connection resource index
1764   */
phy_con_resource_index(struct s_smc * smc,int phy)1765  static int phy_con_resource_index(struct s_smc *smc, int phy)
1766  {
1767  #ifdef	CONCENTRATOR
1768  	return entity_to_index(smc, cem_get_downstream(smc, ENTITY_PHY(phy))) ;
1769  #else
1770  	switch (smc->mib.fddiSMTCF_State) {
1771  	case SC9_C_WRAP_A :
1772  		return phy == PA ? 3 : 2;
1773  	case SC10_C_WRAP_B :
1774  		return phy == PA ? 1 : 3;
1775  	case SC4_THRU_A :
1776  		return phy == PA ? 3 : 1;
1777  	case SC5_THRU_B :
1778  		return phy == PA ? 2 : 3;
1779  	case SC11_C_WRAP_S :
1780  		return 2;
1781  	}
1782  	return phy;
1783  #endif
1784  }
1785  
1786  #ifdef	CONCENTRATOR
entity_to_index(struct s_smc * smc,int e)1787  static int entity_to_index(struct s_smc *smc, int e)
1788  {
1789  	if (e == ENTITY_MAC)
1790  		return mac_index(smc, 1);
1791  	else
1792  		return phy_index(smc, e - ENTITY_PHY(0));
1793  }
1794  #endif
1795  
1796  #ifdef	LITTLE_ENDIAN
smt_swap_short(u_short s)1797  static int smt_swap_short(u_short s)
1798  {
1799  	return ((s>>8)&0xff) | ((s&0xff)<<8);
1800  }
1801  
smt_swap_para(struct smt_header * sm,int len,int direction)1802  void smt_swap_para(struct smt_header *sm, int len, int direction)
1803  /* int direction;	0 encode 1 decode */
1804  {
1805  	struct smt_para	*pa ;
1806  	const  struct smt_pdef	*pd ;
1807  	char	*p ;
1808  	int	plen ;
1809  	int	type ;
1810  	int	i ;
1811  
1812  /*	printf("smt_swap_para sm %x len %d dir %d\n",
1813  		sm,len,direction) ;
1814   */
1815  	smt_string_swap((char *)sm,SWAP_SMTHEADER,len) ;
1816  
1817  	/* swap args */
1818  	len -= sizeof(struct smt_header) ;
1819  
1820  	p = (char *) (sm + 1) ;
1821  	while (len > 0) {
1822  		pa = (struct smt_para *) p ;
1823  		plen = pa->p_len ;
1824  		type = pa->p_type ;
1825  		pa->p_type = smt_swap_short(pa->p_type) ;
1826  		pa->p_len = smt_swap_short(pa->p_len) ;
1827  		if (direction) {
1828  			plen = pa->p_len ;
1829  			type = pa->p_type ;
1830  		}
1831  		/*
1832  		 * note: paras can have 0 length !
1833  		 */
1834  		if (plen < 0)
1835  			break ;
1836  		plen += PARA_LEN ;
1837  		for (i = N_SMT_PLEN, pd = smt_pdef; i ; i--,pd++) {
1838  			if (pd->ptype == type)
1839  				break ;
1840  		}
1841  		if (i && pd->pswap) {
1842  			smt_string_swap(p+PARA_LEN,pd->pswap,len) ;
1843  		}
1844  		len -= plen ;
1845  		p += plen ;
1846  	}
1847  }
1848  
1849  
smt_string_swap(char * data,const char * format,int len)1850  static void smt_string_swap(char *data, const char *format, int len)
1851  {
1852  	const char	*open_paren = NULL ;
1853  
1854  	while (len > 0  && *format) {
1855  		switch (*format) {
1856  		case '[' :
1857  			open_paren = format ;
1858  			break ;
1859  		case ']' :
1860  			format = open_paren ;
1861  			break ;
1862  		case '1' :
1863  		case '2' :
1864  		case '3' :
1865  		case '4' :
1866  		case '5' :
1867  		case '6' :
1868  		case '7' :
1869  		case '8' :
1870  		case '9' :
1871  			data  += *format - '0' ;
1872  			len   -= *format - '0' ;
1873  			break ;
1874  		case 'c':
1875  			data++ ;
1876  			len-- ;
1877  			break ;
1878  		case 's' :
1879  			swap(data[0], data[1]) ;
1880  			data += 2 ;
1881  			len -= 2 ;
1882  			break ;
1883  		case 'l' :
1884  			swap(data[0], data[3]) ;
1885  			swap(data[1], data[2]) ;
1886  			data += 4 ;
1887  			len -= 4 ;
1888  			break ;
1889  		}
1890  		format++ ;
1891  	}
1892  }
1893  #else
smt_swap_para(struct smt_header * sm,int len,int direction)1894  void smt_swap_para(struct smt_header *sm, int len, int direction)
1895  /* int direction;	0 encode 1 decode */
1896  {
1897  	SK_UNUSED(sm) ;
1898  	SK_UNUSED(len) ;
1899  	SK_UNUSED(direction) ;
1900  }
1901  #endif
1902  
1903  /*
1904   * PMF actions
1905   */
smt_action(struct s_smc * smc,int class,int code,int index)1906  int smt_action(struct s_smc *smc, int class, int code, int index)
1907  {
1908  	int	event ;
1909  	int	port ;
1910  	DB_SMT("SMT: action %d code %d", class, code);
1911  	switch(class) {
1912  	case SMT_STATION_ACTION :
1913  		switch(code) {
1914  		case SMT_STATION_ACTION_CONNECT :
1915  			smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
1916  			queue_event(smc,EVENT_ECM,EC_CONNECT) ;
1917  			break ;
1918  		case SMT_STATION_ACTION_DISCONNECT :
1919  			queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
1920  			smc->mib.fddiSMTRemoteDisconnectFlag = TRUE ;
1921  			RS_SET(smc,RS_DISCONNECT) ;
1922  			AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1923  				FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_DISCONNECT,
1924  				smt_get_event_word(smc));
1925  			break ;
1926  		case SMT_STATION_ACTION_PATHTEST :
1927  			AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1928  				FDDI_SMT_EVENT, (u_long) FDDI_PATH_TEST,
1929  				smt_get_event_word(smc));
1930  			break ;
1931  		case SMT_STATION_ACTION_SELFTEST :
1932  			AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1933  				FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_SELF_TEST,
1934  				smt_get_event_word(smc));
1935  			break ;
1936  		case SMT_STATION_ACTION_DISABLE_A :
1937  			if (smc->y[PA].pc_mode == PM_PEER) {
1938  				RS_SET(smc,RS_EVENT) ;
1939  				queue_event(smc,EVENT_PCM+PA,PC_DISABLE) ;
1940  			}
1941  			break ;
1942  		case SMT_STATION_ACTION_DISABLE_B :
1943  			if (smc->y[PB].pc_mode == PM_PEER) {
1944  				RS_SET(smc,RS_EVENT) ;
1945  				queue_event(smc,EVENT_PCM+PB,PC_DISABLE) ;
1946  			}
1947  			break ;
1948  		case SMT_STATION_ACTION_DISABLE_M :
1949  			for (port = 0 ; port <  NUMPHYS ; port++) {
1950  				if (smc->mib.p[port].fddiPORTMy_Type != TM)
1951  					continue ;
1952  				RS_SET(smc,RS_EVENT) ;
1953  				queue_event(smc,EVENT_PCM+port,PC_DISABLE) ;
1954  			}
1955  			break ;
1956  		default :
1957  			return 1;
1958  		}
1959  		break ;
1960  	case SMT_PORT_ACTION :
1961  		switch(code) {
1962  		case SMT_PORT_ACTION_ENABLE :
1963  			event = PC_ENABLE ;
1964  			break ;
1965  		case SMT_PORT_ACTION_DISABLE :
1966  			event = PC_DISABLE ;
1967  			break ;
1968  		case SMT_PORT_ACTION_MAINT :
1969  			event = PC_MAINT ;
1970  			break ;
1971  		case SMT_PORT_ACTION_START :
1972  			event = PC_START ;
1973  			break ;
1974  		case SMT_PORT_ACTION_STOP :
1975  			event = PC_STOP ;
1976  			break ;
1977  		default :
1978  			return 1;
1979  		}
1980  		queue_event(smc,EVENT_PCM+index,event) ;
1981  		break ;
1982  	default :
1983  		return 1;
1984  	}
1985  	return 0;
1986  }
1987  
1988  /*
1989   * canonical conversion of <len> bytes beginning form *data
1990   */
1991  #ifdef  USE_CAN_ADDR
hwm_conv_can(struct s_smc * smc,char * data,int len)1992  static void hwm_conv_can(struct s_smc *smc, char *data, int len)
1993  {
1994  	int i ;
1995  
1996  	SK_UNUSED(smc) ;
1997  
1998  	for (i = len; i ; i--, data++)
1999  		*data = bitrev8(*data);
2000  }
2001  #endif
2002  
2003  #endif	/* no SLIM_SMT */
2004  
2005