xref: /openbmc/linux/drivers/net/fddi/skfp/smt.c (revision 2a11fb1d)
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