?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ARM] pxa: update defconfig for Verdex Pro
[linux-2.6/verdex.git] / drivers / net / skfp / pcmplc.c
blobe6b33ee05ede1473ba91c8b4e8d9124a9122f793
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 /*
18 PCM
19 Physical Connection Management
20 */
21
22 /*
23 * Hardware independent state machine implemantation
24 * The following external SMT functions are referenced :
25 *
26 * queue_event()
27 * smt_timer_start()
28 * smt_timer_stop()
29 *
30 * The following external HW dependent functions are referenced :
31 * sm_pm_control()
32 * sm_ph_linestate()
33 * sm_pm_ls_latch()
34 *
35 * The following HW dependent events are required :
36 * PC_QLS
37 * PC_ILS
38 * PC_HLS
39 * PC_MLS
40 * PC_NSE
41 * PC_LEM
42 *
43 */
44
45
46 #include "h/types.h"
47 #include "h/fddi.h"
48 #include "h/smc.h"
49 #include "h/supern_2.h"
50 #define KERNEL
51 #include "h/smtstate.h"
52
53 #ifndef lint
54 static const char ID_sccs[] = "@(#)pcmplc.c 2.55 99/08/05 (C) SK " ;
55 #endif
56
57 #ifdef FDDI_MIB
58 extern int snmp_fddi_trap(
59 #ifdef ANSIC
60 struct s_smc * smc, int type, int index
61 #endif
62 );
63 #endif
64 #ifdef CONCENTRATOR
65 extern int plc_is_installed(
66 #ifdef ANSIC
67 struct s_smc *smc ,
68 int p
69 #endif
70 ) ;
71 #endif
72 /*
73 * FSM Macros
74 */
75 #define AFLAG (0x20)
76 #define GO_STATE(x) (mib->fddiPORTPCMState = (x)|AFLAG)
77 #define ACTIONS_DONE() (mib->fddiPORTPCMState &= ~AFLAG)
78 #define ACTIONS(x) (x|AFLAG)
79
80 /*
81 * PCM states
82 */
83 #define PC0_OFF 0
84 #define PC1_BREAK 1
85 #define PC2_TRACE 2
86 #define PC3_CONNECT 3
87 #define PC4_NEXT 4
88 #define PC5_SIGNAL 5
89 #define PC6_JOIN 6
90 #define PC7_VERIFY 7
91 #define PC8_ACTIVE 8
92 #define PC9_MAINT 9
93
94 #ifdef DEBUG
95 /*
96 * symbolic state names
97 */
98 static const char * const pcm_states[] = {
99 "PC0_OFF","PC1_BREAK","PC2_TRACE","PC3_CONNECT","PC4_NEXT",
100 "PC5_SIGNAL","PC6_JOIN","PC7_VERIFY","PC8_ACTIVE","PC9_MAINT"
101 } ;
102
103 /*
104 * symbolic event names
105 */
106 static const char * const pcm_events[] = {
107 "NONE","PC_START","PC_STOP","PC_LOOP","PC_JOIN","PC_SIGNAL",
108 "PC_REJECT","PC_MAINT","PC_TRACE","PC_PDR",
109 "PC_ENABLE","PC_DISABLE",
110 "PC_QLS","PC_ILS","PC_MLS","PC_HLS","PC_LS_PDR","PC_LS_NONE",
111 "PC_TIMEOUT_TB_MAX","PC_TIMEOUT_TB_MIN",
112 "PC_TIMEOUT_C_MIN","PC_TIMEOUT_T_OUT",
113 "PC_TIMEOUT_TL_MIN","PC_TIMEOUT_T_NEXT","PC_TIMEOUT_LCT",
114 "PC_NSE","PC_LEM"
115 } ;
116 #endif
117
118 #ifdef MOT_ELM
119 /*
120 * PCL-S control register
121 * this register in the PLC-S controls the scrambling parameters
122 */
123 #define PLCS_CONTROL_C_U 0
124 #define PLCS_CONTROL_C_S (PL_C_SDOFF_ENABLE | PL_C_SDON_ENABLE | \
125 PL_C_CIPHER_ENABLE)
126 #define PLCS_FASSERT_U 0
127 #define PLCS_FASSERT_S 0xFd76 /* 52.0 us */
128 #define PLCS_FDEASSERT_U 0
129 #define PLCS_FDEASSERT_S 0
130 #else /* nMOT_ELM */
131 /*
132 * PCL-S control register
133 * this register in the PLC-S controls the scrambling parameters
134 * can be patched for ANSI compliance if standard changes
135 */
136 static const u_char plcs_control_c_u[17] = "PLC_CNTRL_C_U=\0\0" ;
137 static const u_char plcs_control_c_s[17] = "PLC_CNTRL_C_S=\01\02" ;
138
139 #define PLCS_CONTROL_C_U (plcs_control_c_u[14] | (plcs_control_c_u[15]<<8))
140 #define PLCS_CONTROL_C_S (plcs_control_c_s[14] | (plcs_control_c_s[15]<<8))
141 #endif /* nMOT_ELM */
142
143 /*
144 * external vars
145 */
146 /* struct definition see 'cmtdef.h' (also used by CFM) */
147
148 #define PS_OFF 0
149 #define PS_BIT3 1
150 #define PS_BIT4 2
151 #define PS_BIT7 3
152 #define PS_LCT 4
153 #define PS_BIT8 5
154 #define PS_JOIN 6
155 #define PS_ACTIVE 7
156
157 #define LCT_LEM_MAX 255
158
159 /*
160 * PLC timing parameter
161 */
162
163 #define PLC_MS(m) ((int)((0x10000L-(m*100000L/2048))))
164 #define SLOW_TL_MIN PLC_MS(6)
165 #define SLOW_C_MIN PLC_MS(10)
166
167 static const struct plt {
168 int timer ; /* relative plc timer address */
169 int para ; /* default timing parameters */
170 } pltm[] = {
171 { PL_C_MIN, SLOW_C_MIN }, /* min t. to remain Connect State */
172 { PL_TL_MIN, SLOW_TL_MIN }, /* min t. to transmit a Line State */
173 { PL_TB_MIN, TP_TB_MIN }, /* min break time */
174 { PL_T_OUT, TP_T_OUT }, /* Signaling timeout */
175 { PL_LC_LENGTH, TP_LC_LENGTH }, /* Link Confidence Test Time */
176 { PL_T_SCRUB, TP_T_SCRUB }, /* Scrub Time == MAC TVX time ! */
177 { PL_NS_MAX, TP_NS_MAX }, /* max t. that noise is tolerated */
178 { 0,0 }
179 } ;
180
181 /*
182 * interrupt mask
183 */
184 #ifdef SUPERNET_3
185 /*
186 * Do we need the EBUF error during signaling, too, to detect SUPERNET_3
187 * PLL bug?
188 */
189 static const int plc_imsk_na = PL_PCM_CODE | PL_TRACE_PROP | PL_PCM_BREAK |
190 PL_PCM_ENABLED | PL_SELF_TEST | PL_EBUF_ERR;
191 #else /* SUPERNET_3 */
192 /*
193 * We do NOT need the elasticity buffer error during signaling.
194 */
195 static int plc_imsk_na = PL_PCM_CODE | PL_TRACE_PROP | PL_PCM_BREAK |
196 PL_PCM_ENABLED | PL_SELF_TEST ;
197 #endif /* SUPERNET_3 */
198 static const int plc_imsk_act = PL_PCM_CODE | PL_TRACE_PROP | PL_PCM_BREAK |
199 PL_PCM_ENABLED | PL_SELF_TEST | PL_EBUF_ERR;
200
201 /* internal functions */
202 static void pcm_fsm(struct s_smc *smc, struct s_phy *phy, int cmd);
203 static void pc_rcode_actions(struct s_smc *smc, int bit, struct s_phy *phy);
204 static void pc_tcode_actions(struct s_smc *smc, const int bit, struct s_phy *phy);
205 static void reset_lem_struct(struct s_phy *phy);
206 static void plc_init(struct s_smc *smc, int p);
207 static void sm_ph_lem_start(struct s_smc *smc, int np, int threshold);
208 static void sm_ph_lem_stop(struct s_smc *smc, int np);
209 static void sm_ph_linestate(struct s_smc *smc, int phy, int ls);
210 static void real_init_plc(struct s_smc *smc);
211
212 /*
213 * SMT timer interface
214 * start PCM timer 0
215 */
216 static void start_pcm_timer0(struct s_smc *smc, u_long value, int event,
217 struct s_phy *phy)
218 {
219 phy->timer0_exp = FALSE ; /* clear timer event flag */
220 smt_timer_start(smc,&phy->pcm_timer0,value,
221 EV_TOKEN(EVENT_PCM+phy->np,event)) ;
222 }
223 /*
224 * SMT timer interface
225 * stop PCM timer 0
226 */
227 static void stop_pcm_timer0(struct s_smc *smc, struct s_phy *phy)
228 {
229 if (phy->pcm_timer0.tm_active)
230 smt_timer_stop(smc,&phy->pcm_timer0) ;
231 }
232
233 /*
234 init PCM state machine (called by driver)
235 clear all PCM vars and flags
236 */
237 void pcm_init(struct s_smc *smc)
238 {
239 int i ;
240 int np ;
241 struct s_phy *phy ;
242 struct fddi_mib_p *mib ;
243
244 for (np = 0,phy = smc->y ; np < NUMPHYS ; np++,phy++) {
245 /* Indicates the type of PHY being used */
246 mib = phy->mib ;
247 mib->fddiPORTPCMState = ACTIONS(PC0_OFF) ;
248 phy->np = np ;
249 switch (smc->s.sas) {
250 #ifdef CONCENTRATOR
251 case SMT_SAS :
252 mib->fddiPORTMy_Type = (np == PS) ? TS : TM ;
253 break ;
254 case SMT_DAS :
255 mib->fddiPORTMy_Type = (np == PA) ? TA :
256 (np == PB) ? TB : TM ;
257 break ;
258 case SMT_NAC :
259 mib->fddiPORTMy_Type = TM ;
260 break;
261 #else
262 case SMT_SAS :
263 mib->fddiPORTMy_Type = (np == PS) ? TS : TNONE ;
264 mib->fddiPORTHardwarePresent = (np == PS) ? TRUE :
265 FALSE ;
266 #ifndef SUPERNET_3
267 smc->y[PA].mib->fddiPORTPCMState = PC0_OFF ;
268 #else
269 smc->y[PB].mib->fddiPORTPCMState = PC0_OFF ;
270 #endif
271 break ;
272 case SMT_DAS :
273 mib->fddiPORTMy_Type = (np == PB) ? TB : TA ;
274 break ;
275 #endif
276 }
277 /*
278 * set PMD-type
279 */
280 phy->pmd_scramble = 0 ;
281 switch (phy->pmd_type[PMD_SK_PMD]) {
282 case 'P' :
283 mib->fddiPORTPMDClass = MIB_PMDCLASS_MULTI ;
284 break ;
285 case 'L' :
286 mib->fddiPORTPMDClass = MIB_PMDCLASS_LCF ;
287 break ;
288 case 'D' :
289 mib->fddiPORTPMDClass = MIB_PMDCLASS_TP ;
290 break ;
291 case 'S' :
292 mib->fddiPORTPMDClass = MIB_PMDCLASS_TP ;
293 phy->pmd_scramble = TRUE ;
294 break ;
295 case 'U' :
296 mib->fddiPORTPMDClass = MIB_PMDCLASS_TP ;
297 phy->pmd_scramble = TRUE ;
298 break ;
299 case '1' :
300 mib->fddiPORTPMDClass = MIB_PMDCLASS_SINGLE1 ;
301 break ;
302 case '2' :
303 mib->fddiPORTPMDClass = MIB_PMDCLASS_SINGLE2 ;
304 break ;
305 case '3' :
306 mib->fddiPORTPMDClass = MIB_PMDCLASS_SINGLE2 ;
307 break ;
308 case '4' :
309 mib->fddiPORTPMDClass = MIB_PMDCLASS_SINGLE1 ;
310 break ;
311 case 'H' :
312 mib->fddiPORTPMDClass = MIB_PMDCLASS_UNKNOWN ;
313 break ;
314 case 'I' :
315 mib->fddiPORTPMDClass = MIB_PMDCLASS_TP ;
316 break ;
317 case 'G' :
318 mib->fddiPORTPMDClass = MIB_PMDCLASS_TP ;
319 break ;
320 default:
321 mib->fddiPORTPMDClass = MIB_PMDCLASS_UNKNOWN ;
322 break ;
323 }
324 /*
325 * A and B port can be on primary and secondary path
326 */
327 switch (mib->fddiPORTMy_Type) {
328 case TA :
329 mib->fddiPORTAvailablePaths |= MIB_PATH_S ;
330 mib->fddiPORTRequestedPaths[1] = MIB_P_PATH_LOCAL ;
331 mib->fddiPORTRequestedPaths[2] =
332 MIB_P_PATH_LOCAL |
333 MIB_P_PATH_CON_ALTER |
334 MIB_P_PATH_SEC_PREFER ;
335 mib->fddiPORTRequestedPaths[3] =
336 MIB_P_PATH_LOCAL |
337 MIB_P_PATH_CON_ALTER |
338 MIB_P_PATH_SEC_PREFER |
339 MIB_P_PATH_THRU ;
340 break ;
341 case TB :
342 mib->fddiPORTAvailablePaths |= MIB_PATH_S ;
343 mib->fddiPORTRequestedPaths[1] = MIB_P_PATH_LOCAL ;
344 mib->fddiPORTRequestedPaths[2] =
345 MIB_P_PATH_LOCAL |
346 MIB_P_PATH_PRIM_PREFER ;
347 mib->fddiPORTRequestedPaths[3] =
348 MIB_P_PATH_LOCAL |
349 MIB_P_PATH_PRIM_PREFER |
350 MIB_P_PATH_CON_PREFER |
351 MIB_P_PATH_THRU ;
352 break ;
353 case TS :
354 mib->fddiPORTAvailablePaths |= MIB_PATH_S ;
355 mib->fddiPORTRequestedPaths[1] = MIB_P_PATH_LOCAL ;
356 mib->fddiPORTRequestedPaths[2] =
357 MIB_P_PATH_LOCAL |
358 MIB_P_PATH_CON_ALTER |
359 MIB_P_PATH_PRIM_PREFER ;
360 mib->fddiPORTRequestedPaths[3] =
361 MIB_P_PATH_LOCAL |
362 MIB_P_PATH_CON_ALTER |
363 MIB_P_PATH_PRIM_PREFER ;
364 break ;
365 case TM :
366 mib->fddiPORTRequestedPaths[1] = MIB_P_PATH_LOCAL ;
367 mib->fddiPORTRequestedPaths[2] =
368 MIB_P_PATH_LOCAL |
369 MIB_P_PATH_SEC_ALTER |
370 MIB_P_PATH_PRIM_ALTER ;
371 mib->fddiPORTRequestedPaths[3] = 0 ;
372 break ;
373 }
374
375 phy->pc_lem_fail = FALSE ;
376 mib->fddiPORTPCMStateX = mib->fddiPORTPCMState ;
377 mib->fddiPORTLCTFail_Ct = 0 ;
378 mib->fddiPORTBS_Flag = 0 ;
379 mib->fddiPORTCurrentPath = MIB_PATH_ISOLATED ;
380 mib->fddiPORTNeighborType = TNONE ;
381 phy->ls_flag = 0 ;
382 phy->rc_flag = 0 ;
383 phy->tc_flag = 0 ;
384 phy->td_flag = 0 ;
385 if (np >= PM)
386 phy->phy_name = '0' + np - PM ;
387 else
388 phy->phy_name = 'A' + np ;
389 phy->wc_flag = FALSE ; /* set by SMT */
390 memset((char *)&phy->lem,0,sizeof(struct lem_counter)) ;
391 reset_lem_struct(phy) ;
392 memset((char *)&phy->plc,0,sizeof(struct s_plc)) ;
393 phy->plc.p_state = PS_OFF ;
394 for (i = 0 ; i < NUMBITS ; i++) {
395 phy->t_next[i] = 0 ;
396 }
397 }
398 real_init_plc(smc) ;
399 }
400
401 void init_plc(struct s_smc *smc)
402 {
403 SK_UNUSED(smc) ;
404
405 /*
406 * dummy
407 * this is an obsolete public entry point that has to remain
408 * for compat. It is used by various drivers.
409 * the work is now done in real_init_plc()
410 * which is called from pcm_init() ;
411 */
412 }
413
414 static void real_init_plc(struct s_smc *smc)
415 {
416 int p ;
417
418 for (p = 0 ; p < NUMPHYS ; p++)
419 plc_init(smc,p) ;
420 }
421
422 static void plc_init(struct s_smc *smc, int p)
423 {
424 int i ;
425 #ifndef MOT_ELM
426 int rev ; /* Revision of PLC-x */
427 #endif /* MOT_ELM */
428
429 /* transit PCM state machine to MAINT state */
430 outpw(PLC(p,PL_CNTRL_B),0) ;
431 outpw(PLC(p,PL_CNTRL_B),PL_PCM_STOP) ;
432 outpw(PLC(p,PL_CNTRL_A),0) ;
433
434 /*
435 * if PLC-S then set control register C
436 */
437 #ifndef MOT_ELM
438 rev = inpw(PLC(p,PL_STATUS_A)) & PLC_REV_MASK ;
439 if (rev != PLC_REVISION_A)
440 #endif /* MOT_ELM */
441 {
442 if (smc->y[p].pmd_scramble) {
443 outpw(PLC(p,PL_CNTRL_C),PLCS_CONTROL_C_S) ;
444 #ifdef MOT_ELM
445 outpw(PLC(p,PL_T_FOT_ASS),PLCS_FASSERT_S) ;
446 outpw(PLC(p,PL_T_FOT_DEASS),PLCS_FDEASSERT_S) ;
447 #endif /* MOT_ELM */
448 }
449 else {
450 outpw(PLC(p,PL_CNTRL_C),PLCS_CONTROL_C_U) ;
451 #ifdef MOT_ELM
452 outpw(PLC(p,PL_T_FOT_ASS),PLCS_FASSERT_U) ;
453 outpw(PLC(p,PL_T_FOT_DEASS),PLCS_FDEASSERT_U) ;
454 #endif /* MOT_ELM */
455 }
456 }
457
458 /*
459 * set timer register
460 */
461 for ( i = 0 ; pltm[i].timer; i++) /* set timer parameter reg */
462 outpw(PLC(p,pltm[i].timer),pltm[i].para) ;
463
464 (void)inpw(PLC(p,PL_INTR_EVENT)) ; /* clear interrupt event reg */
465 plc_clear_irq(smc,p) ;
466 outpw(PLC(p,PL_INTR_MASK),plc_imsk_na); /* enable non active irq's */
467
468 /*
469 * if PCM is configured for class s, it will NOT go to the
470 * REMOVE state if offline (page 3-36;)
471 * in the concentrator, all inactive PHYS always must be in
472 * the remove state
473 * there's no real need to use this feature at all ..
474 */
475 #ifndef CONCENTRATOR
476 if ((smc->s.sas == SMT_SAS) && (p == PS)) {
477 outpw(PLC(p,PL_CNTRL_B),PL_CLASS_S) ;
478 }
479 #endif
480 }
481
482 /*
483 * control PCM state machine
484 */
485 static void plc_go_state(struct s_smc *smc, int p, int state)
486 {
487 HW_PTR port ;
488 int val ;
489
490 SK_UNUSED(smc) ;
491
492 port = (HW_PTR) (PLC(p,PL_CNTRL_B)) ;
493 val = inpw(port) & ~(PL_PCM_CNTRL | PL_MAINT) ;
494 outpw(port,val) ;
495 outpw(port,val | state) ;
496 }
497
498 /*
499 * read current line state (called by ECM & PCM)
500 */
501 int sm_pm_get_ls(struct s_smc *smc, int phy)
502 {
503 int state ;
504
505 #ifdef CONCENTRATOR
506 if (!plc_is_installed(smc,phy))
507 return(PC_QLS) ;
508 #endif
509
510 state = inpw(PLC(phy,PL_STATUS_A)) & PL_LINE_ST ;
511 switch(state) {
512 case PL_L_QLS:
513 state = PC_QLS ;
514 break ;
515 case PL_L_MLS:
516 state = PC_MLS ;
517 break ;
518 case PL_L_HLS:
519 state = PC_HLS ;
520 break ;
521 case PL_L_ILS4:
522 case PL_L_ILS16:
523 state = PC_ILS ;
524 break ;
525 case PL_L_ALS:
526 state = PC_LS_PDR ;
527 break ;
528 default :
529 state = PC_LS_NONE ;
530 }
531 return(state) ;
532 }
533
534 static int plc_send_bits(struct s_smc *smc, struct s_phy *phy, int len)
535 {
536 int np = phy->np ; /* PHY index */
537 int n ;
538 int i ;
539
540 SK_UNUSED(smc) ;
541
542 /* create bit vector */
543 for (i = len-1,n = 0 ; i >= 0 ; i--) {
544 n = (n<<1) | phy->t_val[phy->bitn+i] ;
545 }
546 if (inpw(PLC(np,PL_STATUS_B)) & PL_PCM_SIGNAL) {
547 #if 0
548 printf("PL_PCM_SIGNAL is set\n") ;
549 #endif
550 return(1) ;
551 }
552 /* write bit[n] & length = 1 to regs */
553 outpw(PLC(np,PL_VECTOR_LEN),len-1) ; /* len=nr-1 */
554 outpw(PLC(np,PL_XMIT_VECTOR),n) ;
555 #ifdef DEBUG
556 #if 1
557 #ifdef DEBUG_BRD
558 if (smc->debug.d_plc & 0x80)
559 #else
560 if (debug.d_plc & 0x80)
561 #endif
562 printf("SIGNALING bit %d .. %d\n",phy->bitn,phy->bitn+len-1) ;
563 #endif
564 #endif
565 return(0) ;
566 }
567
568 /*
569 * config plc muxes
570 */
571 void plc_config_mux(struct s_smc *smc, int mux)
572 {
573 if (smc->s.sas != SMT_DAS)
574 return ;
575 if (mux == MUX_WRAPB) {
576 SETMASK(PLC(PA,PL_CNTRL_B),PL_CONFIG_CNTRL,PL_CONFIG_CNTRL) ;
577 SETMASK(PLC(PA,PL_CNTRL_A),PL_SC_REM_LOOP,PL_SC_REM_LOOP) ;
578 }
579 else {
580 CLEAR(PLC(PA,PL_CNTRL_B),PL_CONFIG_CNTRL) ;
581 CLEAR(PLC(PA,PL_CNTRL_A),PL_SC_REM_LOOP) ;
582 }
583 CLEAR(PLC(PB,PL_CNTRL_B),PL_CONFIG_CNTRL) ;
584 CLEAR(PLC(PB,PL_CNTRL_A),PL_SC_REM_LOOP) ;
585 }
586
587 /*
588 PCM state machine
589 called by dispatcher & fddi_init() (driver)
590 do
591 display state change
592 process event
593 until SM is stable
594 */
595 void pcm(struct s_smc *smc, const int np, int event)
596 {
597 int state ;
598 int oldstate ;
599 struct s_phy *phy ;
600 struct fddi_mib_p *mib ;
601
602 #ifndef CONCENTRATOR
603 /*
604 * ignore 2nd PHY if SAS
605 */
606 if ((np != PS) && (smc->s.sas == SMT_SAS))
607 return ;
608 #endif
609 phy = &smc->y[np] ;
610 mib = phy->mib ;
611 oldstate = mib->fddiPORTPCMState ;
612 do {
613 DB_PCM("PCM %c: state %s",
614 phy->phy_name,
615 (mib->fddiPORTPCMState & AFLAG) ? "ACTIONS " : "") ;
616 DB_PCM("%s, event %s\n",
617 pcm_states[mib->fddiPORTPCMState & ~AFLAG],
618 pcm_events[event]) ;
619 state = mib->fddiPORTPCMState ;
620 pcm_fsm(smc,phy,event) ;
621 event = 0 ;
622 } while (state != mib->fddiPORTPCMState) ;
623 /*
624 * because the PLC does the bit signaling for us,
625 * we're always in SIGNAL state
626 * the MIB want's to see CONNECT
627 * we therefore fake an entry in the MIB
628 */
629 if (state == PC5_SIGNAL)
630 mib->fddiPORTPCMStateX = PC3_CONNECT ;
631 else
632 mib->fddiPORTPCMStateX = state ;
633
634 #ifndef SLIM_SMT
635 /*
636 * path change
637 */
638 if ( mib->fddiPORTPCMState != oldstate &&
639 ((oldstate == PC8_ACTIVE) || (mib->fddiPORTPCMState == PC8_ACTIVE))) {
640 smt_srf_event(smc,SMT_EVENT_PORT_PATH_CHANGE,
641 (int) (INDEX_PORT+ phy->np),0) ;
642 }
643 #endif
644
645 #ifdef FDDI_MIB
646 /* check whether a snmp-trap has to be sent */
647
648 if ( mib->fddiPORTPCMState != oldstate ) {
649 /* a real state change took place */
650 DB_SNMP ("PCM from %d to %d\n", oldstate, mib->fddiPORTPCMState);
651 if ( mib->fddiPORTPCMState == PC0_OFF ) {
652 /* send first trap */
653 snmp_fddi_trap (smc, 1, (int) mib->fddiPORTIndex );
654 } else if ( oldstate == PC0_OFF ) {
655 /* send second trap */
656 snmp_fddi_trap (smc, 2, (int) mib->fddiPORTIndex );
657 } else if ( mib->fddiPORTPCMState != PC2_TRACE &&
658 oldstate == PC8_ACTIVE ) {
659 /* send third trap */
660 snmp_fddi_trap (smc, 3, (int) mib->fddiPORTIndex );
661 } else if ( mib->fddiPORTPCMState == PC8_ACTIVE ) {
662 /* send fourth trap */
663 snmp_fddi_trap (smc, 4, (int) mib->fddiPORTIndex );
664 }
665 }
666 #endif
667
668 pcm_state_change(smc,np,state) ;
669 }
670
671 /*
672 * PCM state machine
673 */
674 static void pcm_fsm(struct s_smc *smc, struct s_phy *phy, int cmd)
675 {
676 int i ;
677 int np = phy->np ; /* PHY index */
678 struct s_plc *plc ;
679 struct fddi_mib_p *mib ;
680 #ifndef MOT_ELM
681 u_short plc_rev ; /* Revision of the plc */
682 #endif /* nMOT_ELM */
683
684 plc = &phy->plc ;
685 mib = phy->mib ;
686
687 /*
688 * general transitions independent of state
689 */
690 switch (cmd) {
691 case PC_STOP :
692 /*PC00-PC80*/
693 if (mib->fddiPORTPCMState != PC9_MAINT) {
694 GO_STATE(PC0_OFF) ;
695 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
696 FDDI_PORT_EVENT, (u_long) FDDI_PORT_STOP,
697 smt_get_port_event_word(smc));
698 }
699 return ;
700 case PC_START :
701 /*PC01-PC81*/
702 if (mib->fddiPORTPCMState != PC9_MAINT)
703 GO_STATE(PC1_BREAK) ;
704 return ;
705 case PC_DISABLE :
706 /* PC09-PC99 */
707 GO_STATE(PC9_MAINT) ;
708 AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
709 FDDI_PORT_EVENT, (u_long) FDDI_PORT_DISABLED,
710 smt_get_port_event_word(smc));
711 return ;
712 case PC_TIMEOUT_LCT :
713 /* if long or extended LCT */
714 stop_pcm_timer0(smc,phy) ;
715 CLEAR(PLC(np,PL_CNTRL_B),PL_LONG) ;
716 /* end of LCT is indicate by PCM_CODE (initiate PCM event) */
717 return ;
718 }
719
720 switch(mib->fddiPORTPCMState) {
721 case ACTIONS(PC0_OFF) :
722 stop_pcm_timer0(smc,phy) ;
723 outpw(PLC(np,PL_CNTRL_A),0) ;
724 CLEAR(PLC(np,PL_CNTRL_B),PL_PC_JOIN) ;
725 CLEAR(PLC(np,PL_CNTRL_B),PL_LONG) ;
726 sm_ph_lem_stop(smc,np) ; /* disable LEM */
727 phy->cf_loop = FALSE ;
728 phy->cf_join = FALSE ;
729 queue_event(smc,EVENT_CFM,CF_JOIN+np) ;
730 plc_go_state(smc,np,PL_PCM_STOP) ;
731 mib->fddiPORTConnectState = PCM_DISABLED ;
732 ACTIONS_DONE() ;
733 break ;
734 case PC0_OFF:
735 /*PC09*/
736 if (cmd == PC_MAINT) {
737 GO_STATE(PC9_MAINT) ;
738 break ;
739 }
740 break ;
741 case ACTIONS(PC1_BREAK) :
742 /* Stop the LCT timer if we came from Signal state */
743 stop_pcm_timer0(smc,phy) ;
744 ACTIONS_DONE() ;
745 plc_go_state(smc,np,0) ;
746 CLEAR(PLC(np,PL_CNTRL_B),PL_PC_JOIN) ;
747 CLEAR(PLC(np,PL_CNTRL_B),PL_LONG) ;
748 sm_ph_lem_stop(smc,np) ; /* disable LEM */
749 /*
750 * if vector is already loaded, go to OFF to clear PCM_SIGNAL
751 */
752 #if 0
753 if (inpw(PLC(np,PL_STATUS_B)) & PL_PCM_SIGNAL) {
754 plc_go_state(smc,np,PL_PCM_STOP) ;
755 /* TB_MIN ? */
756 }
757 #endif
758 /*
759 * Go to OFF state in any case.
760 */
761 plc_go_state(smc,np,PL_PCM_STOP) ;
762
763 if (mib->fddiPORTPC_Withhold == PC_WH_NONE)
764 mib->fddiPORTConnectState = PCM_CONNECTING ;
765 phy->cf_loop = FALSE ;
766 phy->cf_join = FALSE ;
767 queue_event(smc,EVENT_CFM,CF_JOIN+np) ;
768 phy->ls_flag = FALSE ;
769 phy->pc_mode = PM_NONE ; /* needed by CFM */
770 phy->bitn = 0 ; /* bit signaling start bit */
771 for (i = 0 ; i < 3 ; i++)
772 pc_tcode_actions(smc,i,phy) ;
773
774 /* Set the non-active interrupt mask register */
775 outpw(PLC(np,PL_INTR_MASK),plc_imsk_na) ;
776
777 /*
778 * If the LCT was stopped. There might be a
779 * PCM_CODE interrupt event present.
780 * This must be cleared.
781 */
782 (void)inpw(PLC(np,PL_INTR_EVENT)) ;
783 #ifndef MOT_ELM
784 /* Get the plc revision for revision dependent code */
785 plc_rev = inpw(PLC(np,PL_STATUS_A)) & PLC_REV_MASK ;
786
787 if (plc_rev != PLC_REV_SN3)
788 #endif /* MOT_ELM */
789 {
790 /*
791 * No supernet III PLC, so set Xmit verctor and
792 * length BEFORE starting the state machine.
793 */
794 if (plc_send_bits(smc,phy,3)) {
795 return ;
796 }
797 }
798
799 /*
800 * Now give the Start command.
801 * - The start command shall be done before setting the bits
802 * to be signaled. (In PLC-S description and PLCS in SN3.
803 * - The start command shall be issued AFTER setting the
804 * XMIT vector and the XMIT length register.
805 *
806 * We do it exactly according this specs for the old PLC and
807 * the new PLCS inside the SN3.
808 * For the usual PLCS we try it the way it is done for the
809 * old PLC and set the XMIT registers again, if the PLC is
810 * not in SIGNAL state. This is done according to an PLCS
811 * errata workaround.
812 */
813
814 plc_go_state(smc,np,PL_PCM_START) ;
815
816 /*
817 * workaround for PLC-S eng. sample errata
818 */
819 #ifdef MOT_ELM
820 if (!(inpw(PLC(np,PL_STATUS_B)) & PL_PCM_SIGNAL))
821 #else /* nMOT_ELM */
822 if (((inpw(PLC(np,PL_STATUS_A)) & PLC_REV_MASK) !=
823 PLC_REVISION_A) &&
824 !(inpw(PLC(np,PL_STATUS_B)) & PL_PCM_SIGNAL))
825 #endif /* nMOT_ELM */
826 {
827 /*
828 * Set register again (PLCS errata) or the first time
829 * (new SN3 PLCS).
830 */
831 (void) plc_send_bits(smc,phy,3) ;
832 }
833 /*
834 * end of workaround
835 */
836
837 GO_STATE(PC5_SIGNAL) ;
838 plc->p_state = PS_BIT3 ;
839 plc->p_bits = 3 ;
840 plc->p_start = 0 ;
841
842 break ;
843 case PC1_BREAK :
844 break ;
845 case ACTIONS(PC2_TRACE) :
846 plc_go_state(smc,np,PL_PCM_TRACE) ;
847 ACTIONS_DONE() ;
848 break ;
849 case PC2_TRACE :
850 break ;
851
852 case PC3_CONNECT : /* these states are done by hardware */
853 case PC4_NEXT :
854 break ;
855
856 case ACTIONS(PC5_SIGNAL) :
857 ACTIONS_DONE() ;
858 case PC5_SIGNAL :
859 if ((cmd != PC_SIGNAL) && (cmd != PC_TIMEOUT_LCT))
860 break ;
861 switch (plc->p_state) {
862 case PS_BIT3 :
863 for (i = 0 ; i <= 2 ; i++)
864 pc_rcode_actions(smc,i,phy) ;
865 pc_tcode_actions(smc,3,phy) ;
866 plc->p_state = PS_BIT4 ;
867 plc->p_bits = 1 ;
868 plc->p_start = 3 ;
869 phy->bitn = 3 ;
870 if (plc_send_bits(smc,phy,1)) {
871 return ;
872 }
873 break ;
874 case PS_BIT4 :
875 pc_rcode_actions(smc,3,phy) ;
876 for (i = 4 ; i <= 6 ; i++)
877 pc_tcode_actions(smc,i,phy) ;
878 plc->p_state = PS_BIT7 ;
879 plc->p_bits = 3 ;
880 plc->p_start = 4 ;
881 phy->bitn = 4 ;
882 if (plc_send_bits(smc,phy,3)) {
883 return ;
884 }
885 break ;
886 case PS_BIT7 :
887 for (i = 3 ; i <= 6 ; i++)
888 pc_rcode_actions(smc,i,phy) ;
889 plc->p_state = PS_LCT ;
890 plc->p_bits = 0 ;
891 plc->p_start = 7 ;
892 phy->bitn = 7 ;
893 sm_ph_lem_start(smc,np,(int)smc->s.lct_short) ; /* enable LEM */
894 /* start LCT */
895 i = inpw(PLC(np,PL_CNTRL_B)) & ~PL_PC_LOOP ;
896 outpw(PLC(np,PL_CNTRL_B),i) ; /* must be cleared */
897 outpw(PLC(np,PL_CNTRL_B),i | PL_RLBP) ;
898 break ;
899 case PS_LCT :
900 /* check for local LCT failure */
901 pc_tcode_actions(smc,7,phy) ;
902 /*
903 * set tval[7]
904 */
905 plc->p_state = PS_BIT8 ;
906 plc->p_bits = 1 ;
907 plc->p_start = 7 ;
908 phy->bitn = 7 ;
909 if (plc_send_bits(smc,phy,1)) {
910 return ;
911 }
912 break ;
913 case PS_BIT8 :
914 /* check for remote LCT failure */
915 pc_rcode_actions(smc,7,phy) ;
916 if (phy->t_val[7] || phy->r_val[7]) {
917 plc_go_state(smc,np,PL_PCM_STOP) ;
918 GO_STATE(PC1_BREAK) ;
919 break ;
920 }
921 for (i = 8 ; i <= 9 ; i++)
922 pc_tcode_actions(smc,i,phy) ;
923 plc->p_state = PS_JOIN ;
924 plc->p_bits = 2 ;
925 plc->p_start = 8 ;
926 phy->bitn = 8 ;
927 if (plc_send_bits(smc,phy,2)) {
928 return ;
929 }
930 break ;
931 case PS_JOIN :
932 for (i = 8 ; i <= 9 ; i++)
933 pc_rcode_actions(smc,i,phy) ;
934 plc->p_state = PS_ACTIVE ;
935 GO_STATE(PC6_JOIN) ;
936 break ;
937 }
938 break ;
939
940 case ACTIONS(PC6_JOIN) :
941 /*
942 * prevent mux error when going from WRAP_A to WRAP_B
943 */
944 if (smc->s.sas == SMT_DAS && np == PB &&
945 (smc->y[PA].pc_mode == PM_TREE ||
946 smc->y[PB].pc_mode == PM_TREE)) {
947 SETMASK(PLC(np,PL_CNTRL_A),
948 PL_SC_REM_LOOP,PL_SC_REM_LOOP) ;
949 SETMASK(PLC(np,PL_CNTRL_B),
950 PL_CONFIG_CNTRL,PL_CONFIG_CNTRL) ;
951 }
952 SETMASK(PLC(np,PL_CNTRL_B),PL_PC_JOIN,PL_PC_JOIN) ;
953 SETMASK(PLC(np,PL_CNTRL_B),PL_PC_JOIN,PL_PC_JOIN) ;
954 ACTIONS_DONE() ;
955 cmd = 0 ;
956 /* fall thru */
957 case PC6_JOIN :
958 switch (plc->p_state) {
959 case PS_ACTIVE:
960 /*PC88b*/
961 if (!phy->cf_join) {
962 phy->cf_join = TRUE ;
963 queue_event(smc,EVENT_CFM,CF_JOIN+np) ;
964 }
965 if (cmd == PC_JOIN)
966 GO_STATE(PC8_ACTIVE) ;
967 /*PC82*/
968 if (cmd == PC_TRACE) {
969 GO_STATE(PC2_TRACE) ;
970 break ;
971 }
972 break ;
973 }
974 break ;
975
976 case PC7_VERIFY :
977 break ;
978
979 case ACTIONS(PC8_ACTIVE) :
980 /*
981 * start LEM for SMT
982 */
983 sm_ph_lem_start(smc,(int)phy->np,LCT_LEM_MAX) ;
984
985 phy->tr_flag = FALSE ;
986 mib->fddiPORTConnectState = PCM_ACTIVE ;
987
988 /* Set the active interrupt mask register */
989 outpw(PLC(np,PL_INTR_MASK),plc_imsk_act) ;
990
991 ACTIONS_DONE() ;
992 break ;
993 case PC8_ACTIVE :
994 /*PC81 is done by PL_TNE_EXPIRED irq */
995 /*PC82*/
996 if (cmd == PC_TRACE) {
997 GO_STATE(PC2_TRACE) ;
998 break ;
999 }
1000 /*PC88c: is done by TRACE_PROP irq */
1001
1002 break ;
1003 case ACTIONS(PC9_MAINT) :
1004 stop_pcm_timer0(smc,phy) ;
1005 CLEAR(PLC(np,PL_CNTRL_B),PL_PC_JOIN) ;
1006 CLEAR(PLC(np,PL_CNTRL_B),PL_LONG) ;
1007 CLEAR(PLC(np,PL_INTR_MASK),PL_LE_CTR) ; /* disable LEM int. */
1008 sm_ph_lem_stop(smc,np) ; /* disable LEM */
1009 phy->cf_loop = FALSE ;
1010 phy->cf_join = FALSE ;
1011 queue_event(smc,EVENT_CFM,CF_JOIN+np) ;
1012 plc_go_state(smc,np,PL_PCM_STOP) ;
1013 mib->fddiPORTConnectState = PCM_DISABLED ;
1014 SETMASK(PLC(np,PL_CNTRL_B),PL_MAINT,PL_MAINT) ;
1015 sm_ph_linestate(smc,np,(int) MIB2LS(mib->fddiPORTMaint_LS)) ;
1016 outpw(PLC(np,PL_CNTRL_A),PL_SC_BYPASS) ;
1017 ACTIONS_DONE() ;
1018 break ;
1019 case PC9_MAINT :
1020 DB_PCMN(1,"PCM %c : MAINT\n",phy->phy_name,0) ;
1021 /*PC90*/
1022 if (cmd == PC_ENABLE) {
1023 GO_STATE(PC0_OFF) ;
1024 break ;
1025 }
1026 break ;
1027
1028 default:
1029 SMT_PANIC(smc,SMT_E0118, SMT_E0118_MSG) ;
1030 break ;
1031 }
1032 }
1033
1034 /*
1035 * force line state on a PHY output (only in MAINT state)
1036 */
1037 static void sm_ph_linestate(struct s_smc *smc, int phy, int ls)
1038 {
1039 int cntrl ;
1040
1041 SK_UNUSED(smc) ;
1042
1043 cntrl = (inpw(PLC(phy,PL_CNTRL_B)) & ~PL_MAINT_LS) |
1044 PL_PCM_STOP | PL_MAINT ;
1045 switch(ls) {
1046 case PC_QLS: /* Force Quiet */
1047 cntrl |= PL_M_QUI0 ;
1048 break ;
1049 case PC_MLS: /* Force Master */
1050 cntrl |= PL_M_MASTR ;
1051 break ;
1052 case PC_HLS: /* Force Halt */
1053 cntrl |= PL_M_HALT ;
1054 break ;
1055 default :
1056 case PC_ILS: /* Force Idle */
1057 cntrl |= PL_M_IDLE ;
1058 break ;
1059 case PC_LS_PDR: /* Enable repeat filter */
1060 cntrl |= PL_M_TPDR ;
1061 break ;
1062 }
1063 outpw(PLC(phy,PL_CNTRL_B),cntrl) ;
1064 }
1065
1066 static void reset_lem_struct(struct s_phy *phy)
1067 {
1068 struct lem_counter *lem = &phy->lem ;
1069
1070 phy->mib->fddiPORTLer_Estimate = 15 ;
1071 lem->lem_float_ber = 15 * 100 ;
1072 }
1073
1074 /*
1075 * link error monitor
1076 */
1077 static void lem_evaluate(struct s_smc *smc, struct s_phy *phy)
1078 {
1079 int ber ;
1080 u_long errors ;
1081 struct lem_counter *lem = &phy->lem ;
1082 struct fddi_mib_p *mib ;
1083 int cond ;
1084
1085 mib = phy->mib ;
1086
1087 if (!lem->lem_on)
1088 return ;
1089
1090 errors = inpw(PLC(((int) phy->np),PL_LINK_ERR_CTR)) ;
1091 lem->lem_errors += errors ;
1092 mib->fddiPORTLem_Ct += errors ;
1093
1094 errors = lem->lem_errors ;
1095 /*
1096 * calculation is called on a intervall of 8 seconds
1097 * -> this means, that one error in 8 sec. is one of 8*125*10E6
1098 * the same as BER = 10E-9
1099 * Please note:
1100 * -> 9 errors in 8 seconds mean:
1101 * BER = 9 * 10E-9 and this is
1102 * < 10E-8, so the limit of 10E-8 is not reached!
1103 */
1104
1105 if (!errors) ber = 15 ;
1106 else if (errors <= 9) ber = 9 ;
1107 else if (errors <= 99) ber = 8 ;
1108 else if (errors <= 999) ber = 7 ;
1109 else if (errors <= 9999) ber = 6 ;
1110 else if (errors <= 99999) ber = 5 ;
1111 else if (errors <= 999999) ber = 4 ;
1112 else if (errors <= 9999999) ber = 3 ;
1113 else if (errors <= 99999999) ber = 2 ;
1114 else if (errors <= 999999999) ber = 1 ;
1115 else ber = 0 ;
1116
1117 /*
1118 * weighted average
1119 */
1120 ber *= 100 ;
1121 lem->lem_float_ber = lem->lem_float_ber * 7 + ber * 3 ;
1122 lem->lem_float_ber /= 10 ;
1123 mib->fddiPORTLer_Estimate = lem->lem_float_ber / 100 ;
1124 if (mib->fddiPORTLer_Estimate < 4) {
1125 mib->fddiPORTLer_Estimate = 4 ;
1126 }
1127
1128 if (lem->lem_errors) {
1129 DB_PCMN(1,"LEM %c :\n",phy->np == PB? 'B' : 'A',0) ;
1130 DB_PCMN(1,"errors : %ld\n",lem->lem_errors,0) ;
1131 DB_PCMN(1,"sum_errors : %ld\n",mib->fddiPORTLem_Ct,0) ;
1132 DB_PCMN(1,"current BER : 10E-%d\n",ber/100,0) ;
1133 DB_PCMN(1,"float BER : 10E-(%d/100)\n",lem->lem_float_ber,0) ;
1134 DB_PCMN(1,"avg. BER : 10E-%d\n",
1135 mib->fddiPORTLer_Estimate,0) ;
1136 }
1137
1138 lem->lem_errors = 0L ;
1139
1140 #ifndef SLIM_SMT
1141 cond = (mib->fddiPORTLer_Estimate <= mib->fddiPORTLer_Alarm) ?
1142 TRUE : FALSE ;
1143 #ifdef SMT_EXT_CUTOFF
1144 smt_ler_alarm_check(smc,phy,cond) ;
1145 #endif /* nSMT_EXT_CUTOFF */
1146 if (cond != mib->fddiPORTLerFlag) {
1147 smt_srf_event(smc,SMT_COND_PORT_LER,
1148 (int) (INDEX_PORT+ phy->np) ,cond) ;
1149 }
1150 #endif
1151
1152 if ( mib->fddiPORTLer_Estimate <= mib->fddiPORTLer_Cutoff) {
1153 phy->pc_lem_fail = TRUE ; /* flag */
1154 mib->fddiPORTLem_Reject_Ct++ ;
1155 /*
1156 * "forgive 10e-2" if we cutoff so we can come
1157 * up again ..
1158 */
1159 lem->lem_float_ber += 2*100 ;
1160
1161 /*PC81b*/
1162 #ifdef CONCENTRATOR
1163 DB_PCMN(1,"PCM: LER cutoff on port %d cutoff %d\n",
1164 phy->np, mib->fddiPORTLer_Cutoff) ;
1165 #endif
1166 #ifdef SMT_EXT_CUTOFF
1167 smt_port_off_event(smc,phy->np);
1168 #else /* nSMT_EXT_CUTOFF */
1169 queue_event(smc,(int)(EVENT_PCM+phy->np),PC_START) ;
1170 #endif /* nSMT_EXT_CUTOFF */
1171 }
1172 }
1173
1174 /*
1175 * called by SMT to calculate LEM bit error rate
1176 */
1177 void sm_lem_evaluate(struct s_smc *smc)
1178 {
1179 int np ;
1180
1181 for (np = 0 ; np < NUMPHYS ; np++)
1182 lem_evaluate(smc,&smc->y[np]) ;
1183 }
1184
1185 static void lem_check_lct(struct s_smc *smc, struct s_phy *phy)
1186 {
1187 struct lem_counter *lem = &phy->lem ;
1188 struct fddi_mib_p *mib ;
1189 int errors ;
1190
1191 mib = phy->mib ;
1192
1193 phy->pc_lem_fail = FALSE ; /* flag */
1194 errors = inpw(PLC(((int)phy->np),PL_LINK_ERR_CTR)) ;
1195 lem->lem_errors += errors ;
1196 mib->fddiPORTLem_Ct += errors ;
1197 if (lem->lem_errors) {
1198 switch(phy->lc_test) {
1199 case LC_SHORT:
1200 if (lem->lem_errors >= smc->s.lct_short)
1201 phy->pc_lem_fail = TRUE ;
1202 break ;
1203 case LC_MEDIUM:
1204 if (lem->lem_errors >= smc->s.lct_medium)
1205 phy->pc_lem_fail = TRUE ;
1206 break ;
1207 case LC_LONG:
1208 if (lem->lem_errors >= smc->s.lct_long)
1209 phy->pc_lem_fail = TRUE ;
1210 break ;
1211 case LC_EXTENDED:
1212 if (lem->lem_errors >= smc->s.lct_extended)
1213 phy->pc_lem_fail = TRUE ;
1214 break ;
1215 }
1216 DB_PCMN(1," >>errors : %d\n",lem->lem_errors,0) ;
1217 }
1218 if (phy->pc_lem_fail) {
1219 mib->fddiPORTLCTFail_Ct++ ;
1220 mib->fddiPORTLem_Reject_Ct++ ;
1221 }
1222 else
1223 mib->fddiPORTLCTFail_Ct = 0 ;
1224 }
1225
1226 /*
1227 * LEM functions
1228 */
1229 static void sm_ph_lem_start(struct s_smc *smc, int np, int threshold)
1230 {
1231 struct lem_counter *lem = &smc->y[np].lem ;
1232
1233 lem->lem_on = 1 ;
1234 lem->lem_errors = 0L ;
1235
1236 /* Do NOT reset mib->fddiPORTLer_Estimate here. It is called too
1237 * often.
1238 */
1239
1240 outpw(PLC(np,PL_LE_THRESHOLD),threshold) ;
1241 (void)inpw(PLC(np,PL_LINK_ERR_CTR)) ; /* clear error counter */
1242
1243 /* enable LE INT */
1244 SETMASK(PLC(np,PL_INTR_MASK),PL_LE_CTR,PL_LE_CTR) ;
1245 }
1246
1247 static void sm_ph_lem_stop(struct s_smc *smc, int np)
1248 {
1249 struct lem_counter *lem = &smc->y[np].lem ;
1250
1251 lem->lem_on = 0 ;
1252 CLEAR(PLC(np,PL_INTR_MASK),PL_LE_CTR) ;
1253 }
1254
1255 /* ARGSUSED */
1256 void sm_pm_ls_latch(struct s_smc *smc, int phy, int on_off)
1257 /* int on_off; en- or disable ident. ls */
1258 {
1259 SK_UNUSED(smc) ;
1260
1261 phy = phy ; on_off = on_off ;
1262 }
1263
1264
1265 /*
1266 * PCM pseudo code
1267 * receive actions are called AFTER the bit n is received,
1268 * i.e. if pc_rcode_actions(5) is called, bit 6 is the next bit to be received
1269 */
1270
1271 /*
1272 * PCM pseudo code 5.1 .. 6.1
1273 */
1274 static void pc_rcode_actions(struct s_smc *smc, int bit, struct s_phy *phy)
1275 {
1276 struct fddi_mib_p *mib ;
1277
1278 mib = phy->mib ;
1279
1280 DB_PCMN(1,"SIG rec %x %x: \n", bit,phy->r_val[bit] ) ;
1281 bit++ ;
1282
1283 switch(bit) {
1284 case 0:
1285 case 1:
1286 case 2:
1287 break ;
1288 case 3 :
1289 if (phy->r_val[1] == 0 && phy->r_val[2] == 0)
1290 mib->fddiPORTNeighborType = TA ;
1291 else if (phy->r_val[1] == 0 && phy->r_val[2] == 1)
1292 mib->fddiPORTNeighborType = TB ;
1293 else if (phy->r_val[1] == 1 && phy->r_val[2] == 0)
1294 mib->fddiPORTNeighborType = TS ;
1295 else if (phy->r_val[1] == 1 && phy->r_val[2] == 1)
1296 mib->fddiPORTNeighborType = TM ;
1297 break ;
1298 case 4:
1299 if (mib->fddiPORTMy_Type == TM &&
1300 mib->fddiPORTNeighborType == TM) {
1301 DB_PCMN(1,"PCM %c : E100 withhold M-M\n",
1302 phy->phy_name,0) ;
1303 mib->fddiPORTPC_Withhold = PC_WH_M_M ;
1304 RS_SET(smc,RS_EVENT) ;
1305 }
1306 else if (phy->t_val[3] || phy->r_val[3]) {
1307 mib->fddiPORTPC_Withhold = PC_WH_NONE ;
1308 if (mib->fddiPORTMy_Type == TM ||
1309 mib->fddiPORTNeighborType == TM)
1310 phy->pc_mode = PM_TREE ;
1311 else
1312 phy->pc_mode = PM_PEER ;
1313
1314 /* reevaluate the selection criteria (wc_flag) */
1315 all_selection_criteria (smc);
1316
1317 if (phy->wc_flag) {
1318 mib->fddiPORTPC_Withhold = PC_WH_PATH ;
1319 }
1320 }
1321 else {
1322 mib->fddiPORTPC_Withhold = PC_WH_OTHER ;
1323 RS_SET(smc,RS_EVENT) ;
1324 DB_PCMN(1,"PCM %c : E101 withhold other\n",
1325 phy->phy_name,0) ;
1326 }
1327 phy->twisted = ((mib->fddiPORTMy_Type != TS) &&
1328 (mib->fddiPORTMy_Type != TM) &&
1329 (mib->fddiPORTNeighborType ==
1330 mib->fddiPORTMy_Type)) ;
1331 if (phy->twisted) {
1332 DB_PCMN(1,"PCM %c : E102 !!! TWISTED !!!\n",
1333 phy->phy_name,0) ;
1334 }
1335 break ;
1336 case 5 :
1337 break ;
1338 case 6:
1339 if (phy->t_val[4] || phy->r_val[4]) {
1340 if ((phy->t_val[4] && phy->t_val[5]) ||
1341 (phy->r_val[4] && phy->r_val[5]) )
1342 phy->lc_test = LC_EXTENDED ;
1343 else
1344 phy->lc_test = LC_LONG ;
1345 }
1346 else if (phy->t_val[5] || phy->r_val[5])
1347 phy->lc_test = LC_MEDIUM ;
1348 else
1349 phy->lc_test = LC_SHORT ;
1350 switch (phy->lc_test) {
1351 case LC_SHORT : /* 50ms */
1352 outpw(PLC((int)phy->np,PL_LC_LENGTH), TP_LC_LENGTH ) ;
1353 phy->t_next[7] = smc->s.pcm_lc_short ;
1354 break ;
1355 case LC_MEDIUM : /* 500ms */
1356 outpw(PLC((int)phy->np,PL_LC_LENGTH), TP_LC_LONGLN ) ;
1357 phy->t_next[7] = smc->s.pcm_lc_medium ;
1358 break ;
1359 case LC_LONG :
1360 SETMASK(PLC((int)phy->np,PL_CNTRL_B),PL_LONG,PL_LONG) ;
1361 phy->t_next[7] = smc->s.pcm_lc_long ;
1362 break ;
1363 case LC_EXTENDED :
1364 SETMASK(PLC((int)phy->np,PL_CNTRL_B),PL_LONG,PL_LONG) ;
1365 phy->t_next[7] = smc->s.pcm_lc_extended ;
1366 break ;
1367 }
1368 if (phy->t_next[7] > smc->s.pcm_lc_medium) {
1369 start_pcm_timer0(smc,phy->t_next[7],PC_TIMEOUT_LCT,phy);
1370 }
1371 DB_PCMN(1,"LCT timer = %ld us\n", phy->t_next[7], 0) ;
1372 phy->t_next[9] = smc->s.pcm_t_next_9 ;
1373 break ;
1374 case 7:
1375 if (phy->t_val[6]) {
1376 phy->cf_loop = TRUE ;
1377 }
1378 phy->td_flag = TRUE ;
1379 break ;
1380 case 8:
1381 if (phy->t_val[7] || phy->r_val[7]) {
1382 DB_PCMN(1,"PCM %c : E103 LCT fail %s\n",
1383 phy->phy_name,phy->t_val[7]? "local":"remote") ;
1384 queue_event(smc,(int)(EVENT_PCM+phy->np),PC_START) ;
1385 }
1386 break ;
1387 case 9:
1388 if (phy->t_val[8] || phy->r_val[8]) {
1389 if (phy->t_val[8])
1390 phy->cf_loop = TRUE ;
1391 phy->td_flag = TRUE ;
1392 }
1393 break ;
1394 case 10:
1395 if (phy->r_val[9]) {
1396 /* neighbor intends to have MAC on output */ ;
1397 mib->fddiPORTMacIndicated.R_val = TRUE ;
1398 }
1399 else {
1400 /* neighbor does not intend to have MAC on output */ ;
1401 mib->fddiPORTMacIndicated.R_val = FALSE ;
1402 }
1403 break ;
1404 }
1405 }
1406
1407 /*
1408 * PCM pseudo code 5.1 .. 6.1
1409 */
1410 static void pc_tcode_actions(struct s_smc *smc, const int bit, struct s_phy *phy)
1411 {
1412 int np = phy->np ;
1413 struct fddi_mib_p *mib ;
1414
1415 mib = phy->mib ;
1416
1417 switch(bit) {
1418 case 0:
1419 phy->t_val[0] = 0 ; /* no escape used */
1420 break ;
1421 case 1:
1422 if (mib->fddiPORTMy_Type == TS || mib->fddiPORTMy_Type == TM)
1423 phy->t_val[1] = 1 ;
1424 else
1425 phy->t_val[1] = 0 ;
1426 break ;
1427 case 2 :
1428 if (mib->fddiPORTMy_Type == TB || mib->fddiPORTMy_Type == TM)
1429 phy->t_val[2] = 1 ;
1430 else
1431 phy->t_val[2] = 0 ;
1432 break ;
1433 case 3:
1434 {
1435 int type,ne ;
1436 int policy ;
1437
1438 type = mib->fddiPORTMy_Type ;
1439 ne = mib->fddiPORTNeighborType ;
1440 policy = smc->mib.fddiSMTConnectionPolicy ;
1441
1442 phy->t_val[3] = 1 ; /* Accept connection */
1443 switch (type) {
1444 case TA :
1445 if (
1446 ((policy & POLICY_AA) && ne == TA) ||
1447 ((policy & POLICY_AB) && ne == TB) ||
1448 ((policy & POLICY_AS) && ne == TS) ||
1449 ((policy & POLICY_AM) && ne == TM) )
1450 phy->t_val[3] = 0 ; /* Reject */
1451 break ;
1452 case TB :
1453 if (
1454 ((policy & POLICY_BA) && ne == TA) ||
1455 ((policy & POLICY_BB) && ne == TB) ||
1456 ((policy & POLICY_BS) && ne == TS) ||
1457 ((policy & POLICY_BM) && ne == TM) )
1458 phy->t_val[3] = 0 ; /* Reject */
1459 break ;
1460 case TS :
1461 if (
1462 ((policy & POLICY_SA) && ne == TA) ||
1463 ((policy & POLICY_SB) && ne == TB) ||
1464 ((policy & POLICY_SS) && ne == TS) ||
1465 ((policy & POLICY_SM) && ne == TM) )
1466 phy->t_val[3] = 0 ; /* Reject */
1467 break ;
1468 case TM :
1469 if ( ne == TM ||
1470 ((policy & POLICY_MA) && ne == TA) ||
1471 ((policy & POLICY_MB) && ne == TB) ||
1472 ((policy & POLICY_MS) && ne == TS) ||
1473 ((policy & POLICY_MM) && ne == TM) )
1474 phy->t_val[3] = 0 ; /* Reject */
1475 break ;
1476 }
1477 #ifndef SLIM_SMT
1478 /*
1479 * detect undesirable connection attempt event
1480 */
1481 if ( (type == TA && ne == TA ) ||
1482 (type == TA && ne == TS ) ||
1483 (type == TB && ne == TB ) ||
1484 (type == TB && ne == TS ) ||
1485 (type == TS && ne == TA ) ||
1486 (type == TS && ne == TB ) ) {
1487 smt_srf_event(smc,SMT_EVENT_PORT_CONNECTION,
1488 (int) (INDEX_PORT+ phy->np) ,0) ;
1489 }
1490 #endif
1491 }
1492 break ;
1493 case 4:
1494 if (mib->fddiPORTPC_Withhold == PC_WH_NONE) {
1495 if (phy->pc_lem_fail) {
1496 phy->t_val[4] = 1 ; /* long */
1497 phy->t_val[5] = 0 ;
1498 }
1499 else {
1500 phy->t_val[4] = 0 ;
1501 if (mib->fddiPORTLCTFail_Ct > 0)
1502 phy->t_val[5] = 1 ; /* medium */
1503 else
1504 phy->t_val[5] = 0 ; /* short */
1505
1506 /*
1507 * Implementers choice: use medium
1508 * instead of short when undesired
1509 * connection attempt is made.
1510 */
1511 if (phy->wc_flag)
1512 phy->t_val[5] = 1 ; /* medium */
1513 }
1514 mib->fddiPORTConnectState = PCM_CONNECTING ;
1515 }
1516 else {
1517 mib->fddiPORTConnectState = PCM_STANDBY ;
1518 phy->t_val[4] = 1 ; /* extended */
1519 phy->t_val[5] = 1 ;
1520 }
1521 break ;
1522 case 5:
1523 break ;
1524 case 6:
1525 /* we do NOT have a MAC for LCT */
1526 phy->t_val[6] = 0 ;
1527 break ;
1528 case 7:
1529 phy->cf_loop = FALSE ;
1530 lem_check_lct(smc,phy) ;
1531 if (phy->pc_lem_fail) {
1532 DB_PCMN(1,"PCM %c : E104 LCT failed\n",
1533 phy->phy_name,0) ;
1534 phy->t_val[7] = 1 ;
1535 }
1536 else
1537 phy->t_val[7] = 0 ;
1538 break ;
1539 case 8:
1540 phy->t_val[8] = 0 ; /* Don't request MAC loopback */
1541 break ;
1542 case 9:
1543 phy->cf_loop = 0 ;
1544 if ((mib->fddiPORTPC_Withhold != PC_WH_NONE) ||
1545 ((smc->s.sas == SMT_DAS) && (phy->wc_flag))) {
1546 queue_event(smc,EVENT_PCM+np,PC_START) ;
1547 break ;
1548 }
1549 phy->t_val[9] = FALSE ;
1550 switch (smc->s.sas) {
1551 case SMT_DAS :
1552 /*
1553 * MAC intended on output
1554 */
1555 if (phy->pc_mode == PM_TREE) {
1556 if ((np == PB) || ((np == PA) &&
1557 (smc->y[PB].mib->fddiPORTConnectState !=
1558 PCM_ACTIVE)))
1559 phy->t_val[9] = TRUE ;
1560 }
1561 else {
1562 if (np == PB)
1563 phy->t_val[9] = TRUE ;
1564 }
1565 break ;
1566 case SMT_SAS :
1567 if (np == PS)
1568 phy->t_val[9] = TRUE ;
1569 break ;
1570 #ifdef CONCENTRATOR
1571 case SMT_NAC :
1572 /*
1573 * MAC intended on output
1574 */
1575 if (np == PB)
1576 phy->t_val[9] = TRUE ;
1577 break ;
1578 #endif
1579 }
1580 mib->fddiPORTMacIndicated.T_val = phy->t_val[9] ;
1581 break ;
1582 }
1583 DB_PCMN(1,"SIG snd %x %x: \n", bit,phy->t_val[bit] ) ;
1584 }
1585
1586 /*
1587 * return status twisted (called by SMT)
1588 */
1589 int pcm_status_twisted(struct s_smc *smc)
1590 {
1591 int twist = 0 ;
1592 if (smc->s.sas != SMT_DAS)
1593 return(0) ;
1594 if (smc->y[PA].twisted && (smc->y[PA].mib->fddiPORTPCMState == PC8_ACTIVE))
1595 twist |= 1 ;
1596 if (smc->y[PB].twisted && (smc->y[PB].mib->fddiPORTPCMState == PC8_ACTIVE))
1597 twist |= 2 ;
1598 return(twist) ;
1599 }
1600
1601 /*
1602 * return status (called by SMT)
1603 * type
1604 * state
1605 * remote phy type
1606 * remote mac yes/no
1607 */
1608 void pcm_status_state(struct s_smc *smc, int np, int *type, int *state,
1609 int *remote, int *mac)
1610 {
1611 struct s_phy *phy = &smc->y[np] ;
1612 struct fddi_mib_p *mib ;
1613
1614 mib = phy->mib ;
1615
1616 /* remote PHY type and MAC - set only if active */
1617 *mac = 0 ;
1618 *type = mib->fddiPORTMy_Type ; /* our PHY type */
1619 *state = mib->fddiPORTConnectState ;
1620 *remote = mib->fddiPORTNeighborType ;
1621
1622 switch(mib->fddiPORTPCMState) {
1623 case PC8_ACTIVE :
1624 *mac = mib->fddiPORTMacIndicated.R_val ;
1625 break ;
1626 }
1627 }
1628
1629 /*
1630 * return rooted station status (called by SMT)
1631 */
1632 int pcm_rooted_station(struct s_smc *smc)
1633 {
1634 int n ;
1635
1636 for (n = 0 ; n < NUMPHYS ; n++) {
1637 if (smc->y[n].mib->fddiPORTPCMState == PC8_ACTIVE &&
1638 smc->y[n].mib->fddiPORTNeighborType == TM)
1639 return(0) ;
1640 }
1641 return(1) ;
1642 }
1643
1644 /*
1645 * Interrupt actions for PLC & PCM events
1646 */
1647 void plc_irq(struct s_smc *smc, int np, unsigned int cmd)
1648 /* int np; PHY index */
1649 {
1650 struct s_phy *phy = &smc->y[np] ;
1651 struct s_plc *plc = &phy->plc ;
1652 int n ;
1653 #ifdef SUPERNET_3
1654 int corr_mask ;
1655 #endif /* SUPERNET_3 */
1656 int i ;
1657
1658 if (np >= smc->s.numphys) {
1659 plc->soft_err++ ;
1660 return ;
1661 }
1662 if (cmd & PL_EBUF_ERR) { /* elastic buff. det. over-|underflow*/
1663 /*
1664 * Check whether the SRF Condition occurred.
1665 */
1666 if (!plc->ebuf_cont && phy->mib->fddiPORTPCMState == PC8_ACTIVE){
1667 /*
1668 * This is the real Elasticity Error.
1669 * More than one in a row are treated as a
1670 * single one.
1671 * Only count this in the active state.
1672 */
1673 phy->mib->fddiPORTEBError_Ct ++ ;
1674
1675 }
1676
1677 plc->ebuf_err++ ;
1678 if (plc->ebuf_cont <= 1000) {
1679 /*
1680 * Prevent counter from being wrapped after
1681 * hanging years in that interrupt.
1682 */
1683 plc->ebuf_cont++ ; /* Ebuf continous error */
1684 }
1685
1686 #ifdef SUPERNET_3
1687 if (plc->ebuf_cont == 1000 &&
1688 ((inpw(PLC(np,PL_STATUS_A)) & PLC_REV_MASK) ==
1689 PLC_REV_SN3)) {
1690 /*
1691 * This interrupt remeained high for at least
1692 * 1000 consecutive interrupt calls.
1693 *
1694 * This is caused by a hardware error of the
1695 * ORION part of the Supernet III chipset.
1696 *
1697 * Disable this bit from the mask.
1698 */
1699 corr_mask = (plc_imsk_na & ~PL_EBUF_ERR) ;
1700 outpw(PLC(np,PL_INTR_MASK),corr_mask);
1701
1702 /*
1703 * Disconnect from the ring.
1704 * Call the driver with the reset indication.
1705 */
1706 queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
1707
1708 /*
1709 * Make an error log entry.
1710 */
1711 SMT_ERR_LOG(smc,SMT_E0136, SMT_E0136_MSG) ;
1712
1713 /*
1714 * Indicate the Reset.
1715 */
1716 drv_reset_indication(smc) ;
1717 }
1718 #endif /* SUPERNET_3 */
1719 } else {
1720 /* Reset the continous error variable */
1721 plc->ebuf_cont = 0 ; /* reset Ebuf continous error */
1722 }
1723 if (cmd & PL_PHYINV) { /* physical layer invalid signal */
1724 plc->phyinv++ ;
1725 }
1726 if (cmd & PL_VSYM_CTR) { /* violation symbol counter has incr.*/
1727 plc->vsym_ctr++ ;
1728 }
1729 if (cmd & PL_MINI_CTR) { /* dep. on PLC_CNTRL_A's MINI_CTR_INT*/
1730 plc->mini_ctr++ ;
1731 }
1732 if (cmd & PL_LE_CTR) { /* link error event counter */
1733 int j ;
1734
1735 /*
1736 * note: PL_LINK_ERR_CTR MUST be read to clear it
1737 */
1738 j = inpw(PLC(np,PL_LE_THRESHOLD)) ;
1739 i = inpw(PLC(np,PL_LINK_ERR_CTR)) ;
1740
1741 if (i < j) {
1742 /* wrapped around */
1743 i += 256 ;
1744 }
1745
1746 if (phy->lem.lem_on) {
1747 /* Note: Lem errors shall only be counted when
1748 * link is ACTIVE or LCT is active.
1749 */
1750 phy->lem.lem_errors += i ;
1751 phy->mib->fddiPORTLem_Ct += i ;
1752 }
1753 }
1754 if (cmd & PL_TPC_EXPIRED) { /* TPC timer reached zero */
1755 if (plc->p_state == PS_LCT) {
1756 /*
1757 * end of LCT
1758 */
1759 ;
1760 }
1761 plc->tpc_exp++ ;
1762 }
1763 if (cmd & PL_LS_MATCH) { /* LS == LS in PLC_CNTRL_B's MATCH_LS*/
1764 switch (inpw(PLC(np,PL_CNTRL_B)) & PL_MATCH_LS) {
1765 case PL_I_IDLE : phy->curr_ls = PC_ILS ; break ;
1766 case PL_I_HALT : phy->curr_ls = PC_HLS ; break ;
1767 case PL_I_MASTR : phy->curr_ls = PC_MLS ; break ;
1768 case PL_I_QUIET : phy->curr_ls = PC_QLS ; break ;
1769 }
1770 }
1771 if (cmd & PL_PCM_BREAK) { /* PCM has entered the BREAK state */
1772 int reason;
1773
1774 reason = inpw(PLC(np,PL_STATUS_B)) & PL_BREAK_REASON ;
1775
1776 switch (reason) {
1777 case PL_B_PCS : plc->b_pcs++ ; break ;
1778 case PL_B_TPC : plc->b_tpc++ ; break ;
1779 case PL_B_TNE : plc->b_tne++ ; break ;
1780 case PL_B_QLS : plc->b_qls++ ; break ;
1781 case PL_B_ILS : plc->b_ils++ ; break ;
1782 case PL_B_HLS : plc->b_hls++ ; break ;
1783 }
1784
1785 /*jd 05-Aug-1999 changed: Bug #10419 */
1786 DB_PCMN(1,"PLC %d: MDcF = %x\n", np, smc->e.DisconnectFlag);
1787 if (smc->e.DisconnectFlag == FALSE) {
1788 DB_PCMN(1,"PLC %d: restart (reason %x)\n", np, reason);
1789 queue_event(smc,EVENT_PCM+np,PC_START) ;
1790 }
1791 else {
1792 DB_PCMN(1,"PLC %d: NO!! restart (reason %x)\n", np, reason);
1793 }
1794 return ;
1795 }
1796 /*
1797 * If both CODE & ENABLE are set ignore enable
1798 */
1799 if (cmd & PL_PCM_CODE) { /* receive last sign.-bit | LCT complete */
1800 queue_event(smc,EVENT_PCM+np,PC_SIGNAL) ;
1801 n = inpw(PLC(np,PL_RCV_VECTOR)) ;
1802 for (i = 0 ; i < plc->p_bits ; i++) {
1803 phy->r_val[plc->p_start+i] = n & 1 ;
1804 n >>= 1 ;
1805 }
1806 }
1807 else if (cmd & PL_PCM_ENABLED) { /* asserted SC_JOIN, scrub.completed*/
1808 queue_event(smc,EVENT_PCM+np,PC_JOIN) ;
1809 }
1810 if (cmd & PL_TRACE_PROP) { /* MLS while PC8_ACTIV || PC2_TRACE */
1811 /*PC22b*/
1812 if (!phy->tr_flag) {
1813 DB_PCMN(1,"PCM : irq TRACE_PROP %d %d\n",
1814 np,smc->mib.fddiSMTECMState) ;
1815 phy->tr_flag = TRUE ;
1816 smc->e.trace_prop |= ENTITY_BIT(ENTITY_PHY(np)) ;
1817 queue_event(smc,EVENT_ECM,EC_TRACE_PROP) ;
1818 }
1819 }
1820 /*
1821 * filter PLC glitch ???
1822 * QLS || HLS only while in PC2_TRACE state
1823 */
1824 if ((cmd & PL_SELF_TEST) && (phy->mib->fddiPORTPCMState == PC2_TRACE)) {
1825 /*PC22a*/
1826 if (smc->e.path_test == PT_PASSED) {
1827 DB_PCMN(1,"PCM : state = %s %d\n", get_pcmstate(smc,np),
1828 phy->mib->fddiPORTPCMState) ;
1829
1830 smc->e.path_test = PT_PENDING ;
1831 queue_event(smc,EVENT_ECM,EC_PATH_TEST) ;
1832 }
1833 }
1834 if (cmd & PL_TNE_EXPIRED) { /* TNE: length of noise events */
1835 /* break_required (TNE > NS_Max) */
1836 if (phy->mib->fddiPORTPCMState == PC8_ACTIVE) {
1837 if (!phy->tr_flag) {
1838 DB_PCMN(1,"PCM %c : PC81 %s\n",phy->phy_name,"NSE");
1839 queue_event(smc,EVENT_PCM+np,PC_START) ;
1840 return ;
1841 }
1842 }
1843 }
1844 #if 0
1845 if (cmd & PL_NP_ERR) { /* NP has requested to r/w an inv reg*/
1846 /*
1847 * It's a bug by AMD
1848 */
1849 plc->np_err++ ;
1850 }
1851 /* pin inactiv (GND) */
1852 if (cmd & PL_PARITY_ERR) { /* p. error dedected on TX9-0 inp */
1853 plc->parity_err++ ;
1854 }
1855 if (cmd & PL_LSDO) { /* carrier detected */
1856 ;
1857 }
1858 #endif
1859 }
1860
1861 #ifdef DEBUG
1862 /*
1863 * fill state struct
1864 */
1865 void pcm_get_state(struct s_smc *smc, struct smt_state *state)
1866 {
1867 struct s_phy *phy ;
1868 struct pcm_state *pcs ;
1869 int i ;
1870 int ii ;
1871 short rbits ;
1872 short tbits ;
1873 struct fddi_mib_p *mib ;
1874
1875 for (i = 0, phy = smc->y, pcs = state->pcm_state ; i < NUMPHYS ;
1876 i++ , phy++, pcs++ ) {
1877 mib = phy->mib ;
1878 pcs->pcm_type = (u_char) mib->fddiPORTMy_Type ;
1879 pcs->pcm_state = (u_char) mib->fddiPORTPCMState ;
1880 pcs->pcm_mode = phy->pc_mode ;
1881 pcs->pcm_neighbor = (u_char) mib->fddiPORTNeighborType ;
1882 pcs->pcm_bsf = mib->fddiPORTBS_Flag ;
1883 pcs->pcm_lsf = phy->ls_flag ;
1884 pcs->pcm_lct_fail = (u_char) mib->fddiPORTLCTFail_Ct ;
1885 pcs->pcm_ls_rx = LS2MIB(sm_pm_get_ls(smc,i)) ;
1886 for (ii = 0, rbits = tbits = 0 ; ii < NUMBITS ; ii++) {
1887 rbits <<= 1 ;
1888 tbits <<= 1 ;
1889 if (phy->r_val[NUMBITS-1-ii])
1890 rbits |= 1 ;
1891 if (phy->t_val[NUMBITS-1-ii])
1892 tbits |= 1 ;
1893 }
1894 pcs->pcm_r_val = rbits ;
1895 pcs->pcm_t_val = tbits ;
1896 }
1897 }
1898
1899 int get_pcm_state(struct s_smc *smc, int np)
1900 {
1901 int pcs ;
1902
1903 SK_UNUSED(smc) ;
1904
1905 switch (inpw(PLC(np,PL_STATUS_B)) & PL_PCM_STATE) {
1906 case PL_PC0 : pcs = PC_STOP ; break ;
1907 case PL_PC1 : pcs = PC_START ; break ;
1908 case PL_PC2 : pcs = PC_TRACE ; break ;
1909 case PL_PC3 : pcs = PC_SIGNAL ; break ;
1910 case PL_PC4 : pcs = PC_SIGNAL ; break ;
1911 case PL_PC5 : pcs = PC_SIGNAL ; break ;
1912 case PL_PC6 : pcs = PC_JOIN ; break ;
1913 case PL_PC7 : pcs = PC_JOIN ; break ;
1914 case PL_PC8 : pcs = PC_ENABLE ; break ;
1915 case PL_PC9 : pcs = PC_MAINT ; break ;
1916 default : pcs = PC_DISABLE ; break ;
1917 }
1918 return(pcs) ;
1919 }
1920
1921 char *get_linestate(struct s_smc *smc, int np)
1922 {
1923 char *ls = "" ;
1924
1925 SK_UNUSED(smc) ;
1926
1927 switch (inpw(PLC(np,PL_STATUS_A)) & PL_LINE_ST) {
1928 case PL_L_NLS : ls = "NOISE" ; break ;
1929 case PL_L_ALS : ls = "ACTIV" ; break ;
1930 case PL_L_UND : ls = "UNDEF" ; break ;
1931 case PL_L_ILS4: ls = "ILS 4" ; break ;
1932 case PL_L_QLS : ls = "QLS" ; break ;
1933 case PL_L_MLS : ls = "MLS" ; break ;
1934 case PL_L_HLS : ls = "HLS" ; break ;
1935 case PL_L_ILS16:ls = "ILS16" ; break ;
1936 #ifdef lint
1937 default: ls = "unknown" ; break ;
1938 #endif
1939 }
1940 return(ls) ;
1941 }
1942
1943 char *get_pcmstate(struct s_smc *smc, int np)
1944 {
1945 char *pcs ;
1946
1947 SK_UNUSED(smc) ;
1948
1949 switch (inpw(PLC(np,PL_STATUS_B)) & PL_PCM_STATE) {
1950 case PL_PC0 : pcs = "OFF" ; break ;
1951 case PL_PC1 : pcs = "BREAK" ; break ;
1952 case PL_PC2 : pcs = "TRACE" ; break ;
1953 case PL_PC3 : pcs = "CONNECT"; break ;
1954 case PL_PC4 : pcs = "NEXT" ; break ;
1955 case PL_PC5 : pcs = "SIGNAL" ; break ;
1956 case PL_PC6 : pcs = "JOIN" ; break ;
1957 case PL_PC7 : pcs = "VERIFY" ; break ;
1958 case PL_PC8 : pcs = "ACTIV" ; break ;
1959 case PL_PC9 : pcs = "MAINT" ; break ;
1960 default : pcs = "UNKNOWN" ; break ;
1961 }
1962 return(pcs) ;
1963 }
1964
1965 void list_phy(struct s_smc *smc)
1966 {
1967 struct s_plc *plc ;
1968 int np ;
1969
1970 for (np = 0 ; np < NUMPHYS ; np++) {
1971 plc = &smc->y[np].plc ;
1972 printf("PHY %d:\tERRORS\t\t\tBREAK_REASONS\t\tSTATES:\n",np) ;
1973 printf("\tsoft_error: %ld \t\tPC_Start : %ld\n",
1974 plc->soft_err,plc->b_pcs);
1975 printf("\tparity_err: %ld \t\tTPC exp. : %ld\t\tLine: %s\n",
1976 plc->parity_err,plc->b_tpc,get_linestate(smc,np)) ;
1977 printf("\tebuf_error: %ld \t\tTNE exp. : %ld\n",
1978 plc->ebuf_err,plc->b_tne) ;
1979 printf("\tphyinvalid: %ld \t\tQLS det. : %ld\t\tPCM : %s\n",
1980 plc->phyinv,plc->b_qls,get_pcmstate(smc,np)) ;
1981 printf("\tviosym_ctr: %ld \t\tILS det. : %ld\n",
1982 plc->vsym_ctr,plc->b_ils) ;
1983 printf("\tmingap_ctr: %ld \t\tHLS det. : %ld\n",
1984 plc->mini_ctr,plc->b_hls) ;
1985 printf("\tnodepr_err: %ld\n",plc->np_err) ;
1986 printf("\tTPC_exp : %ld\n",plc->tpc_exp) ;
1987 printf("\tLEM_err : %ld\n",smc->y[np].lem.lem_errors) ;
1988 }
1989 }
1990
1991
1992 #ifdef CONCENTRATOR
1993 void pcm_lem_dump(struct s_smc *smc)
1994 {
1995 int i ;
1996 struct s_phy *phy ;
1997 struct fddi_mib_p *mib ;
1998
1999 char *entostring() ;
2000
2001 printf("PHY errors BER\n") ;
2002 printf("----------------------\n") ;
2003 for (i = 0,phy = smc->y ; i < NUMPHYS ; i++,phy++) {
2004 if (!plc_is_installed(smc,i))
2005 continue ;
2006 mib = phy->mib ;
2007 printf("%s\t%ld\t10E-%d\n",
2008 entostring(smc,ENTITY_PHY(i)),
2009 mib->fddiPORTLem_Ct,
2010 mib->fddiPORTLer_Estimate) ;
2011 }
2012 }
2013 #endif
2014 #endif
Verdex Pro support