← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/net/fddi/skfp/pcmplc.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/fddi/skfp/pcmplc.c
 
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 continuous 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 continuous error variable */
 
1721
                plc->ebuf_cont = 0 ;    /* reset Ebuf continuous 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