drivers/net/skfp/pmf.c: Use offsetof() macro
[linux-2.6.git] / drivers / net / skfp / ecm.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         SMT ECM
19         Entity Coordination Management
20         Hardware independent state machine
21 */
22
23 /*
24  * Hardware independent state machine implemantation
25  * The following external SMT functions are referenced :
26  *
27  *              queue_event()
28  *              smt_timer_start()
29  *              smt_timer_stop()
30  *
31  *      The following external HW dependent functions are referenced :
32  *              sm_pm_bypass_req()
33  *              sm_pm_ls_latch()
34  *              sm_pm_get_ls()
35  * 
36  *      The following HW dependent events are required :
37  *              NONE
38  *
39  */
40
41 #include "h/types.h"
42 #include "h/fddi.h"
43 #include "h/smc.h"
44
45 #define KERNEL
46 #include "h/smtstate.h"
47
48 #ifndef lint
49 static const char ID_sccs[] = "@(#)ecm.c        2.7 99/08/05 (C) SK " ;
50 #endif
51
52 /*
53  * FSM Macros
54  */
55 #define AFLAG   0x10
56 #define GO_STATE(x)     (smc->mib.fddiSMTECMState = (x)|AFLAG)
57 #define ACTIONS_DONE()  (smc->mib.fddiSMTECMState &= ~AFLAG)
58 #define ACTIONS(x)      (x|AFLAG)
59
60 #define EC0_OUT         0                       /* not inserted */
61 #define EC1_IN          1                       /* inserted */
62 #define EC2_TRACE       2                       /* tracing */
63 #define EC3_LEAVE       3                       /* leaving the ring */
64 #define EC4_PATH_TEST   4                       /* performing path test */
65 #define EC5_INSERT      5                       /* bypass being turned on */
66 #define EC6_CHECK       6                       /* checking bypass */
67 #define EC7_DEINSERT    7                       /* bypass being turnde off */
68
69 #ifdef  DEBUG
70 /*
71  * symbolic state names
72  */
73 static const char * const ecm_states[] = {
74         "EC0_OUT","EC1_IN","EC2_TRACE","EC3_LEAVE","EC4_PATH_TEST",
75         "EC5_INSERT","EC6_CHECK","EC7_DEINSERT"
76 } ;
77
78 /*
79  * symbolic event names
80  */
81 static const char * const ecm_events[] = {
82         "NONE","EC_CONNECT","EC_DISCONNECT","EC_TRACE_PROP","EC_PATH_TEST",
83         "EC_TIMEOUT_TD","EC_TIMEOUT_TMAX",
84         "EC_TIMEOUT_IMAX","EC_TIMEOUT_INMAX","EC_TEST_DONE"
85 } ;
86 #endif
87
88 /*
89  * all Globals  are defined in smc.h
90  * struct s_ecm
91  */
92
93 /*
94  * function declarations
95  */
96
97 static void ecm_fsm(struct s_smc *smc, int cmd);
98 static void start_ecm_timer(struct s_smc *smc, u_long value, int event);
99 static void stop_ecm_timer(struct s_smc *smc);
100 static void prop_actions(struct s_smc *smc);
101
102 /*
103         init ECM state machine
104         clear all ECM vars and flags
105 */
106 void ecm_init(struct s_smc *smc)
107 {
108         smc->e.path_test = PT_PASSED ;
109         smc->e.trace_prop = 0 ;
110         smc->e.sb_flag = 0 ;
111         smc->mib.fddiSMTECMState = ACTIONS(EC0_OUT) ;
112         smc->e.ecm_line_state = FALSE ;
113 }
114
115 /*
116         ECM state machine
117         called by dispatcher
118
119         do
120                 display state change
121                 process event
122         until SM is stable
123 */
124 void ecm(struct s_smc *smc, int event)
125 {
126         int     state ;
127
128         do {
129                 DB_ECM("ECM : state %s%s",
130                         (smc->mib.fddiSMTECMState & AFLAG) ? "ACTIONS " : "",
131                         ecm_states[smc->mib.fddiSMTECMState & ~AFLAG]) ;
132                 DB_ECM(" event %s\n",ecm_events[event],0) ;
133                 state = smc->mib.fddiSMTECMState ;
134                 ecm_fsm(smc,event) ;
135                 event = 0 ;
136         } while (state != smc->mib.fddiSMTECMState) ;
137         ecm_state_change(smc,(int)smc->mib.fddiSMTECMState) ;
138 }
139
140 /*
141         process ECM event
142 */
143 static void ecm_fsm(struct s_smc *smc, int cmd)
144 {
145         int ls_a ;                      /* current line state PHY A */
146         int ls_b ;                      /* current line state PHY B */
147         int     p ;                     /* ports */
148
149
150         smc->mib.fddiSMTBypassPresent = sm_pm_bypass_present(smc) ;
151         if (cmd == EC_CONNECT)
152                 smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
153
154         /* For AIX event notification: */
155         /* Is a disconnect  command remotely issued ? */
156         if (cmd == EC_DISCONNECT &&
157                 smc->mib.fddiSMTRemoteDisconnectFlag == TRUE)
158                 AIX_EVENT (smc, (u_long) CIO_HARD_FAIL, (u_long)
159                         FDDI_REMOTE_DISCONNECT, smt_get_event_word(smc),
160                         smt_get_error_word(smc) );
161
162         /*jd 05-Aug-1999 Bug #10419 "Port Disconnect fails at Dup MAc Cond."*/
163         if (cmd == EC_CONNECT) {
164                 smc->e.DisconnectFlag = FALSE ;
165         }
166         else if (cmd == EC_DISCONNECT) {
167                 smc->e.DisconnectFlag = TRUE ;
168         }
169         
170         switch(smc->mib.fddiSMTECMState) {
171         case ACTIONS(EC0_OUT) :
172                 /*
173                  * We do not perform a path test
174                  */
175                 smc->e.path_test = PT_PASSED ;
176                 smc->e.ecm_line_state = FALSE ;
177                 stop_ecm_timer(smc) ;
178                 ACTIONS_DONE() ;
179                 break ;
180         case EC0_OUT:
181                 /*EC01*/
182                 if (cmd == EC_CONNECT && !smc->mib.fddiSMTBypassPresent
183                         && smc->e.path_test==PT_PASSED) {
184                         GO_STATE(EC1_IN) ;
185                         break ;
186                 }
187                 /*EC05*/
188                 else if (cmd == EC_CONNECT && (smc->e.path_test==PT_PASSED) &&
189                         smc->mib.fddiSMTBypassPresent &&
190                         (smc->s.sas == SMT_DAS)) {
191                         GO_STATE(EC5_INSERT) ;
192                         break ;
193                 }
194                 break;
195         case ACTIONS(EC1_IN) :
196                 stop_ecm_timer(smc) ;
197                 smc->e.trace_prop = 0 ;
198                 sm_ma_control(smc,MA_TREQ) ;
199                 for (p = 0 ; p < NUMPHYS ; p++)
200                         if (smc->mib.p[p].fddiPORTHardwarePresent)
201                                 queue_event(smc,EVENT_PCMA+p,PC_START) ;
202                 ACTIONS_DONE() ;
203                 break ;
204         case EC1_IN:
205                 /*EC12*/
206                 if (cmd == EC_TRACE_PROP) {
207                         prop_actions(smc) ;
208                         GO_STATE(EC2_TRACE) ;
209                         break ;
210                 }
211                 /*EC13*/
212                 else if (cmd == EC_DISCONNECT) {
213                         GO_STATE(EC3_LEAVE) ;
214                         break ;
215                 }
216                 break;
217         case ACTIONS(EC2_TRACE) :
218                 start_ecm_timer(smc,MIB2US(smc->mib.fddiSMTTrace_MaxExpiration),
219                         EC_TIMEOUT_TMAX) ;
220                 ACTIONS_DONE() ;
221                 break ;
222         case EC2_TRACE :
223                 /*EC22*/
224                 if (cmd == EC_TRACE_PROP) {
225                         prop_actions(smc) ;
226                         GO_STATE(EC2_TRACE) ;
227                         break ;
228                 }
229                 /*EC23a*/
230                 else if (cmd == EC_DISCONNECT) {
231                         smc->e.path_test = PT_EXITING ;
232                         GO_STATE(EC3_LEAVE) ;
233                         break ;
234                 }
235                 /*EC23b*/
236                 else if (smc->e.path_test == PT_PENDING) {
237                         GO_STATE(EC3_LEAVE) ;
238                         break ;
239                 }
240                 /*EC23c*/
241                 else if (cmd == EC_TIMEOUT_TMAX) {
242                         /* Trace_Max is expired */
243                         /* -> send AIX_EVENT */
244                         AIX_EVENT(smc, (u_long) FDDI_RING_STATUS,
245                                 (u_long) FDDI_SMT_ERROR, (u_long)
246                                 FDDI_TRACE_MAX, smt_get_error_word(smc));
247                         smc->e.path_test = PT_PENDING ;
248                         GO_STATE(EC3_LEAVE) ;
249                         break ;
250                 }
251                 break ;
252         case ACTIONS(EC3_LEAVE) :
253                 start_ecm_timer(smc,smc->s.ecm_td_min,EC_TIMEOUT_TD) ;
254                 for (p = 0 ; p < NUMPHYS ; p++)
255                         queue_event(smc,EVENT_PCMA+p,PC_STOP) ;
256                 ACTIONS_DONE() ;
257                 break ;
258         case EC3_LEAVE:
259                 /*EC30*/
260                 if (cmd == EC_TIMEOUT_TD && !smc->mib.fddiSMTBypassPresent &&
261                         (smc->e.path_test != PT_PENDING)) {
262                         GO_STATE(EC0_OUT) ;
263                         break ;
264                 }
265                 /*EC34*/
266                 else if (cmd == EC_TIMEOUT_TD &&
267                         (smc->e.path_test == PT_PENDING)) {
268                         GO_STATE(EC4_PATH_TEST) ;
269                         break ;
270                 }
271                 /*EC31*/
272                 else if (cmd == EC_CONNECT && smc->e.path_test == PT_PASSED) {
273                         GO_STATE(EC1_IN) ;
274                         break ;
275                 }
276                 /*EC33*/
277                 else if (cmd == EC_DISCONNECT &&
278                         smc->e.path_test == PT_PENDING) {
279                         smc->e.path_test = PT_EXITING ;
280                         /*
281                          * stay in state - state will be left via timeout
282                          */
283                 }
284                 /*EC37*/
285                 else if (cmd == EC_TIMEOUT_TD &&
286                         smc->mib.fddiSMTBypassPresent &&
287                         smc->e.path_test != PT_PENDING) {
288                         GO_STATE(EC7_DEINSERT) ;
289                         break ;
290                 }
291                 break ;
292         case ACTIONS(EC4_PATH_TEST) :
293                 stop_ecm_timer(smc) ;
294                 smc->e.path_test = PT_TESTING ;
295                 start_ecm_timer(smc,smc->s.ecm_test_done,EC_TEST_DONE) ;
296                 /* now perform path test ... just a simulation */
297                 ACTIONS_DONE() ;
298                 break ;
299         case EC4_PATH_TEST :
300                 /* path test done delay */
301                 if (cmd == EC_TEST_DONE)
302                         smc->e.path_test = PT_PASSED ;
303
304                 if (smc->e.path_test == PT_FAILED)
305                         RS_SET(smc,RS_PATHTEST) ;
306
307                 /*EC40a*/
308                 if (smc->e.path_test == PT_FAILED &&
309                         !smc->mib.fddiSMTBypassPresent) {
310                         GO_STATE(EC0_OUT) ;
311                         break ;
312                 }
313                 /*EC40b*/
314                 else if (cmd == EC_DISCONNECT &&
315                         !smc->mib.fddiSMTBypassPresent) {
316                         GO_STATE(EC0_OUT) ;
317                         break ;
318                 }
319                 /*EC41*/
320                 else if (smc->e.path_test == PT_PASSED) {
321                         GO_STATE(EC1_IN) ;
322                         break ;
323                 }
324                 /*EC47a*/
325                 else if (smc->e.path_test == PT_FAILED &&
326                         smc->mib.fddiSMTBypassPresent) {
327                         GO_STATE(EC7_DEINSERT) ;
328                         break ;
329                 }
330                 /*EC47b*/
331                 else if (cmd == EC_DISCONNECT &&
332                         smc->mib.fddiSMTBypassPresent) {
333                         GO_STATE(EC7_DEINSERT) ;
334                         break ;
335                 }
336                 break ;
337         case ACTIONS(EC5_INSERT) :
338                 sm_pm_bypass_req(smc,BP_INSERT);
339                 start_ecm_timer(smc,smc->s.ecm_in_max,EC_TIMEOUT_INMAX) ;
340                 ACTIONS_DONE() ;
341                 break ;
342         case EC5_INSERT :
343                 /*EC56*/
344                 if (cmd == EC_TIMEOUT_INMAX) {
345                         GO_STATE(EC6_CHECK) ;
346                         break ;
347                 }
348                 /*EC57*/
349                 else if (cmd == EC_DISCONNECT) {
350                         GO_STATE(EC7_DEINSERT) ;
351                         break ;
352                 }
353                 break ;
354         case ACTIONS(EC6_CHECK) :
355                 /*
356                  * in EC6_CHECK, we *POLL* the line state !
357                  * check whether both bypass switches have switched.
358                  */
359                 start_ecm_timer(smc,smc->s.ecm_check_poll,0) ;
360                 smc->e.ecm_line_state = TRUE ;  /* flag to pcm: report Q/HLS */
361                 (void) sm_pm_ls_latch(smc,PA,1) ; /* enable line state latch */
362                 (void) sm_pm_ls_latch(smc,PB,1) ; /* enable line state latch */
363                 ACTIONS_DONE() ;
364                 break ;
365         case EC6_CHECK :
366                 ls_a = sm_pm_get_ls(smc,PA) ;
367                 ls_b = sm_pm_get_ls(smc,PB) ;
368
369                 /*EC61*/
370                 if (((ls_a == PC_QLS) || (ls_a == PC_HLS)) &&
371                     ((ls_b == PC_QLS) || (ls_b == PC_HLS)) ) {
372                         smc->e.sb_flag = FALSE ;
373                         smc->e.ecm_line_state = FALSE ;
374                         GO_STATE(EC1_IN) ;
375                         break ;
376                 }
377                 /*EC66*/
378                 else if (!smc->e.sb_flag &&
379                          (((ls_a == PC_ILS) && (ls_b == PC_QLS)) ||
380                           ((ls_a == PC_QLS) && (ls_b == PC_ILS)))){
381                         smc->e.sb_flag = TRUE ;
382                         DB_ECMN(1,"ECM : EC6_CHECK - stuck bypass\n",0,0) ;
383                         AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
384                                 FDDI_SMT_ERROR, (u_long) FDDI_BYPASS_STUCK,
385                                 smt_get_error_word(smc));
386                 }
387                 /*EC67*/
388                 else if (cmd == EC_DISCONNECT) {
389                         smc->e.ecm_line_state = FALSE ;
390                         GO_STATE(EC7_DEINSERT) ;
391                         break ;
392                 }
393                 else {
394                         /*
395                          * restart poll
396                          */
397                         start_ecm_timer(smc,smc->s.ecm_check_poll,0) ;
398                 }
399                 break ;
400         case ACTIONS(EC7_DEINSERT) :
401                 sm_pm_bypass_req(smc,BP_DEINSERT);
402                 start_ecm_timer(smc,smc->s.ecm_i_max,EC_TIMEOUT_IMAX) ;
403                 ACTIONS_DONE() ;
404                 break ;
405         case EC7_DEINSERT:
406                 /*EC70*/
407                 if (cmd == EC_TIMEOUT_IMAX) {
408                         GO_STATE(EC0_OUT) ;
409                         break ;
410                 }
411                 /*EC75*/
412                 else if (cmd == EC_CONNECT && smc->e.path_test == PT_PASSED) {
413                         GO_STATE(EC5_INSERT) ;
414                         break ;
415                 }
416                 break;
417         default:
418                 SMT_PANIC(smc,SMT_E0107, SMT_E0107_MSG) ;
419                 break;
420         }
421 }
422
423 #ifndef CONCENTRATOR
424 /*
425  * trace propagation actions for SAS & DAS
426  */
427 static void prop_actions(struct s_smc *smc)
428 {
429         int     port_in = 0 ;
430         int     port_out = 0 ;
431
432         RS_SET(smc,RS_EVENT) ;
433         switch (smc->s.sas) {
434         case SMT_SAS :
435                 port_in = port_out = pcm_get_s_port(smc) ;
436                 break ;
437         case SMT_DAS :
438                 port_in = cfm_get_mac_input(smc) ;      /* PA or PB */
439                 port_out = cfm_get_mac_output(smc) ;    /* PA or PB */
440                 break ;
441         case SMT_NAC :
442                 SMT_PANIC(smc,SMT_E0108, SMT_E0108_MSG) ;
443                 return ;
444         }
445
446         DB_ECM("ECM : prop_actions - trace_prop %d\n", smc->e.trace_prop,0) ;
447         DB_ECM("ECM : prop_actions - in %d out %d\n", port_in,port_out) ;
448
449         if (smc->e.trace_prop & ENTITY_BIT(ENTITY_MAC)) {
450                 /* trace initiatior */
451                 DB_ECM("ECM : initiate TRACE on PHY %c\n",'A'+port_in-PA,0) ;
452                 queue_event(smc,EVENT_PCM+port_in,PC_TRACE) ;
453         }
454         else if ((smc->e.trace_prop & ENTITY_BIT(ENTITY_PHY(PA))) &&
455                 port_out != PA) {
456                 /* trace propagate upstream */
457                 DB_ECM("ECM : propagate TRACE on PHY B\n",0,0) ;
458                 queue_event(smc,EVENT_PCMB,PC_TRACE) ;
459         }
460         else if ((smc->e.trace_prop & ENTITY_BIT(ENTITY_PHY(PB))) &&
461                 port_out != PB) {
462                 /* trace propagate upstream */
463                 DB_ECM("ECM : propagate TRACE on PHY A\n",0,0) ;
464                 queue_event(smc,EVENT_PCMA,PC_TRACE) ;
465         }
466         else {
467                 /* signal trace termination */
468                 DB_ECM("ECM : TRACE terminated\n",0,0) ;
469                 smc->e.path_test = PT_PENDING ;
470         }
471         smc->e.trace_prop = 0 ;
472 }
473 #else
474 /*
475  * trace propagation actions for Concentrator
476  */
477 static void prop_actions(struct s_smc *smc)
478 {
479         int     initiator ;
480         int     upstream ;
481         int     p ;
482
483         RS_SET(smc,RS_EVENT) ;
484         while (smc->e.trace_prop) {
485                 DB_ECM("ECM : prop_actions - trace_prop %d\n",
486                         smc->e.trace_prop,0) ;
487
488                 if (smc->e.trace_prop & ENTITY_BIT(ENTITY_MAC)) {
489                         initiator = ENTITY_MAC ;
490                         smc->e.trace_prop &= ~ENTITY_BIT(ENTITY_MAC) ;
491                         DB_ECM("ECM: MAC initiates trace\n",0,0) ;
492                 }
493                 else {
494                         for (p = NUMPHYS-1 ; p >= 0 ; p--) {
495                                 if (smc->e.trace_prop &
496                                         ENTITY_BIT(ENTITY_PHY(p)))
497                                         break ;
498                         }
499                         initiator = ENTITY_PHY(p) ;
500                         smc->e.trace_prop &= ~ENTITY_BIT(ENTITY_PHY(p)) ;
501                 }
502                 upstream = cem_get_upstream(smc,initiator) ;
503
504                 if (upstream == ENTITY_MAC) {
505                         /* signal trace termination */
506                         DB_ECM("ECM : TRACE terminated\n",0,0) ;
507                         smc->e.path_test = PT_PENDING ;
508                 }
509                 else {
510                         /* trace propagate upstream */
511                         DB_ECM("ECM : propagate TRACE on PHY %d\n",upstream,0) ;
512                         queue_event(smc,EVENT_PCM+upstream,PC_TRACE) ;
513                 }
514         }
515 }
516 #endif
517
518
519 /*
520  * SMT timer interface
521  *      start ECM timer
522  */
523 static void start_ecm_timer(struct s_smc *smc, u_long value, int event)
524 {
525         smt_timer_start(smc,&smc->e.ecm_timer,value,EV_TOKEN(EVENT_ECM,event));
526 }
527
528 /*
529  * SMT timer interface
530  *      stop ECM timer
531  */
532 static void stop_ecm_timer(struct s_smc *smc)
533 {
534         if (smc->e.ecm_timer.tm_active)
535                 smt_timer_stop(smc,&smc->e.ecm_timer) ;
536 }