1 /******************************************************************************
2  *
3  *	(C)Copyright 1998,1999 SysKonnect,
4  *	a business unit of Schneider & Koch & Co. Datensysteme GmbH.
5  *
6  *	See the file "skfddi.c" for further information.
7  *
8  *	This program is free software; you can redistribute it and/or modify
9  *	it under the terms of the GNU General Public License as published by
10  *	the Free Software Foundation; either version 2 of the License, or
11  *	(at your option) any later version.
12  *
13  *	The information in this file is provided "AS IS" without warranty.
14  *
15  ******************************************************************************/
16 
17 #include "h/types.h"
18 #include "h/fddi.h"
19 #include "h/smc.h"
20 #include "h/smt_p.h"
21 #include <linux/bitrev.h>
22 #include <linux/kernel.h>
23 
24 #define KERNEL
25 #include "h/smtstate.h"
26 
27 #ifndef	lint
28 static const char ID_sccs[] = "@(#)smt.c	2.43 98/11/23 (C) SK " ;
29 #endif
30 
31 /*
32  * FC in SMbuf
33  */
34 #define m_fc(mb)	((mb)->sm_data[0])
35 
36 #define SMT_TID_MAGIC	0x1f0a7b3c
37 
38 #ifdef	DEBUG
39 static const char *const smt_type_name[] = {
40 	"SMT_00??", "SMT_INFO", "SMT_02??", "SMT_03??",
41 	"SMT_04??", "SMT_05??", "SMT_06??", "SMT_07??",
42 	"SMT_08??", "SMT_09??", "SMT_0A??", "SMT_0B??",
43 	"SMT_0C??", "SMT_0D??", "SMT_0E??", "SMT_NSA"
44 } ;
45 
46 static const char *const smt_class_name[] = {
47 	"UNKNOWN","NIF","SIF_CONFIG","SIF_OPER","ECF","RAF","RDF",
48 	"SRF","PMF_GET","PMF_SET","ESF"
49 } ;
50 #endif
51 #define LAST_CLASS	(SMT_PMF_SET)
52 
53 static const struct fddi_addr SMT_Unknown = {
54 	{ 0,0,0x1f,0,0,0 }
55 } ;
56 
57 /*
58  * function prototypes
59  */
60 #ifdef	LITTLE_ENDIAN
61 static int smt_swap_short(u_short s);
62 #endif
63 static int mac_index(struct s_smc *smc, int mac);
64 static int phy_index(struct s_smc *smc, int phy);
65 static int mac_con_resource_index(struct s_smc *smc, int mac);
66 static int phy_con_resource_index(struct s_smc *smc, int phy);
67 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
68 			 int local);
69 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
70 			 int fc, u_long tid, int type, int local);
71 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
72                          u_long tid, int type, int len);
73 static void smt_echo_test(struct s_smc *smc, int dna);
74 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
75 				u_long tid, int local);
76 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
77 				   u_long tid, int local);
78 #ifdef LITTLE_ENDIAN
79 static void smt_string_swap(char *data, const char *format, int len);
80 #endif
81 static void smt_add_frame_len(SMbuf *mb, int len);
82 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una);
83 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde);
84 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state);
85 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts);
86 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy);
87 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency);
88 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor);
89 static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path);
90 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st);
91 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy);
92 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers);
93 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc);
94 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc);
95 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc);
96 static void smt_fill_manufacturer(struct s_smc *smc,
97 				  struct smp_p_manufacturer *man);
98 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user);
99 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount);
100 static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
101 			  int len);
102 
103 static void smt_clear_una_dna(struct s_smc *smc);
104 static void smt_clear_old_una_dna(struct s_smc *smc);
105 #ifdef	CONCENTRATOR
106 static int entity_to_index(void);
107 #endif
108 static void update_dac(struct s_smc *smc, int report);
109 static int div_ratio(u_long upper, u_long lower);
110 #ifdef  USE_CAN_ADDR
111 static void	hwm_conv_can(struct s_smc *smc, char *data, int len);
112 #else
113 #define		hwm_conv_can(smc,data,len)
114 #endif
115 
116 
is_my_addr(const struct s_smc * smc,const struct fddi_addr * addr)117 static inline int is_my_addr(const struct s_smc *smc,
118 			     const struct fddi_addr *addr)
119 {
120 	return(*(short *)(&addr->a[0]) ==
121 		*(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[0])
122 	  && *(short *)(&addr->a[2]) ==
123 		*(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[2])
124 	  && *(short *)(&addr->a[4]) ==
125 		*(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[4])) ;
126 }
127 
is_broadcast(const struct fddi_addr * addr)128 static inline int is_broadcast(const struct fddi_addr *addr)
129 {
130 	return *(u_short *)(&addr->a[0]) == 0xffff &&
131 	       *(u_short *)(&addr->a[2]) == 0xffff &&
132 	       *(u_short *)(&addr->a[4]) == 0xffff;
133 }
134 
is_individual(const struct fddi_addr * addr)135 static inline int is_individual(const struct fddi_addr *addr)
136 {
137 	return !(addr->a[0] & GROUP_ADDR);
138 }
139 
is_equal(const struct fddi_addr * addr1,const struct fddi_addr * addr2)140 static inline int is_equal(const struct fddi_addr *addr1,
141 			   const struct fddi_addr *addr2)
142 {
143 	return *(u_short *)(&addr1->a[0]) == *(u_short *)(&addr2->a[0]) &&
144 	       *(u_short *)(&addr1->a[2]) == *(u_short *)(&addr2->a[2]) &&
145 	       *(u_short *)(&addr1->a[4]) == *(u_short *)(&addr2->a[4]);
146 }
147 
148 /*
149  * list of mandatory paras in frames
150  */
151 static const u_short plist_nif[] = { SMT_P_UNA,SMT_P_SDE,SMT_P_STATE,0 } ;
152 
153 /*
154  * init SMT agent
155  */
smt_agent_init(struct s_smc * smc)156 void smt_agent_init(struct s_smc *smc)
157 {
158 	int		i ;
159 
160 	/*
161 	 * get MAC address
162 	 */
163 	smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
164 
165 	/*
166 	 * get OUI address from driver (bia == built-in-address)
167 	 */
168 	smc->mib.fddiSMTStationId.sid_oem[0] = 0 ;
169 	smc->mib.fddiSMTStationId.sid_oem[1] = 0 ;
170 	driver_get_bia(smc,&smc->mib.fddiSMTStationId.sid_node) ;
171 	for (i = 0 ; i < 6 ; i ++) {
172 		smc->mib.fddiSMTStationId.sid_node.a[i] =
173 			bitrev8(smc->mib.fddiSMTStationId.sid_node.a[i]);
174 	}
175 	smc->mib.fddiSMTManufacturerData[0] =
176 		smc->mib.fddiSMTStationId.sid_node.a[0] ;
177 	smc->mib.fddiSMTManufacturerData[1] =
178 		smc->mib.fddiSMTStationId.sid_node.a[1] ;
179 	smc->mib.fddiSMTManufacturerData[2] =
180 		smc->mib.fddiSMTStationId.sid_node.a[2] ;
181 	smc->sm.smt_tid = 0 ;
182 	smc->mib.m[MAC0].fddiMACDupAddressTest = DA_NONE ;
183 	smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
184 #ifndef	SLIM_SMT
185 	smt_clear_una_dna(smc) ;
186 	smt_clear_old_una_dna(smc) ;
187 #endif
188 	for (i = 0 ; i < SMT_MAX_TEST ; i++)
189 		smc->sm.pend[i] = 0 ;
190 	smc->sm.please_reconnect = 0 ;
191 	smc->sm.uniq_ticks = 0 ;
192 }
193 
194 /*
195  * SMT task
196  * forever
197  *	delay 30 seconds
198  *	send NIF
199  *	check tvu & tvd
200  * end
201  */
smt_agent_task(struct s_smc * smc)202 void smt_agent_task(struct s_smc *smc)
203 {
204 	smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
205 		EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
206 	DB_SMT("SMT agent task\n",0,0) ;
207 }
208 
209 #ifndef SMT_REAL_TOKEN_CT
smt_emulate_token_ct(struct s_smc * smc,int mac_index)210 void smt_emulate_token_ct(struct s_smc *smc, int mac_index)
211 {
212 	u_long	count;
213 	u_long	time;
214 
215 
216 	time = smt_get_time();
217 	count =	((time - smc->sm.last_tok_time[mac_index]) *
218 					100)/TICKS_PER_SECOND;
219 
220 	/*
221 	 * Only when ring is up we will have a token count. The
222 	 * flag is unfortunately a single instance value. This
223 	 * doesn't matter now, because we currently have only
224 	 * one MAC instance.
225 	 */
226 	if (smc->hw.mac_ring_is_up){
227 		smc->mib.m[mac_index].fddiMACToken_Ct += count;
228 	}
229 
230 	/* Remember current time */
231 	smc->sm.last_tok_time[mac_index] = time;
232 
233 }
234 #endif
235 
236 /*ARGSUSED1*/
smt_event(struct s_smc * smc,int event)237 void smt_event(struct s_smc *smc, int event)
238 {
239 	u_long		time ;
240 #ifndef SMT_REAL_TOKEN_CT
241 	int		i ;
242 #endif
243 
244 
245 	if (smc->sm.please_reconnect) {
246 		smc->sm.please_reconnect -- ;
247 		if (smc->sm.please_reconnect == 0) {
248 			/* Counted down */
249 			queue_event(smc,EVENT_ECM,EC_CONNECT) ;
250 		}
251 	}
252 
253 	if (event == SM_FAST)
254 		return ;
255 
256 	/*
257 	 * timer for periodic cleanup in driver
258 	 * reset and start the watchdog (FM2)
259 	 * ESS timer
260 	 * SBA timer
261 	 */
262 	smt_timer_poll(smc) ;
263 	smt_start_watchdog(smc) ;
264 #ifndef	SLIM_SMT
265 #ifndef BOOT
266 #ifdef	ESS
267 	ess_timer_poll(smc) ;
268 #endif
269 #endif
270 #ifdef	SBA
271 	sba_timer_poll(smc) ;
272 #endif
273 
274 	smt_srf_event(smc,0,0,0) ;
275 
276 #endif	/* no SLIM_SMT */
277 
278 	time = smt_get_time() ;
279 
280 	if (time - smc->sm.smt_last_lem >= TICKS_PER_SECOND*8) {
281 		/*
282 		 * Use 8 sec. for the time intervall, it simplifies the
283 		 * LER estimation.
284 		 */
285 		struct fddi_mib_m	*mib ;
286 		u_long			upper ;
287 		u_long			lower ;
288 		int			cond ;
289 		int			port;
290 		struct s_phy		*phy ;
291 		/*
292 		 * calculate LEM bit error rate
293 		 */
294 		sm_lem_evaluate(smc) ;
295 		smc->sm.smt_last_lem = time ;
296 
297 		/*
298 		 * check conditions
299 		 */
300 #ifndef	SLIM_SMT
301 		mac_update_counter(smc) ;
302 		mib = smc->mib.m ;
303 		upper =
304 		(mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) +
305 		(mib->fddiMACError_Ct - mib->fddiMACOld_Error_Ct) ;
306 		lower =
307 		(mib->fddiMACFrame_Ct - mib->fddiMACOld_Frame_Ct) +
308 		(mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) ;
309 		mib->fddiMACFrameErrorRatio = div_ratio(upper,lower) ;
310 
311 		cond =
312 			((!mib->fddiMACFrameErrorThreshold &&
313 			mib->fddiMACError_Ct != mib->fddiMACOld_Error_Ct) ||
314 			(mib->fddiMACFrameErrorRatio >
315 			mib->fddiMACFrameErrorThreshold)) ;
316 
317 		if (cond != mib->fddiMACFrameErrorFlag)
318 			smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
319 				INDEX_MAC,cond) ;
320 
321 		upper =
322 		(mib->fddiMACNotCopied_Ct - mib->fddiMACOld_NotCopied_Ct) ;
323 		lower =
324 		upper +
325 		(mib->fddiMACCopied_Ct - mib->fddiMACOld_Copied_Ct) ;
326 		mib->fddiMACNotCopiedRatio = div_ratio(upper,lower) ;
327 
328 		cond =
329 			((!mib->fddiMACNotCopiedThreshold &&
330 			mib->fddiMACNotCopied_Ct !=
331 				mib->fddiMACOld_NotCopied_Ct)||
332 			(mib->fddiMACNotCopiedRatio >
333 			mib->fddiMACNotCopiedThreshold)) ;
334 
335 		if (cond != mib->fddiMACNotCopiedFlag)
336 			smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
337 				INDEX_MAC,cond) ;
338 
339 		/*
340 		 * set old values
341 		 */
342 		mib->fddiMACOld_Frame_Ct = mib->fddiMACFrame_Ct ;
343 		mib->fddiMACOld_Copied_Ct = mib->fddiMACCopied_Ct ;
344 		mib->fddiMACOld_Error_Ct = mib->fddiMACError_Ct ;
345 		mib->fddiMACOld_Lost_Ct = mib->fddiMACLost_Ct ;
346 		mib->fddiMACOld_NotCopied_Ct = mib->fddiMACNotCopied_Ct ;
347 
348 		/*
349 		 * Check port EBError Condition
350 		 */
351 		for (port = 0; port < NUMPHYS; port ++) {
352 			phy = &smc->y[port] ;
353 
354 			if (!phy->mib->fddiPORTHardwarePresent) {
355 				continue;
356 			}
357 
358 			cond = (phy->mib->fddiPORTEBError_Ct -
359 				phy->mib->fddiPORTOldEBError_Ct > 5) ;
360 
361 			/* If ratio is more than 5 in 8 seconds
362 			 * Set the condition.
363 			 */
364 			smt_srf_event(smc,SMT_COND_PORT_EB_ERROR,
365 				(int) (INDEX_PORT+ phy->np) ,cond) ;
366 
367 			/*
368 			 * set old values
369 			 */
370 			phy->mib->fddiPORTOldEBError_Ct =
371 				phy->mib->fddiPORTEBError_Ct ;
372 		}
373 
374 #endif	/* no SLIM_SMT */
375 	}
376 
377 #ifndef	SLIM_SMT
378 
379 	if (time - smc->sm.smt_last_notify >= (u_long)
380 		(smc->mib.fddiSMTTT_Notify * TICKS_PER_SECOND) ) {
381 		/*
382 		 * we can either send an announcement or a request
383 		 * a request will trigger a reply so that we can update
384 		 * our dna
385 		 * note: same tid must be used until reply is received
386 		 */
387 		if (!smc->sm.pend[SMT_TID_NIF])
388 			smc->sm.pend[SMT_TID_NIF] = smt_get_tid(smc) ;
389 		smt_send_nif(smc,&fddi_broadcast, FC_SMT_NSA,
390 			smc->sm.pend[SMT_TID_NIF], SMT_REQUEST,0) ;
391 		smc->sm.smt_last_notify = time ;
392 	}
393 
394 	/*
395 	 * check timer
396 	 */
397 	if (smc->sm.smt_tvu &&
398 	    time - smc->sm.smt_tvu > 228*TICKS_PER_SECOND) {
399 		DB_SMT("SMT : UNA expired\n",0,0) ;
400 		smc->sm.smt_tvu = 0 ;
401 
402 		if (!is_equal(&smc->mib.m[MAC0].fddiMACUpstreamNbr,
403 			&SMT_Unknown)){
404 			/* Do not update unknown address */
405 			smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
406 				smc->mib.m[MAC0].fddiMACUpstreamNbr ;
407 		}
408 		smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
409 		smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
410 		/*
411 		 * Make sure the fddiMACUNDA_Flag = FALSE is
412 		 * included in the SRF so we don't generate
413 		 * a separate SRF for the deassertion of this
414 		 * condition
415 		 */
416 		update_dac(smc,0) ;
417 		smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
418 			INDEX_MAC,0) ;
419 	}
420 	if (smc->sm.smt_tvd &&
421 	    time - smc->sm.smt_tvd > 228*TICKS_PER_SECOND) {
422 		DB_SMT("SMT : DNA expired\n",0,0) ;
423 		smc->sm.smt_tvd = 0 ;
424 		if (!is_equal(&smc->mib.m[MAC0].fddiMACDownstreamNbr,
425 			&SMT_Unknown)){
426 			/* Do not update unknown address */
427 			smc->mib.m[MAC0].fddiMACOldDownstreamNbr=
428 				smc->mib.m[MAC0].fddiMACDownstreamNbr ;
429 		}
430 		smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
431 		smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
432 			INDEX_MAC,0) ;
433 	}
434 
435 #endif	/* no SLIM_SMT */
436 
437 #ifndef SMT_REAL_TOKEN_CT
438 	/*
439 	 * Token counter emulation section. If hardware supports the token
440 	 * count, the token counter will be updated in mac_update_counter.
441 	 */
442 	for (i = MAC0; i < NUMMACS; i++ ){
443 		if (time - smc->sm.last_tok_time[i] > 2*TICKS_PER_SECOND ){
444 			smt_emulate_token_ct( smc, i );
445 		}
446 	}
447 #endif
448 
449 	smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
450 		EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
451 }
452 
div_ratio(u_long upper,u_long lower)453 static int div_ratio(u_long upper, u_long lower)
454 {
455 	if ((upper<<16L) < upper)
456 		upper = 0xffff0000L ;
457 	else
458 		upper <<= 16L ;
459 	if (!lower)
460 		return 0;
461 	return (int)(upper/lower) ;
462 }
463 
464 #ifndef	SLIM_SMT
465 
466 /*
467  * receive packet handler
468  */
smt_received_pack(struct s_smc * smc,SMbuf * mb,int fs)469 void smt_received_pack(struct s_smc *smc, SMbuf *mb, int fs)
470 /* int fs;  frame status */
471 {
472 	struct smt_header	*sm ;
473 	int			local ;
474 
475 	int			illegal = 0 ;
476 
477 	switch (m_fc(mb)) {
478 	case FC_SMT_INFO :
479 	case FC_SMT_LAN_LOC :
480 	case FC_SMT_LOC :
481 	case FC_SMT_NSA :
482 		break ;
483 	default :
484 		smt_free_mbuf(smc,mb) ;
485 		return ;
486 	}
487 
488 	smc->mib.m[MAC0].fddiMACSMTCopied_Ct++ ;
489 	sm = smtod(mb,struct smt_header *) ;
490 	local = ((fs & L_INDICATOR) != 0) ;
491 	hwm_conv_can(smc,(char *)sm,12) ;
492 
493 	/* check destination address */
494 	if (is_individual(&sm->smt_dest) && !is_my_addr(smc,&sm->smt_dest)) {
495 		smt_free_mbuf(smc,mb) ;
496 		return ;
497 	}
498 #if	0		/* for DUP recognition, do NOT filter them */
499 	/* ignore loop back packets */
500 	if (is_my_addr(smc,&sm->smt_source) && !local) {
501 		smt_free_mbuf(smc,mb) ;
502 		return ;
503 	}
504 #endif
505 
506 	smt_swap_para(sm,(int) mb->sm_len,1) ;
507 	DB_SMT("SMT : received packet [%s] at 0x%x\n",
508 		smt_type_name[m_fc(mb) & 0xf],sm) ;
509 	DB_SMT("SMT : version %d, class %s\n",sm->smt_version,
510 		smt_class_name[(sm->smt_class>LAST_CLASS)?0 : sm->smt_class]) ;
511 
512 #ifdef	SBA
513 	/*
514 	 * check if NSA frame
515 	 */
516 	if (m_fc(mb) == FC_SMT_NSA && sm->smt_class == SMT_NIF &&
517 		(sm->smt_type == SMT_ANNOUNCE || sm->smt_type == SMT_REQUEST)) {
518 			smc->sba.sm = sm ;
519 			sba(smc,NIF) ;
520 	}
521 #endif
522 
523 	/*
524 	 * ignore any packet with NSA and A-indicator set
525 	 */
526 	if ( (fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) {
527 		DB_SMT("SMT : ignoring NSA with A-indicator set from %s\n",
528 			addr_to_string(&sm->smt_source),0) ;
529 		smt_free_mbuf(smc,mb) ;
530 		return ;
531 	}
532 
533 	/*
534 	 * ignore frames with illegal length
535 	 */
536 	if (((sm->smt_class == SMT_ECF) && (sm->smt_len > SMT_MAX_ECHO_LEN)) ||
537 	    ((sm->smt_class != SMT_ECF) && (sm->smt_len > SMT_MAX_INFO_LEN))) {
538 		smt_free_mbuf(smc,mb) ;
539 		return ;
540 	}
541 
542 	/*
543 	 * check SMT version
544 	 */
545 	switch (sm->smt_class) {
546 	case SMT_NIF :
547 	case SMT_SIF_CONFIG :
548 	case SMT_SIF_OPER :
549 	case SMT_ECF :
550 		if (sm->smt_version != SMT_VID)
551 			illegal = 1;
552 		break ;
553 	default :
554 		if (sm->smt_version != SMT_VID_2)
555 			illegal = 1;
556 		break ;
557 	}
558 	if (illegal) {
559 		DB_SMT("SMT : version = %d, dest = %s\n",
560 			sm->smt_version,addr_to_string(&sm->smt_source)) ;
561 		smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_VERSION,local) ;
562 		smt_free_mbuf(smc,mb) ;
563 		return ;
564 	}
565 	if ((sm->smt_len > mb->sm_len - sizeof(struct smt_header)) ||
566 	    ((sm->smt_len & 3) && (sm->smt_class != SMT_ECF))) {
567 		DB_SMT("SMT: info length error, len = %d\n",sm->smt_len,0) ;
568 		smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,local) ;
569 		smt_free_mbuf(smc,mb) ;
570 		return ;
571 	}
572 	switch (sm->smt_class) {
573 	case SMT_NIF :
574 		if (smt_check_para(smc,sm,plist_nif)) {
575 			DB_SMT("SMT: NIF with para problem, ignoring\n",0,0) ;
576 			break ;
577 		}
578 		switch (sm->smt_type) {
579 		case SMT_ANNOUNCE :
580 		case SMT_REQUEST :
581 			if (!(fs & C_INDICATOR) && m_fc(mb) == FC_SMT_NSA
582 				&& is_broadcast(&sm->smt_dest)) {
583 				struct smt_p_state	*st ;
584 
585 				/* set my UNA */
586 				if (!is_equal(
587 					&smc->mib.m[MAC0].fddiMACUpstreamNbr,
588 					&sm->smt_source)) {
589 					DB_SMT("SMT : updated my UNA = %s\n",
590 					addr_to_string(&sm->smt_source),0) ;
591 					if (!is_equal(&smc->mib.m[MAC0].
592 					    fddiMACUpstreamNbr,&SMT_Unknown)){
593 					 /* Do not update unknown address */
594 					 smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
595 					 smc->mib.m[MAC0].fddiMACUpstreamNbr ;
596 					}
597 
598 					smc->mib.m[MAC0].fddiMACUpstreamNbr =
599 						sm->smt_source ;
600 					smt_srf_event(smc,
601 						SMT_EVENT_MAC_NEIGHBOR_CHANGE,
602 						INDEX_MAC,0) ;
603 					smt_echo_test(smc,0) ;
604 				}
605 				smc->sm.smt_tvu = smt_get_time() ;
606 				st = (struct smt_p_state *)
607 					sm_to_para(smc,sm,SMT_P_STATE) ;
608 				if (st) {
609 					smc->mib.m[MAC0].fddiMACUNDA_Flag =
610 					(st->st_dupl_addr & SMT_ST_MY_DUPA) ?
611 					TRUE : FALSE ;
612 					update_dac(smc,1) ;
613 				}
614 			}
615 			if ((sm->smt_type == SMT_REQUEST) &&
616 			    is_individual(&sm->smt_source) &&
617 			    ((!(fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) ||
618 			     (m_fc(mb) != FC_SMT_NSA))) {
619 				DB_SMT("SMT : replying to NIF request %s\n",
620 					addr_to_string(&sm->smt_source),0) ;
621 				smt_send_nif(smc,&sm->smt_source,
622 					FC_SMT_INFO,
623 					sm->smt_tid,
624 					SMT_REPLY,local) ;
625 			}
626 			break ;
627 		case SMT_REPLY :
628 			DB_SMT("SMT : received NIF response from %s\n",
629 				addr_to_string(&sm->smt_source),0) ;
630 			if (fs & A_INDICATOR) {
631 				smc->sm.pend[SMT_TID_NIF] = 0 ;
632 				DB_SMT("SMT : duplicate address\n",0,0) ;
633 				smc->mib.m[MAC0].fddiMACDupAddressTest =
634 					DA_FAILED ;
635 				smc->r.dup_addr_test = DA_FAILED ;
636 				queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
637 				smc->mib.m[MAC0].fddiMACDA_Flag = TRUE ;
638 				update_dac(smc,1) ;
639 				break ;
640 			}
641 			if (sm->smt_tid == smc->sm.pend[SMT_TID_NIF]) {
642 				smc->sm.pend[SMT_TID_NIF] = 0 ;
643 				/* set my DNA */
644 				if (!is_equal(
645 					&smc->mib.m[MAC0].fddiMACDownstreamNbr,
646 					&sm->smt_source)) {
647 					DB_SMT("SMT : updated my DNA\n",0,0) ;
648 					if (!is_equal(&smc->mib.m[MAC0].
649 					 fddiMACDownstreamNbr, &SMT_Unknown)){
650 					 /* Do not update unknown address */
651 				smc->mib.m[MAC0].fddiMACOldDownstreamNbr =
652 					 smc->mib.m[MAC0].fddiMACDownstreamNbr ;
653 					}
654 
655 					smc->mib.m[MAC0].fddiMACDownstreamNbr =
656 						sm->smt_source ;
657 					smt_srf_event(smc,
658 						SMT_EVENT_MAC_NEIGHBOR_CHANGE,
659 						INDEX_MAC,0) ;
660 					smt_echo_test(smc,1) ;
661 				}
662 				smc->mib.m[MAC0].fddiMACDA_Flag = FALSE ;
663 				update_dac(smc,1) ;
664 				smc->sm.smt_tvd = smt_get_time() ;
665 				smc->mib.m[MAC0].fddiMACDupAddressTest =
666 					DA_PASSED ;
667 				if (smc->r.dup_addr_test != DA_PASSED) {
668 					smc->r.dup_addr_test = DA_PASSED ;
669 					queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
670 				}
671 			}
672 			else if (sm->smt_tid ==
673 				smc->sm.pend[SMT_TID_NIF_TEST]) {
674 				DB_SMT("SMT : NIF test TID ok\n",0,0) ;
675 			}
676 			else {
677 				DB_SMT("SMT : expected TID %lx, got %lx\n",
678 				smc->sm.pend[SMT_TID_NIF],sm->smt_tid) ;
679 			}
680 			break ;
681 		default :
682 			illegal = 2 ;
683 			break ;
684 		}
685 		break ;
686 	case SMT_SIF_CONFIG :	/* station information */
687 		if (sm->smt_type != SMT_REQUEST)
688 			break ;
689 		DB_SMT("SMT : replying to SIF Config request from %s\n",
690 			addr_to_string(&sm->smt_source),0) ;
691 		smt_send_sif_config(smc,&sm->smt_source,sm->smt_tid,local) ;
692 		break ;
693 	case SMT_SIF_OPER :	/* station information */
694 		if (sm->smt_type != SMT_REQUEST)
695 			break ;
696 		DB_SMT("SMT : replying to SIF Operation request from %s\n",
697 			addr_to_string(&sm->smt_source),0) ;
698 		smt_send_sif_operation(smc,&sm->smt_source,sm->smt_tid,local) ;
699 		break ;
700 	case SMT_ECF :		/* echo frame */
701 		switch (sm->smt_type) {
702 		case SMT_REPLY :
703 			smc->mib.priv.fddiPRIVECF_Reply_Rx++ ;
704 			DB_SMT("SMT: received ECF reply from %s\n",
705 				addr_to_string(&sm->smt_source),0) ;
706 			if (sm_to_para(smc,sm,SMT_P_ECHODATA) == NULL) {
707 				DB_SMT("SMT: ECHODATA missing\n",0,0) ;
708 				break ;
709 			}
710 			if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
711 				DB_SMT("SMT : ECF test TID ok\n",0,0) ;
712 			}
713 			else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
714 				DB_SMT("SMT : ECF test UNA ok\n",0,0) ;
715 			}
716 			else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
717 				DB_SMT("SMT : ECF test DNA ok\n",0,0) ;
718 			}
719 			else {
720 				DB_SMT("SMT : expected TID %lx, got %lx\n",
721 					smc->sm.pend[SMT_TID_ECF],
722 					sm->smt_tid) ;
723 			}
724 			break ;
725 		case SMT_REQUEST :
726 			smc->mib.priv.fddiPRIVECF_Req_Rx++ ;
727 			{
728 			if (sm->smt_len && !sm_to_para(smc,sm,SMT_P_ECHODATA)) {
729 			DB_SMT("SMT: ECF with para problem,sending RDF\n",0,0) ;
730 				smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,
731 					local) ;
732 				break ;
733 			}
734 			DB_SMT("SMT - sending ECF reply to %s\n",
735 				addr_to_string(&sm->smt_source),0) ;
736 
737 			/* set destination addr.  & reply */
738 			sm->smt_dest = sm->smt_source ;
739 			sm->smt_type = SMT_REPLY ;
740 			dump_smt(smc,sm,"ECF REPLY") ;
741 			smc->mib.priv.fddiPRIVECF_Reply_Tx++ ;
742 			smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
743 			return ;		/* DON'T free mbuf */
744 			}
745 		default :
746 			illegal = 1 ;
747 			break ;
748 		}
749 		break ;
750 #ifndef	BOOT
751 	case SMT_RAF :		/* resource allocation */
752 #ifdef	ESS
753 		DB_ESSN(2,"ESS: RAF frame received\n",0,0) ;
754 		fs = ess_raf_received_pack(smc,mb,sm,fs) ;
755 #endif
756 
757 #ifdef	SBA
758 		DB_SBAN(2,"SBA: RAF frame received\n",0,0) ;
759 		sba_raf_received_pack(smc,sm,fs) ;
760 #endif
761 		break ;
762 	case SMT_RDF :		/* request denied */
763 		smc->mib.priv.fddiPRIVRDF_Rx++ ;
764 		break ;
765 	case SMT_ESF :		/* extended service - not supported */
766 		if (sm->smt_type == SMT_REQUEST) {
767 			DB_SMT("SMT - received ESF, sending RDF\n",0,0) ;
768 			smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
769 		}
770 		break ;
771 	case SMT_PMF_GET :
772 	case SMT_PMF_SET :
773 		if (sm->smt_type != SMT_REQUEST)
774 			break ;
775 		/* update statistics */
776 		if (sm->smt_class == SMT_PMF_GET)
777 			smc->mib.priv.fddiPRIVPMF_Get_Rx++ ;
778 		else
779 			smc->mib.priv.fddiPRIVPMF_Set_Rx++ ;
780 		/*
781 		 * ignore PMF SET with I/G set
782 		 */
783 		if ((sm->smt_class == SMT_PMF_SET) &&
784 			!is_individual(&sm->smt_dest)) {
785 			DB_SMT("SMT: ignoring PMF-SET with I/G set\n",0,0) ;
786 			break ;
787 		}
788 		smt_pmf_received_pack(smc,mb, local) ;
789 		break ;
790 	case SMT_SRF :
791 		dump_smt(smc,sm,"SRF received") ;
792 		break ;
793 	default :
794 		if (sm->smt_type != SMT_REQUEST)
795 			break ;
796 		/*
797 		 * For frames with unknown class:
798 		 * we need to send a RDF frame according to 8.1.3.1.1,
799 		 * only if it is a REQUEST.
800 		 */
801 		DB_SMT("SMT : class = %d, send RDF to %s\n",
802 			sm->smt_class, addr_to_string(&sm->smt_source)) ;
803 
804 		smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
805 		break ;
806 #endif
807 	}
808 	if (illegal) {
809 		DB_SMT("SMT: discarding invalid frame, reason = %d\n",
810 			illegal,0) ;
811 	}
812 	smt_free_mbuf(smc,mb) ;
813 }
814 
update_dac(struct s_smc * smc,int report)815 static void update_dac(struct s_smc *smc, int report)
816 {
817 	int	cond ;
818 
819 	cond = ( smc->mib.m[MAC0].fddiMACUNDA_Flag |
820 		smc->mib.m[MAC0].fddiMACDA_Flag) != 0 ;
821 	if (report && (cond != smc->mib.m[MAC0].fddiMACDuplicateAddressCond))
822 		smt_srf_event(smc, SMT_COND_MAC_DUP_ADDR,INDEX_MAC,cond) ;
823 	else
824 		smc->mib.m[MAC0].fddiMACDuplicateAddressCond = cond ;
825 }
826 
827 /*
828  * send SMT frame
829  *	set source address
830  *	set station ID
831  *	send frame
832  */
smt_send_frame(struct s_smc * smc,SMbuf * mb,int fc,int local)833 void smt_send_frame(struct s_smc *smc, SMbuf *mb, int fc, int local)
834 /* SMbuf *mb;	buffer to send */
835 /* int fc;	FC value */
836 {
837 	struct smt_header	*sm ;
838 
839 	if (!smc->r.sm_ma_avail && !local) {
840 		smt_free_mbuf(smc,mb) ;
841 		return ;
842 	}
843 	sm = smtod(mb,struct smt_header *) ;
844 	sm->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
845 	sm->smt_sid = smc->mib.fddiSMTStationId ;
846 
847 	smt_swap_para(sm,(int) mb->sm_len,0) ;		/* swap para & header */
848 	hwm_conv_can(smc,(char *)sm,12) ;		/* convert SA and DA */
849 	smc->mib.m[MAC0].fddiMACSMTTransmit_Ct++ ;
850 	smt_send_mbuf(smc,mb,local ? FC_SMT_LOC : fc) ;
851 }
852 
853 /*
854  * generate and send RDF
855  */
smt_send_rdf(struct s_smc * smc,SMbuf * rej,int fc,int reason,int local)856 static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
857 			 int local)
858 /* SMbuf *rej;	mbuf of offending frame */
859 /* int fc;	FC of denied frame */
860 /* int reason;	reason code */
861 {
862 	SMbuf	*mb ;
863 	struct smt_header	*sm ;	/* header of offending frame */
864 	struct smt_rdf	*rdf ;
865 	int		len ;
866 	int		frame_len ;
867 
868 	sm = smtod(rej,struct smt_header *) ;
869 	if (sm->smt_type != SMT_REQUEST)
870 		return ;
871 
872 	DB_SMT("SMT: sending RDF to %s,reason = 0x%x\n",
873 		addr_to_string(&sm->smt_source),reason) ;
874 
875 
876 	/*
877 	 * note: get framelength from MAC length, NOT from SMT header
878 	 * smt header length is included in sm_len
879 	 */
880 	frame_len = rej->sm_len ;
881 
882 	if (!(mb=smt_build_frame(smc,SMT_RDF,SMT_REPLY,sizeof(struct smt_rdf))))
883 		return ;
884 	rdf = smtod(mb,struct smt_rdf *) ;
885 	rdf->smt.smt_tid = sm->smt_tid ;		/* use TID from sm */
886 	rdf->smt.smt_dest = sm->smt_source ;		/* set dest = source */
887 
888 	/* set P12 */
889 	rdf->reason.para.p_type = SMT_P_REASON ;
890 	rdf->reason.para.p_len = sizeof(struct smt_p_reason) - PARA_LEN ;
891 	rdf->reason.rdf_reason = reason ;
892 
893 	/* set P14 */
894 	rdf->version.para.p_type = SMT_P_VERSION ;
895 	rdf->version.para.p_len = sizeof(struct smt_p_version) - PARA_LEN ;
896 	rdf->version.v_pad = 0 ;
897 	rdf->version.v_n = 1 ;
898 	rdf->version.v_index = 1 ;
899 	rdf->version.v_version[0] = SMT_VID_2 ;
900 	rdf->version.v_pad2 = 0 ;
901 
902 	/* set P13 */
903 	if ((unsigned) frame_len <= SMT_MAX_INFO_LEN - sizeof(*rdf) +
904 		2*sizeof(struct smt_header))
905 		len = frame_len ;
906 	else
907 		len = SMT_MAX_INFO_LEN - sizeof(*rdf) +
908 			2*sizeof(struct smt_header) ;
909 	/* make length multiple of 4 */
910 	len &= ~3 ;
911 	rdf->refused.para.p_type = SMT_P_REFUSED ;
912 	/* length of para is smt_frame + ref_fc */
913 	rdf->refused.para.p_len = len + 4 ;
914 	rdf->refused.ref_fc = fc ;
915 
916 	/* swap it back */
917 	smt_swap_para(sm,frame_len,0) ;
918 
919 	memcpy((char *) &rdf->refused.ref_header,(char *) sm,len) ;
920 
921 	len -= sizeof(struct smt_header) ;
922 	mb->sm_len += len ;
923 	rdf->smt.smt_len += len ;
924 
925 	dump_smt(smc,(struct smt_header *)rdf,"RDF") ;
926 	smc->mib.priv.fddiPRIVRDF_Tx++ ;
927 	smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
928 }
929 
930 /*
931  * generate and send NIF
932  */
smt_send_nif(struct s_smc * smc,const struct fddi_addr * dest,int fc,u_long tid,int type,int local)933 static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest,
934 			 int fc, u_long tid, int type, int local)
935 /* struct fddi_addr *dest;	dest address */
936 /* int fc;			frame control */
937 /* u_long tid;			transaction id */
938 /* int type;			frame type */
939 {
940 	struct smt_nif	*nif ;
941 	SMbuf		*mb ;
942 
943 	if (!(mb = smt_build_frame(smc,SMT_NIF,type,sizeof(struct smt_nif))))
944 		return ;
945 	nif = smtod(mb, struct smt_nif *) ;
946 	smt_fill_una(smc,&nif->una) ;	/* set UNA */
947 	smt_fill_sde(smc,&nif->sde) ;	/* set station descriptor */
948 	smt_fill_state(smc,&nif->state) ;	/* set state information */
949 #ifdef	SMT6_10
950 	smt_fill_fsc(smc,&nif->fsc) ;	/* set frame status cap. */
951 #endif
952 	nif->smt.smt_dest = *dest ;	/* destination address */
953 	nif->smt.smt_tid = tid ;	/* transaction ID */
954 	dump_smt(smc,(struct smt_header *)nif,"NIF") ;
955 	smt_send_frame(smc,mb,fc,local) ;
956 }
957 
958 #ifdef	DEBUG
959 /*
960  * send NIF request (test purpose)
961  */
smt_send_nif_request(struct s_smc * smc,struct fddi_addr * dest)962 static void smt_send_nif_request(struct s_smc *smc, struct fddi_addr *dest)
963 {
964 	smc->sm.pend[SMT_TID_NIF_TEST] = smt_get_tid(smc) ;
965 	smt_send_nif(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_NIF_TEST],
966 		SMT_REQUEST,0) ;
967 }
968 
969 /*
970  * send ECF request (test purpose)
971  */
smt_send_ecf_request(struct s_smc * smc,struct fddi_addr * dest,int len)972 static void smt_send_ecf_request(struct s_smc *smc, struct fddi_addr *dest,
973 				 int len)
974 {
975 	smc->sm.pend[SMT_TID_ECF] = smt_get_tid(smc) ;
976 	smt_send_ecf(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_ECF],
977 		SMT_REQUEST,len) ;
978 }
979 #endif
980 
981 /*
982  * echo test
983  */
smt_echo_test(struct s_smc * smc,int dna)984 static void smt_echo_test(struct s_smc *smc, int dna)
985 {
986 	u_long	tid ;
987 
988 	smc->sm.pend[dna ? SMT_TID_ECF_DNA : SMT_TID_ECF_UNA] =
989 		tid = smt_get_tid(smc) ;
990 	smt_send_ecf(smc, dna ?
991 		&smc->mib.m[MAC0].fddiMACDownstreamNbr :
992 		&smc->mib.m[MAC0].fddiMACUpstreamNbr,
993 		FC_SMT_INFO,tid, SMT_REQUEST, (SMT_TEST_ECHO_LEN & ~3)-8) ;
994 }
995 
996 /*
997  * generate and send ECF
998  */
smt_send_ecf(struct s_smc * smc,struct fddi_addr * dest,int fc,u_long tid,int type,int len)999 static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
1000 			 u_long tid, int type, int len)
1001 /* struct fddi_addr *dest;	dest address */
1002 /* int fc;			frame control */
1003 /* u_long tid;			transaction id */
1004 /* int type;			frame type */
1005 /* int len;			frame length */
1006 {
1007 	struct smt_ecf	*ecf ;
1008 	SMbuf		*mb ;
1009 
1010 	if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
1011 		return ;
1012 	ecf = smtod(mb, struct smt_ecf *) ;
1013 
1014 	smt_fill_echo(smc,&ecf->ec_echo,tid,len) ;	/* set ECHO */
1015 	ecf->smt.smt_dest = *dest ;	/* destination address */
1016 	ecf->smt.smt_tid = tid ;	/* transaction ID */
1017 	smc->mib.priv.fddiPRIVECF_Req_Tx++ ;
1018 	smt_send_frame(smc,mb,fc,0) ;
1019 }
1020 
1021 /*
1022  * generate and send SIF config response
1023  */
1024 
smt_send_sif_config(struct s_smc * smc,struct fddi_addr * dest,u_long tid,int local)1025 static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
1026 				u_long tid, int local)
1027 /* struct fddi_addr *dest;	dest address */
1028 /* u_long tid;			transaction id */
1029 {
1030 	struct smt_sif_config	*sif ;
1031 	SMbuf			*mb ;
1032 	int			len ;
1033 	if (!(mb = smt_build_frame(smc,SMT_SIF_CONFIG,SMT_REPLY,
1034 		SIZEOF_SMT_SIF_CONFIG)))
1035 		return ;
1036 
1037 	sif = smtod(mb, struct smt_sif_config *) ;
1038 	smt_fill_timestamp(smc,&sif->ts) ;	/* set time stamp */
1039 	smt_fill_sde(smc,&sif->sde) ;		/* set station descriptor */
1040 	smt_fill_version(smc,&sif->version) ;	/* set version information */
1041 	smt_fill_state(smc,&sif->state) ;	/* set state information */
1042 	smt_fill_policy(smc,&sif->policy) ;	/* set station policy */
1043 	smt_fill_latency(smc,&sif->latency);	/* set station latency */
1044 	smt_fill_neighbor(smc,&sif->neighbor);	/* set station neighbor */
1045 	smt_fill_setcount(smc,&sif->setcount) ;	/* set count */
1046 	len = smt_fill_path(smc,&sif->path);	/* set station path descriptor*/
1047 	sif->smt.smt_dest = *dest ;		/* destination address */
1048 	sif->smt.smt_tid = tid ;		/* transaction ID */
1049 	smt_add_frame_len(mb,len) ;		/* adjust length fields */
1050 	dump_smt(smc,(struct smt_header *)sif,"SIF Configuration Reply") ;
1051 	smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1052 }
1053 
1054 /*
1055  * generate and send SIF operation response
1056  */
1057 
smt_send_sif_operation(struct s_smc * smc,struct fddi_addr * dest,u_long tid,int local)1058 static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
1059 				   u_long tid, int local)
1060 /* struct fddi_addr *dest;	dest address */
1061 /* u_long tid;			transaction id */
1062 {
1063 	struct smt_sif_operation *sif ;
1064 	SMbuf			*mb ;
1065 	int			ports ;
1066 	int			i ;
1067 
1068 	ports = NUMPHYS ;
1069 #ifndef	CONCENTRATOR
1070 	if (smc->s.sas == SMT_SAS)
1071 		ports = 1 ;
1072 #endif
1073 
1074 	if (!(mb = smt_build_frame(smc,SMT_SIF_OPER,SMT_REPLY,
1075 		SIZEOF_SMT_SIF_OPERATION+ports*sizeof(struct smt_p_lem))))
1076 		return ;
1077 	sif = smtod(mb, struct smt_sif_operation *) ;
1078 	smt_fill_timestamp(smc,&sif->ts) ;	/* set time stamp */
1079 	smt_fill_mac_status(smc,&sif->status) ; /* set mac status */
1080 	smt_fill_mac_counter(smc,&sif->mc) ; /* set mac counter field */
1081 	smt_fill_mac_fnc(smc,&sif->fnc) ; /* set frame not copied counter */
1082 	smt_fill_manufacturer(smc,&sif->man) ; /* set manufacturer field */
1083 	smt_fill_user(smc,&sif->user) ;		/* set user field */
1084 	smt_fill_setcount(smc,&sif->setcount) ;	/* set count */
1085 	/*
1086 	 * set link error mon information
1087 	 */
1088 	if (ports == 1) {
1089 		smt_fill_lem(smc,sif->lem,PS) ;
1090 	}
1091 	else {
1092 		for (i = 0 ; i < ports ; i++) {
1093 			smt_fill_lem(smc,&sif->lem[i],i) ;
1094 		}
1095 	}
1096 
1097 	sif->smt.smt_dest = *dest ;	/* destination address */
1098 	sif->smt.smt_tid = tid ;	/* transaction ID */
1099 	dump_smt(smc,(struct smt_header *)sif,"SIF Operation Reply") ;
1100 	smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1101 }
1102 
1103 /*
1104  * get and initialize SMT frame
1105  */
smt_build_frame(struct s_smc * smc,int class,int type,int length)1106 SMbuf *smt_build_frame(struct s_smc *smc, int class, int type,
1107 				  int length)
1108 {
1109 	SMbuf			*mb ;
1110 	struct smt_header	*smt ;
1111 
1112 #if	0
1113 	if (!smc->r.sm_ma_avail) {
1114 		return 0;
1115 	}
1116 #endif
1117 	if (!(mb = smt_get_mbuf(smc)))
1118 		return mb;
1119 
1120 	mb->sm_len = length ;
1121 	smt = smtod(mb, struct smt_header *) ;
1122 	smt->smt_dest = fddi_broadcast ; /* set dest = broadcast */
1123 	smt->smt_class = class ;
1124 	smt->smt_type = type ;
1125 	switch (class) {
1126 	case SMT_NIF :
1127 	case SMT_SIF_CONFIG :
1128 	case SMT_SIF_OPER :
1129 	case SMT_ECF :
1130 		smt->smt_version = SMT_VID ;
1131 		break ;
1132 	default :
1133 		smt->smt_version = SMT_VID_2 ;
1134 		break ;
1135 	}
1136 	smt->smt_tid = smt_get_tid(smc) ;	/* set transaction ID */
1137 	smt->smt_pad = 0 ;
1138 	smt->smt_len = length - sizeof(struct smt_header) ;
1139 	return mb;
1140 }
1141 
smt_add_frame_len(SMbuf * mb,int len)1142 static void smt_add_frame_len(SMbuf *mb, int len)
1143 {
1144 	struct smt_header	*smt ;
1145 
1146 	smt = smtod(mb, struct smt_header *) ;
1147 	smt->smt_len += len ;
1148 	mb->sm_len += len ;
1149 }
1150 
1151 
1152 
1153 /*
1154  * fill values in UNA parameter
1155  */
smt_fill_una(struct s_smc * smc,struct smt_p_una * una)1156 static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una)
1157 {
1158 	SMTSETPARA(una,SMT_P_UNA) ;
1159 	una->una_pad = 0 ;
1160 	una->una_node = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1161 }
1162 
1163 /*
1164  * fill values in SDE parameter
1165  */
smt_fill_sde(struct s_smc * smc,struct smt_p_sde * sde)1166 static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde)
1167 {
1168 	SMTSETPARA(sde,SMT_P_SDE) ;
1169 	sde->sde_non_master = smc->mib.fddiSMTNonMaster_Ct ;
1170 	sde->sde_master = smc->mib.fddiSMTMaster_Ct ;
1171 	sde->sde_mac_count = NUMMACS ;		/* only 1 MAC */
1172 #ifdef	CONCENTRATOR
1173 	sde->sde_type = SMT_SDE_CONCENTRATOR ;
1174 #else
1175 	sde->sde_type = SMT_SDE_STATION ;
1176 #endif
1177 }
1178 
1179 /*
1180  * fill in values in station state parameter
1181  */
smt_fill_state(struct s_smc * smc,struct smt_p_state * state)1182 static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state)
1183 {
1184 	int	top ;
1185 	int	twist ;
1186 
1187 	SMTSETPARA(state,SMT_P_STATE) ;
1188 	state->st_pad = 0 ;
1189 
1190 	/* determine topology */
1191 	top = 0 ;
1192 	if (smc->mib.fddiSMTPeerWrapFlag) {
1193 		top |= SMT_ST_WRAPPED ;		/* state wrapped */
1194 	}
1195 #ifdef	CONCENTRATOR
1196 	if (cfm_status_unattached(smc)) {
1197 		top |= SMT_ST_UNATTACHED ;	/* unattached concentrator */
1198 	}
1199 #endif
1200 	if ((twist = pcm_status_twisted(smc)) & 1) {
1201 		top |= SMT_ST_TWISTED_A ;	/* twisted cable */
1202 	}
1203 	if (twist & 2) {
1204 		top |= SMT_ST_TWISTED_B ;	/* twisted cable */
1205 	}
1206 #ifdef	OPT_SRF
1207 	top |= SMT_ST_SRF ;
1208 #endif
1209 	if (pcm_rooted_station(smc))
1210 		top |= SMT_ST_ROOTED_S ;
1211 	if (smc->mib.a[0].fddiPATHSbaPayload != 0)
1212 		top |= SMT_ST_SYNC_SERVICE ;
1213 	state->st_topology = top ;
1214 	state->st_dupl_addr =
1215 		((smc->mib.m[MAC0].fddiMACDA_Flag ? SMT_ST_MY_DUPA : 0 ) |
1216 		 (smc->mib.m[MAC0].fddiMACUNDA_Flag ? SMT_ST_UNA_DUPA : 0)) ;
1217 }
1218 
1219 /*
1220  * fill values in timestamp parameter
1221  */
smt_fill_timestamp(struct s_smc * smc,struct smt_p_timestamp * ts)1222 static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts)
1223 {
1224 
1225 	SMTSETPARA(ts,SMT_P_TIMESTAMP) ;
1226 	smt_set_timestamp(smc,ts->ts_time) ;
1227 }
1228 
smt_set_timestamp(struct s_smc * smc,u_char * p)1229 void smt_set_timestamp(struct s_smc *smc, u_char *p)
1230 {
1231 	u_long	time ;
1232 	u_long	utime ;
1233 
1234 	/*
1235 	 * timestamp is 64 bits long ; resolution is 80 nS
1236 	 * our clock resolution is 10mS
1237 	 * 10mS/80ns = 125000 ~ 2^17 = 131072
1238 	 */
1239 	utime = smt_get_time() ;
1240 	time = utime * 100 ;
1241 	time /= TICKS_PER_SECOND ;
1242 	p[0] = 0 ;
1243 	p[1] = (u_char)((time>>(8+8+8+8-1)) & 1) ;
1244 	p[2] = (u_char)(time>>(8+8+8-1)) ;
1245 	p[3] = (u_char)(time>>(8+8-1)) ;
1246 	p[4] = (u_char)(time>>(8-1)) ;
1247 	p[5] = (u_char)(time<<1) ;
1248 	p[6] = (u_char)(smc->sm.uniq_ticks>>8) ;
1249 	p[7] = (u_char)smc->sm.uniq_ticks ;
1250 	/*
1251 	 * make sure we don't wrap: restart whenever the upper digits change
1252 	 */
1253 	if (utime != smc->sm.uniq_time) {
1254 		smc->sm.uniq_ticks = 0 ;
1255 	}
1256 	smc->sm.uniq_ticks++ ;
1257 	smc->sm.uniq_time = utime ;
1258 }
1259 
1260 /*
1261  * fill values in station policy parameter
1262  */
smt_fill_policy(struct s_smc * smc,struct smt_p_policy * policy)1263 static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy)
1264 {
1265 	int	i ;
1266 	const u_char *map ;
1267 	u_short	in ;
1268 	u_short	out ;
1269 
1270 	/*
1271 	 * MIB para 101b (fddiSMTConnectionPolicy) coding
1272 	 * is different from 0005 coding
1273 	 */
1274 	static const u_char ansi_weirdness[16] = {
1275 		0,7,5,3,8,1,6,4,9,10,2,11,12,13,14,15
1276 	} ;
1277 	SMTSETPARA(policy,SMT_P_POLICY) ;
1278 
1279 	out = 0 ;
1280 	in = smc->mib.fddiSMTConnectionPolicy ;
1281 	for (i = 0, map = ansi_weirdness ; i < 16 ; i++) {
1282 		if (in & 1)
1283 			out |= (1<<*map) ;
1284 		in >>= 1 ;
1285 		map++ ;
1286 	}
1287 	policy->pl_config = smc->mib.fddiSMTConfigPolicy ;
1288 	policy->pl_connect = out ;
1289 }
1290 
1291 /*
1292  * fill values in latency equivalent parameter
1293  */
smt_fill_latency(struct s_smc * smc,struct smt_p_latency * latency)1294 static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency)
1295 {
1296 	SMTSETPARA(latency,SMT_P_LATENCY) ;
1297 
1298 	latency->lt_phyout_idx1 = phy_index(smc,0) ;
1299 	latency->lt_latency1 = 10 ;	/* in octets (byte clock) */
1300 	/*
1301 	 * note: latency has two phy entries by definition
1302 	 * for a SAS, the 2nd one is null
1303 	 */
1304 	if (smc->s.sas == SMT_DAS) {
1305 		latency->lt_phyout_idx2 = phy_index(smc,1) ;
1306 		latency->lt_latency2 = 10 ;	/* in octets (byte clock) */
1307 	}
1308 	else {
1309 		latency->lt_phyout_idx2 = 0 ;
1310 		latency->lt_latency2 = 0 ;
1311 	}
1312 }
1313 
1314 /*
1315  * fill values in MAC neighbors parameter
1316  */
smt_fill_neighbor(struct s_smc * smc,struct smt_p_neighbor * neighbor)1317 static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor)
1318 {
1319 	SMTSETPARA(neighbor,SMT_P_NEIGHBORS) ;
1320 
1321 	neighbor->nb_mib_index = INDEX_MAC ;
1322 	neighbor->nb_mac_index = mac_index(smc,1) ;
1323 	neighbor->nb_una = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1324 	neighbor->nb_dna = smc->mib.m[MAC0].fddiMACDownstreamNbr ;
1325 }
1326 
1327 /*
1328  * fill values in path descriptor
1329  */
1330 #ifdef	CONCENTRATOR
1331 #define ALLPHYS	NUMPHYS
1332 #else
1333 #define ALLPHYS	((smc->s.sas == SMT_SAS) ? 1 : 2)
1334 #endif
1335 
smt_fill_path(struct s_smc * smc,struct smt_p_path * path)1336 static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path)
1337 {
1338 	SK_LOC_DECL(int,type) ;
1339 	SK_LOC_DECL(int,state) ;
1340 	SK_LOC_DECL(int,remote) ;
1341 	SK_LOC_DECL(int,mac) ;
1342 	int	len ;
1343 	int	p ;
1344 	int	physp ;
1345 	struct smt_phy_rec	*phy ;
1346 	struct smt_mac_rec	*pd_mac ;
1347 
1348 	len =	PARA_LEN +
1349 		sizeof(struct smt_mac_rec) * NUMMACS +
1350 		sizeof(struct smt_phy_rec) * ALLPHYS ;
1351 	path->para.p_type = SMT_P_PATH ;
1352 	path->para.p_len = len - PARA_LEN ;
1353 
1354 	/* PHYs */
1355 	for (p = 0,phy = path->pd_phy ; p < ALLPHYS ; p++, phy++) {
1356 		physp = p ;
1357 #ifndef	CONCENTRATOR
1358 		if (smc->s.sas == SMT_SAS)
1359 			physp = PS ;
1360 #endif
1361 		pcm_status_state(smc,physp,&type,&state,&remote,&mac) ;
1362 #ifdef	LITTLE_ENDIAN
1363 		phy->phy_mib_index = smt_swap_short((u_short)p+INDEX_PORT) ;
1364 #else
1365 		phy->phy_mib_index = p+INDEX_PORT ;
1366 #endif
1367 		phy->phy_type = type ;
1368 		phy->phy_connect_state = state ;
1369 		phy->phy_remote_type = remote ;
1370 		phy->phy_remote_mac = mac ;
1371 		phy->phy_resource_idx = phy_con_resource_index(smc,p) ;
1372 	}
1373 
1374 	/* MAC */
1375 	pd_mac = (struct smt_mac_rec *) phy ;
1376 	pd_mac->mac_addr = smc->mib.m[MAC0].fddiMACSMTAddress ;
1377 	pd_mac->mac_resource_idx = mac_con_resource_index(smc,1) ;
1378 	return len;
1379 }
1380 
1381 /*
1382  * fill values in mac status
1383  */
smt_fill_mac_status(struct s_smc * smc,struct smt_p_mac_status * st)1384 static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st)
1385 {
1386 	SMTSETPARA(st,SMT_P_MAC_STATUS) ;
1387 
1388 	st->st_mib_index = INDEX_MAC ;
1389 	st->st_mac_index = mac_index(smc,1) ;
1390 
1391 	mac_update_counter(smc) ;
1392 	/*
1393 	 * timer values are represented in SMT as 2's complement numbers
1394 	 * units :	internal :  2's complement BCLK
1395 	 */
1396 	st->st_t_req = smc->mib.m[MAC0].fddiMACT_Req ;
1397 	st->st_t_neg = smc->mib.m[MAC0].fddiMACT_Neg ;
1398 	st->st_t_max = smc->mib.m[MAC0].fddiMACT_Max ;
1399 	st->st_tvx_value = smc->mib.m[MAC0].fddiMACTvxValue ;
1400 	st->st_t_min = smc->mib.m[MAC0].fddiMACT_Min ;
1401 
1402 	st->st_sba = smc->mib.a[PATH0].fddiPATHSbaPayload ;
1403 	st->st_frame_ct = smc->mib.m[MAC0].fddiMACFrame_Ct ;
1404 	st->st_error_ct = smc->mib.m[MAC0].fddiMACError_Ct ;
1405 	st->st_lost_ct = smc->mib.m[MAC0].fddiMACLost_Ct ;
1406 }
1407 
1408 /*
1409  * fill values in LEM status
1410  */
smt_fill_lem(struct s_smc * smc,struct smt_p_lem * lem,int phy)1411 static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy)
1412 {
1413 	struct fddi_mib_p	*mib ;
1414 
1415 	mib = smc->y[phy].mib ;
1416 
1417 	SMTSETPARA(lem,SMT_P_LEM) ;
1418 	lem->lem_mib_index = phy+INDEX_PORT ;
1419 	lem->lem_phy_index = phy_index(smc,phy) ;
1420 	lem->lem_pad2 = 0 ;
1421 	lem->lem_cutoff = mib->fddiPORTLer_Cutoff ;
1422 	lem->lem_alarm = mib->fddiPORTLer_Alarm ;
1423 	/* long term bit error rate */
1424 	lem->lem_estimate = mib->fddiPORTLer_Estimate ;
1425 	/* # of rejected connections */
1426 	lem->lem_reject_ct = mib->fddiPORTLem_Reject_Ct ;
1427 	lem->lem_ct = mib->fddiPORTLem_Ct ;	/* total number of errors */
1428 }
1429 
1430 /*
1431  * fill version parameter
1432  */
smt_fill_version(struct s_smc * smc,struct smt_p_version * vers)1433 static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers)
1434 {
1435 	SK_UNUSED(smc) ;
1436 	SMTSETPARA(vers,SMT_P_VERSION) ;
1437 	vers->v_pad = 0 ;
1438 	vers->v_n = 1 ;				/* one version is enough .. */
1439 	vers->v_index = 1 ;
1440 	vers->v_version[0] = SMT_VID_2 ;
1441 	vers->v_pad2 = 0 ;
1442 }
1443 
1444 #ifdef	SMT6_10
1445 /*
1446  * fill frame status capabilities
1447  */
1448 /*
1449  * note: this para 200B is NOT in swap table, because it's also set in
1450  * PMF add_para
1451  */
smt_fill_fsc(struct s_smc * smc,struct smt_p_fsc * fsc)1452 static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc)
1453 {
1454 	SK_UNUSED(smc) ;
1455 	SMTSETPARA(fsc,SMT_P_FSC) ;
1456 	fsc->fsc_pad0 = 0 ;
1457 	fsc->fsc_mac_index = INDEX_MAC ;	/* this is MIB ; MIB is NOT
1458 						 * mac_index ()i !
1459 						 */
1460 	fsc->fsc_pad1 = 0 ;
1461 	fsc->fsc_value = FSC_TYPE0 ;		/* "normal" node */
1462 #ifdef	LITTLE_ENDIAN
1463 	fsc->fsc_mac_index = smt_swap_short(INDEX_MAC) ;
1464 	fsc->fsc_value = smt_swap_short(FSC_TYPE0) ;
1465 #endif
1466 }
1467 #endif
1468 
1469 /*
1470  * fill mac counter field
1471  */
smt_fill_mac_counter(struct s_smc * smc,struct smt_p_mac_counter * mc)1472 static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc)
1473 {
1474 	SMTSETPARA(mc,SMT_P_MAC_COUNTER) ;
1475 	mc->mc_mib_index = INDEX_MAC ;
1476 	mc->mc_index = mac_index(smc,1) ;
1477 	mc->mc_receive_ct = smc->mib.m[MAC0].fddiMACCopied_Ct ;
1478 	mc->mc_transmit_ct =  smc->mib.m[MAC0].fddiMACTransmit_Ct ;
1479 }
1480 
1481 /*
1482  * fill mac frame not copied counter
1483  */
smt_fill_mac_fnc(struct s_smc * smc,struct smt_p_mac_fnc * fnc)1484 static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc)
1485 {
1486 	SMTSETPARA(fnc,SMT_P_MAC_FNC) ;
1487 	fnc->nc_mib_index = INDEX_MAC ;
1488 	fnc->nc_index = mac_index(smc,1) ;
1489 	fnc->nc_counter = smc->mib.m[MAC0].fddiMACNotCopied_Ct ;
1490 }
1491 
1492 
1493 /*
1494  * fill manufacturer field
1495  */
smt_fill_manufacturer(struct s_smc * smc,struct smp_p_manufacturer * man)1496 static void smt_fill_manufacturer(struct s_smc *smc,
1497 				  struct smp_p_manufacturer *man)
1498 {
1499 	SMTSETPARA(man,SMT_P_MANUFACTURER) ;
1500 	memcpy((char *) man->mf_data,
1501 		(char *) smc->mib.fddiSMTManufacturerData,
1502 		sizeof(man->mf_data)) ;
1503 }
1504 
1505 /*
1506  * fill user field
1507  */
smt_fill_user(struct s_smc * smc,struct smp_p_user * user)1508 static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user)
1509 {
1510 	SMTSETPARA(user,SMT_P_USER) ;
1511 	memcpy((char *) user->us_data,
1512 		(char *) smc->mib.fddiSMTUserData,
1513 		sizeof(user->us_data)) ;
1514 }
1515 
1516 /*
1517  * fill set count
1518  */
smt_fill_setcount(struct s_smc * smc,struct smt_p_setcount * setcount)1519 static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount)
1520 {
1521 	SK_UNUSED(smc) ;
1522 	SMTSETPARA(setcount,SMT_P_SETCOUNT) ;
1523 	setcount->count = smc->mib.fddiSMTSetCount.count ;
1524 	memcpy((char *)setcount->timestamp,
1525 		(char *)smc->mib.fddiSMTSetCount.timestamp,8) ;
1526 }
1527 
1528 /*
1529  * fill echo data
1530  */
smt_fill_echo(struct s_smc * smc,struct smt_p_echo * echo,u_long seed,int len)1531 static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
1532 			  int len)
1533 {
1534 	u_char	*p ;
1535 
1536 	SK_UNUSED(smc) ;
1537 	SMTSETPARA(echo,SMT_P_ECHODATA) ;
1538 	echo->para.p_len = len ;
1539 	for (p = echo->ec_data ; len ; len--) {
1540 		*p++ = (u_char) seed ;
1541 		seed += 13 ;
1542 	}
1543 }
1544 
1545 /*
1546  * clear DNA and UNA
1547  * called from CFM if configuration changes
1548  */
smt_clear_una_dna(struct s_smc * smc)1549 static void smt_clear_una_dna(struct s_smc *smc)
1550 {
1551 	smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
1552 	smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
1553 }
1554 
smt_clear_old_una_dna(struct s_smc * smc)1555 static void smt_clear_old_una_dna(struct s_smc *smc)
1556 {
1557 	smc->mib.m[MAC0].fddiMACOldUpstreamNbr = SMT_Unknown ;
1558 	smc->mib.m[MAC0].fddiMACOldDownstreamNbr = SMT_Unknown ;
1559 }
1560 
smt_get_tid(struct s_smc * smc)1561 u_long smt_get_tid(struct s_smc *smc)
1562 {
1563 	u_long	tid ;
1564 	while ((tid = ++(smc->sm.smt_tid) ^ SMT_TID_MAGIC) == 0)
1565 		;
1566 	return tid & 0x3fffffffL;
1567 }
1568 
1569 
1570 /*
1571  * table of parameter lengths
1572  */
1573 static const struct smt_pdef {
1574 	int	ptype ;
1575 	int	plen ;
1576 	const char	*pswap ;
1577 } smt_pdef[] = {
1578 	{ SMT_P_UNA,	sizeof(struct smt_p_una) ,
1579 		SWAP_SMT_P_UNA					} ,
1580 	{ SMT_P_SDE,	sizeof(struct smt_p_sde) ,
1581 		SWAP_SMT_P_SDE					} ,
1582 	{ SMT_P_STATE,	sizeof(struct smt_p_state) ,
1583 		SWAP_SMT_P_STATE				} ,
1584 	{ SMT_P_TIMESTAMP,sizeof(struct smt_p_timestamp) ,
1585 		SWAP_SMT_P_TIMESTAMP				} ,
1586 	{ SMT_P_POLICY,	sizeof(struct smt_p_policy) ,
1587 		SWAP_SMT_P_POLICY				} ,
1588 	{ SMT_P_LATENCY,	sizeof(struct smt_p_latency) ,
1589 		SWAP_SMT_P_LATENCY				} ,
1590 	{ SMT_P_NEIGHBORS,sizeof(struct smt_p_neighbor) ,
1591 		SWAP_SMT_P_NEIGHBORS				} ,
1592 	{ SMT_P_PATH,	sizeof(struct smt_p_path) ,
1593 		SWAP_SMT_P_PATH					} ,
1594 	{ SMT_P_MAC_STATUS,sizeof(struct smt_p_mac_status) ,
1595 		SWAP_SMT_P_MAC_STATUS				} ,
1596 	{ SMT_P_LEM,	sizeof(struct smt_p_lem) ,
1597 		SWAP_SMT_P_LEM					} ,
1598 	{ SMT_P_MAC_COUNTER,sizeof(struct smt_p_mac_counter) ,
1599 		SWAP_SMT_P_MAC_COUNTER				} ,
1600 	{ SMT_P_MAC_FNC,sizeof(struct smt_p_mac_fnc) ,
1601 		SWAP_SMT_P_MAC_FNC				} ,
1602 	{ SMT_P_PRIORITY,sizeof(struct smt_p_priority) ,
1603 		SWAP_SMT_P_PRIORITY				} ,
1604 	{ SMT_P_EB,sizeof(struct smt_p_eb) ,
1605 		SWAP_SMT_P_EB					} ,
1606 	{ SMT_P_MANUFACTURER,sizeof(struct smp_p_manufacturer) ,
1607 		SWAP_SMT_P_MANUFACTURER				} ,
1608 	{ SMT_P_REASON,	sizeof(struct smt_p_reason) ,
1609 		SWAP_SMT_P_REASON				} ,
1610 	{ SMT_P_REFUSED, sizeof(struct smt_p_refused) ,
1611 		SWAP_SMT_P_REFUSED				} ,
1612 	{ SMT_P_VERSION, sizeof(struct smt_p_version) ,
1613 		SWAP_SMT_P_VERSION				} ,
1614 #ifdef ESS
1615 	{ SMT_P0015, sizeof(struct smt_p_0015) , SWAP_SMT_P0015 } ,
1616 	{ SMT_P0016, sizeof(struct smt_p_0016) , SWAP_SMT_P0016 } ,
1617 	{ SMT_P0017, sizeof(struct smt_p_0017) , SWAP_SMT_P0017 } ,
1618 	{ SMT_P0018, sizeof(struct smt_p_0018) , SWAP_SMT_P0018 } ,
1619 	{ SMT_P0019, sizeof(struct smt_p_0019) , SWAP_SMT_P0019 } ,
1620 	{ SMT_P001A, sizeof(struct smt_p_001a) , SWAP_SMT_P001A } ,
1621 	{ SMT_P001B, sizeof(struct smt_p_001b) , SWAP_SMT_P001B } ,
1622 	{ SMT_P001C, sizeof(struct smt_p_001c) , SWAP_SMT_P001C } ,
1623 	{ SMT_P001D, sizeof(struct smt_p_001d) , SWAP_SMT_P001D } ,
1624 #endif
1625 #if	0
1626 	{ SMT_P_FSC,	sizeof(struct smt_p_fsc) ,
1627 		SWAP_SMT_P_FSC					} ,
1628 #endif
1629 
1630 	{ SMT_P_SETCOUNT,0,	SWAP_SMT_P_SETCOUNT		} ,
1631 	{ SMT_P1048,	0,	SWAP_SMT_P1048			} ,
1632 	{ SMT_P208C,	0,	SWAP_SMT_P208C			} ,
1633 	{ SMT_P208D,	0,	SWAP_SMT_P208D			} ,
1634 	{ SMT_P208E,	0,	SWAP_SMT_P208E			} ,
1635 	{ SMT_P208F,	0,	SWAP_SMT_P208F			} ,
1636 	{ SMT_P2090,	0,	SWAP_SMT_P2090			} ,
1637 #ifdef	ESS
1638 	{ SMT_P320B, sizeof(struct smt_p_320b) , SWAP_SMT_P320B } ,
1639 	{ SMT_P320F, sizeof(struct smt_p_320f) , SWAP_SMT_P320F } ,
1640 	{ SMT_P3210, sizeof(struct smt_p_3210) , SWAP_SMT_P3210 } ,
1641 #endif
1642 	{ SMT_P4050,	0,	SWAP_SMT_P4050			} ,
1643 	{ SMT_P4051,	0,	SWAP_SMT_P4051			} ,
1644 	{ SMT_P4052,	0,	SWAP_SMT_P4052			} ,
1645 	{ SMT_P4053,	0,	SWAP_SMT_P4053			} ,
1646 } ;
1647 
1648 #define N_SMT_PLEN	ARRAY_SIZE(smt_pdef)
1649 
smt_check_para(struct s_smc * smc,struct smt_header * sm,const u_short list[])1650 int smt_check_para(struct s_smc *smc, struct smt_header	*sm,
1651 		   const u_short list[])
1652 {
1653 	const u_short		*p = list ;
1654 	while (*p) {
1655 		if (!sm_to_para(smc,sm,(int) *p)) {
1656 			DB_SMT("SMT: smt_check_para - missing para %x\n",*p,0);
1657 			return -1;
1658 		}
1659 		p++ ;
1660 	}
1661 	return 0;
1662 }
1663 
sm_to_para(struct s_smc * smc,struct smt_header * sm,int para)1664 void *sm_to_para(struct s_smc *smc, struct smt_header *sm, int para)
1665 {
1666 	char	*p ;
1667 	int	len ;
1668 	int	plen ;
1669 	void	*found = NULL;
1670 
1671 	SK_UNUSED(smc) ;
1672 
1673 	len = sm->smt_len ;
1674 	p = (char *)(sm+1) ;		/* pointer to info */
1675 	while (len > 0 ) {
1676 		if (((struct smt_para *)p)->p_type == para)
1677 			found = (void *) p ;
1678 		plen = ((struct smt_para *)p)->p_len + PARA_LEN ;
1679 		p += plen ;
1680 		len -= plen ;
1681 		if (len < 0) {
1682 			DB_SMT("SMT : sm_to_para - length error %d\n",plen,0) ;
1683 			return NULL;
1684 		}
1685 		if ((plen & 3) && (para != SMT_P_ECHODATA)) {
1686 			DB_SMT("SMT : sm_to_para - odd length %d\n",plen,0) ;
1687 			return NULL;
1688 		}
1689 		if (found)
1690 			return found;
1691 	}
1692 	return NULL;
1693 }
1694 
1695 #if	0
1696 /*
1697  * send ANTC data test frame
1698  */
1699 void fddi_send_antc(struct s_smc *smc, struct fddi_addr *dest)
1700 {
1701 	SK_UNUSED(smc) ;
1702 	SK_UNUSED(dest) ;
1703 #if	0
1704 	SMbuf			*mb ;
1705 	struct smt_header	*smt ;
1706 	int			i ;
1707 	char			*p ;
1708 
1709 	mb = smt_get_mbuf() ;
1710 	mb->sm_len = 3000+12 ;
1711 	p = smtod(mb, char *) + 12 ;
1712 	for (i = 0 ; i < 3000 ; i++)
1713 		*p++ = 1 << (i&7) ;
1714 
1715 	smt = smtod(mb, struct smt_header *) ;
1716 	smt->smt_dest = *dest ;
1717 	smt->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
1718 	smt_send_mbuf(smc,mb,FC_ASYNC_LLC) ;
1719 #endif
1720 }
1721 #endif
1722 
1723 #ifdef	DEBUG
addr_to_string(struct fddi_addr * addr)1724 char *addr_to_string(struct fddi_addr *addr)
1725 {
1726 	int	i ;
1727 	static char	string[6*3] = "****" ;
1728 
1729 	for (i = 0 ; i < 6 ; i++) {
1730 		string[i * 3] = hex_asc_hi(addr->a[i]);
1731 		string[i * 3 + 1] = hex_asc_lo(addr->a[i]);
1732 		string[i * 3 + 2] = ':';
1733 	}
1734 	string[5 * 3 + 2] = 0;
1735 	return string;
1736 }
1737 #endif
1738 
1739 #ifdef	AM29K
smt_ifconfig(int argc,char * argv[])1740 int smt_ifconfig(int argc, char *argv[])
1741 {
1742 	if (argc >= 2 && !strcmp(argv[0],"opt_bypass") &&
1743 	    !strcmp(argv[1],"yes")) {
1744 		smc->mib.fddiSMTBypassPresent = 1 ;
1745 		return 0;
1746 	}
1747 	return amdfddi_config(0, argc, argv);
1748 }
1749 #endif
1750 
1751 /*
1752  * return static mac index
1753  */
mac_index(struct s_smc * smc,int mac)1754 static int mac_index(struct s_smc *smc, int mac)
1755 {
1756 	SK_UNUSED(mac) ;
1757 #ifdef	CONCENTRATOR
1758 	SK_UNUSED(smc) ;
1759 	return NUMPHYS + 1;
1760 #else
1761 	return (smc->s.sas == SMT_SAS) ? 2 : 3;
1762 #endif
1763 }
1764 
1765 /*
1766  * return static phy index
1767  */
phy_index(struct s_smc * smc,int phy)1768 static int phy_index(struct s_smc *smc, int phy)
1769 {
1770 	SK_UNUSED(smc) ;
1771 	return phy + 1;
1772 }
1773 
1774 /*
1775  * return dynamic mac connection resource index
1776  */
mac_con_resource_index(struct s_smc * smc,int mac)1777 static int mac_con_resource_index(struct s_smc *smc, int mac)
1778 {
1779 #ifdef	CONCENTRATOR
1780 	SK_UNUSED(smc) ;
1781 	SK_UNUSED(mac) ;
1782 	return entity_to_index(smc, cem_get_downstream(smc, ENTITY_MAC));
1783 #else
1784 	SK_UNUSED(mac) ;
1785 	switch (smc->mib.fddiSMTCF_State) {
1786 	case SC9_C_WRAP_A :
1787 	case SC5_THRU_B :
1788 	case SC11_C_WRAP_S :
1789 		return 1;
1790 	case SC10_C_WRAP_B :
1791 	case SC4_THRU_A :
1792 		return 2;
1793 	}
1794 	return smc->s.sas == SMT_SAS ? 2 : 3;
1795 #endif
1796 }
1797 
1798 /*
1799  * return dynamic phy connection resource index
1800  */
phy_con_resource_index(struct s_smc * smc,int phy)1801 static int phy_con_resource_index(struct s_smc *smc, int phy)
1802 {
1803 #ifdef	CONCENTRATOR
1804 	return entity_to_index(smc, cem_get_downstream(smc, ENTITY_PHY(phy))) ;
1805 #else
1806 	switch (smc->mib.fddiSMTCF_State) {
1807 	case SC9_C_WRAP_A :
1808 		return phy == PA ? 3 : 2;
1809 	case SC10_C_WRAP_B :
1810 		return phy == PA ? 1 : 3;
1811 	case SC4_THRU_A :
1812 		return phy == PA ? 3 : 1;
1813 	case SC5_THRU_B :
1814 		return phy == PA ? 2 : 3;
1815 	case SC11_C_WRAP_S :
1816 		return 2;
1817 	}
1818 	return phy;
1819 #endif
1820 }
1821 
1822 #ifdef	CONCENTRATOR
entity_to_index(struct s_smc * smc,int e)1823 static int entity_to_index(struct s_smc *smc, int e)
1824 {
1825 	if (e == ENTITY_MAC)
1826 		return mac_index(smc, 1);
1827 	else
1828 		return phy_index(smc, e - ENTITY_PHY(0));
1829 }
1830 #endif
1831 
1832 #ifdef	LITTLE_ENDIAN
smt_swap_short(u_short s)1833 static int smt_swap_short(u_short s)
1834 {
1835 	return ((s>>8)&0xff) | ((s&0xff)<<8);
1836 }
1837 
smt_swap_para(struct smt_header * sm,int len,int direction)1838 void smt_swap_para(struct smt_header *sm, int len, int direction)
1839 /* int direction;	0 encode 1 decode */
1840 {
1841 	struct smt_para	*pa ;
1842 	const  struct smt_pdef	*pd ;
1843 	char	*p ;
1844 	int	plen ;
1845 	int	type ;
1846 	int	i ;
1847 
1848 /*	printf("smt_swap_para sm %x len %d dir %d\n",
1849 		sm,len,direction) ;
1850  */
1851 	smt_string_swap((char *)sm,SWAP_SMTHEADER,len) ;
1852 
1853 	/* swap args */
1854 	len -= sizeof(struct smt_header) ;
1855 
1856 	p = (char *) (sm + 1) ;
1857 	while (len > 0) {
1858 		pa = (struct smt_para *) p ;
1859 		plen = pa->p_len ;
1860 		type = pa->p_type ;
1861 		pa->p_type = smt_swap_short(pa->p_type) ;
1862 		pa->p_len = smt_swap_short(pa->p_len) ;
1863 		if (direction) {
1864 			plen = pa->p_len ;
1865 			type = pa->p_type ;
1866 		}
1867 		/*
1868 		 * note: paras can have 0 length !
1869 		 */
1870 		if (plen < 0)
1871 			break ;
1872 		plen += PARA_LEN ;
1873 		for (i = N_SMT_PLEN, pd = smt_pdef; i ; i--,pd++) {
1874 			if (pd->ptype == type)
1875 				break ;
1876 		}
1877 		if (i && pd->pswap) {
1878 			smt_string_swap(p+PARA_LEN,pd->pswap,len) ;
1879 		}
1880 		len -= plen ;
1881 		p += plen ;
1882 	}
1883 }
1884 
smt_string_swap(char * data,const char * format,int len)1885 static void smt_string_swap(char *data, const char *format, int len)
1886 {
1887 	const char	*open_paren = NULL ;
1888 	int	x ;
1889 
1890 	while (len > 0  && *format) {
1891 		switch (*format) {
1892 		case '[' :
1893 			open_paren = format ;
1894 			break ;
1895 		case ']' :
1896 			format = open_paren ;
1897 			break ;
1898 		case '1' :
1899 		case '2' :
1900 		case '3' :
1901 		case '4' :
1902 		case '5' :
1903 		case '6' :
1904 		case '7' :
1905 		case '8' :
1906 		case '9' :
1907 			data  += *format - '0' ;
1908 			len   -= *format - '0' ;
1909 			break ;
1910 		case 'c':
1911 			data++ ;
1912 			len-- ;
1913 			break ;
1914 		case 's' :
1915 			x = data[0] ;
1916 			data[0] = data[1] ;
1917 			data[1] = x ;
1918 			data += 2 ;
1919 			len -= 2 ;
1920 			break ;
1921 		case 'l' :
1922 			x = data[0] ;
1923 			data[0] = data[3] ;
1924 			data[3] = x ;
1925 			x = data[1] ;
1926 			data[1] = data[2] ;
1927 			data[2] = x ;
1928 			data += 4 ;
1929 			len -= 4 ;
1930 			break ;
1931 		}
1932 		format++ ;
1933 	}
1934 }
1935 #else
smt_swap_para(struct smt_header * sm,int len,int direction)1936 void smt_swap_para(struct smt_header *sm, int len, int direction)
1937 /* int direction;	0 encode 1 decode */
1938 {
1939 	SK_UNUSED(sm) ;
1940 	SK_UNUSED(len) ;
1941 	SK_UNUSED(direction) ;
1942 }
1943 #endif
1944 
1945 /*
1946  * PMF actions
1947  */
smt_action(struct s_smc * smc,int class,int code,int index)1948 int smt_action(struct s_smc *smc, int class, int code, int index)
1949 {
1950 	int	event ;
1951 	int	port ;
1952 	DB_SMT("SMT: action %d code %d\n",class,code) ;
1953 	switch(class) {
1954 	case SMT_STATION_ACTION :
1955 		switch(code) {
1956 		case SMT_STATION_ACTION_CONNECT :
1957 			smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
1958 			queue_event(smc,EVENT_ECM,EC_CONNECT) ;
1959 			break ;
1960 		case SMT_STATION_ACTION_DISCONNECT :
1961 			queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
1962 			smc->mib.fddiSMTRemoteDisconnectFlag = TRUE ;
1963 			RS_SET(smc,RS_DISCONNECT) ;
1964 			AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1965 				FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_DISCONNECT,
1966 				smt_get_event_word(smc));
1967 			break ;
1968 		case SMT_STATION_ACTION_PATHTEST :
1969 			AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1970 				FDDI_SMT_EVENT, (u_long) FDDI_PATH_TEST,
1971 				smt_get_event_word(smc));
1972 			break ;
1973 		case SMT_STATION_ACTION_SELFTEST :
1974 			AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1975 				FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_SELF_TEST,
1976 				smt_get_event_word(smc));
1977 			break ;
1978 		case SMT_STATION_ACTION_DISABLE_A :
1979 			if (smc->y[PA].pc_mode == PM_PEER) {
1980 				RS_SET(smc,RS_EVENT) ;
1981 				queue_event(smc,EVENT_PCM+PA,PC_DISABLE) ;
1982 			}
1983 			break ;
1984 		case SMT_STATION_ACTION_DISABLE_B :
1985 			if (smc->y[PB].pc_mode == PM_PEER) {
1986 				RS_SET(smc,RS_EVENT) ;
1987 				queue_event(smc,EVENT_PCM+PB,PC_DISABLE) ;
1988 			}
1989 			break ;
1990 		case SMT_STATION_ACTION_DISABLE_M :
1991 			for (port = 0 ; port <  NUMPHYS ; port++) {
1992 				if (smc->mib.p[port].fddiPORTMy_Type != TM)
1993 					continue ;
1994 				RS_SET(smc,RS_EVENT) ;
1995 				queue_event(smc,EVENT_PCM+port,PC_DISABLE) ;
1996 			}
1997 			break ;
1998 		default :
1999 			return 1;
2000 		}
2001 		break ;
2002 	case SMT_PORT_ACTION :
2003 		switch(code) {
2004 		case SMT_PORT_ACTION_ENABLE :
2005 			event = PC_ENABLE ;
2006 			break ;
2007 		case SMT_PORT_ACTION_DISABLE :
2008 			event = PC_DISABLE ;
2009 			break ;
2010 		case SMT_PORT_ACTION_MAINT :
2011 			event = PC_MAINT ;
2012 			break ;
2013 		case SMT_PORT_ACTION_START :
2014 			event = PC_START ;
2015 			break ;
2016 		case SMT_PORT_ACTION_STOP :
2017 			event = PC_STOP ;
2018 			break ;
2019 		default :
2020 			return 1;
2021 		}
2022 		queue_event(smc,EVENT_PCM+index,event) ;
2023 		break ;
2024 	default :
2025 		return 1;
2026 	}
2027 	return 0;
2028 }
2029 
2030 /*
2031  * canonical conversion of <len> bytes beginning form *data
2032  */
2033 #ifdef  USE_CAN_ADDR
hwm_conv_can(struct s_smc * smc,char * data,int len)2034 static void hwm_conv_can(struct s_smc *smc, char *data, int len)
2035 {
2036 	int i ;
2037 
2038 	SK_UNUSED(smc) ;
2039 
2040 	for (i = len; i ; i--, data++)
2041 		*data = bitrev8(*data);
2042 }
2043 #endif
2044 
2045 #endif	/* no SLIM_SMT */
2046 
2047