?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / net / fddi / skfp / srf.c
blob4cad68c3f49b367d112f9afe26e283580fabfadd
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 7.2 Status Response Frame Implementation
15 SRF state machine and frame generation
16 */
17
18 #include "h/types.h"
19 #include "h/fddi.h"
20 #include "h/smc.h"
21 #include "h/smt_p.h"
22
23 #define KERNEL
24 #include "h/smtstate.h"
25
26 #ifndef SLIM_SMT
27 #ifndef BOOT
28
29 /*
30 * function declarations
31 */
32 static void clear_all_rep(struct s_smc *smc);
33 static void clear_reported(struct s_smc *smc);
34 static void smt_send_srf(struct s_smc *smc);
35 static struct s_srf_evc *smt_get_evc(struct s_smc *smc, int code, int index);
36
37 #define MAX_EVCS ARRAY_SIZE(smc->evcs)
38
39 struct evc_init {
40 u_char code ;
41 u_char index ;
42 u_char n ;
43 u_short para ;
44 } ;
45
46 static const struct evc_init evc_inits[] = {
47 { SMT_COND_SMT_PEER_WRAP, 0,1,SMT_P1048 } ,
48
49 { SMT_COND_MAC_DUP_ADDR, INDEX_MAC, NUMMACS,SMT_P208C } ,
50 { SMT_COND_MAC_FRAME_ERROR, INDEX_MAC, NUMMACS,SMT_P208D } ,
51 { SMT_COND_MAC_NOT_COPIED, INDEX_MAC, NUMMACS,SMT_P208E } ,
52 { SMT_EVENT_MAC_NEIGHBOR_CHANGE, INDEX_MAC, NUMMACS,SMT_P208F } ,
53 { SMT_EVENT_MAC_PATH_CHANGE, INDEX_MAC, NUMMACS,SMT_P2090 } ,
54
55 { SMT_COND_PORT_LER, INDEX_PORT,NUMPHYS,SMT_P4050 } ,
56 { SMT_COND_PORT_EB_ERROR, INDEX_PORT,NUMPHYS,SMT_P4052 } ,
57 { SMT_EVENT_PORT_CONNECTION, INDEX_PORT,NUMPHYS,SMT_P4051 } ,
58 { SMT_EVENT_PORT_PATH_CHANGE, INDEX_PORT,NUMPHYS,SMT_P4053 } ,
59 } ;
60
61 #define MAX_INIT_EVC ARRAY_SIZE(evc_inits)
62
63 void smt_init_evc(struct s_smc *smc)
64 {
65 struct s_srf_evc *evc ;
66 const struct evc_init *init ;
67 unsigned int i ;
68 int index ;
69 int offset ;
70
71 static u_char fail_safe = FALSE ;
72
73 memset((char *)smc->evcs,0,sizeof(smc->evcs)) ;
74
75 evc = smc->evcs ;
76 init = evc_inits ;
77
78 for (i = 0 ; i < MAX_INIT_EVC ; i++) {
79 for (index = 0 ; index < init->n ; index++) {
80 evc->evc_code = init->code ;
81 evc->evc_para = init->para ;
82 evc->evc_index = init->index + index ;
83 #ifndef DEBUG
84 evc->evc_multiple = &fail_safe ;
85 evc->evc_cond_state = &fail_safe ;
86 #endif
87 evc++ ;
88 }
89 init++ ;
90 }
91
92 if ((unsigned int) (evc - smc->evcs) > MAX_EVCS) {
93 SMT_PANIC(smc,SMT_E0127, SMT_E0127_MSG) ;
94 }
95
96 /*
97 * conditions
98 */
99 smc->evcs[0].evc_cond_state = &smc->mib.fddiSMTPeerWrapFlag ;
100 smc->evcs[1].evc_cond_state =
101 &smc->mib.m[MAC0].fddiMACDuplicateAddressCond ;
102 smc->evcs[2].evc_cond_state =
103 &smc->mib.m[MAC0].fddiMACFrameErrorFlag ;
104 smc->evcs[3].evc_cond_state =
105 &smc->mib.m[MAC0].fddiMACNotCopiedFlag ;
106
107 /*
108 * events
109 */
110 smc->evcs[4].evc_multiple = &smc->mib.m[MAC0].fddiMACMultiple_N ;
111 smc->evcs[5].evc_multiple = &smc->mib.m[MAC0].fddiMACMultiple_P ;
112
113 offset = 6 ;
114 for (i = 0 ; i < NUMPHYS ; i++) {
115 /*
116 * conditions
117 */
118 smc->evcs[offset + 0*NUMPHYS].evc_cond_state =
119 &smc->mib.p[i].fddiPORTLerFlag ;
120 smc->evcs[offset + 1*NUMPHYS].evc_cond_state =
121 &smc->mib.p[i].fddiPORTEB_Condition ;
122
123 /*
124 * events
125 */
126 smc->evcs[offset + 2*NUMPHYS].evc_multiple =
127 &smc->mib.p[i].fddiPORTMultiple_U ;
128 smc->evcs[offset + 3*NUMPHYS].evc_multiple =
129 &smc->mib.p[i].fddiPORTMultiple_P ;
130 offset++ ;
131 }
132 #ifdef DEBUG
133 for (i = 0, evc = smc->evcs ; i < MAX_EVCS ; i++, evc++) {
134 if (SMT_IS_CONDITION(evc->evc_code)) {
135 if (!evc->evc_cond_state) {
136 SMT_PANIC(smc,SMT_E0128, SMT_E0128_MSG) ;
137 }
138 evc->evc_multiple = &fail_safe ;
139 }
140 else {
141 if (!evc->evc_multiple) {
142 SMT_PANIC(smc,SMT_E0129, SMT_E0129_MSG) ;
143 }
144 evc->evc_cond_state = &fail_safe ;
145 }
146 }
147 #endif
148 smc->srf.TSR = smt_get_time() ;
149 smc->srf.sr_state = SR0_WAIT ;
150 }
151
152 static struct s_srf_evc *smt_get_evc(struct s_smc *smc, int code, int index)
153 {
154 unsigned int i ;
155 struct s_srf_evc *evc ;
156
157 for (i = 0, evc = smc->evcs ; i < MAX_EVCS ; i++, evc++) {
158 if (evc->evc_code == code && evc->evc_index == index)
159 return evc;
160 }
161 return NULL;
162 }
163
164 #define THRESHOLD_2 (2*TICKS_PER_SECOND)
165 #define THRESHOLD_32 (32*TICKS_PER_SECOND)
166
167 static const char * const srf_names[] = {
168 "None","MACPathChangeEvent", "MACNeighborChangeEvent",
169 "PORTPathChangeEvent", "PORTUndesiredConnectionAttemptEvent",
170 "SMTPeerWrapCondition", "SMTHoldCondition",
171 "MACFrameErrorCondition", "MACDuplicateAddressCondition",
172 "MACNotCopiedCondition", "PORTEBErrorCondition",
173 "PORTLerCondition"
174 } ;
175
176 void smt_srf_event(struct s_smc *smc, int code, int index, int cond)
177 {
178 struct s_srf_evc *evc ;
179 int cond_asserted = 0 ;
180 int cond_deasserted = 0 ;
181 int event_occurred = 0 ;
182 int tsr ;
183 int T_Limit = 2*TICKS_PER_SECOND ;
184
185 if (code == SMT_COND_MAC_DUP_ADDR && cond) {
186 RS_SET(smc,RS_DUPADDR) ;
187 }
188
189 if (code) {
190 DB_SMT("SRF: %s index %d", srf_names[code], index);
191
192 if (!(evc = smt_get_evc(smc,code,index))) {
193 DB_SMT("SRF : smt_get_evc() failed");
194 return ;
195 }
196 /*
197 * ignore condition if no change
198 */
199 if (SMT_IS_CONDITION(code)) {
200 if (*evc->evc_cond_state == cond)
201 return ;
202 }
203
204 /*
205 * set transition time stamp
206 */
207 smt_set_timestamp(smc,smc->mib.fddiSMTTransitionTimeStamp) ;
208 if (SMT_IS_CONDITION(code)) {
209 DB_SMT("SRF: condition is %s", cond ? "ON" : "OFF");
210 if (cond) {
211 *evc->evc_cond_state = TRUE ;
212 evc->evc_rep_required = TRUE ;
213 smc->srf.any_report = TRUE ;
214 cond_asserted = TRUE ;
215 }
216 else {
217 *evc->evc_cond_state = FALSE ;
218 cond_deasserted = TRUE ;
219 }
220 }
221 else {
222 if (evc->evc_rep_required) {
223 *evc->evc_multiple = TRUE ;
224 }
225 else {
226 evc->evc_rep_required = TRUE ;
227 *evc->evc_multiple = FALSE ;
228 }
229 smc->srf.any_report = TRUE ;
230 event_occurred = TRUE ;
231 }
232 #ifdef FDDI_MIB
233 snmp_srf_event(smc,evc) ;
234 #endif /* FDDI_MIB */
235 }
236 tsr = smt_get_time() - smc->srf.TSR ;
237
238 switch (smc->srf.sr_state) {
239 case SR0_WAIT :
240 /* SR01a */
241 if (cond_asserted && tsr < T_Limit) {
242 smc->srf.SRThreshold = THRESHOLD_2 ;
243 smc->srf.sr_state = SR1_HOLDOFF ;
244 break ;
245 }
246 /* SR01b */
247 if (cond_deasserted && tsr < T_Limit) {
248 smc->srf.sr_state = SR1_HOLDOFF ;
249 break ;
250 }
251 /* SR01c */
252 if (event_occurred && tsr < T_Limit) {
253 smc->srf.sr_state = SR1_HOLDOFF ;
254 break ;
255 }
256 /* SR00b */
257 if (cond_asserted && tsr >= T_Limit) {
258 smc->srf.SRThreshold = THRESHOLD_2 ;
259 smc->srf.TSR = smt_get_time() ;
260 smt_send_srf(smc) ;
261 break ;
262 }
263 /* SR00c */
264 if (cond_deasserted && tsr >= T_Limit) {
265 smc->srf.TSR = smt_get_time() ;
266 smt_send_srf(smc) ;
267 break ;
268 }
269 /* SR00d */
270 if (event_occurred && tsr >= T_Limit) {
271 smc->srf.TSR = smt_get_time() ;
272 smt_send_srf(smc) ;
273 break ;
274 }
275 /* SR00e */
276 if (smc->srf.any_report && (u_long) tsr >=
277 smc->srf.SRThreshold) {
278 smc->srf.SRThreshold *= 2 ;
279 if (smc->srf.SRThreshold > THRESHOLD_32)
280 smc->srf.SRThreshold = THRESHOLD_32 ;
281 smc->srf.TSR = smt_get_time() ;
282 smt_send_srf(smc) ;
283 break ;
284 }
285 /* SR02 */
286 if (!smc->mib.fddiSMTStatRptPolicy) {
287 smc->srf.sr_state = SR2_DISABLED ;
288 break ;
289 }
290 break ;
291 case SR1_HOLDOFF :
292 /* SR10b */
293 if (tsr >= T_Limit) {
294 smc->srf.sr_state = SR0_WAIT ;
295 smc->srf.TSR = smt_get_time() ;
296 smt_send_srf(smc) ;
297 break ;
298 }
299 /* SR11a */
300 if (cond_asserted) {
301 smc->srf.SRThreshold = THRESHOLD_2 ;
302 }
303 /* SR11b */
304 /* SR11c */
305 /* handled above */
306 /* SR12 */
307 if (!smc->mib.fddiSMTStatRptPolicy) {
308 smc->srf.sr_state = SR2_DISABLED ;
309 break ;
310 }
311 break ;
312 case SR2_DISABLED :
313 if (smc->mib.fddiSMTStatRptPolicy) {
314 smc->srf.sr_state = SR0_WAIT ;
315 smc->srf.TSR = smt_get_time() ;
316 smc->srf.SRThreshold = THRESHOLD_2 ;
317 clear_all_rep(smc) ;
318 break ;
319 }
320 break ;
321 }
322 }
323
324 static void clear_all_rep(struct s_smc *smc)
325 {
326 struct s_srf_evc *evc ;
327 unsigned int i ;
328
329 for (i = 0, evc = smc->evcs ; i < MAX_EVCS ; i++, evc++) {
330 evc->evc_rep_required = FALSE ;
331 if (SMT_IS_CONDITION(evc->evc_code))
332 *evc->evc_cond_state = FALSE ;
333 }
334 smc->srf.any_report = FALSE ;
335 }
336
337 static void clear_reported(struct s_smc *smc)
338 {
339 struct s_srf_evc *evc ;
340 unsigned int i ;
341
342 smc->srf.any_report = FALSE ;
343 for (i = 0, evc = smc->evcs ; i < MAX_EVCS ; i++, evc++) {
344 if (SMT_IS_CONDITION(evc->evc_code)) {
345 if (*evc->evc_cond_state == FALSE)
346 evc->evc_rep_required = FALSE ;
347 else
348 smc->srf.any_report = TRUE ;
349 }
350 else {
351 evc->evc_rep_required = FALSE ;
352 *evc->evc_multiple = FALSE ;
353 }
354 }
355 }
356
357 /*
358 * build and send SMT SRF frame
359 */
360 static void smt_send_srf(struct s_smc *smc)
361 {
362
363 struct smt_header *smt ;
364 struct s_srf_evc *evc ;
365 SK_LOC_DECL(struct s_pcon,pcon) ;
366 SMbuf *mb ;
367 unsigned int i ;
368
369 static const struct fddi_addr SMT_SRF_DA = {
370 { 0x80, 0x01, 0x43, 0x00, 0x80, 0x08 }
371 } ;
372
373 /*
374 * build SMT header
375 */
376 if (!smc->r.sm_ma_avail)
377 return ;
378 if (!(mb = smt_build_frame(smc,SMT_SRF,SMT_ANNOUNCE,0)))
379 return ;
380
381 RS_SET(smc,RS_SOFTERROR) ;
382
383 smt = smtod(mb, struct smt_header *) ;
384 smt->smt_dest = SMT_SRF_DA ; /* DA == SRF multicast */
385
386 /*
387 * setup parameter status
388 */
389 pcon.pc_len = SMT_MAX_INFO_LEN ; /* max para length */
390 pcon.pc_err = 0 ; /* no error */
391 pcon.pc_badset = 0 ; /* no bad set count */
392 pcon.pc_p = (void *) (smt + 1) ; /* paras start here */
393
394 smt_add_para(smc,&pcon,(u_short) SMT_P1033,0,0) ;
395 smt_add_para(smc,&pcon,(u_short) SMT_P1034,0,0) ;
396
397 for (i = 0, evc = smc->evcs ; i < MAX_EVCS ; i++, evc++) {
398 if (evc->evc_rep_required) {
399 smt_add_para(smc,&pcon,evc->evc_para,
400 (int)evc->evc_index,0) ;
401 }
402 }
403 smt->smt_len = SMT_MAX_INFO_LEN - pcon.pc_len ;
404 mb->sm_len = smt->smt_len + sizeof(struct smt_header) ;
405
406 DB_SMT("SRF: sending SRF at %p, len %d", smt, mb->sm_len);
407 DB_SMT("SRF: state SR%d Threshold %lu",
408 smc->srf.sr_state, smc->srf.SRThreshold / TICKS_PER_SECOND);
409 #ifdef DEBUG
410 dump_smt(smc,smt,"SRF Send") ;
411 #endif
412 smt_send_frame(smc,mb,FC_SMT_INFO,0) ;
413 clear_reported(smc) ;
414 }
415
416 #endif /* no BOOT */
417 #endif /* no SLIM_SMT */
418
Linux with added FPC-III support