?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux-2.6.12-rc2
[linux-2.6/kvm.git] / drivers / net / sk98lin / skrlmt.c
blob9ea11ab2296a440cc0b300430e52c5b1fa69f550
1 /******************************************************************************
2 *
3 * Name: skrlmt.c
4 * Project: GEnesis, PCI Gigabit Ethernet Adapter
5 * Version: $Revision: 1.69 $
6 * Date: $Date: 2003/04/15 09:39:22 $
7 * Purpose: Manage links on SK-NET Adapters, esp. redundant ones.
8 *
9 ******************************************************************************/
10
11 /******************************************************************************
12 *
13 * (C)Copyright 1998-2002 SysKonnect GmbH.
14 * (C)Copyright 2002-2003 Marvell.
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * The information in this file is provided "AS IS" without warranty.
22 *
23 ******************************************************************************/
24
25 /******************************************************************************
26 *
27 * Description:
28 *
29 * This module contains code for Link ManagemenT (LMT) of SK-NET Adapters.
30 * It is mainly intended for adapters with more than one link.
31 * For such adapters, this module realizes Redundant Link ManagemenT (RLMT).
32 *
33 * Include File Hierarchy:
34 *
35 * "skdrv1st.h"
36 * "skdrv2nd.h"
37 *
38 ******************************************************************************/
39
40 #ifndef lint
41 static const char SysKonnectFileId[] =
42 "@(#) $Id: skrlmt.c,v 1.69 2003/04/15 09:39:22 tschilli Exp $ (C) Marvell.";
43 #endif /* !defined(lint) */
44
45 #define __SKRLMT_C
46
47 #ifdef __cplusplus
48 extern "C" {
49 #endif /* cplusplus */
50
51 #include "h/skdrv1st.h"
52 #include "h/skdrv2nd.h"
53
54 /* defines ********************************************************************/
55
56 #ifndef SK_HWAC_LINK_LED
57 #define SK_HWAC_LINK_LED(a,b,c,d)
58 #endif /* !defined(SK_HWAC_LINK_LED) */
59
60 #ifndef DEBUG
61 #define RLMT_STATIC static
62 #else /* DEBUG */
63 #define RLMT_STATIC
64
65 #ifndef SK_LITTLE_ENDIAN
66 /* First 32 bits */
67 #define OFFS_LO32 1
68
69 /* Second 32 bits */
70 #define OFFS_HI32 0
71 #else /* SK_LITTLE_ENDIAN */
72 /* First 32 bits */
73 #define OFFS_LO32 0
74
75 /* Second 32 bits */
76 #define OFFS_HI32 1
77 #endif /* SK_LITTLE_ENDIAN */
78
79 #endif /* DEBUG */
80
81 /* ----- Private timeout values ----- */
82
83 #define SK_RLMT_MIN_TO_VAL 125000 /* 1/8 sec. */
84 #define SK_RLMT_DEF_TO_VAL 1000000 /* 1 sec. */
85 #define SK_RLMT_PORTDOWN_TIM_VAL 900000 /* another 0.9 sec. */
86 #define SK_RLMT_PORTSTART_TIM_VAL 100000 /* 0.1 sec. */
87 #define SK_RLMT_PORTUP_TIM_VAL 2500000 /* 2.5 sec. */
88 #define SK_RLMT_SEG_TO_VAL 900000000 /* 15 min. */
89
90 /* Assume tick counter increment is 1 - may be set OS-dependent. */
91 #ifndef SK_TICK_INCR
92 #define SK_TICK_INCR SK_CONSTU64(1)
93 #endif /* !defined(SK_TICK_INCR) */
94
95 /*
96 * Amount that a time stamp must be later to be recognized as "substantially
97 * later". This is about 1/128 sec, but above 1 tick counter increment.
98 */
99 #define SK_RLMT_BC_DELTA (1 + ((SK_TICKS_PER_SEC >> 7) > SK_TICK_INCR ? \
100 (SK_TICKS_PER_SEC >> 7) : SK_TICK_INCR))
101
102 /* ----- Private RLMT defaults ----- */
103
104 #define SK_RLMT_DEF_PREF_PORT 0 /* "Lower" port. */
105 #define SK_RLMT_DEF_MODE SK_RLMT_CHECK_LINK /* Default RLMT Mode. */
106
107 /* ----- Private RLMT checking states ----- */
108
109 #define SK_RLMT_RCS_SEG 1 /* RLMT Check State: check seg. */
110 #define SK_RLMT_RCS_START_SEG 2 /* RLMT Check State: start check seg. */
111 #define SK_RLMT_RCS_SEND_SEG 4 /* RLMT Check State: send BPDU packet */
112 #define SK_RLMT_RCS_REPORT_SEG 8 /* RLMT Check State: report seg. */
113
114 /* ----- Private PORT checking states ----- */
115
116 #define SK_RLMT_PCS_TX 1 /* Port Check State: check tx. */
117 #define SK_RLMT_PCS_RX 2 /* Port Check State: check rx. */
118
119 /* ----- Private PORT events ----- */
120
121 /* Note: Update simulation when changing these. */
122 #define SK_RLMT_PORTSTART_TIM 1100 /* Port start timeout. */
123 #define SK_RLMT_PORTUP_TIM 1101 /* Port can now go up. */
124 #define SK_RLMT_PORTDOWN_RX_TIM 1102 /* Port did not receive once ... */
125 #define SK_RLMT_PORTDOWN 1103 /* Port went down. */
126 #define SK_RLMT_PORTDOWN_TX_TIM 1104 /* Partner did not receive ... */
127
128 /* ----- Private RLMT events ----- */
129
130 /* Note: Update simulation when changing these. */
131 #define SK_RLMT_TIM 2100 /* RLMT timeout. */
132 #define SK_RLMT_SEG_TIM 2101 /* RLMT segmentation check timeout. */
133
134 #define TO_SHORTEN(tim) ((tim) / 2)
135
136 /* Error numbers and messages. */
137 #define SKERR_RLMT_E001 (SK_ERRBASE_RLMT + 0)
138 #define SKERR_RLMT_E001_MSG "No Packet."
139 #define SKERR_RLMT_E002 (SKERR_RLMT_E001 + 1)
140 #define SKERR_RLMT_E002_MSG "Short Packet."
141 #define SKERR_RLMT_E003 (SKERR_RLMT_E002 + 1)
142 #define SKERR_RLMT_E003_MSG "Unknown RLMT event."
143 #define SKERR_RLMT_E004 (SKERR_RLMT_E003 + 1)
144 #define SKERR_RLMT_E004_MSG "PortsUp incorrect."
145 #define SKERR_RLMT_E005 (SKERR_RLMT_E004 + 1)
146 #define SKERR_RLMT_E005_MSG \
147 "Net seems to be segmented (different root bridges are reported on the ports)."
148 #define SKERR_RLMT_E006 (SKERR_RLMT_E005 + 1)
149 #define SKERR_RLMT_E006_MSG "Duplicate MAC Address detected."
150 #define SKERR_RLMT_E007 (SKERR_RLMT_E006 + 1)
151 #define SKERR_RLMT_E007_MSG "LinksUp incorrect."
152 #define SKERR_RLMT_E008 (SKERR_RLMT_E007 + 1)
153 #define SKERR_RLMT_E008_MSG "Port not started but link came up."
154 #define SKERR_RLMT_E009 (SKERR_RLMT_E008 + 1)
155 #define SKERR_RLMT_E009_MSG "Corrected illegal setting of Preferred Port."
156 #define SKERR_RLMT_E010 (SKERR_RLMT_E009 + 1)
157 #define SKERR_RLMT_E010_MSG "Ignored illegal Preferred Port."
158
159 /* LLC field values. */
160 #define LLC_COMMAND_RESPONSE_BIT 1
161 #define LLC_TEST_COMMAND 0xE3
162 #define LLC_UI 0x03
163
164 /* RLMT Packet fields. */
165 #define SK_RLMT_DSAP 0
166 #define SK_RLMT_SSAP 0
167 #define SK_RLMT_CTRL (LLC_TEST_COMMAND)
168 #define SK_RLMT_INDICATOR0 0x53 /* S */
169 #define SK_RLMT_INDICATOR1 0x4B /* K */
170 #define SK_RLMT_INDICATOR2 0x2D /* - */
171 #define SK_RLMT_INDICATOR3 0x52 /* R */
172 #define SK_RLMT_INDICATOR4 0x4C /* L */
173 #define SK_RLMT_INDICATOR5 0x4D /* M */
174 #define SK_RLMT_INDICATOR6 0x54 /* T */
175 #define SK_RLMT_PACKET_VERSION 0
176
177 /* RLMT SPT Flag values. */
178 #define SK_RLMT_SPT_FLAG_CHANGE 0x01
179 #define SK_RLMT_SPT_FLAG_CHANGE_ACK 0x80
180
181 /* RLMT SPT Packet fields. */
182 #define SK_RLMT_SPT_DSAP 0x42
183 #define SK_RLMT_SPT_SSAP 0x42
184 #define SK_RLMT_SPT_CTRL (LLC_UI)
185 #define SK_RLMT_SPT_PROTOCOL_ID0 0x00
186 #define SK_RLMT_SPT_PROTOCOL_ID1 0x00
187 #define SK_RLMT_SPT_PROTOCOL_VERSION_ID 0x00
188 #define SK_RLMT_SPT_BPDU_TYPE 0x00
189 #define SK_RLMT_SPT_FLAGS 0x00 /* ?? */
190 #define SK_RLMT_SPT_ROOT_ID0 0xFF /* Lowest possible priority. */
191 #define SK_RLMT_SPT_ROOT_ID1 0xFF /* Lowest possible priority. */
192
193 /* Remaining 6 bytes will be the current port address. */
194 #define SK_RLMT_SPT_ROOT_PATH_COST0 0x00
195 #define SK_RLMT_SPT_ROOT_PATH_COST1 0x00
196 #define SK_RLMT_SPT_ROOT_PATH_COST2 0x00
197 #define SK_RLMT_SPT_ROOT_PATH_COST3 0x00
198 #define SK_RLMT_SPT_BRIDGE_ID0 0xFF /* Lowest possible priority. */
199 #define SK_RLMT_SPT_BRIDGE_ID1 0xFF /* Lowest possible priority. */
200
201 /* Remaining 6 bytes will be the current port address. */
202 #define SK_RLMT_SPT_PORT_ID0 0xFF /* Lowest possible priority. */
203 #define SK_RLMT_SPT_PORT_ID1 0xFF /* Lowest possible priority. */
204 #define SK_RLMT_SPT_MSG_AGE0 0x00
205 #define SK_RLMT_SPT_MSG_AGE1 0x00
206 #define SK_RLMT_SPT_MAX_AGE0 0x00
207 #define SK_RLMT_SPT_MAX_AGE1 0xFF
208 #define SK_RLMT_SPT_HELLO_TIME0 0x00
209 #define SK_RLMT_SPT_HELLO_TIME1 0xFF
210 #define SK_RLMT_SPT_FWD_DELAY0 0x00
211 #define SK_RLMT_SPT_FWD_DELAY1 0x40
212
213 /* Size defines. */
214 #define SK_RLMT_MIN_PACKET_SIZE 34
215 #define SK_RLMT_MAX_PACKET_SIZE (SK_RLMT_MAX_TX_BUF_SIZE)
216 #define SK_PACKET_DATA_LEN (SK_RLMT_MAX_PACKET_SIZE - \
217 SK_RLMT_MIN_PACKET_SIZE)
218
219 /* ----- RLMT packet types ----- */
220 #define SK_PACKET_ANNOUNCE 1 /* Port announcement. */
221 #define SK_PACKET_ALIVE 2 /* Alive packet to port. */
222 #define SK_PACKET_ADDR_CHANGED 3 /* Port address changed. */
223 #define SK_PACKET_CHECK_TX 4 /* Check your tx line. */
224
225 #ifdef SK_LITTLE_ENDIAN
226 #define SK_U16_TO_NETWORK_ORDER(Val,Addr) { \
227 SK_U8 *_Addr = (SK_U8*)(Addr); \
228 SK_U16 _Val = (SK_U16)(Val); \
229 *_Addr++ = (SK_U8)(_Val >> 8); \
230 *_Addr = (SK_U8)(_Val & 0xFF); \
231 }
232 #endif /* SK_LITTLE_ENDIAN */
233
234 #ifdef SK_BIG_ENDIAN
235 #define SK_U16_TO_NETWORK_ORDER(Val,Addr) (*(SK_U16*)(Addr) = (SK_U16)(Val))
236 #endif /* SK_BIG_ENDIAN */
237
238 #define AUTONEG_FAILED SK_FALSE
239 #define AUTONEG_SUCCESS SK_TRUE
240
241
242 /* typedefs *******************************************************************/
243
244 /* RLMT packet. Length: SK_RLMT_MAX_PACKET_SIZE (60) bytes. */
245 typedef struct s_RlmtPacket {
246 SK_U8 DstAddr[SK_MAC_ADDR_LEN];
247 SK_U8 SrcAddr[SK_MAC_ADDR_LEN];
248 SK_U8 TypeLen[2];
249 SK_U8 DSap;
250 SK_U8 SSap;
251 SK_U8 Ctrl;
252 SK_U8 Indicator[7];
253 SK_U8 RlmtPacketType[2];
254 SK_U8 Align1[2];
255 SK_U8 Random[4]; /* Random value of requesting(!) station. */
256 SK_U8 RlmtPacketVersion[2]; /* RLMT Packet version. */
257 SK_U8 Data[SK_PACKET_DATA_LEN];
258 } SK_RLMT_PACKET;
259
260 typedef struct s_SpTreeRlmtPacket {
261 SK_U8 DstAddr[SK_MAC_ADDR_LEN];
262 SK_U8 SrcAddr[SK_MAC_ADDR_LEN];
263 SK_U8 TypeLen[2];
264 SK_U8 DSap;
265 SK_U8 SSap;
266 SK_U8 Ctrl;
267 SK_U8 ProtocolId[2];
268 SK_U8 ProtocolVersionId;
269 SK_U8 BpduType;
270 SK_U8 Flags;
271 SK_U8 RootId[8];
272 SK_U8 RootPathCost[4];
273 SK_U8 BridgeId[8];
274 SK_U8 PortId[2];
275 SK_U8 MessageAge[2];
276 SK_U8 MaxAge[2];
277 SK_U8 HelloTime[2];
278 SK_U8 ForwardDelay[2];
279 } SK_SPTREE_PACKET;
280
281 /* global variables ***********************************************************/
282
283 SK_MAC_ADDR SkRlmtMcAddr = {{0x01, 0x00, 0x5A, 0x52, 0x4C, 0x4D}};
284 SK_MAC_ADDR BridgeMcAddr = {{0x01, 0x80, 0xC2, 0x00, 0x00, 0x00}};
285 SK_MAC_ADDR BcAddr = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
286
287 /* local variables ************************************************************/
288
289 /* None. */
290
291 /* functions ******************************************************************/
292
293 RLMT_STATIC void SkRlmtCheckSwitch(
294 SK_AC *pAC,
295 SK_IOC IoC,
296 SK_U32 NetIdx);
297 RLMT_STATIC void SkRlmtCheckSeg(
298 SK_AC *pAC,
299 SK_IOC IoC,
300 SK_U32 NetIdx);
301 RLMT_STATIC void SkRlmtEvtSetNets(
302 SK_AC *pAC,
303 SK_IOC IoC,
304 SK_EVPARA Para);
305
306 /******************************************************************************
307 *
308 * SkRlmtInit - initialize data, set state to init
309 *
310 * Description:
311 *
312 * SK_INIT_DATA
313 * ============
314 *
315 * This routine initializes all RLMT-related variables to a known state.
316 * The initial state is SK_RLMT_RS_INIT.
317 * All ports are initialized to SK_RLMT_PS_INIT.
318 *
319 *
320 * SK_INIT_IO
321 * ==========
322 *
323 * Nothing.
324 *
325 *
326 * SK_INIT_RUN
327 * ===========
328 *
329 * Determine the adapter's random value.
330 * Set the hw registers, the "logical MAC address", the
331 * RLMT multicast address, and eventually the BPDU multicast address.
332 *
333 * Context:
334 * init, pageable
335 *
336 * Returns:
337 * Nothing.
338 */
339 void SkRlmtInit(
340 SK_AC *pAC, /* Adapter Context */
341 SK_IOC IoC, /* I/O Context */
342 int Level) /* Initialization Level */
343 {
344 SK_U32 i, j;
345 SK_U64 Random;
346 SK_EVPARA Para;
347 SK_MAC_ADDR VirtualMacAddress;
348 SK_MAC_ADDR PhysicalAMacAddress;
349 SK_BOOL VirtualMacAddressSet;
350 SK_BOOL PhysicalAMacAddressSet;
351
352 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_INIT,
353 ("RLMT Init level %d.\n", Level))
354
355 switch (Level) {
356 case SK_INIT_DATA: /* Initialize data structures. */
357 SK_MEMSET((char *)&pAC->Rlmt, 0, sizeof(SK_RLMT));
358
359 for (i = 0; i < SK_MAX_MACS; i++) {
360 pAC->Rlmt.Port[i].PortState = SK_RLMT_PS_INIT;
361 pAC->Rlmt.Port[i].LinkDown = SK_TRUE;
362 pAC->Rlmt.Port[i].PortDown = SK_TRUE;
363 pAC->Rlmt.Port[i].PortStarted = SK_FALSE;
364 pAC->Rlmt.Port[i].PortNoRx = SK_FALSE;
365 pAC->Rlmt.Port[i].RootIdSet = SK_FALSE;
366 pAC->Rlmt.Port[i].PortNumber = i;
367 pAC->Rlmt.Port[i].Net = &pAC->Rlmt.Net[0];
368 pAC->Rlmt.Port[i].AddrPort = &pAC->Addr.Port[i];
369 }
370
371 pAC->Rlmt.NumNets = 1;
372 for (i = 0; i < SK_MAX_NETS; i++) {
373 pAC->Rlmt.Net[i].RlmtState = SK_RLMT_RS_INIT;
374 pAC->Rlmt.Net[i].RootIdSet = SK_FALSE;
375 pAC->Rlmt.Net[i].PrefPort = SK_RLMT_DEF_PREF_PORT;
376 pAC->Rlmt.Net[i].Preference = 0xFFFFFFFF; /* Automatic. */
377 /* Just assuming. */
378 pAC->Rlmt.Net[i].ActivePort = pAC->Rlmt.Net[i].PrefPort;
379 pAC->Rlmt.Net[i].RlmtMode = SK_RLMT_DEF_MODE;
380 pAC->Rlmt.Net[i].TimeoutValue = SK_RLMT_DEF_TO_VAL;
381 pAC->Rlmt.Net[i].NetNumber = i;
382 }
383
384 pAC->Rlmt.Net[0].Port[0] = &pAC->Rlmt.Port[0];
385 pAC->Rlmt.Net[0].Port[1] = &pAC->Rlmt.Port[1];
386 #if SK_MAX_NETS > 1
387 pAC->Rlmt.Net[1].Port[0] = &pAC->Rlmt.Port[1];
388 #endif /* SK_MAX_NETS > 1 */
389 break;
390
391 case SK_INIT_IO: /* GIMacsFound first available here. */
392 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_INIT,
393 ("RLMT: %d MACs were detected.\n", pAC->GIni.GIMacsFound))
394
395 pAC->Rlmt.Net[0].NumPorts = pAC->GIni.GIMacsFound;
396
397 /* Initialize HW registers? */
398 if (pAC->GIni.GIMacsFound == 1) {
399 Para.Para32[0] = SK_RLMT_MODE_CLS;
400 Para.Para32[1] = 0;
401 (void)SkRlmtEvent(pAC, IoC, SK_RLMT_MODE_CHANGE, Para);
402 }
403 break;
404
405 case SK_INIT_RUN:
406 /* Ensure RLMT is set to one net. */
407 if (pAC->Rlmt.NumNets > 1) {
408 Para.Para32[0] = 1;
409 Para.Para32[1] = -1;
410 SkRlmtEvtSetNets(pAC, IoC, Para);
411 }
412
413 for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
414 Random = SkOsGetTime(pAC);
415 *(SK_U32*)&pAC->Rlmt.Port[i].Random = *(SK_U32*)&Random;
416
417 for (j = 0; j < 4; j++) {
418 pAC->Rlmt.Port[i].Random[j] ^= pAC->Rlmt.Port[i].AddrPort->
419 CurrentMacAddress.a[SK_MAC_ADDR_LEN - 1 - j];
420 }
421
422 (void)SkAddrMcClear(pAC, IoC, i, SK_ADDR_PERMANENT | SK_MC_SW_ONLY);
423
424 /* Add RLMT MC address. */
425 (void)SkAddrMcAdd(pAC, IoC, i, &SkRlmtMcAddr, SK_ADDR_PERMANENT);
426
427 if (pAC->Rlmt.Net[0].RlmtMode & SK_RLMT_CHECK_SEG) {
428 /* Add BPDU MC address. */
429 (void)SkAddrMcAdd(pAC, IoC, i, &BridgeMcAddr, SK_ADDR_PERMANENT);
430 }
431
432 (void)SkAddrMcUpdate(pAC, IoC, i);
433 }
434
435 VirtualMacAddressSet = SK_FALSE;
436 /* Read virtual MAC address from Control Register File. */
437 for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
438
439 SK_IN8(IoC, B2_MAC_1 + j, &VirtualMacAddress.a[j]);
440 VirtualMacAddressSet |= VirtualMacAddress.a[j];
441 }
442
443 PhysicalAMacAddressSet = SK_FALSE;
444 /* Read physical MAC address for MAC A from Control Register File. */
445 for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
446
447 SK_IN8(IoC, B2_MAC_2 + j, &PhysicalAMacAddress.a[j]);
448 PhysicalAMacAddressSet |= PhysicalAMacAddress.a[j];
449 }
450
451 /* check if the two mac addresses contain reasonable values */
452 if (!VirtualMacAddressSet || !PhysicalAMacAddressSet) {
453
454 pAC->Rlmt.RlmtOff = SK_TRUE;
455 }
456
457 /* if the two mac addresses are equal switch off the RLMT_PRE_LOOKAHEAD
458 and the RLMT_LOOKAHEAD macros */
459 else if (SK_ADDR_EQUAL(PhysicalAMacAddress.a, VirtualMacAddress.a)) {
460
461 pAC->Rlmt.RlmtOff = SK_TRUE;
462 }
463 else {
464 pAC->Rlmt.RlmtOff = SK_FALSE;
465 }
466 break;
467
468 default: /* error */
469 break;
470 }
471 return;
472 } /* SkRlmtInit */
473
474
475 /******************************************************************************
476 *
477 * SkRlmtBuildCheckChain - build the check chain
478 *
479 * Description:
480 * This routine builds the local check chain:
481 * - Each port that is up checks the next port.
482 * - The last port that is up checks the first port that is up.
483 *
484 * Notes:
485 * - Currently only local ports are considered when building the chain.
486 * - Currently the SuspectState is just reset;
487 * it would be better to save it ...
488 *
489 * Context:
490 * runtime, pageable?
491 *
492 * Returns:
493 * Nothing
494 */
495 RLMT_STATIC void SkRlmtBuildCheckChain(
496 SK_AC *pAC, /* Adapter Context */
497 SK_U32 NetIdx) /* Net Number */
498 {
499 SK_U32 i;
500 SK_U32 NumMacsUp;
501 SK_RLMT_PORT * FirstMacUp;
502 SK_RLMT_PORT * PrevMacUp;
503
504 FirstMacUp = NULL;
505 PrevMacUp = NULL;
506
507 if (!(pAC->Rlmt.Net[NetIdx].RlmtMode & SK_RLMT_CHECK_LOC_LINK)) {
508 for (i = 0; i < pAC->Rlmt.Net[i].NumPorts; i++) {
509 pAC->Rlmt.Net[NetIdx].Port[i]->PortsChecked = 0;
510 }
511 return; /* Done. */
512 }
513
514 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
515 ("SkRlmtBuildCheckChain.\n"))
516
517 NumMacsUp = 0;
518
519 for (i = 0; i < pAC->Rlmt.Net[NetIdx].NumPorts; i++) {
520 pAC->Rlmt.Net[NetIdx].Port[i]->PortsChecked = 0;
521 pAC->Rlmt.Net[NetIdx].Port[i]->PortsSuspect = 0;
522 pAC->Rlmt.Net[NetIdx].Port[i]->CheckingState &=
523 ~(SK_RLMT_PCS_RX | SK_RLMT_PCS_TX);
524
525 /*
526 * If more than two links are detected we should consider
527 * checking at least two other ports:
528 * 1. the next port that is not LinkDown and
529 * 2. the next port that is not PortDown.
530 */
531 if (!pAC->Rlmt.Net[NetIdx].Port[i]->LinkDown) {
532 if (NumMacsUp == 0) {
533 FirstMacUp = pAC->Rlmt.Net[NetIdx].Port[i];
534 }
535 else {
536 PrevMacUp->PortCheck[
537 pAC->Rlmt.Net[NetIdx].Port[i]->PortsChecked].CheckAddr =
538 pAC->Rlmt.Net[NetIdx].Port[i]->AddrPort->CurrentMacAddress;
539 PrevMacUp->PortCheck[
540 PrevMacUp->PortsChecked].SuspectTx = SK_FALSE;
541 PrevMacUp->PortsChecked++;
542 }
543 PrevMacUp = pAC->Rlmt.Net[NetIdx].Port[i];
544 NumMacsUp++;
545 }
546 }
547
548 if (NumMacsUp > 1) {
549 PrevMacUp->PortCheck[PrevMacUp->PortsChecked].CheckAddr =
550 FirstMacUp->AddrPort->CurrentMacAddress;
551 PrevMacUp->PortCheck[PrevMacUp->PortsChecked].SuspectTx =
552 SK_FALSE;
553 PrevMacUp->PortsChecked++;
554 }
555
556 #ifdef DEBUG
557 for (i = 0; i < pAC->Rlmt.Net[NetIdx].NumPorts; i++) {
558 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
559 ("Port %d checks %d other ports: %2X.\n", i,
560 pAC->Rlmt.Net[NetIdx].Port[i]->PortsChecked,
561 pAC->Rlmt.Net[NetIdx].Port[i]->PortCheck[0].CheckAddr.a[5]))
562 }
563 #endif /* DEBUG */
564
565 return;
566 } /* SkRlmtBuildCheckChain */
567
568
569 /******************************************************************************
570 *
571 * SkRlmtBuildPacket - build an RLMT packet
572 *
573 * Description:
574 * This routine sets up an RLMT packet.
575 *
576 * Context:
577 * runtime, pageable?
578 *
579 * Returns:
580 * NULL or pointer to RLMT mbuf
581 */
582 RLMT_STATIC SK_MBUF *SkRlmtBuildPacket(
583 SK_AC *pAC, /* Adapter Context */
584 SK_IOC IoC, /* I/O Context */
585 SK_U32 PortNumber, /* Sending port */
586 SK_U16 PacketType, /* RLMT packet type */
587 SK_MAC_ADDR *SrcAddr, /* Source address */
588 SK_MAC_ADDR *DestAddr) /* Destination address */
589 {
590 int i;
591 SK_U16 Length;
592 SK_MBUF *pMb;
593 SK_RLMT_PACKET *pPacket;
594
595 #ifdef DEBUG
596 SK_U8 CheckSrc = 0;
597 SK_U8 CheckDest = 0;
598
599 for (i = 0; i < SK_MAC_ADDR_LEN; ++i) {
600 CheckSrc |= SrcAddr->a[i];
601 CheckDest |= DestAddr->a[i];
602 }
603
604 if ((CheckSrc == 0) || (CheckDest == 0)) {
605 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_ERR,
606 ("SkRlmtBuildPacket: Invalid %s%saddr.\n",
607 (CheckSrc == 0 ? "Src" : ""), (CheckDest == 0 ? "Dest" : "")))
608 }
609 #endif
610
611 if ((pMb = SkDrvAllocRlmtMbuf(pAC, IoC, SK_RLMT_MAX_PACKET_SIZE)) != NULL) {
612 pPacket = (SK_RLMT_PACKET*)pMb->pData;
613 for (i = 0; i < SK_MAC_ADDR_LEN; i++) {
614 pPacket->DstAddr[i] = DestAddr->a[i];
615 pPacket->SrcAddr[i] = SrcAddr->a[i];
616 }
617 pPacket->DSap = SK_RLMT_DSAP;
618 pPacket->SSap = SK_RLMT_SSAP;
619 pPacket->Ctrl = SK_RLMT_CTRL;
620 pPacket->Indicator[0] = SK_RLMT_INDICATOR0;
621 pPacket->Indicator[1] = SK_RLMT_INDICATOR1;
622 pPacket->Indicator[2] = SK_RLMT_INDICATOR2;
623 pPacket->Indicator[3] = SK_RLMT_INDICATOR3;
624 pPacket->Indicator[4] = SK_RLMT_INDICATOR4;
625 pPacket->Indicator[5] = SK_RLMT_INDICATOR5;
626 pPacket->Indicator[6] = SK_RLMT_INDICATOR6;
627
628 SK_U16_TO_NETWORK_ORDER(PacketType, &pPacket->RlmtPacketType[0]);
629
630 for (i = 0; i < 4; i++) {
631 pPacket->Random[i] = pAC->Rlmt.Port[PortNumber].Random[i];
632 }
633
634 SK_U16_TO_NETWORK_ORDER(
635 SK_RLMT_PACKET_VERSION, &pPacket->RlmtPacketVersion[0]);
636
637 for (i = 0; i < SK_PACKET_DATA_LEN; i++) {
638 pPacket->Data[i] = 0x00;
639 }
640
641 Length = SK_RLMT_MAX_PACKET_SIZE; /* Or smaller. */
642 pMb->Length = Length;
643 pMb->PortIdx = PortNumber;
644 Length -= 14;
645 SK_U16_TO_NETWORK_ORDER(Length, &pPacket->TypeLen[0]);
646
647 if (PacketType == SK_PACKET_ALIVE) {
648 pAC->Rlmt.Port[PortNumber].TxHelloCts++;
649 }
650 }
651
652 return (pMb);
653 } /* SkRlmtBuildPacket */
654
655
656 /******************************************************************************
657 *
658 * SkRlmtBuildSpanningTreePacket - build spanning tree check packet
659 *
660 * Description:
661 * This routine sets up a BPDU packet for spanning tree check.
662 *
663 * Context:
664 * runtime, pageable?
665 *
666 * Returns:
667 * NULL or pointer to RLMT mbuf
668 */
669 RLMT_STATIC SK_MBUF *SkRlmtBuildSpanningTreePacket(
670 SK_AC *pAC, /* Adapter Context */
671 SK_IOC IoC, /* I/O Context */
672 SK_U32 PortNumber) /* Sending port */
673 {
674 unsigned i;
675 SK_U16 Length;
676 SK_MBUF *pMb;
677 SK_SPTREE_PACKET *pSPacket;
678
679 if ((pMb = SkDrvAllocRlmtMbuf(pAC, IoC, SK_RLMT_MAX_PACKET_SIZE)) !=
680 NULL) {
681 pSPacket = (SK_SPTREE_PACKET*)pMb->pData;
682 for (i = 0; i < SK_MAC_ADDR_LEN; i++) {
683 pSPacket->DstAddr[i] = BridgeMcAddr.a[i];
684 pSPacket->SrcAddr[i] =
685 pAC->Addr.Port[PortNumber].CurrentMacAddress.a[i];
686 }
687 pSPacket->DSap = SK_RLMT_SPT_DSAP;
688 pSPacket->SSap = SK_RLMT_SPT_SSAP;
689 pSPacket->Ctrl = SK_RLMT_SPT_CTRL;
690
691 pSPacket->ProtocolId[0] = SK_RLMT_SPT_PROTOCOL_ID0;
692 pSPacket->ProtocolId[1] = SK_RLMT_SPT_PROTOCOL_ID1;
693 pSPacket->ProtocolVersionId = SK_RLMT_SPT_PROTOCOL_VERSION_ID;
694 pSPacket->BpduType = SK_RLMT_SPT_BPDU_TYPE;
695 pSPacket->Flags = SK_RLMT_SPT_FLAGS;
696 pSPacket->RootId[0] = SK_RLMT_SPT_ROOT_ID0;
697 pSPacket->RootId[1] = SK_RLMT_SPT_ROOT_ID1;
698 pSPacket->RootPathCost[0] = SK_RLMT_SPT_ROOT_PATH_COST0;
699 pSPacket->RootPathCost[1] = SK_RLMT_SPT_ROOT_PATH_COST1;
700 pSPacket->RootPathCost[2] = SK_RLMT_SPT_ROOT_PATH_COST2;
701 pSPacket->RootPathCost[3] = SK_RLMT_SPT_ROOT_PATH_COST3;
702 pSPacket->BridgeId[0] = SK_RLMT_SPT_BRIDGE_ID0;
703 pSPacket->BridgeId[1] = SK_RLMT_SPT_BRIDGE_ID1;
704
705 /*
706 * Use logical MAC address as bridge ID and filter these packets
707 * on receive.
708 */
709 for (i = 0; i < SK_MAC_ADDR_LEN; i++) {
710 pSPacket->BridgeId[i + 2] = pSPacket->RootId[i + 2] =
711 pAC->Addr.Net[pAC->Rlmt.Port[PortNumber].Net->NetNumber].
712 CurrentMacAddress.a[i];
713 }
714 pSPacket->PortId[0] = SK_RLMT_SPT_PORT_ID0;
715 pSPacket->PortId[1] = SK_RLMT_SPT_PORT_ID1;
716 pSPacket->MessageAge[0] = SK_RLMT_SPT_MSG_AGE0;
717 pSPacket->MessageAge[1] = SK_RLMT_SPT_MSG_AGE1;
718 pSPacket->MaxAge[0] = SK_RLMT_SPT_MAX_AGE0;
719 pSPacket->MaxAge[1] = SK_RLMT_SPT_MAX_AGE1;
720 pSPacket->HelloTime[0] = SK_RLMT_SPT_HELLO_TIME0;
721 pSPacket->HelloTime[1] = SK_RLMT_SPT_HELLO_TIME1;
722 pSPacket->ForwardDelay[0] = SK_RLMT_SPT_FWD_DELAY0;
723 pSPacket->ForwardDelay[1] = SK_RLMT_SPT_FWD_DELAY1;
724
725 Length = SK_RLMT_MAX_PACKET_SIZE; /* Or smaller. */
726 pMb->Length = Length;
727 pMb->PortIdx = PortNumber;
728 Length -= 14;
729 SK_U16_TO_NETWORK_ORDER(Length, &pSPacket->TypeLen[0]);
730
731 pAC->Rlmt.Port[PortNumber].TxSpHelloReqCts++;
732 }
733
734 return (pMb);
735 } /* SkRlmtBuildSpanningTreePacket */
736
737
738 /******************************************************************************
739 *
740 * SkRlmtSend - build and send check packets
741 *
742 * Description:
743 * Depending on the RLMT state and the checking state, several packets
744 * are sent through the indicated port.
745 *
746 * Context:
747 * runtime, pageable?
748 *
749 * Returns:
750 * Nothing.
751 */
752 RLMT_STATIC void SkRlmtSend(
753 SK_AC *pAC, /* Adapter Context */
754 SK_IOC IoC, /* I/O Context */
755 SK_U32 PortNumber) /* Sending port */
756 {
757 unsigned j;
758 SK_EVPARA Para;
759 SK_RLMT_PORT *pRPort;
760
761 pRPort = &pAC->Rlmt.Port[PortNumber];
762 if (pAC->Rlmt.Port[PortNumber].Net->RlmtMode & SK_RLMT_CHECK_LOC_LINK) {
763 if (pRPort->CheckingState & (SK_RLMT_PCS_TX | SK_RLMT_PCS_RX)) {
764 /* Port is suspicious. Send the RLMT packet to the RLMT mc addr. */
765 if ((Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC, PortNumber,
766 SK_PACKET_ALIVE, &pAC->Addr.Port[PortNumber].CurrentMacAddress,
767 &SkRlmtMcAddr)) != NULL) {
768 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
769 }
770 }
771 else {
772 /*
773 * Send a directed RLMT packet to all ports that are
774 * checked by the indicated port.
775 */
776 for (j = 0; j < pRPort->PortsChecked; j++) {
777 if ((Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC, PortNumber,
778 SK_PACKET_ALIVE, &pAC->Addr.Port[PortNumber].CurrentMacAddress,
779 &pRPort->PortCheck[j].CheckAddr)) != NULL) {
780 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
781 }
782 }
783 }
784 }
785
786 if ((pAC->Rlmt.Port[PortNumber].Net->RlmtMode & SK_RLMT_CHECK_SEG) &&
787 (pAC->Rlmt.Port[PortNumber].Net->CheckingState & SK_RLMT_RCS_SEND_SEG)) {
788 /*
789 * Send a BPDU packet to make a connected switch tell us
790 * the correct root bridge.
791 */
792 if ((Para.pParaPtr =
793 SkRlmtBuildSpanningTreePacket(pAC, IoC, PortNumber)) != NULL) {
794 pAC->Rlmt.Port[PortNumber].Net->CheckingState &= ~SK_RLMT_RCS_SEND_SEG;
795 pRPort->RootIdSet = SK_FALSE;
796
797 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
798 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_TX,
799 ("SkRlmtSend: BPDU Packet on Port %u.\n", PortNumber))
800 }
801 }
802 return;
803 } /* SkRlmtSend */
804
805
806 /******************************************************************************
807 *
808 * SkRlmtPortReceives - check if port is (going) down and bring it up
809 *
810 * Description:
811 * This routine checks if a port who received a non-BPDU packet
812 * needs to go up or needs to be stopped going down.
813 *
814 * Context:
815 * runtime, pageable?
816 *
817 * Returns:
818 * Nothing.
819 */
820 RLMT_STATIC void SkRlmtPortReceives(
821 SK_AC *pAC, /* Adapter Context */
822 SK_IOC IoC, /* I/O Context */
823 SK_U32 PortNumber) /* Port to check */
824 {
825 SK_RLMT_PORT *pRPort;
826 SK_EVPARA Para;
827
828 pRPort = &pAC->Rlmt.Port[PortNumber];
829 pRPort->PortNoRx = SK_FALSE;
830
831 if ((pRPort->PortState == SK_RLMT_PS_DOWN) &&
832 !(pRPort->CheckingState & SK_RLMT_PCS_TX)) {
833 /*
834 * Port is marked down (rx), but received a non-BPDU packet.
835 * Bring it up.
836 */
837 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
838 ("SkRlmtPacketReceive: Received on PortDown.\n"))
839
840 pRPort->PortState = SK_RLMT_PS_GOING_UP;
841 pRPort->GuTimeStamp = SkOsGetTime(pAC);
842 Para.Para32[0] = PortNumber;
843 Para.Para32[1] = (SK_U32)-1;
844 SkTimerStart(pAC, IoC, &pRPort->UpTimer, SK_RLMT_PORTUP_TIM_VAL,
845 SKGE_RLMT, SK_RLMT_PORTUP_TIM, Para);
846 pRPort->CheckingState &= ~SK_RLMT_PCS_RX;
847 /* pAC->Rlmt.CheckSwitch = SK_TRUE; */
848 SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
849 } /* PortDown && !SuspectTx */
850 else if (pRPort->CheckingState & SK_RLMT_PCS_RX) {
851 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
852 ("SkRlmtPacketReceive: Stop bringing port down.\n"))
853 SkTimerStop(pAC, IoC, &pRPort->DownRxTimer);
854 pRPort->CheckingState &= ~SK_RLMT_PCS_RX;
855 /* pAC->Rlmt.CheckSwitch = SK_TRUE; */
856 SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
857 } /* PortGoingDown */
858
859 return;
860 } /* SkRlmtPortReceives */
861
862
863 /******************************************************************************
864 *
865 * SkRlmtPacketReceive - receive a packet for closer examination
866 *
867 * Description:
868 * This routine examines a packet more closely than SK_RLMT_LOOKAHEAD.
869 *
870 * Context:
871 * runtime, pageable?
872 *
873 * Returns:
874 * Nothing.
875 */
876 RLMT_STATIC void SkRlmtPacketReceive(
877 SK_AC *pAC, /* Adapter Context */
878 SK_IOC IoC, /* I/O Context */
879 SK_MBUF *pMb) /* Received packet */
880 {
881 #ifdef xDEBUG
882 extern void DumpData(char *p, int size);
883 #endif /* DEBUG */
884 int i;
885 unsigned j;
886 SK_U16 PacketType;
887 SK_U32 PortNumber;
888 SK_ADDR_PORT *pAPort;
889 SK_RLMT_PORT *pRPort;
890 SK_RLMT_PACKET *pRPacket;
891 SK_SPTREE_PACKET *pSPacket;
892 SK_EVPARA Para;
893
894 PortNumber = pMb->PortIdx;
895 pAPort = &pAC->Addr.Port[PortNumber];
896 pRPort = &pAC->Rlmt.Port[PortNumber];
897
898 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
899 ("SkRlmtPacketReceive: PortNumber == %d.\n", PortNumber))
900
901 pRPacket = (SK_RLMT_PACKET*)pMb->pData;
902 pSPacket = (SK_SPTREE_PACKET*)pRPacket;
903
904 #ifdef xDEBUG
905 DumpData((char *)pRPacket, 32);
906 #endif /* DEBUG */
907
908 if ((pRPort->PacketsPerTimeSlot - pRPort->BpduPacketsPerTimeSlot) != 0) {
909 SkRlmtPortReceives(pAC, IoC, PortNumber);
910 }
911
912 /* Check destination address. */
913
914 if (!SK_ADDR_EQUAL(pAPort->CurrentMacAddress.a, pRPacket->DstAddr) &&
915 !SK_ADDR_EQUAL(SkRlmtMcAddr.a, pRPacket->DstAddr) &&
916 !SK_ADDR_EQUAL(BridgeMcAddr.a, pRPacket->DstAddr)) {
917
918 /* Not sent to current MAC or registered MC address => Trash it. */
919 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
920 ("SkRlmtPacketReceive: Not for me.\n"))
921
922 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
923 return;
924 }
925 else if (SK_ADDR_EQUAL(pAPort->CurrentMacAddress.a, pRPacket->SrcAddr)) {
926
927 /*
928 * Was sent by same port (may happen during port switching
929 * or in case of duplicate MAC addresses).
930 */
931
932 /*
933 * Check for duplicate address here:
934 * If Packet.Random != My.Random => DupAddr.
935 */
936 for (i = 3; i >= 0; i--) {
937 if (pRPort->Random[i] != pRPacket->Random[i]) {
938 break;
939 }
940 }
941
942 /*
943 * CAUTION: Do not check for duplicate MAC address in RLMT Alive Reply
944 * packets (they have the LLC_COMMAND_RESPONSE_BIT set in
945 * pRPacket->SSap).
946 */
947 if (i >= 0 && pRPacket->DSap == SK_RLMT_DSAP &&
948 pRPacket->Ctrl == SK_RLMT_CTRL &&
949 pRPacket->SSap == SK_RLMT_SSAP &&
950 pRPacket->Indicator[0] == SK_RLMT_INDICATOR0 &&
951 pRPacket->Indicator[1] == SK_RLMT_INDICATOR1 &&
952 pRPacket->Indicator[2] == SK_RLMT_INDICATOR2 &&
953 pRPacket->Indicator[3] == SK_RLMT_INDICATOR3 &&
954 pRPacket->Indicator[4] == SK_RLMT_INDICATOR4 &&
955 pRPacket->Indicator[5] == SK_RLMT_INDICATOR5 &&
956 pRPacket->Indicator[6] == SK_RLMT_INDICATOR6) {
957 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
958 ("SkRlmtPacketReceive: Duplicate MAC Address.\n"))
959
960 /* Error Log entry. */
961 SK_ERR_LOG(pAC, SK_ERRCL_COMM, SKERR_RLMT_E006, SKERR_RLMT_E006_MSG);
962 }
963 else {
964 /* Simply trash it. */
965 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
966 ("SkRlmtPacketReceive: Sent by me.\n"))
967 }
968
969 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
970 return;
971 }
972
973 /* Check SuspectTx entries. */
974 if (pRPort->PortsSuspect > 0) {
975 for (j = 0; j < pRPort->PortsChecked; j++) {
976 if (pRPort->PortCheck[j].SuspectTx &&
977 SK_ADDR_EQUAL(
978 pRPacket->SrcAddr, pRPort->PortCheck[j].CheckAddr.a)) {
979 pRPort->PortCheck[j].SuspectTx = SK_FALSE;
980 pRPort->PortsSuspect--;
981 break;
982 }
983 }
984 }
985
986 /* Determine type of packet. */
987 if (pRPacket->DSap == SK_RLMT_DSAP &&
988 pRPacket->Ctrl == SK_RLMT_CTRL &&
989 (pRPacket->SSap & ~LLC_COMMAND_RESPONSE_BIT) == SK_RLMT_SSAP &&
990 pRPacket->Indicator[0] == SK_RLMT_INDICATOR0 &&
991 pRPacket->Indicator[1] == SK_RLMT_INDICATOR1 &&
992 pRPacket->Indicator[2] == SK_RLMT_INDICATOR2 &&
993 pRPacket->Indicator[3] == SK_RLMT_INDICATOR3 &&
994 pRPacket->Indicator[4] == SK_RLMT_INDICATOR4 &&
995 pRPacket->Indicator[5] == SK_RLMT_INDICATOR5 &&
996 pRPacket->Indicator[6] == SK_RLMT_INDICATOR6) {
997
998 /* It's an RLMT packet. */
999 PacketType = (SK_U16)((pRPacket->RlmtPacketType[0] << 8) |
1000 pRPacket->RlmtPacketType[1]);
1001
1002 switch (PacketType) {
1003 case SK_PACKET_ANNOUNCE: /* Not yet used. */
1004 #if 0
1005 /* Build the check chain. */
1006 SkRlmtBuildCheckChain(pAC);
1007 #endif /* 0 */
1008
1009 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
1010 ("SkRlmtPacketReceive: Announce.\n"))
1011
1012 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
1013 break;
1014
1015 case SK_PACKET_ALIVE:
1016 if (pRPacket->SSap & LLC_COMMAND_RESPONSE_BIT) {
1017 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
1018 ("SkRlmtPacketReceive: Alive Reply.\n"))
1019
1020 if (!(pAC->Addr.Port[PortNumber].PromMode & SK_PROM_MODE_LLC) ||
1021 SK_ADDR_EQUAL(
1022 pRPacket->DstAddr, pAPort->CurrentMacAddress.a)) {
1023 /* Obviously we could send something. */
1024 if (pRPort->CheckingState & SK_RLMT_PCS_TX) {
1025 pRPort->CheckingState &= ~SK_RLMT_PCS_TX;
1026 SkTimerStop(pAC, IoC, &pRPort->DownTxTimer);
1027 }
1028
1029 if ((pRPort->PortState == SK_RLMT_PS_DOWN) &&
1030 !(pRPort->CheckingState & SK_RLMT_PCS_RX)) {
1031 pRPort->PortState = SK_RLMT_PS_GOING_UP;
1032 pRPort->GuTimeStamp = SkOsGetTime(pAC);
1033
1034 SkTimerStop(pAC, IoC, &pRPort->DownTxTimer);
1035
1036 Para.Para32[0] = PortNumber;
1037 Para.Para32[1] = (SK_U32)-1;
1038 SkTimerStart(pAC, IoC, &pRPort->UpTimer,
1039 SK_RLMT_PORTUP_TIM_VAL, SKGE_RLMT,
1040 SK_RLMT_PORTUP_TIM, Para);
1041 }
1042 }
1043
1044 /* Mark sending port as alive? */
1045 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
1046 }
1047 else { /* Alive Request Packet. */
1048 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
1049 ("SkRlmtPacketReceive: Alive Request.\n"))
1050
1051 pRPort->RxHelloCts++;
1052
1053 /* Answer. */
1054 for (i = 0; i < SK_MAC_ADDR_LEN; i++) {
1055 pRPacket->DstAddr[i] = pRPacket->SrcAddr[i];
1056 pRPacket->SrcAddr[i] =
1057 pAC->Addr.Port[PortNumber].CurrentMacAddress.a[i];
1058 }
1059 pRPacket->SSap |= LLC_COMMAND_RESPONSE_BIT;
1060
1061 Para.pParaPtr = pMb;
1062 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
1063 }
1064 break;
1065
1066 case SK_PACKET_CHECK_TX:
1067 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
1068 ("SkRlmtPacketReceive: Check your tx line.\n"))
1069
1070 /* A port checking us requests us to check our tx line. */
1071 pRPort->CheckingState |= SK_RLMT_PCS_TX;
1072
1073 /* Start PortDownTx timer. */
1074 Para.Para32[0] = PortNumber;
1075 Para.Para32[1] = (SK_U32)-1;
1076 SkTimerStart(pAC, IoC, &pRPort->DownTxTimer,
1077 SK_RLMT_PORTDOWN_TIM_VAL, SKGE_RLMT,
1078 SK_RLMT_PORTDOWN_TX_TIM, Para);
1079
1080 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
1081
1082 if ((Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC, PortNumber,
1083 SK_PACKET_ALIVE, &pAC->Addr.Port[PortNumber].CurrentMacAddress,
1084 &SkRlmtMcAddr)) != NULL) {
1085 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
1086 }
1087 break;
1088
1089 case SK_PACKET_ADDR_CHANGED:
1090 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
1091 ("SkRlmtPacketReceive: Address Change.\n"))
1092
1093 /* Build the check chain. */
1094 SkRlmtBuildCheckChain(pAC, pRPort->Net->NetNumber);
1095 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
1096 break;
1097
1098 default:
1099 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
1100 ("SkRlmtPacketReceive: Unknown RLMT packet.\n"))
1101
1102 /* RA;:;: ??? */
1103 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
1104 }
1105 }
1106 else if (pSPacket->DSap == SK_RLMT_SPT_DSAP &&
1107 pSPacket->Ctrl == SK_RLMT_SPT_CTRL &&
1108 (pSPacket->SSap & ~LLC_COMMAND_RESPONSE_BIT) == SK_RLMT_SPT_SSAP) {
1109 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
1110 ("SkRlmtPacketReceive: BPDU Packet.\n"))
1111
1112 /* Spanning Tree packet. */
1113 pRPort->RxSpHelloCts++;
1114
1115 if (!SK_ADDR_EQUAL(&pSPacket->RootId[2], &pAC->Addr.Net[pAC->Rlmt.
1116 Port[PortNumber].Net->NetNumber].CurrentMacAddress.a[0])) {
1117 /*
1118 * Check segmentation if a new root bridge is set and
1119 * the segmentation check is not currently running.
1120 */
1121 if (!SK_ADDR_EQUAL(&pSPacket->RootId[2], &pRPort->Root.Id[2]) &&
1122 (pAC->Rlmt.Port[PortNumber].Net->LinksUp > 1) &&
1123 (pAC->Rlmt.Port[PortNumber].Net->RlmtMode & SK_RLMT_CHECK_SEG)
1124 != 0 && (pAC->Rlmt.Port[PortNumber].Net->CheckingState &
1125 SK_RLMT_RCS_SEG) == 0) {
1126 pAC->Rlmt.Port[PortNumber].Net->CheckingState |=
1127 SK_RLMT_RCS_START_SEG | SK_RLMT_RCS_SEND_SEG;
1128 }
1129
1130 /* Store tree view of this port. */
1131 for (i = 0; i < 8; i++) {
1132 pRPort->Root.Id[i] = pSPacket->RootId[i];
1133 }
1134 pRPort->RootIdSet = SK_TRUE;
1135
1136 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_DUMP,
1137 ("Root ID %d: %02x %02x %02x %02x %02x %02x %02x %02x.\n",
1138 PortNumber,
1139 pRPort->Root.Id[0], pRPort->Root.Id[1],
1140 pRPort->Root.Id[2], pRPort->Root.Id[3],
1141 pRPort->Root.Id[4], pRPort->Root.Id[5],
1142 pRPort->Root.Id[6], pRPort->Root.Id[7]))
1143 }
1144
1145 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
1146 if ((pAC->Rlmt.Port[PortNumber].Net->CheckingState &
1147 SK_RLMT_RCS_REPORT_SEG) != 0) {
1148 SkRlmtCheckSeg(pAC, IoC, pAC->Rlmt.Port[PortNumber].Net->NetNumber);
1149 }
1150 }
1151 else {
1152 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
1153 ("SkRlmtPacketReceive: Unknown Packet Type.\n"))
1154
1155 /* Unknown packet. */
1156 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
1157 }
1158 return;
1159 } /* SkRlmtPacketReceive */
1160
1161
1162 /******************************************************************************
1163 *
1164 * SkRlmtCheckPort - check if a port works
1165 *
1166 * Description:
1167 * This routine checks if a port whose link is up received something
1168 * and if it seems to transmit successfully.
1169 *
1170 * # PortState: PsInit, PsLinkDown, PsDown, PsGoingUp, PsUp
1171 * # PortCheckingState (Bitfield): ChkTx, ChkRx, ChkSeg
1172 * # RlmtCheckingState (Bitfield): ChkSeg, StartChkSeg, ReportSeg
1173 *
1174 * if (Rx - RxBpdu == 0) { # No rx.
1175 * if (state == PsUp) {
1176 * PortCheckingState |= ChkRx
1177 * }
1178 * if (ModeCheckSeg && (Timeout ==
1179 * TO_SHORTEN(RLMT_DEFAULT_TIMEOUT))) {
1180 * RlmtCheckingState |= ChkSeg)
1181 * PortCheckingState |= ChkSeg
1182 * }
1183 * NewTimeout = TO_SHORTEN(Timeout)
1184 * if (NewTimeout < RLMT_MIN_TIMEOUT) {
1185 * NewTimeout = RLMT_MIN_TIMEOUT
1186 * PortState = PsDown
1187 * ...
1188 * }
1189 * }
1190 * else { # something was received
1191 * # Set counter to 0 at LinkDown?
1192 * # No - rx may be reported after LinkDown ???
1193 * PortCheckingState &= ~ChkRx
1194 * NewTimeout = RLMT_DEFAULT_TIMEOUT
1195 * if (RxAck == 0) {
1196 * possible reasons:
1197 * is my tx line bad? --
1198 * send RLMT multicast and report
1199 * back internally? (only possible
1200 * between ports on same adapter)
1201 * }
1202 * if (RxChk == 0) {
1203 * possible reasons:
1204 * - tx line of port set to check me
1205 * maybe bad
1206 * - no other port/adapter available or set
1207 * to check me
1208 * - adapter checking me has a longer
1209 * timeout
1210 * ??? anything that can be done here?
1211 * }
1212 * }
1213 *
1214 * Context:
1215 * runtime, pageable?
1216 *
1217 * Returns:
1218 * New timeout value.
1219 */
1220 RLMT_STATIC SK_U32 SkRlmtCheckPort(
1221 SK_AC *pAC, /* Adapter Context */
1222 SK_IOC IoC, /* I/O Context */
1223 SK_U32 PortNumber) /* Port to check */
1224 {
1225 unsigned i;
1226 SK_U32 NewTimeout;
1227 SK_RLMT_PORT *pRPort;
1228 SK_EVPARA Para;
1229
1230 pRPort = &pAC->Rlmt.Port[PortNumber];
1231
1232 if ((pRPort->PacketsPerTimeSlot - pRPort->BpduPacketsPerTimeSlot) == 0) {
1233 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1234 ("SkRlmtCheckPort %d: No (%d) receives in last time slot.\n",
1235 PortNumber, pRPort->PacketsPerTimeSlot))
1236
1237 /*
1238 * Check segmentation if there was no receive at least twice
1239 * in a row (PortNoRx is already set) and the segmentation
1240 * check is not currently running.
1241 */
1242
1243 if (pRPort->PortNoRx && (pAC->Rlmt.Port[PortNumber].Net->LinksUp > 1) &&
1244 (pAC->Rlmt.Port[PortNumber].Net->RlmtMode & SK_RLMT_CHECK_SEG) &&
1245 !(pAC->Rlmt.Port[PortNumber].Net->CheckingState & SK_RLMT_RCS_SEG)) {
1246 pAC->Rlmt.Port[PortNumber].Net->CheckingState |=
1247 SK_RLMT_RCS_START_SEG | SK_RLMT_RCS_SEND_SEG;
1248 }
1249
1250 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1251 ("SkRlmtCheckPort: PortsSuspect %d, PcsRx %d.\n",
1252 pRPort->PortsSuspect, pRPort->CheckingState & SK_RLMT_PCS_RX))
1253
1254 if (pRPort->PortState != SK_RLMT_PS_DOWN) {
1255 NewTimeout = TO_SHORTEN(pAC->Rlmt.Port[PortNumber].Net->TimeoutValue);
1256 if (NewTimeout < SK_RLMT_MIN_TO_VAL) {
1257 NewTimeout = SK_RLMT_MIN_TO_VAL;
1258 }
1259
1260 if (!(pRPort->CheckingState & SK_RLMT_PCS_RX)) {
1261 Para.Para32[0] = PortNumber;
1262 pRPort->CheckingState |= SK_RLMT_PCS_RX;
1263
1264 /*
1265 * What shall we do if the port checked by this one receives
1266 * our request frames? What's bad - our rx line or his tx line?
1267 */
1268 Para.Para32[1] = (SK_U32)-1;
1269 SkTimerStart(pAC, IoC, &pRPort->DownRxTimer,
1270 SK_RLMT_PORTDOWN_TIM_VAL, SKGE_RLMT,
1271 SK_RLMT_PORTDOWN_RX_TIM, Para);
1272
1273 for (i = 0; i < pRPort->PortsChecked; i++) {
1274 if (pRPort->PortCheck[i].SuspectTx) {
1275 continue;
1276 }
1277 pRPort->PortCheck[i].SuspectTx = SK_TRUE;
1278 pRPort->PortsSuspect++;
1279 if ((Para.pParaPtr =
1280 SkRlmtBuildPacket(pAC, IoC, PortNumber, SK_PACKET_CHECK_TX,
1281 &pAC->Addr.Port[PortNumber].CurrentMacAddress,
1282 &pRPort->PortCheck[i].CheckAddr)) != NULL) {
1283 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
1284 }
1285 }
1286 }
1287 }
1288 else { /* PortDown -- or all partners suspect. */
1289 NewTimeout = SK_RLMT_DEF_TO_VAL;
1290 }
1291 pRPort->PortNoRx = SK_TRUE;
1292 }
1293 else { /* A non-BPDU packet was received. */
1294 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1295 ("SkRlmtCheckPort %d: %d (%d) receives in last time slot.\n",
1296 PortNumber,
1297 pRPort->PacketsPerTimeSlot - pRPort->BpduPacketsPerTimeSlot,
1298 pRPort->PacketsPerTimeSlot))
1299
1300 SkRlmtPortReceives(pAC, IoC, PortNumber);
1301 if (pAC->Rlmt.CheckSwitch) {
1302 SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
1303 }
1304
1305 NewTimeout = SK_RLMT_DEF_TO_VAL;
1306 }
1307
1308 return (NewTimeout);
1309 } /* SkRlmtCheckPort */
1310
1311
1312 /******************************************************************************
1313 *
1314 * SkRlmtSelectBcRx - select new active port, criteria 1 (CLP)
1315 *
1316 * Description:
1317 * This routine selects the port that received a broadcast frame
1318 * substantially later than all other ports.
1319 *
1320 * Context:
1321 * runtime, pageable?
1322 *
1323 * Returns:
1324 * SK_BOOL
1325 */
1326 RLMT_STATIC SK_BOOL SkRlmtSelectBcRx(
1327 SK_AC *pAC, /* Adapter Context */
1328 SK_IOC IoC, /* I/O Context */
1329 SK_U32 Active, /* Active port */
1330 SK_U32 PrefPort, /* Preferred port */
1331 SK_U32 *pSelect) /* New active port */
1332 {
1333 SK_U64 BcTimeStamp;
1334 SK_U32 i;
1335 SK_BOOL PortFound;
1336
1337 BcTimeStamp = 0; /* Not totally necessary, but feeling better. */
1338 PortFound = SK_FALSE;
1339
1340 /* Select port with the latest TimeStamp. */
1341 for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
1342
1343 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1344 ("TimeStamp Port %d (Down: %d, NoRx: %d): %08x %08x.\n",
1345 i,
1346 pAC->Rlmt.Port[i].PortDown, pAC->Rlmt.Port[i].PortNoRx,
1347 *((SK_U32*)(&pAC->Rlmt.Port[i].BcTimeStamp) + OFFS_HI32),
1348 *((SK_U32*)(&pAC->Rlmt.Port[i].BcTimeStamp) + OFFS_LO32)))
1349
1350 if (!pAC->Rlmt.Port[i].PortDown && !pAC->Rlmt.Port[i].PortNoRx) {
1351 if (!PortFound || pAC->Rlmt.Port[i].BcTimeStamp > BcTimeStamp) {
1352 BcTimeStamp = pAC->Rlmt.Port[i].BcTimeStamp;
1353 *pSelect = i;
1354 PortFound = SK_TRUE;
1355 }
1356 }
1357 }
1358
1359 if (PortFound) {
1360 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1361 ("Port %d received the last broadcast.\n", *pSelect))
1362
1363 /* Look if another port's time stamp is similar. */
1364 for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
1365 if (i == *pSelect) {
1366 continue;
1367 }
1368 if (!pAC->Rlmt.Port[i].PortDown && !pAC->Rlmt.Port[i].PortNoRx &&
1369 (pAC->Rlmt.Port[i].BcTimeStamp >
1370 BcTimeStamp - SK_RLMT_BC_DELTA ||
1371 pAC->Rlmt.Port[i].BcTimeStamp +
1372 SK_RLMT_BC_DELTA > BcTimeStamp)) {
1373 PortFound = SK_FALSE;
1374
1375 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1376 ("Port %d received a broadcast at a similar time.\n", i))
1377 break;
1378 }
1379 }
1380 }
1381
1382 #ifdef DEBUG
1383 if (PortFound) {
1384 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1385 ("SK_RLMT_SELECT_BCRX found Port %d receiving the substantially "
1386 "latest broadcast (%u).\n",
1387 *pSelect,
1388 BcTimeStamp - pAC->Rlmt.Port[1 - *pSelect].BcTimeStamp))
1389 }
1390 #endif /* DEBUG */
1391
1392 return (PortFound);
1393 } /* SkRlmtSelectBcRx */
1394
1395
1396 /******************************************************************************
1397 *
1398 * SkRlmtSelectNotSuspect - select new active port, criteria 2 (CLP)
1399 *
1400 * Description:
1401 * This routine selects a good port (it is PortUp && !SuspectRx).
1402 *
1403 * Context:
1404 * runtime, pageable?
1405 *
1406 * Returns:
1407 * SK_BOOL
1408 */
1409 RLMT_STATIC SK_BOOL SkRlmtSelectNotSuspect(
1410 SK_AC *pAC, /* Adapter Context */
1411 SK_IOC IoC, /* I/O Context */
1412 SK_U32 Active, /* Active port */
1413 SK_U32 PrefPort, /* Preferred port */
1414 SK_U32 *pSelect) /* New active port */
1415 {
1416 SK_U32 i;
1417 SK_BOOL PortFound;
1418
1419 PortFound = SK_FALSE;
1420
1421 /* Select first port that is PortUp && !SuspectRx. */
1422 for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
1423 if (!pAC->Rlmt.Port[i].PortDown &&
1424 !(pAC->Rlmt.Port[i].CheckingState & SK_RLMT_PCS_RX)) {
1425 *pSelect = i;
1426 if (!pAC->Rlmt.Port[Active].PortDown &&
1427 !(pAC->Rlmt.Port[Active].CheckingState & SK_RLMT_PCS_RX)) {
1428 *pSelect = Active;
1429 }
1430 if (!pAC->Rlmt.Port[PrefPort].PortDown &&
1431 !(pAC->Rlmt.Port[PrefPort].CheckingState & SK_RLMT_PCS_RX)) {
1432 *pSelect = PrefPort;
1433 }
1434 PortFound = SK_TRUE;
1435 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1436 ("SK_RLMT_SELECT_NOTSUSPECT found Port %d up and not check RX.\n",
1437 *pSelect))
1438 break;
1439 }
1440 }
1441 return (PortFound);
1442 } /* SkRlmtSelectNotSuspect */
1443
1444
1445 /******************************************************************************
1446 *
1447 * SkRlmtSelectUp - select new active port, criteria 3, 4 (CLP)
1448 *
1449 * Description:
1450 * This routine selects a port that is up.
1451 *
1452 * Context:
1453 * runtime, pageable?
1454 *
1455 * Returns:
1456 * SK_BOOL
1457 */
1458 RLMT_STATIC SK_BOOL SkRlmtSelectUp(
1459 SK_AC *pAC, /* Adapter Context */
1460 SK_IOC IoC, /* I/O Context */
1461 SK_U32 Active, /* Active port */
1462 SK_U32 PrefPort, /* Preferred port */
1463 SK_U32 *pSelect, /* New active port */
1464 SK_BOOL AutoNegDone) /* Successfully auto-negotiated? */
1465 {
1466 SK_U32 i;
1467 SK_BOOL PortFound;
1468
1469 PortFound = SK_FALSE;
1470
1471 /* Select first port that is PortUp. */
1472 for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
1473 if (pAC->Rlmt.Port[i].PortState == SK_RLMT_PS_UP &&
1474 pAC->GIni.GP[i].PAutoNegFail != AutoNegDone) {
1475 *pSelect = i;
1476 if (pAC->Rlmt.Port[Active].PortState == SK_RLMT_PS_UP &&
1477 pAC->GIni.GP[Active].PAutoNegFail != AutoNegDone) {
1478 *pSelect = Active;
1479 }
1480 if (pAC->Rlmt.Port[PrefPort].PortState == SK_RLMT_PS_UP &&
1481 pAC->GIni.GP[PrefPort].PAutoNegFail != AutoNegDone) {
1482 *pSelect = PrefPort;
1483 }
1484 PortFound = SK_TRUE;
1485 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1486 ("SK_RLMT_SELECT_UP found Port %d up.\n", *pSelect))
1487 break;
1488 }
1489 }
1490 return (PortFound);
1491 } /* SkRlmtSelectUp */
1492
1493
1494 /******************************************************************************
1495 *
1496 * SkRlmtSelectGoingUp - select new active port, criteria 5, 6 (CLP)
1497 *
1498 * Description:
1499 * This routine selects the port that is going up for the longest time.
1500 *
1501 * Context:
1502 * runtime, pageable?
1503 *
1504 * Returns:
1505 * SK_BOOL
1506 */
1507 RLMT_STATIC SK_BOOL SkRlmtSelectGoingUp(
1508 SK_AC *pAC, /* Adapter Context */
1509 SK_IOC IoC, /* I/O Context */
1510 SK_U32 Active, /* Active port */
1511 SK_U32 PrefPort, /* Preferred port */
1512 SK_U32 *pSelect, /* New active port */
1513 SK_BOOL AutoNegDone) /* Successfully auto-negotiated? */
1514 {
1515 SK_U64 GuTimeStamp;
1516 SK_U32 i;
1517 SK_BOOL PortFound;
1518
1519 GuTimeStamp = 0;
1520 PortFound = SK_FALSE;
1521
1522 /* Select port that is PortGoingUp for the longest time. */
1523 for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
1524 if (pAC->Rlmt.Port[i].PortState == SK_RLMT_PS_GOING_UP &&
1525 pAC->GIni.GP[i].PAutoNegFail != AutoNegDone) {
1526 GuTimeStamp = pAC->Rlmt.Port[i].GuTimeStamp;
1527 *pSelect = i;
1528 PortFound = SK_TRUE;
1529 break;
1530 }
1531 }
1532
1533 if (!PortFound) {
1534 return (SK_FALSE);
1535 }
1536
1537 for (i = *pSelect + 1; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
1538 if (pAC->Rlmt.Port[i].PortState == SK_RLMT_PS_GOING_UP &&
1539 pAC->Rlmt.Port[i].GuTimeStamp < GuTimeStamp &&
1540 pAC->GIni.GP[i].PAutoNegFail != AutoNegDone) {
1541 GuTimeStamp = pAC->Rlmt.Port[i].GuTimeStamp;
1542 *pSelect = i;
1543 }
1544 }
1545
1546 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1547 ("SK_RLMT_SELECT_GOINGUP found Port %d going up.\n", *pSelect))
1548 return (SK_TRUE);
1549 } /* SkRlmtSelectGoingUp */
1550
1551
1552 /******************************************************************************
1553 *
1554 * SkRlmtSelectDown - select new active port, criteria 7, 8 (CLP)
1555 *
1556 * Description:
1557 * This routine selects a port that is down.
1558 *
1559 * Context:
1560 * runtime, pageable?
1561 *
1562 * Returns:
1563 * SK_BOOL
1564 */
1565 RLMT_STATIC SK_BOOL SkRlmtSelectDown(
1566 SK_AC *pAC, /* Adapter Context */
1567 SK_IOC IoC, /* I/O Context */
1568 SK_U32 Active, /* Active port */
1569 SK_U32 PrefPort, /* Preferred port */
1570 SK_U32 *pSelect, /* New active port */
1571 SK_BOOL AutoNegDone) /* Successfully auto-negotiated? */
1572 {
1573 SK_U32 i;
1574 SK_BOOL PortFound;
1575
1576 PortFound = SK_FALSE;
1577
1578 /* Select first port that is PortDown. */
1579 for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
1580 if (pAC->Rlmt.Port[i].PortState == SK_RLMT_PS_DOWN &&
1581 pAC->GIni.GP[i].PAutoNegFail != AutoNegDone) {
1582 *pSelect = i;
1583 if (pAC->Rlmt.Port[Active].PortState == SK_RLMT_PS_DOWN &&
1584 pAC->GIni.GP[Active].PAutoNegFail != AutoNegDone) {
1585 *pSelect = Active;
1586 }
1587 if (pAC->Rlmt.Port[PrefPort].PortState == SK_RLMT_PS_DOWN &&
1588 pAC->GIni.GP[PrefPort].PAutoNegFail != AutoNegDone) {
1589 *pSelect = PrefPort;
1590 }
1591 PortFound = SK_TRUE;
1592 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1593 ("SK_RLMT_SELECT_DOWN found Port %d down.\n", *pSelect))
1594 break;
1595 }
1596 }
1597 return (PortFound);
1598 } /* SkRlmtSelectDown */
1599
1600
1601 /******************************************************************************
1602 *
1603 * SkRlmtCheckSwitch - select new active port and switch to it
1604 *
1605 * Description:
1606 * This routine decides which port should be the active one and queues
1607 * port switching if necessary.
1608 *
1609 * Context:
1610 * runtime, pageable?
1611 *
1612 * Returns:
1613 * Nothing.
1614 */
1615 RLMT_STATIC void SkRlmtCheckSwitch(
1616 SK_AC *pAC, /* Adapter Context */
1617 SK_IOC IoC, /* I/O Context */
1618 SK_U32 NetIdx) /* Net index */
1619 {
1620 SK_EVPARA Para;
1621 SK_U32 Active;
1622 SK_U32 PrefPort;
1623 SK_U32 i;
1624 SK_BOOL PortFound;
1625
1626 Active = pAC->Rlmt.Net[NetIdx].ActivePort; /* Index of active port. */
1627 PrefPort = pAC->Rlmt.Net[NetIdx].PrefPort; /* Index of preferred port. */
1628 PortFound = SK_FALSE;
1629 pAC->Rlmt.CheckSwitch = SK_FALSE;
1630
1631 #if 0 /* RW 2001/10/18 - active port becomes always prefered one */
1632 if (pAC->Rlmt.Net[NetIdx].Preference == 0xFFFFFFFF) { /* Automatic */
1633 /* disable auto-fail back */
1634 PrefPort = Active;
1635 }
1636 #endif
1637
1638 if (pAC->Rlmt.Net[NetIdx].LinksUp == 0) {
1639 /* Last link went down - shut down the net. */
1640 pAC->Rlmt.Net[NetIdx].RlmtState = SK_RLMT_RS_NET_DOWN;
1641 Para.Para32[0] = SK_RLMT_NET_DOWN_TEMP;
1642 Para.Para32[1] = NetIdx;
1643 SkEventQueue(pAC, SKGE_DRV, SK_DRV_NET_DOWN, Para);
1644
1645 Para.Para32[0] = pAC->Rlmt.Net[NetIdx].
1646 Port[pAC->Rlmt.Net[NetIdx].ActivePort]->PortNumber;
1647 Para.Para32[1] = NetIdx;
1648 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_ACTIVE_DOWN, Para);
1649 return;
1650 } /* pAC->Rlmt.LinksUp == 0 */
1651 else if (pAC->Rlmt.Net[NetIdx].LinksUp == 1 &&
1652 pAC->Rlmt.Net[NetIdx].RlmtState == SK_RLMT_RS_NET_DOWN) {
1653 /* First link came up - get the net up. */
1654 pAC->Rlmt.Net[NetIdx].RlmtState = SK_RLMT_RS_NET_UP;
1655
1656 /*
1657 * If pAC->Rlmt.ActivePort != Para.Para32[0],
1658 * the DRV switches to the port that came up.
1659 */
1660 for (i = 0; i < pAC->Rlmt.Net[NetIdx].NumPorts; i++) {
1661 if (!pAC->Rlmt.Net[NetIdx].Port[i]->LinkDown) {
1662 if (!pAC->Rlmt.Net[NetIdx].Port[Active]->LinkDown) {
1663 i = Active;
1664 }
1665 if (!pAC->Rlmt.Net[NetIdx].Port[PrefPort]->LinkDown) {
1666 i = PrefPort;
1667 }
1668 PortFound = SK_TRUE;
1669 break;
1670 }
1671 }
1672
1673 if (PortFound) {
1674 Para.Para32[0] = pAC->Rlmt.Net[NetIdx].Port[i]->PortNumber;
1675 Para.Para32[1] = NetIdx;
1676 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_ACTIVE_UP, Para);
1677
1678 pAC->Rlmt.Net[NetIdx].ActivePort = i;
1679 Para.Para32[0] = pAC->Rlmt.Net[NetIdx].Port[i]->PortNumber;
1680 Para.Para32[1] = NetIdx;
1681 SkEventQueue(pAC, SKGE_DRV, SK_DRV_NET_UP, Para);
1682
1683 if ((pAC->Rlmt.Net[NetIdx].RlmtMode & SK_RLMT_TRANSPARENT) == 0 &&
1684 (Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC,
1685 pAC->Rlmt.Net[NetIdx].Port[i]->PortNumber,
1686 SK_PACKET_ANNOUNCE, &pAC->Addr.Net[NetIdx].
1687 CurrentMacAddress, &SkRlmtMcAddr)) != NULL) {
1688 /*
1689 * Send announce packet to RLMT multicast address to force
1690 * switches to learn the new location of the logical MAC address.
1691 */
1692 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
1693 }
1694 }
1695 else {
1696 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E007, SKERR_RLMT_E007_MSG);
1697 }
1698
1699 return;
1700 } /* LinksUp == 1 && RlmtState == SK_RLMT_RS_NET_DOWN */
1701 else { /* Cannot be reached in dual-net mode. */
1702 Para.Para32[0] = Active;
1703
1704 /*
1705 * Preselection:
1706 * If RLMT Mode != CheckLinkState
1707 * select port that received a broadcast frame substantially later
1708 * than all other ports
1709 * else select first port that is not SuspectRx
1710 * else select first port that is PortUp
1711 * else select port that is PortGoingUp for the longest time
1712 * else select first port that is PortDown
1713 * else stop.
1714 *
1715 * For the preselected port:
1716 * If ActivePort is equal in quality, select ActivePort.
1717 *
1718 * If PrefPort is equal in quality, select PrefPort.
1719 *
1720 * If ActivePort != SelectedPort,
1721 * If old ActivePort is LinkDown,
1722 * SwitchHard
1723 * else
1724 * SwitchSoft
1725 */
1726 /* check of ChgBcPrio flag added */
1727 if ((pAC->Rlmt.Net[0].RlmtMode != SK_RLMT_MODE_CLS) &&
1728 (!pAC->Rlmt.Net[0].ChgBcPrio)) {
1729
1730 if (!PortFound) {
1731 PortFound = SkRlmtSelectBcRx(
1732 pAC, IoC, Active, PrefPort, &Para.Para32[1]);
1733 }
1734
1735 if (!PortFound) {
1736 PortFound = SkRlmtSelectNotSuspect(
1737 pAC, IoC, Active, PrefPort, &Para.Para32[1]);
1738 }
1739 } /* pAC->Rlmt.RlmtMode != SK_RLMT_MODE_CLS */
1740
1741 /* with changed priority for last broadcast received */
1742 if ((pAC->Rlmt.Net[0].RlmtMode != SK_RLMT_MODE_CLS) &&
1743 (pAC->Rlmt.Net[0].ChgBcPrio)) {
1744 if (!PortFound) {
1745 PortFound = SkRlmtSelectNotSuspect(
1746 pAC, IoC, Active, PrefPort, &Para.Para32[1]);
1747 }
1748
1749 if (!PortFound) {
1750 PortFound = SkRlmtSelectBcRx(
1751 pAC, IoC, Active, PrefPort, &Para.Para32[1]);
1752 }
1753 } /* pAC->Rlmt.RlmtMode != SK_RLMT_MODE_CLS */
1754
1755 if (!PortFound) {
1756 PortFound = SkRlmtSelectUp(
1757 pAC, IoC, Active, PrefPort, &Para.Para32[1], AUTONEG_SUCCESS);
1758 }
1759
1760 if (!PortFound) {
1761 PortFound = SkRlmtSelectUp(
1762 pAC, IoC, Active, PrefPort, &Para.Para32[1], AUTONEG_FAILED);
1763 }
1764
1765 if (!PortFound) {
1766 PortFound = SkRlmtSelectGoingUp(
1767 pAC, IoC, Active, PrefPort, &Para.Para32[1], AUTONEG_SUCCESS);
1768 }
1769
1770 if (!PortFound) {
1771 PortFound = SkRlmtSelectGoingUp(
1772 pAC, IoC, Active, PrefPort, &Para.Para32[1], AUTONEG_FAILED);
1773 }
1774
1775 if (pAC->Rlmt.Net[0].RlmtMode != SK_RLMT_MODE_CLS) {
1776 if (!PortFound) {
1777 PortFound = SkRlmtSelectDown(pAC, IoC,
1778 Active, PrefPort, &Para.Para32[1], AUTONEG_SUCCESS);
1779 }
1780
1781 if (!PortFound) {
1782 PortFound = SkRlmtSelectDown(pAC, IoC,
1783 Active, PrefPort, &Para.Para32[1], AUTONEG_FAILED);
1784 }
1785 } /* pAC->Rlmt.RlmtMode != SK_RLMT_MODE_CLS */
1786
1787 if (PortFound) {
1788
1789 if (Para.Para32[1] != Active) {
1790 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1791 ("Active: %d, Para1: %d.\n", Active, Para.Para32[1]))
1792 pAC->Rlmt.Net[NetIdx].ActivePort = Para.Para32[1];
1793 Para.Para32[0] = pAC->Rlmt.Net[NetIdx].
1794 Port[Para.Para32[0]]->PortNumber;
1795 Para.Para32[1] = pAC->Rlmt.Net[NetIdx].
1796 Port[Para.Para32[1]]->PortNumber;
1797 SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[1], SK_LED_ACTIVE);
1798 if (pAC->Rlmt.Port[Active].LinkDown) {
1799 SkEventQueue(pAC, SKGE_DRV, SK_DRV_SWITCH_HARD, Para);
1800 }
1801 else {
1802 SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[0], SK_LED_STANDBY);
1803 SkEventQueue(pAC, SKGE_DRV, SK_DRV_SWITCH_SOFT, Para);
1804 }
1805 Para.Para32[1] = NetIdx;
1806 Para.Para32[0] =
1807 pAC->Rlmt.Net[NetIdx].Port[Para.Para32[0]]->PortNumber;
1808 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_ACTIVE_DOWN, Para);
1809 Para.Para32[0] = pAC->Rlmt.Net[NetIdx].
1810 Port[pAC->Rlmt.Net[NetIdx].ActivePort]->PortNumber;
1811 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_ACTIVE_UP, Para);
1812 if ((pAC->Rlmt.Net[NetIdx].RlmtMode & SK_RLMT_TRANSPARENT) == 0 &&
1813 (Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC, Para.Para32[0],
1814 SK_PACKET_ANNOUNCE, &pAC->Addr.Net[NetIdx].CurrentMacAddress,
1815 &SkRlmtMcAddr)) != NULL) {
1816 /*
1817 * Send announce packet to RLMT multicast address to force
1818 * switches to learn the new location of the logical
1819 * MAC address.
1820 */
1821 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
1822 } /* (Para.pParaPtr = SkRlmtBuildPacket(...)) != NULL */
1823 } /* Para.Para32[1] != Active */
1824 } /* PortFound */
1825 else {
1826 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E004, SKERR_RLMT_E004_MSG);
1827 }
1828 } /* LinksUp > 1 || LinksUp == 1 && RlmtState != SK_RLMT_RS_NET_DOWN */
1829 return;
1830 } /* SkRlmtCheckSwitch */
1831
1832
1833 /******************************************************************************
1834 *
1835 * SkRlmtCheckSeg - Report if segmentation is detected
1836 *
1837 * Description:
1838 * This routine checks if the ports see different root bridges and reports
1839 * segmentation in such a case.
1840 *
1841 * Context:
1842 * runtime, pageable?
1843 *
1844 * Returns:
1845 * Nothing.
1846 */
1847 RLMT_STATIC void SkRlmtCheckSeg(
1848 SK_AC *pAC, /* Adapter Context */
1849 SK_IOC IoC, /* I/O Context */
1850 SK_U32 NetIdx) /* Net number */
1851 {
1852 SK_EVPARA Para;
1853 SK_RLMT_NET *pNet;
1854 SK_U32 i, j;
1855 SK_BOOL Equal;
1856
1857 pNet = &pAC->Rlmt.Net[NetIdx];
1858 pNet->RootIdSet = SK_FALSE;
1859 Equal = SK_TRUE;
1860
1861 for (i = 0; i < pNet->NumPorts; i++) {
1862 if (pNet->Port[i]->LinkDown || !pNet->Port[i]->RootIdSet) {
1863 continue;
1864 }
1865
1866 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_DUMP,
1867 ("Root ID %d: %02x %02x %02x %02x %02x %02x %02x %02x.\n", i,
1868 pNet->Port[i]->Root.Id[0], pNet->Port[i]->Root.Id[1],
1869 pNet->Port[i]->Root.Id[2], pNet->Port[i]->Root.Id[3],
1870 pNet->Port[i]->Root.Id[4], pNet->Port[i]->Root.Id[5],
1871 pNet->Port[i]->Root.Id[6], pNet->Port[i]->Root.Id[7]))
1872
1873 if (!pNet->RootIdSet) {
1874 pNet->Root = pNet->Port[i]->Root;
1875 pNet->RootIdSet = SK_TRUE;
1876 continue;
1877 }
1878
1879 for (j = 0; j < 8; j ++) {
1880 Equal &= pNet->Port[i]->Root.Id[j] == pNet->Root.Id[j];
1881 if (!Equal) {
1882 break;
1883 }
1884 }
1885
1886 if (!Equal) {
1887 SK_ERR_LOG(pAC, SK_ERRCL_COMM, SKERR_RLMT_E005, SKERR_RLMT_E005_MSG);
1888 Para.Para32[0] = NetIdx;
1889 Para.Para32[1] = (SK_U32)-1;
1890 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_SEGMENTATION, Para);
1891
1892 pNet->CheckingState &= ~SK_RLMT_RCS_REPORT_SEG;
1893
1894 /* 2000-03-06 RA: New. */
1895 Para.Para32[0] = NetIdx;
1896 Para.Para32[1] = (SK_U32)-1;
1897 SkTimerStart(pAC, IoC, &pNet->SegTimer, SK_RLMT_SEG_TO_VAL,
1898 SKGE_RLMT, SK_RLMT_SEG_TIM, Para);
1899 break;
1900 }
1901 } /* for (i = 0; i < pNet->NumPorts; i++) */
1902
1903 /* 2000-03-06 RA: Moved here. */
1904 /* Segmentation check not running anymore. */
1905 pNet->CheckingState &= ~SK_RLMT_RCS_SEG;
1906
1907 } /* SkRlmtCheckSeg */
1908
1909
1910 /******************************************************************************
1911 *
1912 * SkRlmtPortStart - initialize port variables and start port
1913 *
1914 * Description:
1915 * This routine initializes a port's variables and issues a PORT_START
1916 * to the HWAC module. This handles retries if the start fails or the
1917 * link eventually goes down.
1918 *
1919 * Context:
1920 * runtime, pageable?
1921 *
1922 * Returns:
1923 * Nothing
1924 */
1925 RLMT_STATIC void SkRlmtPortStart(
1926 SK_AC *pAC, /* Adapter Context */
1927 SK_IOC IoC, /* I/O Context */
1928 SK_U32 PortNumber) /* Port number */
1929 {
1930 SK_EVPARA Para;
1931
1932 pAC->Rlmt.Port[PortNumber].PortState = SK_RLMT_PS_LINK_DOWN;
1933 pAC->Rlmt.Port[PortNumber].PortStarted = SK_TRUE;
1934 pAC->Rlmt.Port[PortNumber].LinkDown = SK_TRUE;
1935 pAC->Rlmt.Port[PortNumber].PortDown = SK_TRUE;
1936 pAC->Rlmt.Port[PortNumber].CheckingState = 0;
1937 pAC->Rlmt.Port[PortNumber].RootIdSet = SK_FALSE;
1938 Para.Para32[0] = PortNumber;
1939 Para.Para32[1] = (SK_U32)-1;
1940 SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
1941 } /* SkRlmtPortStart */
1942
1943
1944 /******************************************************************************
1945 *
1946 * SkRlmtEvtPortStartTim - PORT_START_TIM
1947 *
1948 * Description:
1949 * This routine handles PORT_START_TIM events.
1950 *
1951 * Context:
1952 * runtime, pageable?
1953 * may be called after SK_INIT_IO
1954 *
1955 * Returns:
1956 * Nothing
1957 */
1958 RLMT_STATIC void SkRlmtEvtPortStartTim(
1959 SK_AC *pAC, /* Adapter Context */
1960 SK_IOC IoC, /* I/O Context */
1961 SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 -1 */
1962 {
1963 SK_U32 i;
1964
1965 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1966 ("SK_RLMT_PORTSTART_TIMEOUT Port %d Event BEGIN.\n", Para.Para32[0]))
1967
1968 if (Para.Para32[1] != (SK_U32)-1) {
1969 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1970 ("Bad Parameter.\n"))
1971 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1972 ("SK_RLMT_PORTSTART_TIMEOUT Event EMPTY.\n"))
1973 return;
1974 }
1975
1976 /*
1977 * Used to start non-preferred ports if the preferred one
1978 * does not come up.
1979 * This timeout needs only be set when starting the first
1980 * (preferred) port.
1981 */
1982 if (pAC->Rlmt.Port[Para.Para32[0]].LinkDown) {
1983 /* PORT_START failed. */
1984 for (i = 0; i < pAC->Rlmt.Port[Para.Para32[0]].Net->NumPorts; i++) {
1985 if (!pAC->Rlmt.Port[Para.Para32[0]].Net->Port[i]->PortStarted) {
1986 SkRlmtPortStart(pAC, IoC,
1987 pAC->Rlmt.Port[Para.Para32[0]].Net->Port[i]->PortNumber);
1988 }
1989 }
1990 }
1991
1992 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
1993 ("SK_RLMT_PORTSTART_TIMEOUT Event END.\n"))
1994 } /* SkRlmtEvtPortStartTim */
1995
1996
1997 /******************************************************************************
1998 *
1999 * SkRlmtEvtLinkUp - LINK_UP
2000 *
2001 * Description:
2002 * This routine handles LLINK_UP events.
2003 *
2004 * Context:
2005 * runtime, pageable?
2006 * may be called after SK_INIT_IO
2007 *
2008 * Returns:
2009 * Nothing
2010 */
2011 RLMT_STATIC void SkRlmtEvtLinkUp(
2012 SK_AC *pAC, /* Adapter Context */
2013 SK_IOC IoC, /* I/O Context */
2014 SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 Undefined */
2015 {
2016 SK_U32 i;
2017 SK_RLMT_PORT *pRPort;
2018 SK_EVPARA Para2;
2019
2020 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2021 ("SK_RLMT_LINK_UP Port %d Event BEGIN.\n", Para.Para32[0]))
2022
2023 pRPort = &pAC->Rlmt.Port[Para.Para32[0]];
2024 if (!pRPort->PortStarted) {
2025 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E008, SKERR_RLMT_E008_MSG);
2026
2027 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2028 ("SK_RLMT_LINK_UP Event EMPTY.\n"))
2029 return;
2030 }
2031
2032 if (!pRPort->LinkDown) {
2033 /* RA;:;: Any better solution? */
2034 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2035 ("SK_RLMT_LINK_UP Event EMPTY.\n"))
2036 return;
2037 }
2038
2039 SkTimerStop(pAC, IoC, &pRPort->UpTimer);
2040 SkTimerStop(pAC, IoC, &pRPort->DownRxTimer);
2041 SkTimerStop(pAC, IoC, &pRPort->DownTxTimer);
2042
2043 /* Do something if timer already fired? */
2044
2045 pRPort->LinkDown = SK_FALSE;
2046 pRPort->PortState = SK_RLMT_PS_GOING_UP;
2047 pRPort->GuTimeStamp = SkOsGetTime(pAC);
2048 pRPort->BcTimeStamp = 0;
2049 pRPort->Net->LinksUp++;
2050 if (pRPort->Net->LinksUp == 1) {
2051 SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[0], SK_LED_ACTIVE);
2052 }
2053 else {
2054 SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[0], SK_LED_STANDBY);
2055 }
2056
2057 for (i = 0; i < pRPort->Net->NumPorts; i++) {
2058 if (!pRPort->Net->Port[i]->PortStarted) {
2059 SkRlmtPortStart(pAC, IoC, pRPort->Net->Port[i]->PortNumber);
2060 }
2061 }
2062
2063 SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
2064
2065 if (pRPort->Net->LinksUp >= 2) {
2066 if (pRPort->Net->RlmtMode & SK_RLMT_CHECK_LOC_LINK) {
2067 /* Build the check chain. */
2068 SkRlmtBuildCheckChain(pAC, pRPort->Net->NetNumber);
2069 }
2070 }
2071
2072 /* If the first link comes up, start the periodical RLMT timeout. */
2073 if (pRPort->Net->NumPorts > 1 && pRPort->Net->LinksUp == 1 &&
2074 (pRPort->Net->RlmtMode & SK_RLMT_CHECK_OTHERS) != 0) {
2075 Para2.Para32[0] = pRPort->Net->NetNumber;
2076 Para2.Para32[1] = (SK_U32)-1;
2077 SkTimerStart(pAC, IoC, &pRPort->Net->LocTimer,
2078 pRPort->Net->TimeoutValue, SKGE_RLMT, SK_RLMT_TIM, Para2);
2079 }
2080
2081 Para2 = Para;
2082 Para2.Para32[1] = (SK_U32)-1;
2083 SkTimerStart(pAC, IoC, &pRPort->UpTimer, SK_RLMT_PORTUP_TIM_VAL,
2084 SKGE_RLMT, SK_RLMT_PORTUP_TIM, Para2);
2085
2086 /* Later: if (pAC->Rlmt.RlmtMode & SK_RLMT_CHECK_LOC_LINK) && */
2087 if ((pRPort->Net->RlmtMode & SK_RLMT_TRANSPARENT) == 0 &&
2088 (pRPort->Net->RlmtMode & SK_RLMT_CHECK_LINK) != 0 &&
2089 (Para2.pParaPtr =
2090 SkRlmtBuildPacket(pAC, IoC, Para.Para32[0], SK_PACKET_ANNOUNCE,
2091 &pAC->Addr.Port[Para.Para32[0]].CurrentMacAddress, &SkRlmtMcAddr)
2092 ) != NULL) {
2093 /* Send "new" packet to RLMT multicast address. */
2094 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para2);
2095 }
2096
2097 if (pRPort->Net->RlmtMode & SK_RLMT_CHECK_SEG) {
2098 if ((Para2.pParaPtr =
2099 SkRlmtBuildSpanningTreePacket(pAC, IoC, Para.Para32[0])) != NULL) {
2100 pAC->Rlmt.Port[Para.Para32[0]].RootIdSet = SK_FALSE;
2101 pRPort->Net->CheckingState |=
2102 SK_RLMT_RCS_SEG | SK_RLMT_RCS_REPORT_SEG;
2103
2104 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para2);
2105
2106 Para.Para32[1] = (SK_U32)-1;
2107 SkTimerStart(pAC, IoC, &pRPort->Net->SegTimer,
2108 SK_RLMT_SEG_TO_VAL, SKGE_RLMT, SK_RLMT_SEG_TIM, Para);
2109 }
2110 }
2111
2112 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2113 ("SK_RLMT_LINK_UP Event END.\n"))
2114 } /* SkRlmtEvtLinkUp */
2115
2116
2117 /******************************************************************************
2118 *
2119 * SkRlmtEvtPortUpTim - PORT_UP_TIM
2120 *
2121 * Description:
2122 * This routine handles PORT_UP_TIM events.
2123 *
2124 * Context:
2125 * runtime, pageable?
2126 * may be called after SK_INIT_IO
2127 *
2128 * Returns:
2129 * Nothing
2130 */
2131 RLMT_STATIC void SkRlmtEvtPortUpTim(
2132 SK_AC *pAC, /* Adapter Context */
2133 SK_IOC IoC, /* I/O Context */
2134 SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 -1 */
2135 {
2136 SK_RLMT_PORT *pRPort;
2137
2138 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2139 ("SK_RLMT_PORTUP_TIM Port %d Event BEGIN.\n", Para.Para32[0]))
2140
2141 if (Para.Para32[1] != (SK_U32)-1) {
2142 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2143 ("Bad Parameter.\n"))
2144 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2145 ("SK_RLMT_PORTUP_TIM Event EMPTY.\n"))
2146 return;
2147 }
2148
2149 pRPort = &pAC->Rlmt.Port[Para.Para32[0]];
2150 if (pRPort->LinkDown || (pRPort->PortState == SK_RLMT_PS_UP)) {
2151 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2152 ("SK_RLMT_PORTUP_TIM Port %d Event EMPTY.\n", Para.Para32[0]))
2153 return;
2154 }
2155
2156 pRPort->PortDown = SK_FALSE;
2157 pRPort->PortState = SK_RLMT_PS_UP;
2158 pRPort->Net->PortsUp++;
2159 if (pRPort->Net->RlmtState != SK_RLMT_RS_INIT) {
2160 if (pAC->Rlmt.NumNets <= 1) {
2161 SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
2162 }
2163 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_PORT_UP, Para);
2164 }
2165
2166 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2167 ("SK_RLMT_PORTUP_TIM Event END.\n"))
2168 } /* SkRlmtEvtPortUpTim */
2169
2170
2171 /******************************************************************************
2172 *
2173 * SkRlmtEvtPortDownTim - PORT_DOWN_*
2174 *
2175 * Description:
2176 * This routine handles PORT_DOWN_* events.
2177 *
2178 * Context:
2179 * runtime, pageable?
2180 * may be called after SK_INIT_IO
2181 *
2182 * Returns:
2183 * Nothing
2184 */
2185 RLMT_STATIC void SkRlmtEvtPortDownX(
2186 SK_AC *pAC, /* Adapter Context */
2187 SK_IOC IoC, /* I/O Context */
2188 SK_U32 Event, /* Event code */
2189 SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 -1 */
2190 {
2191 SK_RLMT_PORT *pRPort;
2192
2193 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2194 ("SK_RLMT_PORTDOWN* Port %d Event (%d) BEGIN.\n",
2195 Para.Para32[0], Event))
2196
2197 if (Para.Para32[1] != (SK_U32)-1) {
2198 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2199 ("Bad Parameter.\n"))
2200 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2201 ("SK_RLMT_PORTDOWN* Event EMPTY.\n"))
2202 return;
2203 }
2204
2205 pRPort = &pAC->Rlmt.Port[Para.Para32[0]];
2206 if (!pRPort->PortStarted || (Event == SK_RLMT_PORTDOWN_TX_TIM &&
2207 !(pRPort->CheckingState & SK_RLMT_PCS_TX))) {
2208 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2209 ("SK_RLMT_PORTDOWN* Event (%d) EMPTY.\n", Event))
2210 return;
2211 }
2212
2213 /* Stop port's timers. */
2214 SkTimerStop(pAC, IoC, &pRPort->UpTimer);
2215 SkTimerStop(pAC, IoC, &pRPort->DownRxTimer);
2216 SkTimerStop(pAC, IoC, &pRPort->DownTxTimer);
2217
2218 if (pRPort->PortState != SK_RLMT_PS_LINK_DOWN) {
2219 pRPort->PortState = SK_RLMT_PS_DOWN;
2220 }
2221
2222 if (!pRPort->PortDown) {
2223 pRPort->Net->PortsUp--;
2224 pRPort->PortDown = SK_TRUE;
2225 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_PORT_DOWN, Para);
2226 }
2227
2228 pRPort->PacketsPerTimeSlot = 0;
2229 /* pRPort->DataPacketsPerTimeSlot = 0; */
2230 pRPort->BpduPacketsPerTimeSlot = 0;
2231 pRPort->BcTimeStamp = 0;
2232
2233 /*
2234 * RA;:;: To be checked:
2235 * - actions at RLMT_STOP: We should not switch anymore.
2236 */
2237 if (pRPort->Net->RlmtState != SK_RLMT_RS_INIT) {
2238 if (Para.Para32[0] ==
2239 pRPort->Net->Port[pRPort->Net->ActivePort]->PortNumber) {
2240 /* Active Port went down. */
2241 SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
2242 }
2243 }
2244
2245 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2246 ("SK_RLMT_PORTDOWN* Event (%d) END.\n", Event))
2247 } /* SkRlmtEvtPortDownX */
2248
2249
2250 /******************************************************************************
2251 *
2252 * SkRlmtEvtLinkDown - LINK_DOWN
2253 *
2254 * Description:
2255 * This routine handles LINK_DOWN events.
2256 *
2257 * Context:
2258 * runtime, pageable?
2259 * may be called after SK_INIT_IO
2260 *
2261 * Returns:
2262 * Nothing
2263 */
2264 RLMT_STATIC void SkRlmtEvtLinkDown(
2265 SK_AC *pAC, /* Adapter Context */
2266 SK_IOC IoC, /* I/O Context */
2267 SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 Undefined */
2268 {
2269 SK_RLMT_PORT *pRPort;
2270
2271 pRPort = &pAC->Rlmt.Port[Para.Para32[0]];
2272 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2273 ("SK_RLMT_LINK_DOWN Port %d Event BEGIN.\n", Para.Para32[0]))
2274
2275 if (!pAC->Rlmt.Port[Para.Para32[0]].LinkDown) {
2276 pRPort->Net->LinksUp--;
2277 pRPort->LinkDown = SK_TRUE;
2278 pRPort->PortState = SK_RLMT_PS_LINK_DOWN;
2279 SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[0], SK_LED_OFF);
2280
2281 if ((pRPort->Net->RlmtMode & SK_RLMT_CHECK_LOC_LINK) != 0) {
2282 /* Build the check chain. */
2283 SkRlmtBuildCheckChain(pAC, pRPort->Net->NetNumber);
2284 }
2285
2286 /* Ensure that port is marked down. */
2287 Para.Para32[1] = -1;
2288 (void)SkRlmtEvent(pAC, IoC, SK_RLMT_PORTDOWN, Para);
2289 }
2290
2291 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2292 ("SK_RLMT_LINK_DOWN Event END.\n"))
2293 } /* SkRlmtEvtLinkDown */
2294
2295
2296 /******************************************************************************
2297 *
2298 * SkRlmtEvtPortAddr - PORT_ADDR
2299 *
2300 * Description:
2301 * This routine handles PORT_ADDR events.
2302 *
2303 * Context:
2304 * runtime, pageable?
2305 * may be called after SK_INIT_IO
2306 *
2307 * Returns:
2308 * Nothing
2309 */
2310 RLMT_STATIC void SkRlmtEvtPortAddr(
2311 SK_AC *pAC, /* Adapter Context */
2312 SK_IOC IoC, /* I/O Context */
2313 SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 -1 */
2314 {
2315 SK_U32 i, j;
2316 SK_RLMT_PORT *pRPort;
2317 SK_MAC_ADDR *pOldMacAddr;
2318 SK_MAC_ADDR *pNewMacAddr;
2319
2320 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2321 ("SK_RLMT_PORT_ADDR Port %d Event BEGIN.\n", Para.Para32[0]))
2322
2323 if (Para.Para32[1] != (SK_U32)-1) {
2324 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2325 ("Bad Parameter.\n"))
2326 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2327 ("SK_RLMT_PORT_ADDR Event EMPTY.\n"))
2328 return;
2329 }
2330
2331 /* Port's physical MAC address changed. */
2332 pOldMacAddr = &pAC->Addr.Port[Para.Para32[0]].PreviousMacAddress;
2333 pNewMacAddr = &pAC->Addr.Port[Para.Para32[0]].CurrentMacAddress;
2334
2335 /*
2336 * NOTE: This is not scalable for solutions where ports are
2337 * checked remotely. There, we need to send an RLMT
2338 * address change packet - and how do we ensure delivery?
2339 */
2340 for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
2341 pRPort = &pAC->Rlmt.Port[i];
2342 for (j = 0; j < pRPort->PortsChecked; j++) {
2343 if (SK_ADDR_EQUAL(
2344 pRPort->PortCheck[j].CheckAddr.a, pOldMacAddr->a)) {
2345 pRPort->PortCheck[j].CheckAddr = *pNewMacAddr;
2346 }
2347 }
2348 }
2349
2350 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2351 ("SK_RLMT_PORT_ADDR Event END.\n"))
2352 } /* SkRlmtEvtPortAddr */
2353
2354
2355 /******************************************************************************
2356 *
2357 * SkRlmtEvtStart - START
2358 *
2359 * Description:
2360 * This routine handles START events.
2361 *
2362 * Context:
2363 * runtime, pageable?
2364 * may be called after SK_INIT_IO
2365 *
2366 * Returns:
2367 * Nothing
2368 */
2369 RLMT_STATIC void SkRlmtEvtStart(
2370 SK_AC *pAC, /* Adapter Context */
2371 SK_IOC IoC, /* I/O Context */
2372 SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
2373 {
2374 SK_EVPARA Para2;
2375 SK_U32 PortIdx;
2376 SK_U32 PortNumber;
2377
2378 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2379 ("SK_RLMT_START Net %d Event BEGIN.\n", Para.Para32[0]))
2380
2381 if (Para.Para32[1] != (SK_U32)-1) {
2382 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2383 ("Bad Parameter.\n"))
2384 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2385 ("SK_RLMT_START Event EMPTY.\n"))
2386 return;
2387 }
2388
2389 if (Para.Para32[0] >= pAC->Rlmt.NumNets) {
2390 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2391 ("Bad NetNumber %d.\n", Para.Para32[0]))
2392 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2393 ("SK_RLMT_START Event EMPTY.\n"))
2394 return;
2395 }
2396
2397 if (pAC->Rlmt.Net[Para.Para32[0]].RlmtState != SK_RLMT_RS_INIT) {
2398 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2399 ("SK_RLMT_START Event EMPTY.\n"))
2400 return;
2401 }
2402
2403 if (pAC->Rlmt.NetsStarted >= pAC->Rlmt.NumNets) {
2404 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2405 ("All nets should have been started.\n"))
2406 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2407 ("SK_RLMT_START Event EMPTY.\n"))
2408 return;
2409 }
2410
2411 if (pAC->Rlmt.Net[Para.Para32[0]].PrefPort >=
2412 pAC->Rlmt.Net[Para.Para32[0]].NumPorts) {
2413 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E009, SKERR_RLMT_E009_MSG);
2414
2415 /* Change PrefPort to internal default. */
2416 Para2.Para32[0] = 0xFFFFFFFF;
2417 Para2.Para32[1] = Para.Para32[0];
2418 (void)SkRlmtEvent(pAC, IoC, SK_RLMT_PREFPORT_CHANGE, Para2);
2419 }
2420
2421 PortIdx = pAC->Rlmt.Net[Para.Para32[0]].PrefPort;
2422 PortNumber = pAC->Rlmt.Net[Para.Para32[0]].Port[PortIdx]->PortNumber;
2423
2424 pAC->Rlmt.Net[Para.Para32[0]].LinksUp = 0;
2425 pAC->Rlmt.Net[Para.Para32[0]].PortsUp = 0;
2426 pAC->Rlmt.Net[Para.Para32[0]].CheckingState = 0;
2427 pAC->Rlmt.Net[Para.Para32[0]].RlmtState = SK_RLMT_RS_NET_DOWN;
2428
2429 /* Start preferred port. */
2430 SkRlmtPortStart(pAC, IoC, PortNumber);
2431
2432 /* Start Timer (for first port only). */
2433 Para2.Para32[0] = PortNumber;
2434 Para2.Para32[1] = (SK_U32)-1;
2435 SkTimerStart(pAC, IoC, &pAC->Rlmt.Port[PortNumber].UpTimer,
2436 SK_RLMT_PORTSTART_TIM_VAL, SKGE_RLMT, SK_RLMT_PORTSTART_TIM, Para2);
2437
2438 pAC->Rlmt.NetsStarted++;
2439
2440 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2441 ("SK_RLMT_START Event END.\n"))
2442 } /* SkRlmtEvtStart */
2443
2444
2445 /******************************************************************************
2446 *
2447 * SkRlmtEvtStop - STOP
2448 *
2449 * Description:
2450 * This routine handles STOP events.
2451 *
2452 * Context:
2453 * runtime, pageable?
2454 * may be called after SK_INIT_IO
2455 *
2456 * Returns:
2457 * Nothing
2458 */
2459 RLMT_STATIC void SkRlmtEvtStop(
2460 SK_AC *pAC, /* Adapter Context */
2461 SK_IOC IoC, /* I/O Context */
2462 SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
2463 {
2464 SK_EVPARA Para2;
2465 SK_U32 PortNumber;
2466 SK_U32 i;
2467
2468 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2469 ("SK_RLMT_STOP Net %d Event BEGIN.\n", Para.Para32[0]))
2470
2471 if (Para.Para32[1] != (SK_U32)-1) {
2472 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2473 ("Bad Parameter.\n"))
2474 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2475 ("SK_RLMT_STOP Event EMPTY.\n"))
2476 return;
2477 }
2478
2479 if (Para.Para32[0] >= pAC->Rlmt.NumNets) {
2480 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2481 ("Bad NetNumber %d.\n", Para.Para32[0]))
2482 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2483 ("SK_RLMT_STOP Event EMPTY.\n"))
2484 return;
2485 }
2486
2487 if (pAC->Rlmt.Net[Para.Para32[0]].RlmtState == SK_RLMT_RS_INIT) {
2488 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2489 ("SK_RLMT_STOP Event EMPTY.\n"))
2490 return;
2491 }
2492
2493 if (pAC->Rlmt.NetsStarted == 0) {
2494 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2495 ("All nets are stopped.\n"))
2496 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2497 ("SK_RLMT_STOP Event EMPTY.\n"))
2498 return;
2499 }
2500
2501 /* Stop RLMT timers. */
2502 SkTimerStop(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[0]].LocTimer);
2503 SkTimerStop(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[0]].SegTimer);
2504
2505 /* Stop net. */
2506 pAC->Rlmt.Net[Para.Para32[0]].RlmtState = SK_RLMT_RS_INIT;
2507 pAC->Rlmt.Net[Para.Para32[0]].RootIdSet = SK_FALSE;
2508 Para2.Para32[0] = SK_RLMT_NET_DOWN_FINAL;
2509 Para2.Para32[1] = Para.Para32[0]; /* Net# */
2510 SkEventQueue(pAC, SKGE_DRV, SK_DRV_NET_DOWN, Para2);
2511
2512 /* Stop ports. */
2513 for (i = 0; i < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; i++) {
2514 PortNumber = pAC->Rlmt.Net[Para.Para32[0]].Port[i]->PortNumber;
2515 if (pAC->Rlmt.Port[PortNumber].PortState != SK_RLMT_PS_INIT) {
2516 SkTimerStop(pAC, IoC, &pAC->Rlmt.Port[PortNumber].UpTimer);
2517 SkTimerStop(pAC, IoC, &pAC->Rlmt.Port[PortNumber].DownRxTimer);
2518 SkTimerStop(pAC, IoC, &pAC->Rlmt.Port[PortNumber].DownTxTimer);
2519
2520 pAC->Rlmt.Port[PortNumber].PortState = SK_RLMT_PS_INIT;
2521 pAC->Rlmt.Port[PortNumber].RootIdSet = SK_FALSE;
2522 pAC->Rlmt.Port[PortNumber].PortStarted = SK_FALSE;
2523 Para2.Para32[0] = PortNumber;
2524 Para2.Para32[1] = (SK_U32)-1;
2525 SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para2);
2526 }
2527 }
2528
2529 pAC->Rlmt.NetsStarted--;
2530
2531 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2532 ("SK_RLMT_STOP Event END.\n"))
2533 } /* SkRlmtEvtStop */
2534
2535
2536 /******************************************************************************
2537 *
2538 * SkRlmtEvtTim - TIM
2539 *
2540 * Description:
2541 * This routine handles TIM events.
2542 *
2543 * Context:
2544 * runtime, pageable?
2545 * may be called after SK_INIT_IO
2546 *
2547 * Returns:
2548 * Nothing
2549 */
2550 RLMT_STATIC void SkRlmtEvtTim(
2551 SK_AC *pAC, /* Adapter Context */
2552 SK_IOC IoC, /* I/O Context */
2553 SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
2554 {
2555 SK_RLMT_PORT *pRPort;
2556 SK_U32 Timeout;
2557 SK_U32 NewTimeout;
2558 SK_U32 PortNumber;
2559 SK_U32 i;
2560
2561 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2562 ("SK_RLMT_TIM Event BEGIN.\n"))
2563
2564 if (Para.Para32[1] != (SK_U32)-1) {
2565 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2566 ("Bad Parameter.\n"))
2567 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2568 ("SK_RLMT_TIM Event EMPTY.\n"))
2569 return;
2570 }
2571
2572 if ((pAC->Rlmt.Net[Para.Para32[0]].RlmtMode & SK_RLMT_CHECK_OTHERS) == 0 ||
2573 pAC->Rlmt.Net[Para.Para32[0]].LinksUp == 0) {
2574 /* Mode changed or all links down: No more link checking. */
2575 return;
2576 }
2577
2578 #if 0
2579 pAC->Rlmt.SwitchCheckCounter--;
2580 if (pAC->Rlmt.SwitchCheckCounter == 0) {
2581 pAC->Rlmt.SwitchCheckCounter;
2582 }
2583 #endif /* 0 */
2584
2585 NewTimeout = SK_RLMT_DEF_TO_VAL;
2586 for (i = 0; i < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; i++) {
2587 PortNumber = pAC->Rlmt.Net[Para.Para32[0]].Port[i]->PortNumber;
2588 pRPort = &pAC->Rlmt.Port[PortNumber];
2589 if (!pRPort->LinkDown) {
2590 Timeout = SkRlmtCheckPort(pAC, IoC, PortNumber);
2591 if (Timeout < NewTimeout) {
2592 NewTimeout = Timeout;
2593 }
2594
2595 /*
2596 * These counters should be set to 0 for all ports before the
2597 * first frame is sent in the next loop.
2598 */
2599 pRPort->PacketsPerTimeSlot = 0;
2600 /* pRPort->DataPacketsPerTimeSlot = 0; */
2601 pRPort->BpduPacketsPerTimeSlot = 0;
2602 }
2603 }
2604 pAC->Rlmt.Net[Para.Para32[0]].TimeoutValue = NewTimeout;
2605
2606 if (pAC->Rlmt.Net[Para.Para32[0]].LinksUp > 1) {
2607 /*
2608 * If checking remote ports, also send packets if
2609 * (LinksUp == 1) &&
2610 * this port checks at least one (remote) port.
2611 */
2612
2613 /*
2614 * Must be new loop, as SkRlmtCheckPort can request to
2615 * check segmentation when e.g. checking the last port.
2616 */
2617 for (i = 0; i < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; i++) {
2618 if (!pAC->Rlmt.Net[Para.Para32[0]].Port[i]->LinkDown) {
2619 SkRlmtSend(pAC, IoC,
2620 pAC->Rlmt.Net[Para.Para32[0]].Port[i]->PortNumber);
2621 }
2622 }
2623 }
2624
2625 SkTimerStart(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[0]].LocTimer,
2626 pAC->Rlmt.Net[Para.Para32[0]].TimeoutValue, SKGE_RLMT, SK_RLMT_TIM,
2627 Para);
2628
2629 if (pAC->Rlmt.Net[Para.Para32[0]].LinksUp > 1 &&
2630 (pAC->Rlmt.Net[Para.Para32[0]].RlmtMode & SK_RLMT_CHECK_SEG) &&
2631 (pAC->Rlmt.Net[Para.Para32[0]].CheckingState & SK_RLMT_RCS_START_SEG)) {
2632 SkTimerStart(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[0]].SegTimer,
2633 SK_RLMT_SEG_TO_VAL, SKGE_RLMT, SK_RLMT_SEG_TIM, Para);
2634 pAC->Rlmt.Net[Para.Para32[0]].CheckingState &= ~SK_RLMT_RCS_START_SEG;
2635 pAC->Rlmt.Net[Para.Para32[0]].CheckingState |=
2636 SK_RLMT_RCS_SEG | SK_RLMT_RCS_REPORT_SEG;
2637 }
2638
2639 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2640 ("SK_RLMT_TIM Event END.\n"))
2641 } /* SkRlmtEvtTim */
2642
2643
2644 /******************************************************************************
2645 *
2646 * SkRlmtEvtSegTim - SEG_TIM
2647 *
2648 * Description:
2649 * This routine handles SEG_TIM events.
2650 *
2651 * Context:
2652 * runtime, pageable?
2653 * may be called after SK_INIT_IO
2654 *
2655 * Returns:
2656 * Nothing
2657 */
2658 RLMT_STATIC void SkRlmtEvtSegTim(
2659 SK_AC *pAC, /* Adapter Context */
2660 SK_IOC IoC, /* I/O Context */
2661 SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
2662 {
2663 #ifdef xDEBUG
2664 int j;
2665 #endif /* DEBUG */
2666
2667 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2668 ("SK_RLMT_SEG_TIM Event BEGIN.\n"))
2669
2670 if (Para.Para32[1] != (SK_U32)-1) {
2671 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2672 ("Bad Parameter.\n"))
2673 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2674 ("SK_RLMT_SEG_TIM Event EMPTY.\n"))
2675 return;
2676 }
2677
2678 #ifdef xDEBUG
2679 for (j = 0; j < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; j++) {
2680 SK_ADDR_PORT *pAPort;
2681 SK_U32 k;
2682 SK_U16 *InAddr;
2683 SK_U8 InAddr8[6];
2684
2685 InAddr = (SK_U16 *)&InAddr8[0];
2686 pAPort = pAC->Rlmt.Net[Para.Para32[0]].Port[j]->AddrPort;
2687 for (k = 0; k < pAPort->NextExactMatchRlmt; k++) {
2688 /* Get exact match address k from port j. */
2689 XM_INADDR(IoC, pAC->Rlmt.Net[Para.Para32[0]].Port[j]->PortNumber,
2690 XM_EXM(k), InAddr);
2691 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2692 ("MC address %d on Port %u: %02x %02x %02x %02x %02x %02x -- %02x %02x %02x %02x %02x %02x.\n",
2693 k, pAC->Rlmt.Net[Para.Para32[0]].Port[j]->PortNumber,
2694 InAddr8[0], InAddr8[1], InAddr8[2],
2695 InAddr8[3], InAddr8[4], InAddr8[5],
2696 pAPort->Exact[k].a[0], pAPort->Exact[k].a[1],
2697 pAPort->Exact[k].a[2], pAPort->Exact[k].a[3],
2698 pAPort->Exact[k].a[4], pAPort->Exact[k].a[5]))
2699 }
2700 }
2701 #endif /* xDEBUG */
2702
2703 SkRlmtCheckSeg(pAC, IoC, Para.Para32[0]);
2704
2705 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2706 ("SK_RLMT_SEG_TIM Event END.\n"))
2707 } /* SkRlmtEvtSegTim */
2708
2709
2710 /******************************************************************************
2711 *
2712 * SkRlmtEvtPacketRx - PACKET_RECEIVED
2713 *
2714 * Description:
2715 * This routine handles PACKET_RECEIVED events.
2716 *
2717 * Context:
2718 * runtime, pageable?
2719 * may be called after SK_INIT_IO
2720 *
2721 * Returns:
2722 * Nothing
2723 */
2724 RLMT_STATIC void SkRlmtEvtPacketRx(
2725 SK_AC *pAC, /* Adapter Context */
2726 SK_IOC IoC, /* I/O Context */
2727 SK_EVPARA Para) /* SK_MBUF *pMb */
2728 {
2729 SK_MBUF *pMb;
2730 SK_MBUF *pNextMb;
2731 SK_U32 NetNumber;
2732
2733
2734 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2735 ("SK_RLMT_PACKET_RECEIVED Event BEGIN.\n"))
2736
2737 /* Should we ignore frames during port switching? */
2738
2739 #ifdef DEBUG
2740 pMb = Para.pParaPtr;
2741 if (pMb == NULL) {
2742 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL, ("No mbuf.\n"))
2743 }
2744 else if (pMb->pNext != NULL) {
2745 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2746 ("More than one mbuf or pMb->pNext not set.\n"))
2747 }
2748 #endif /* DEBUG */
2749
2750 for (pMb = Para.pParaPtr; pMb != NULL; pMb = pNextMb) {
2751 pNextMb = pMb->pNext;
2752 pMb->pNext = NULL;
2753
2754 NetNumber = pAC->Rlmt.Port[pMb->PortIdx].Net->NetNumber;
2755 if (pAC->Rlmt.Net[NetNumber].RlmtState == SK_RLMT_RS_INIT) {
2756 SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
2757 }
2758 else {
2759 SkRlmtPacketReceive(pAC, IoC, pMb);
2760 }
2761 }
2762
2763 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2764 ("SK_RLMT_PACKET_RECEIVED Event END.\n"))
2765 } /* SkRlmtEvtPacketRx */
2766
2767
2768 /******************************************************************************
2769 *
2770 * SkRlmtEvtStatsClear - STATS_CLEAR
2771 *
2772 * Description:
2773 * This routine handles STATS_CLEAR events.
2774 *
2775 * Context:
2776 * runtime, pageable?
2777 * may be called after SK_INIT_IO
2778 *
2779 * Returns:
2780 * Nothing
2781 */
2782 RLMT_STATIC void SkRlmtEvtStatsClear(
2783 SK_AC *pAC, /* Adapter Context */
2784 SK_IOC IoC, /* I/O Context */
2785 SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
2786 {
2787 SK_U32 i;
2788 SK_RLMT_PORT *pRPort;
2789
2790 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2791 ("SK_RLMT_STATS_CLEAR Event BEGIN.\n"))
2792
2793 if (Para.Para32[1] != (SK_U32)-1) {
2794 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2795 ("Bad Parameter.\n"))
2796 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2797 ("SK_RLMT_STATS_CLEAR Event EMPTY.\n"))
2798 return;
2799 }
2800
2801 if (Para.Para32[0] >= pAC->Rlmt.NumNets) {
2802 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2803 ("Bad NetNumber %d.\n", Para.Para32[0]))
2804 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2805 ("SK_RLMT_STATS_CLEAR Event EMPTY.\n"))
2806 return;
2807 }
2808
2809 /* Clear statistics for logical and physical ports. */
2810 for (i = 0; i < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; i++) {
2811 pRPort =
2812 &pAC->Rlmt.Port[pAC->Rlmt.Net[Para.Para32[0]].Port[i]->PortNumber];
2813 pRPort->TxHelloCts = 0;
2814 pRPort->RxHelloCts = 0;
2815 pRPort->TxSpHelloReqCts = 0;
2816 pRPort->RxSpHelloCts = 0;
2817 }
2818
2819 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2820 ("SK_RLMT_STATS_CLEAR Event END.\n"))
2821 } /* SkRlmtEvtStatsClear */
2822
2823
2824 /******************************************************************************
2825 *
2826 * SkRlmtEvtStatsUpdate - STATS_UPDATE
2827 *
2828 * Description:
2829 * This routine handles STATS_UPDATE events.
2830 *
2831 * Context:
2832 * runtime, pageable?
2833 * may be called after SK_INIT_IO
2834 *
2835 * Returns:
2836 * Nothing
2837 */
2838 RLMT_STATIC void SkRlmtEvtStatsUpdate(
2839 SK_AC *pAC, /* Adapter Context */
2840 SK_IOC IoC, /* I/O Context */
2841 SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
2842 {
2843 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2844 ("SK_RLMT_STATS_UPDATE Event BEGIN.\n"))
2845
2846 if (Para.Para32[1] != (SK_U32)-1) {
2847 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2848 ("Bad Parameter.\n"))
2849 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2850 ("SK_RLMT_STATS_UPDATE Event EMPTY.\n"))
2851 return;
2852 }
2853
2854 if (Para.Para32[0] >= pAC->Rlmt.NumNets) {
2855 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2856 ("Bad NetNumber %d.\n", Para.Para32[0]))
2857 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2858 ("SK_RLMT_STATS_UPDATE Event EMPTY.\n"))
2859 return;
2860 }
2861
2862 /* Update statistics - currently always up-to-date. */
2863
2864 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2865 ("SK_RLMT_STATS_UPDATE Event END.\n"))
2866 } /* SkRlmtEvtStatsUpdate */
2867
2868
2869 /******************************************************************************
2870 *
2871 * SkRlmtEvtPrefportChange - PREFPORT_CHANGE
2872 *
2873 * Description:
2874 * This routine handles PREFPORT_CHANGE events.
2875 *
2876 * Context:
2877 * runtime, pageable?
2878 * may be called after SK_INIT_IO
2879 *
2880 * Returns:
2881 * Nothing
2882 */
2883 RLMT_STATIC void SkRlmtEvtPrefportChange(
2884 SK_AC *pAC, /* Adapter Context */
2885 SK_IOC IoC, /* I/O Context */
2886 SK_EVPARA Para) /* SK_U32 PortIndex; SK_U32 NetNumber */
2887 {
2888 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2889 ("SK_RLMT_PREFPORT_CHANGE to Port %d Event BEGIN.\n", Para.Para32[0]))
2890
2891 if (Para.Para32[1] >= pAC->Rlmt.NumNets) {
2892 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2893 ("Bad NetNumber %d.\n", Para.Para32[1]))
2894 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2895 ("SK_RLMT_PREFPORT_CHANGE Event EMPTY.\n"))
2896 return;
2897 }
2898
2899 /* 0xFFFFFFFF == auto-mode. */
2900 if (Para.Para32[0] == 0xFFFFFFFF) {
2901 pAC->Rlmt.Net[Para.Para32[1]].PrefPort = SK_RLMT_DEF_PREF_PORT;
2902 }
2903 else {
2904 if (Para.Para32[0] >= pAC->Rlmt.Net[Para.Para32[1]].NumPorts) {
2905 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E010, SKERR_RLMT_E010_MSG);
2906
2907 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2908 ("SK_RLMT_PREFPORT_CHANGE Event EMPTY.\n"))
2909 return;
2910 }
2911
2912 pAC->Rlmt.Net[Para.Para32[1]].PrefPort = Para.Para32[0];
2913 }
2914
2915 pAC->Rlmt.Net[Para.Para32[1]].Preference = Para.Para32[0];
2916
2917 if (pAC->Rlmt.Net[Para.Para32[1]].RlmtState != SK_RLMT_RS_INIT) {
2918 SkRlmtCheckSwitch(pAC, IoC, Para.Para32[1]);
2919 }
2920
2921 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2922 ("SK_RLMT_PREFPORT_CHANGE Event END.\n"))
2923 } /* SkRlmtEvtPrefportChange */
2924
2925
2926 /******************************************************************************
2927 *
2928 * SkRlmtEvtSetNets - SET_NETS
2929 *
2930 * Description:
2931 * This routine handles SET_NETS events.
2932 *
2933 * Context:
2934 * runtime, pageable?
2935 * may be called after SK_INIT_IO
2936 *
2937 * Returns:
2938 * Nothing
2939 */
2940 RLMT_STATIC void SkRlmtEvtSetNets(
2941 SK_AC *pAC, /* Adapter Context */
2942 SK_IOC IoC, /* I/O Context */
2943 SK_EVPARA Para) /* SK_U32 NumNets; SK_U32 -1 */
2944 {
2945 int i;
2946
2947 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2948 ("SK_RLMT_SET_NETS Event BEGIN.\n"))
2949
2950 if (Para.Para32[1] != (SK_U32)-1) {
2951 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2952 ("Bad Parameter.\n"))
2953 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2954 ("SK_RLMT_SET_NETS Event EMPTY.\n"))
2955 return;
2956 }
2957
2958 if (Para.Para32[0] == 0 || Para.Para32[0] > SK_MAX_NETS ||
2959 Para.Para32[0] > (SK_U32)pAC->GIni.GIMacsFound) {
2960 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2961 ("Bad number of nets: %d.\n", Para.Para32[0]))
2962 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2963 ("SK_RLMT_SET_NETS Event EMPTY.\n"))
2964 return;
2965 }
2966
2967 if (Para.Para32[0] == pAC->Rlmt.NumNets) { /* No change. */
2968 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2969 ("SK_RLMT_SET_NETS Event EMPTY.\n"))
2970 return;
2971 }
2972
2973 /* Entering and leaving dual mode only allowed while nets are stopped. */
2974 if (pAC->Rlmt.NetsStarted > 0) {
2975 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2976 ("Changing dual mode only allowed while all nets are stopped.\n"))
2977 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
2978 ("SK_RLMT_SET_NETS Event EMPTY.\n"))
2979 return;
2980 }
2981
2982 if (Para.Para32[0] == 1) {
2983 if (pAC->Rlmt.NumNets > 1) {
2984 /* Clear logical MAC addr from second net's active port. */
2985 (void)SkAddrOverride(pAC, IoC, pAC->Rlmt.Net[1].Port[pAC->Addr.
2986 Net[1].ActivePort]->PortNumber, NULL, SK_ADDR_CLEAR_LOGICAL);
2987 pAC->Rlmt.Net[1].NumPorts = 0;
2988 }
2989
2990 pAC->Rlmt.NumNets = Para.Para32[0];
2991 for (i = 0; (SK_U32)i < pAC->Rlmt.NumNets; i++) {
2992 pAC->Rlmt.Net[i].RlmtState = SK_RLMT_RS_INIT;
2993 pAC->Rlmt.Net[i].RootIdSet = SK_FALSE;
2994 pAC->Rlmt.Net[i].Preference = 0xFFFFFFFF; /* "Automatic" */
2995 pAC->Rlmt.Net[i].PrefPort = SK_RLMT_DEF_PREF_PORT;
2996 /* Just assuming. */
2997 pAC->Rlmt.Net[i].ActivePort = pAC->Rlmt.Net[i].PrefPort;
2998 pAC->Rlmt.Net[i].RlmtMode = SK_RLMT_DEF_MODE;
2999 pAC->Rlmt.Net[i].TimeoutValue = SK_RLMT_DEF_TO_VAL;
3000 pAC->Rlmt.Net[i].NetNumber = i;
3001 }
3002
3003 pAC->Rlmt.Port[1].Net= &pAC->Rlmt.Net[0];
3004 pAC->Rlmt.Net[0].NumPorts = pAC->GIni.GIMacsFound;
3005
3006 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_SET_NETS, Para);
3007
3008 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3009 ("RLMT: Changed to one net with two ports.\n"))
3010 }
3011 else if (Para.Para32[0] == 2) {
3012 pAC->Rlmt.Port[1].Net= &pAC->Rlmt.Net[1];
3013 pAC->Rlmt.Net[1].NumPorts = pAC->GIni.GIMacsFound - 1;
3014 pAC->Rlmt.Net[0].NumPorts =
3015 pAC->GIni.GIMacsFound - pAC->Rlmt.Net[1].NumPorts;
3016
3017 pAC->Rlmt.NumNets = Para.Para32[0];
3018 for (i = 0; (SK_U32)i < pAC->Rlmt.NumNets; i++) {
3019 pAC->Rlmt.Net[i].RlmtState = SK_RLMT_RS_INIT;
3020 pAC->Rlmt.Net[i].RootIdSet = SK_FALSE;
3021 pAC->Rlmt.Net[i].Preference = 0xFFFFFFFF; /* "Automatic" */
3022 pAC->Rlmt.Net[i].PrefPort = SK_RLMT_DEF_PREF_PORT;
3023 /* Just assuming. */
3024 pAC->Rlmt.Net[i].ActivePort = pAC->Rlmt.Net[i].PrefPort;
3025 pAC->Rlmt.Net[i].RlmtMode = SK_RLMT_DEF_MODE;
3026 pAC->Rlmt.Net[i].TimeoutValue = SK_RLMT_DEF_TO_VAL;
3027
3028 pAC->Rlmt.Net[i].NetNumber = i;
3029 }
3030
3031 /* Set logical MAC addr on second net's active port. */
3032 (void)SkAddrOverride(pAC, IoC, pAC->Rlmt.Net[1].Port[pAC->Addr.
3033 Net[1].ActivePort]->PortNumber, NULL, SK_ADDR_SET_LOGICAL);
3034
3035 SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_SET_NETS, Para);
3036
3037 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3038 ("RLMT: Changed to two nets with one port each.\n"))
3039 }
3040 else {
3041 /* Not implemented for more than two nets. */
3042 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3043 ("SetNets not implemented for more than two nets.\n"))
3044 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3045 ("SK_RLMT_SET_NETS Event EMPTY.\n"))
3046 return;
3047 }
3048
3049 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3050 ("SK_RLMT_SET_NETS Event END.\n"))
3051 } /* SkRlmtSetNets */
3052
3053
3054 /******************************************************************************
3055 *
3056 * SkRlmtEvtModeChange - MODE_CHANGE
3057 *
3058 * Description:
3059 * This routine handles MODE_CHANGE events.
3060 *
3061 * Context:
3062 * runtime, pageable?
3063 * may be called after SK_INIT_IO
3064 *
3065 * Returns:
3066 * Nothing
3067 */
3068 RLMT_STATIC void SkRlmtEvtModeChange(
3069 SK_AC *pAC, /* Adapter Context */
3070 SK_IOC IoC, /* I/O Context */
3071 SK_EVPARA Para) /* SK_U32 NewMode; SK_U32 NetNumber */
3072 {
3073 SK_EVPARA Para2;
3074 SK_U32 i;
3075 SK_U32 PrevRlmtMode;
3076
3077 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3078 ("SK_RLMT_MODE_CHANGE Event BEGIN.\n"))
3079
3080 if (Para.Para32[1] >= pAC->Rlmt.NumNets) {
3081 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3082 ("Bad NetNumber %d.\n", Para.Para32[1]))
3083 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3084 ("SK_RLMT_MODE_CHANGE Event EMPTY.\n"))
3085 return;
3086 }
3087
3088 Para.Para32[0] |= SK_RLMT_CHECK_LINK;
3089
3090 if ((pAC->Rlmt.Net[Para.Para32[1]].NumPorts == 1) &&
3091 Para.Para32[0] != SK_RLMT_MODE_CLS) {
3092 pAC->Rlmt.Net[Para.Para32[1]].RlmtMode = SK_RLMT_MODE_CLS;
3093 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3094 ("Forced RLMT mode to CLS on single port net.\n"))
3095 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3096 ("SK_RLMT_MODE_CHANGE Event EMPTY.\n"))
3097 return;
3098 }
3099
3100 /* Update RLMT mode. */
3101 PrevRlmtMode = pAC->Rlmt.Net[Para.Para32[1]].RlmtMode;
3102 pAC->Rlmt.Net[Para.Para32[1]].RlmtMode = Para.Para32[0];
3103
3104 if ((PrevRlmtMode & SK_RLMT_CHECK_LOC_LINK) !=
3105 (pAC->Rlmt.Net[Para.Para32[1]].RlmtMode & SK_RLMT_CHECK_LOC_LINK)) {
3106 /* SK_RLMT_CHECK_LOC_LINK bit changed. */
3107 if ((PrevRlmtMode & SK_RLMT_CHECK_OTHERS) == 0 &&
3108 pAC->Rlmt.Net[Para.Para32[1]].NumPorts > 1 &&
3109 pAC->Rlmt.Net[Para.Para32[1]].PortsUp >= 1) {
3110 /* 20001207 RA: Was "PortsUp == 1". */
3111 Para2.Para32[0] = Para.Para32[1];
3112 Para2.Para32[1] = (SK_U32)-1;
3113 SkTimerStart(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[1]].LocTimer,
3114 pAC->Rlmt.Net[Para.Para32[1]].TimeoutValue,
3115 SKGE_RLMT, SK_RLMT_TIM, Para2);
3116 }
3117 }
3118
3119 if ((PrevRlmtMode & SK_RLMT_CHECK_SEG) !=
3120 (pAC->Rlmt.Net[Para.Para32[1]].RlmtMode & SK_RLMT_CHECK_SEG)) {
3121 /* SK_RLMT_CHECK_SEG bit changed. */
3122 for (i = 0; i < pAC->Rlmt.Net[Para.Para32[1]].NumPorts; i++) {
3123 (void)SkAddrMcClear(pAC, IoC,
3124 pAC->Rlmt.Net[Para.Para32[1]].Port[i]->PortNumber,
3125 SK_ADDR_PERMANENT | SK_MC_SW_ONLY);
3126
3127 /* Add RLMT MC address. */
3128 (void)SkAddrMcAdd(pAC, IoC,
3129 pAC->Rlmt.Net[Para.Para32[1]].Port[i]->PortNumber,
3130 &SkRlmtMcAddr, SK_ADDR_PERMANENT);
3131
3132 if ((pAC->Rlmt.Net[Para.Para32[1]].RlmtMode &
3133 SK_RLMT_CHECK_SEG) != 0) {
3134 /* Add BPDU MC address. */
3135 (void)SkAddrMcAdd(pAC, IoC,
3136 pAC->Rlmt.Net[Para.Para32[1]].Port[i]->PortNumber,
3137 &BridgeMcAddr, SK_ADDR_PERMANENT);
3138
3139 if (pAC->Rlmt.Net[Para.Para32[1]].RlmtState != SK_RLMT_RS_INIT) {
3140 if (!pAC->Rlmt.Net[Para.Para32[1]].Port[i]->LinkDown &&
3141 (Para2.pParaPtr = SkRlmtBuildSpanningTreePacket(
3142 pAC, IoC, i)) != NULL) {
3143 pAC->Rlmt.Net[Para.Para32[1]].Port[i]->RootIdSet =
3144 SK_FALSE;
3145 SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para2);
3146 }
3147 }
3148 }
3149 (void)SkAddrMcUpdate(pAC, IoC,
3150 pAC->Rlmt.Net[Para.Para32[1]].Port[i]->PortNumber);
3151 } /* for ... */
3152
3153 if ((pAC->Rlmt.Net[Para.Para32[1]].RlmtMode & SK_RLMT_CHECK_SEG) != 0) {
3154 Para2.Para32[0] = Para.Para32[1];
3155 Para2.Para32[1] = (SK_U32)-1;
3156 SkTimerStart(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[1]].SegTimer,
3157 SK_RLMT_SEG_TO_VAL, SKGE_RLMT, SK_RLMT_SEG_TIM, Para2);
3158 }
3159 } /* SK_RLMT_CHECK_SEG bit changed. */
3160
3161 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3162 ("SK_RLMT_MODE_CHANGE Event END.\n"))
3163 } /* SkRlmtEvtModeChange */
3164
3165
3166 /******************************************************************************
3167 *
3168 * SkRlmtEvent - a PORT- or an RLMT-specific event happened
3169 *
3170 * Description:
3171 * This routine calls subroutines to handle PORT- and RLMT-specific events.
3172 *
3173 * Context:
3174 * runtime, pageable?
3175 * may be called after SK_INIT_IO
3176 *
3177 * Returns:
3178 * 0
3179 */
3180 int SkRlmtEvent(
3181 SK_AC *pAC, /* Adapter Context */
3182 SK_IOC IoC, /* I/O Context */
3183 SK_U32 Event, /* Event code */
3184 SK_EVPARA Para) /* Event-specific parameter */
3185 {
3186 switch (Event) {
3187
3188 /* ----- PORT events ----- */
3189
3190 case SK_RLMT_PORTSTART_TIM: /* From RLMT via TIME. */
3191 SkRlmtEvtPortStartTim(pAC, IoC, Para);
3192 break;
3193 case SK_RLMT_LINK_UP: /* From SIRQ. */
3194 SkRlmtEvtLinkUp(pAC, IoC, Para);
3195 break;
3196 case SK_RLMT_PORTUP_TIM: /* From RLMT via TIME. */
3197 SkRlmtEvtPortUpTim(pAC, IoC, Para);
3198 break;
3199 case SK_RLMT_PORTDOWN: /* From RLMT. */
3200 case SK_RLMT_PORTDOWN_RX_TIM: /* From RLMT via TIME. */
3201 case SK_RLMT_PORTDOWN_TX_TIM: /* From RLMT via TIME. */
3202 SkRlmtEvtPortDownX(pAC, IoC, Event, Para);
3203 break;
3204 case SK_RLMT_LINK_DOWN: /* From SIRQ. */
3205 SkRlmtEvtLinkDown(pAC, IoC, Para);
3206 break;
3207 case SK_RLMT_PORT_ADDR: /* From ADDR. */
3208 SkRlmtEvtPortAddr(pAC, IoC, Para);
3209 break;
3210
3211 /* ----- RLMT events ----- */
3212
3213 case SK_RLMT_START: /* From DRV. */
3214 SkRlmtEvtStart(pAC, IoC, Para);
3215 break;
3216 case SK_RLMT_STOP: /* From DRV. */
3217 SkRlmtEvtStop(pAC, IoC, Para);
3218 break;
3219 case SK_RLMT_TIM: /* From RLMT via TIME. */
3220 SkRlmtEvtTim(pAC, IoC, Para);
3221 break;
3222 case SK_RLMT_SEG_TIM:
3223 SkRlmtEvtSegTim(pAC, IoC, Para);
3224 break;
3225 case SK_RLMT_PACKET_RECEIVED: /* From DRV. */
3226 SkRlmtEvtPacketRx(pAC, IoC, Para);
3227 break;
3228 case SK_RLMT_STATS_CLEAR: /* From PNMI. */
3229 SkRlmtEvtStatsClear(pAC, IoC, Para);
3230 break;
3231 case SK_RLMT_STATS_UPDATE: /* From PNMI. */
3232 SkRlmtEvtStatsUpdate(pAC, IoC, Para);
3233 break;
3234 case SK_RLMT_PREFPORT_CHANGE: /* From PNMI. */
3235 SkRlmtEvtPrefportChange(pAC, IoC, Para);
3236 break;
3237 case SK_RLMT_MODE_CHANGE: /* From PNMI. */
3238 SkRlmtEvtModeChange(pAC, IoC, Para);
3239 break;
3240 case SK_RLMT_SET_NETS: /* From DRV. */
3241 SkRlmtEvtSetNets(pAC, IoC, Para);
3242 break;
3243
3244 /* ----- Unknown events ----- */
3245
3246 default: /* Create error log entry. */
3247 SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
3248 ("Unknown RLMT Event %d.\n", Event))
3249 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E003, SKERR_RLMT_E003_MSG);
3250 break;
3251 } /* switch() */
3252
3253 return (0);
3254 } /* SkRlmtEvent */
3255
3256 #ifdef __cplusplus
3257 }
3258 #endif /* __cplusplus */
kernel-based virtual machine