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