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