upstream u-boot with additional patches for our devices/boards:
https://lists.denx.de/pipermail/u-boot/2017-March/282789.html (AXP crashes) ;
Gbit ethernet patch for some LIME2 revisions ;
with SPI flash support
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3504 lines
101 KiB
3504 lines
101 KiB
/******************************************************************************
|
|
*
|
|
* Name: skrlmt.c
|
|
* Project: GEnesis, PCI Gigabit Ethernet Adapter
|
|
* Version: $Revision: 1.68 $
|
|
* Date: $Date: 2003/01/31 15:26:56 $
|
|
* Purpose: Manage links on SK-NET Adapters, esp. redundant ones.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* (C)Copyright 1998-2001 SysKonnect GmbH.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* The information in this file is provided "AS IS" without warranty.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* History:
|
|
*
|
|
* $Log: skrlmt.c,v $
|
|
* Revision 1.68 2003/01/31 15:26:56 rschmidt
|
|
* Added init for local variables in RlmtInit().
|
|
*
|
|
* Revision 1.67 2003/01/31 14:12:41 mkunz
|
|
* single port adapter runs now with two identical MAC addresses
|
|
*
|
|
* Revision 1.66 2002/09/23 15:14:19 rwahl
|
|
* - Reset broadcast timestamp on link down.
|
|
* - Editorial corrections.
|
|
*
|
|
* Revision 1.65 2002/07/22 14:29:48 rwahl
|
|
* - Removed BRK statement from debug check.
|
|
*
|
|
* Revision 1.64 2001/11/28 19:36:14 rwahl
|
|
* - RLMT Packets sent to an invalid MAC address in CLP/CLPSS mode
|
|
* (#10650).
|
|
* - Reworked fix for port switching in CLS mode (#10639)
|
|
* (no dependency to RLMT module).
|
|
* - Enabled dbg output for entry/exit of event functions.
|
|
* - Editorial changes.
|
|
*
|
|
* Revision 1.63 2001/10/26 07:53:18 afischer
|
|
* Port switching bug in `check local link` mode
|
|
*
|
|
* Revision 1.62 2001/07/03 12:16:30 mkunz
|
|
* New Flag ChgBcPrio (Change priority of last broadcast received)
|
|
*
|
|
* Revision 1.61 2001/03/14 12:52:08 rassmann
|
|
* Fixed reporting of active port up/down to PNMI.
|
|
*
|
|
* Revision 1.60 2001/02/21 16:02:25 gklug
|
|
* fix: when RLMT starts set Active Port for PNMI
|
|
*
|
|
* Revision 1.59 2001/02/16 14:38:19 rassmann
|
|
* Initializing some pointers earlier in the init phase.
|
|
* Rx Mbufs are freed if the net which they belong to is stopped.
|
|
*
|
|
* Revision 1.58 2001/02/14 14:06:31 rassmann
|
|
* Editorial changes.
|
|
*
|
|
* Revision 1.57 2001/02/05 14:25:26 rassmann
|
|
* Prepared RLMT for transparent operation.
|
|
*
|
|
* Revision 1.56 2001/01/30 10:29:09 rassmann
|
|
* Not checking switching befor RlmtStart.
|
|
* Editorial changes.
|
|
*
|
|
* Revision 1.55 2001/01/22 13:41:38 rassmann
|
|
* Supporting two nets on dual-port adapters.
|
|
*
|
|
* Revision 1.54 2000/11/30 13:25:07 rassmann
|
|
* Setting SK_TICK_INCR to 1 by default.
|
|
*
|
|
* Revision 1.53 2000/11/30 10:48:07 cgoos
|
|
* Changed definition of SK_RLMT_BC_DELTA.
|
|
*
|
|
* Revision 1.52 2000/11/27 12:50:03 rassmann
|
|
* Checking ports after receiving broadcasts.
|
|
*
|
|
* Revision 1.51 2000/11/17 08:58:00 rassmann
|
|
* Moved CheckSwitch from SK_RLMT_PACKET_RECEIVED to SK_RLMT_TIM event.
|
|
*
|
|
* Revision 1.50 2000/11/09 12:24:34 rassmann
|
|
* Indicating that segmentation check is not running anymore after
|
|
* SkRlmtCheckSeg().
|
|
* Restarting segmentation timer after segmentation log.
|
|
* Editorial changes.
|
|
*
|
|
* Revision 1.49 1999/11/22 13:38:02 cgoos
|
|
* Changed license header to GPL.
|
|
* Added initialization to some variables to avoid compiler warnings.
|
|
*
|
|
* Revision 1.48 1999/10/04 14:01:17 rassmann
|
|
* Corrected reaction to reception of BPDU frames (#10441).
|
|
*
|
|
* Revision 1.47 1999/07/20 12:53:36 rassmann
|
|
* Fixed documentation errors for lookahead macros.
|
|
*
|
|
* Revision 1.46 1999/05/28 13:29:16 rassmann
|
|
* Replaced C++-style comment.
|
|
*
|
|
* Revision 1.45 1999/05/28 13:28:08 rassmann
|
|
* Corrected syntax error (xxx).
|
|
*
|
|
* Revision 1.44 1999/05/28 11:15:54 rassmann
|
|
* Changed behaviour to reflect Design Spec v1.2.
|
|
* Controlling Link LED(s).
|
|
* Introduced RLMT Packet Version field in RLMT Packet.
|
|
* Newstyle lookahead macros (checking meta-information before looking at
|
|
* the packet).
|
|
*
|
|
* Revision 1.43 1999/01/28 13:12:43 rassmann
|
|
* Corrected Lookahead (bug introduced in previous Rev.).
|
|
*
|
|
* Revision 1.42 1999/01/28 12:50:41 rassmann
|
|
* Not using broadcast time stamps in CheckLinkState mode.
|
|
*
|
|
* Revision 1.41 1999/01/27 14:13:02 rassmann
|
|
* Monitoring broadcast traffic.
|
|
* Switching more reliably and not too early if switch is
|
|
* configured for spanning tree.
|
|
*
|
|
* Revision 1.40 1999/01/22 13:17:30 rassmann
|
|
* Informing PNMI of NET_UP.
|
|
* Clearing RLMT multicast addresses before setting them for the first time.
|
|
* Reporting segmentation earlier, setting a "quiet time"
|
|
* after a report.
|
|
*
|
|
* Revision 1.39 1998/12/10 15:29:53 rassmann
|
|
* Corrected SuspectStatus in SkRlmtBuildCheckChain().
|
|
* Corrected CHECK_SEG mode.
|
|
*
|
|
* Revision 1.38 1998/12/08 13:11:23 rassmann
|
|
* Stopping SegTimer at RlmtStop.
|
|
*
|
|
* Revision 1.37 1998/12/07 16:51:42 rassmann
|
|
* Corrected comments.
|
|
*
|
|
* Revision 1.36 1998/12/04 10:58:56 rassmann
|
|
* Setting next pointer to NULL when receiving.
|
|
*
|
|
* Revision 1.35 1998/12/03 16:12:42 rassmann
|
|
* Ignoring/correcting illegal PrefPort values.
|
|
*
|
|
* Revision 1.34 1998/12/01 11:45:35 rassmann
|
|
* Code cleanup.
|
|
*
|
|
* Revision 1.33 1998/12/01 10:29:32 rassmann
|
|
* Starting standby ports before getting the net up.
|
|
* Checking if a port is started when the link comes up.
|
|
*
|
|
* Revision 1.32 1998/11/30 16:19:50 rassmann
|
|
* New default for PortNoRx.
|
|
*
|
|
* Revision 1.31 1998/11/27 19:17:13 rassmann
|
|
* Corrected handling of LINK_DOWN coming shortly after LINK_UP.
|
|
*
|
|
* Revision 1.30 1998/11/24 12:37:31 rassmann
|
|
* Implemented segmentation check.
|
|
*
|
|
* Revision 1.29 1998/11/18 13:04:32 rassmann
|
|
* Secured PortUpTimer event.
|
|
* Waiting longer before starting standby port(s).
|
|
*
|
|
* Revision 1.28 1998/11/17 13:43:04 rassmann
|
|
* Handling (logical) tx failure.
|
|
* Sending packet on logical address after PORT_SWITCH.
|
|
*
|
|
* Revision 1.27 1998/11/13 17:09:50 rassmann
|
|
* Secured some events against being called in wrong state.
|
|
*
|
|
* Revision 1.26 1998/11/13 16:56:54 rassmann
|
|
* Added macro version of SkRlmtLookaheadPacket.
|
|
*
|
|
* Revision 1.25 1998/11/06 18:06:04 rassmann
|
|
* Corrected timing when RLMT checks fail.
|
|
* Clearing tx counter earlier in periodical checks.
|
|
*
|
|
* Revision 1.24 1998/11/05 10:37:27 rassmann
|
|
* Checking destination address in Lookahead.
|
|
*
|
|
* Revision 1.23 1998/11/03 13:53:49 rassmann
|
|
* RLMT should switch now (at least in mode 3).
|
|
*
|
|
* Revision 1.22 1998/10/29 14:34:49 rassmann
|
|
* Clearing SK_RLMT struct at startup.
|
|
* Initializing PortsUp during SK_RLMT_START.
|
|
*
|
|
* Revision 1.21 1998/10/28 11:30:17 rassmann
|
|
* Default mode is now SK_RLMT_CHECK_LOC_LINK.
|
|
*
|
|
* Revision 1.20 1998/10/26 16:02:03 rassmann
|
|
* Ignoring LINK_DOWN for links that are down.
|
|
*
|
|
* Revision 1.19 1998/10/22 15:54:01 rassmann
|
|
* Corrected EtherLen.
|
|
* Starting Link Check when second port comes up.
|
|
*
|
|
* Revision 1.18 1998/10/22 11:39:50 rassmann
|
|
* Corrected signed/unsigned mismatches.
|
|
* Corrected receive list handling and address recognition.
|
|
*
|
|
* Revision 1.17 1998/10/19 17:01:20 rassmann
|
|
* More detailed checking of received packets.
|
|
*
|
|
* Revision 1.16 1998/10/15 15:16:34 rassmann
|
|
* Finished Spanning Tree checking.
|
|
* Checked with lint.
|
|
*
|
|
* Revision 1.15 1998/09/24 19:16:07 rassmann
|
|
* Code cleanup.
|
|
* Introduced Timer for PORT_DOWN due to no RX.
|
|
*
|
|
* Revision 1.14 1998/09/18 20:27:14 rassmann
|
|
* Added address override.
|
|
*
|
|
* Revision 1.13 1998/09/16 11:31:48 rassmann
|
|
* Including skdrv1st.h again. :(
|
|
*
|
|
* Revision 1.12 1998/09/16 11:09:50 rassmann
|
|
* Syntax corrections.
|
|
*
|
|
* Revision 1.11 1998/09/15 12:32:03 rassmann
|
|
* Syntax correction.
|
|
*
|
|
* Revision 1.10 1998/09/15 11:28:49 rassmann
|
|
* Syntax corrections.
|
|
*
|
|
* Revision 1.9 1998/09/14 17:07:37 rassmann
|
|
* Added code for port checking via LAN.
|
|
* Changed Mbuf definition.
|
|
*
|
|
* Revision 1.8 1998/09/07 11:14:14 rassmann
|
|
* Syntax corrections.
|
|
*
|
|
* Revision 1.7 1998/09/07 09:06:07 rassmann
|
|
* Syntax corrections.
|
|
*
|
|
* Revision 1.6 1998/09/04 19:41:33 rassmann
|
|
* Syntax corrections.
|
|
* Started entering code for checking local links.
|
|
*
|
|
* Revision 1.5 1998/09/04 12:14:27 rassmann
|
|
* Interface cleanup.
|
|
*
|
|
* Revision 1.4 1998/09/02 16:55:28 rassmann
|
|
* Updated to reflect new DRV/HWAC/RLMT interface.
|
|
*
|
|
* Revision 1.3 1998/08/27 14:29:03 rassmann
|
|
* Code cleanup.
|
|
*
|
|
* Revision 1.2 1998/08/27 14:26:24 rassmann
|
|
* Updated interface.
|
|
*
|
|
* Revision 1.1 1998/08/21 08:26:49 rassmann
|
|
* First public version.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Description:
|
|
*
|
|
* This module contains code for Link ManagemenT (LMT) of SK-NET Adapters.
|
|
* It is mainly intended for adapters with more than one link.
|
|
* For such adapters, this module realizes Redundant Link ManagemenT (RLMT).
|
|
*
|
|
* Include File Hierarchy:
|
|
*
|
|
* "skdrv1st.h"
|
|
* "skdrv2nd.h"
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include <config.h>
|
|
|
|
#ifndef lint
|
|
static const char SysKonnectFileId[] =
|
|
"@(#) $Id: skrlmt.c,v 1.68 2003/01/31 15:26:56 rschmidt Exp $ (C) SysKonnect.";
|
|
#endif /* !defined(lint) */
|
|
|
|
#define __SKRLMT_C
|
|
|
|
#ifdef __cplusplus
|
|
#error C++ is not yet supported.
|
|
extern "C" {
|
|
#endif /* cplusplus */
|
|
|
|
#include "h/skdrv1st.h"
|
|
#include "h/skdrv2nd.h"
|
|
|
|
/* defines ********************************************************************/
|
|
|
|
#ifndef SK_HWAC_LINK_LED
|
|
#define SK_HWAC_LINK_LED(a,b,c,d)
|
|
#endif /* !defined(SK_HWAC_LINK_LED) */
|
|
|
|
#ifndef DEBUG
|
|
#define RLMT_STATIC static
|
|
#else /* DEBUG */
|
|
#define RLMT_STATIC
|
|
|
|
#ifndef SK_LITTLE_ENDIAN
|
|
/* First 32 bits */
|
|
#define OFFS_LO32 1
|
|
|
|
/* Second 32 bits */
|
|
#define OFFS_HI32 0
|
|
#else /* SK_LITTLE_ENDIAN */
|
|
/* First 32 bits */
|
|
#define OFFS_LO32 0
|
|
|
|
/* Second 32 bits */
|
|
#define OFFS_HI32 1
|
|
#endif /* SK_LITTLE_ENDIAN */
|
|
|
|
#endif /* DEBUG */
|
|
|
|
/* ----- Private timeout values ----- */
|
|
|
|
#define SK_RLMT_MIN_TO_VAL 125000 /* 1/8 sec. */
|
|
#define SK_RLMT_DEF_TO_VAL 1000000 /* 1 sec. */
|
|
#define SK_RLMT_PORTDOWN_TIM_VAL 900000 /* another 0.9 sec. */
|
|
#define SK_RLMT_PORTSTART_TIM_VAL 100000 /* 0.1 sec. */
|
|
#define SK_RLMT_PORTUP_TIM_VAL 2500000 /* 2.5 sec. */
|
|
#define SK_RLMT_SEG_TO_VAL 900000000 /* 15 min. */
|
|
|
|
/* Assume tick counter increment is 1 - may be set OS-dependent. */
|
|
#ifndef SK_TICK_INCR
|
|
#define SK_TICK_INCR SK_CONSTU64(1)
|
|
#endif /* !defined(SK_TICK_INCR) */
|
|
|
|
/*
|
|
* Amount that a time stamp must be later to be recognized as "substantially
|
|
* later". This is about 1/128 sec, but above 1 tick counter increment.
|
|
*/
|
|
#define SK_RLMT_BC_DELTA (1 + ((SK_TICKS_PER_SEC >> 7) > SK_TICK_INCR ? \
|
|
(SK_TICKS_PER_SEC >> 7) : SK_TICK_INCR))
|
|
|
|
/* ----- Private RLMT defaults ----- */
|
|
|
|
#define SK_RLMT_DEF_PREF_PORT 0 /* "Lower" port. */
|
|
#define SK_RLMT_DEF_MODE SK_RLMT_CHECK_LINK /* Default RLMT Mode. */
|
|
|
|
/* ----- Private RLMT checking states ----- */
|
|
|
|
#define SK_RLMT_RCS_SEG 1 /* RLMT Check State: check seg. */
|
|
#define SK_RLMT_RCS_START_SEG 2 /* RLMT Check State: start check seg. */
|
|
#define SK_RLMT_RCS_SEND_SEG 4 /* RLMT Check State: send BPDU packet */
|
|
#define SK_RLMT_RCS_REPORT_SEG 8 /* RLMT Check State: report seg. */
|
|
|
|
/* ----- Private PORT checking states ----- */
|
|
|
|
#define SK_RLMT_PCS_TX 1 /* Port Check State: check tx. */
|
|
#define SK_RLMT_PCS_RX 2 /* Port Check State: check rx. */
|
|
|
|
/* ----- Private PORT events ----- */
|
|
|
|
/* Note: Update simulation when changing these. */
|
|
#define SK_RLMT_PORTSTART_TIM 1100 /* Port start timeout. */
|
|
#define SK_RLMT_PORTUP_TIM 1101 /* Port can now go up. */
|
|
#define SK_RLMT_PORTDOWN_RX_TIM 1102 /* Port did not receive once ... */
|
|
#define SK_RLMT_PORTDOWN 1103 /* Port went down. */
|
|
#define SK_RLMT_PORTDOWN_TX_TIM 1104 /* Partner did not receive ... */
|
|
|
|
/* ----- Private RLMT events ----- */
|
|
|
|
/* Note: Update simulation when changing these. */
|
|
#define SK_RLMT_TIM 2100 /* RLMT timeout. */
|
|
#define SK_RLMT_SEG_TIM 2101 /* RLMT segmentation check timeout. */
|
|
|
|
#define TO_SHORTEN(tim) ((tim) / 2)
|
|
|
|
/* Error numbers and messages. */
|
|
#define SKERR_RLMT_E001 (SK_ERRBASE_RLMT + 0)
|
|
#define SKERR_RLMT_E001_MSG "No Packet."
|
|
#define SKERR_RLMT_E002 (SKERR_RLMT_E001 + 1)
|
|
#define SKERR_RLMT_E002_MSG "Short Packet."
|
|
#define SKERR_RLMT_E003 (SKERR_RLMT_E002 + 1)
|
|
#define SKERR_RLMT_E003_MSG "Unknown RLMT event."
|
|
#define SKERR_RLMT_E004 (SKERR_RLMT_E003 + 1)
|
|
#define SKERR_RLMT_E004_MSG "PortsUp incorrect."
|
|
#define SKERR_RLMT_E005 (SKERR_RLMT_E004 + 1)
|
|
#define SKERR_RLMT_E005_MSG \
|
|
"Net seems to be segmented (different root bridges are reported on the ports)."
|
|
#define SKERR_RLMT_E006 (SKERR_RLMT_E005 + 1)
|
|
#define SKERR_RLMT_E006_MSG "Duplicate MAC Address detected."
|
|
#define SKERR_RLMT_E007 (SKERR_RLMT_E006 + 1)
|
|
#define SKERR_RLMT_E007_MSG "LinksUp incorrect."
|
|
#define SKERR_RLMT_E008 (SKERR_RLMT_E007 + 1)
|
|
#define SKERR_RLMT_E008_MSG "Port not started but link came up."
|
|
#define SKERR_RLMT_E009 (SKERR_RLMT_E008 + 1)
|
|
#define SKERR_RLMT_E009_MSG "Corrected illegal setting of Preferred Port."
|
|
#define SKERR_RLMT_E010 (SKERR_RLMT_E009 + 1)
|
|
#define SKERR_RLMT_E010_MSG "Ignored illegal Preferred Port."
|
|
|
|
/* LLC field values. */
|
|
#define LLC_COMMAND_RESPONSE_BIT 1
|
|
#define LLC_TEST_COMMAND 0xE3
|
|
#define LLC_UI 0x03
|
|
|
|
/* RLMT Packet fields. */
|
|
#define SK_RLMT_DSAP 0
|
|
#define SK_RLMT_SSAP 0
|
|
#define SK_RLMT_CTRL (LLC_TEST_COMMAND)
|
|
#define SK_RLMT_INDICATOR0 0x53 /* S */
|
|
#define SK_RLMT_INDICATOR1 0x4B /* K */
|
|
#define SK_RLMT_INDICATOR2 0x2D /* - */
|
|
#define SK_RLMT_INDICATOR3 0x52 /* R */
|
|
#define SK_RLMT_INDICATOR4 0x4C /* L */
|
|
#define SK_RLMT_INDICATOR5 0x4D /* M */
|
|
#define SK_RLMT_INDICATOR6 0x54 /* T */
|
|
#define SK_RLMT_PACKET_VERSION 0
|
|
|
|
/* RLMT SPT Flag values. */
|
|
#define SK_RLMT_SPT_FLAG_CHANGE 0x01
|
|
#define SK_RLMT_SPT_FLAG_CHANGE_ACK 0x80
|
|
|
|
/* RLMT SPT Packet fields. */
|
|
#define SK_RLMT_SPT_DSAP 0x42
|
|
#define SK_RLMT_SPT_SSAP 0x42
|
|
#define SK_RLMT_SPT_CTRL (LLC_UI)
|
|
#define SK_RLMT_SPT_PROTOCOL_ID0 0x00
|
|
#define SK_RLMT_SPT_PROTOCOL_ID1 0x00
|
|
#define SK_RLMT_SPT_PROTOCOL_VERSION_ID 0x00
|
|
#define SK_RLMT_SPT_BPDU_TYPE 0x00
|
|
#define SK_RLMT_SPT_FLAGS 0x00 /* ?? */
|
|
#define SK_RLMT_SPT_ROOT_ID0 0xFF /* Lowest possible priority. */
|
|
#define SK_RLMT_SPT_ROOT_ID1 0xFF /* Lowest possible priority. */
|
|
|
|
/* Remaining 6 bytes will be the current port address. */
|
|
#define SK_RLMT_SPT_ROOT_PATH_COST0 0x00
|
|
#define SK_RLMT_SPT_ROOT_PATH_COST1 0x00
|
|
#define SK_RLMT_SPT_ROOT_PATH_COST2 0x00
|
|
#define SK_RLMT_SPT_ROOT_PATH_COST3 0x00
|
|
#define SK_RLMT_SPT_BRIDGE_ID0 0xFF /* Lowest possible priority. */
|
|
#define SK_RLMT_SPT_BRIDGE_ID1 0xFF /* Lowest possible priority. */
|
|
|
|
/* Remaining 6 bytes will be the current port address. */
|
|
#define SK_RLMT_SPT_PORT_ID0 0xFF /* Lowest possible priority. */
|
|
#define SK_RLMT_SPT_PORT_ID1 0xFF /* Lowest possible priority. */
|
|
#define SK_RLMT_SPT_MSG_AGE0 0x00
|
|
#define SK_RLMT_SPT_MSG_AGE1 0x00
|
|
#define SK_RLMT_SPT_MAX_AGE0 0x00
|
|
#define SK_RLMT_SPT_MAX_AGE1 0xFF
|
|
#define SK_RLMT_SPT_HELLO_TIME0 0x00
|
|
#define SK_RLMT_SPT_HELLO_TIME1 0xFF
|
|
#define SK_RLMT_SPT_FWD_DELAY0 0x00
|
|
#define SK_RLMT_SPT_FWD_DELAY1 0x40
|
|
|
|
/* Size defines. */
|
|
#define SK_RLMT_MIN_PACKET_SIZE 34
|
|
#define SK_RLMT_MAX_PACKET_SIZE (SK_RLMT_MAX_TX_BUF_SIZE)
|
|
#define SK_PACKET_DATA_LEN (SK_RLMT_MAX_PACKET_SIZE - \
|
|
SK_RLMT_MIN_PACKET_SIZE)
|
|
|
|
/* ----- RLMT packet types ----- */
|
|
#define SK_PACKET_ANNOUNCE 1 /* Port announcement. */
|
|
#define SK_PACKET_ALIVE 2 /* Alive packet to port. */
|
|
#define SK_PACKET_ADDR_CHANGED 3 /* Port address changed. */
|
|
#define SK_PACKET_CHECK_TX 4 /* Check your tx line. */
|
|
|
|
#ifdef SK_LITTLE_ENDIAN
|
|
#define SK_U16_TO_NETWORK_ORDER(Val,Addr) { \
|
|
SK_U8 *_Addr = (SK_U8*)(Addr); \
|
|
SK_U16 _Val = (SK_U16)(Val); \
|
|
*_Addr++ = (SK_U8)(_Val >> 8); \
|
|
*_Addr = (SK_U8)(_Val & 0xFF); \
|
|
}
|
|
#endif /* SK_LITTLE_ENDIAN */
|
|
|
|
#ifdef SK_BIG_ENDIAN
|
|
#define SK_U16_TO_NETWORK_ORDER(Val,Addr) (*(SK_U16*)(Addr) = (SK_U16)(Val))
|
|
#endif /* SK_BIG_ENDIAN */
|
|
|
|
#define AUTONEG_FAILED SK_FALSE
|
|
#define AUTONEG_SUCCESS SK_TRUE
|
|
|
|
|
|
/* typedefs *******************************************************************/
|
|
|
|
/* RLMT packet. Length: SK_RLMT_MAX_PACKET_SIZE (60) bytes. */
|
|
typedef struct s_RlmtPacket {
|
|
SK_U8 DstAddr[SK_MAC_ADDR_LEN];
|
|
SK_U8 SrcAddr[SK_MAC_ADDR_LEN];
|
|
SK_U8 TypeLen[2];
|
|
SK_U8 DSap;
|
|
SK_U8 SSap;
|
|
SK_U8 Ctrl;
|
|
SK_U8 Indicator[7];
|
|
SK_U8 RlmtPacketType[2];
|
|
SK_U8 Align1[2];
|
|
SK_U8 Random[4]; /* Random value of requesting(!) station. */
|
|
SK_U8 RlmtPacketVersion[2]; /* RLMT Packet version. */
|
|
SK_U8 Data[SK_PACKET_DATA_LEN];
|
|
} SK_RLMT_PACKET;
|
|
|
|
typedef struct s_SpTreeRlmtPacket {
|
|
SK_U8 DstAddr[SK_MAC_ADDR_LEN];
|
|
SK_U8 SrcAddr[SK_MAC_ADDR_LEN];
|
|
SK_U8 TypeLen[2];
|
|
SK_U8 DSap;
|
|
SK_U8 SSap;
|
|
SK_U8 Ctrl;
|
|
SK_U8 ProtocolId[2];
|
|
SK_U8 ProtocolVersionId;
|
|
SK_U8 BpduType;
|
|
SK_U8 Flags;
|
|
SK_U8 RootId[8];
|
|
SK_U8 RootPathCost[4];
|
|
SK_U8 BridgeId[8];
|
|
SK_U8 PortId[2];
|
|
SK_U8 MessageAge[2];
|
|
SK_U8 MaxAge[2];
|
|
SK_U8 HelloTime[2];
|
|
SK_U8 ForwardDelay[2];
|
|
} SK_SPTREE_PACKET;
|
|
|
|
/* global variables ***********************************************************/
|
|
|
|
SK_MAC_ADDR SkRlmtMcAddr = {{0x01, 0x00, 0x5A, 0x52, 0x4C, 0x4D}};
|
|
SK_MAC_ADDR BridgeMcAddr = {{0x01, 0x80, 0xC2, 0x00, 0x00, 0x00}};
|
|
SK_MAC_ADDR BcAddr = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
|
|
|
|
/* local variables ************************************************************/
|
|
|
|
/* None. */
|
|
|
|
/* functions ******************************************************************/
|
|
|
|
RLMT_STATIC void SkRlmtCheckSwitch(
|
|
SK_AC *pAC,
|
|
SK_IOC IoC,
|
|
SK_U32 NetIdx);
|
|
RLMT_STATIC void SkRlmtCheckSeg(
|
|
SK_AC *pAC,
|
|
SK_IOC IoC,
|
|
SK_U32 NetIdx);
|
|
RLMT_STATIC void SkRlmtEvtSetNets(
|
|
SK_AC *pAC,
|
|
SK_IOC IoC,
|
|
SK_EVPARA Para);
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtInit - initialize data, set state to init
|
|
*
|
|
* Description:
|
|
*
|
|
* SK_INIT_DATA
|
|
* ============
|
|
*
|
|
* This routine initializes all RLMT-related variables to a known state.
|
|
* The initial state is SK_RLMT_RS_INIT.
|
|
* All ports are initialized to SK_RLMT_PS_INIT.
|
|
*
|
|
*
|
|
* SK_INIT_IO
|
|
* ==========
|
|
*
|
|
* Nothing.
|
|
*
|
|
*
|
|
* SK_INIT_RUN
|
|
* ===========
|
|
*
|
|
* Determine the adapter's random value.
|
|
* Set the hw registers, the "logical MAC address", the
|
|
* RLMT multicast address, and eventually the BPDU multicast address.
|
|
*
|
|
* Context:
|
|
* init, pageable
|
|
*
|
|
* Returns:
|
|
* Nothing.
|
|
*/
|
|
void SkRlmtInit(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
int Level) /* Initialization Level */
|
|
{
|
|
SK_U32 i, j;
|
|
SK_U64 Random;
|
|
SK_EVPARA Para;
|
|
SK_MAC_ADDR VirtualMacAddress;
|
|
SK_MAC_ADDR PhysicalAMacAddress;
|
|
SK_BOOL VirtualMacAddressSet;
|
|
SK_BOOL PhysicalAMacAddressSet;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_INIT,
|
|
("RLMT Init level %d.\n", Level))
|
|
|
|
switch (Level) {
|
|
case SK_INIT_DATA: /* Initialize data structures. */
|
|
SK_MEMSET((char *)&pAC->Rlmt, 0, sizeof(SK_RLMT));
|
|
|
|
for (i = 0; i < SK_MAX_MACS; i++) {
|
|
pAC->Rlmt.Port[i].PortState = SK_RLMT_PS_INIT;
|
|
pAC->Rlmt.Port[i].LinkDown = SK_TRUE;
|
|
pAC->Rlmt.Port[i].PortDown = SK_TRUE;
|
|
pAC->Rlmt.Port[i].PortStarted = SK_FALSE;
|
|
pAC->Rlmt.Port[i].PortNoRx = SK_FALSE;
|
|
pAC->Rlmt.Port[i].RootIdSet = SK_FALSE;
|
|
pAC->Rlmt.Port[i].PortNumber = i;
|
|
pAC->Rlmt.Port[i].Net = &pAC->Rlmt.Net[0];
|
|
pAC->Rlmt.Port[i].AddrPort = &pAC->Addr.Port[i];
|
|
}
|
|
|
|
pAC->Rlmt.NumNets = 1;
|
|
for (i = 0; i < SK_MAX_NETS; i++) {
|
|
pAC->Rlmt.Net[i].RlmtState = SK_RLMT_RS_INIT;
|
|
pAC->Rlmt.Net[i].RootIdSet = SK_FALSE;
|
|
pAC->Rlmt.Net[i].PrefPort = SK_RLMT_DEF_PREF_PORT;
|
|
pAC->Rlmt.Net[i].Preference = 0xFFFFFFFF; /* Automatic. */
|
|
/* Just assuming. */
|
|
pAC->Rlmt.Net[i].ActivePort = pAC->Rlmt.Net[i].PrefPort;
|
|
pAC->Rlmt.Net[i].RlmtMode = SK_RLMT_DEF_MODE;
|
|
pAC->Rlmt.Net[i].TimeoutValue = SK_RLMT_DEF_TO_VAL;
|
|
pAC->Rlmt.Net[i].NetNumber = i;
|
|
}
|
|
|
|
pAC->Rlmt.Net[0].Port[0] = &pAC->Rlmt.Port[0];
|
|
pAC->Rlmt.Net[0].Port[1] = &pAC->Rlmt.Port[1];
|
|
#if SK_MAX_NETS > 1
|
|
pAC->Rlmt.Net[1].Port[0] = &pAC->Rlmt.Port[1];
|
|
#endif /* SK_MAX_NETS > 1 */
|
|
break;
|
|
|
|
case SK_INIT_IO: /* GIMacsFound first available here. */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_INIT,
|
|
("RLMT: %d MACs were detected.\n", pAC->GIni.GIMacsFound))
|
|
|
|
pAC->Rlmt.Net[0].NumPorts = pAC->GIni.GIMacsFound;
|
|
|
|
/* Initialize HW registers? */
|
|
if (pAC->GIni.GIMacsFound == 1) {
|
|
Para.Para32[0] = SK_RLMT_MODE_CLS;
|
|
Para.Para32[1] = 0;
|
|
(void)SkRlmtEvent(pAC, IoC, SK_RLMT_MODE_CHANGE, Para);
|
|
}
|
|
break;
|
|
|
|
case SK_INIT_RUN:
|
|
/* Ensure RLMT is set to one net. */
|
|
if (pAC->Rlmt.NumNets > 1) {
|
|
Para.Para32[0] = 1;
|
|
Para.Para32[1] = -1;
|
|
SkRlmtEvtSetNets(pAC, IoC, Para);
|
|
}
|
|
|
|
for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
Random = SkOsGetTime(pAC);
|
|
*(SK_U32*)&pAC->Rlmt.Port[i].Random = *(SK_U32*)&Random;
|
|
|
|
for (j = 0; j < 4; j++) {
|
|
pAC->Rlmt.Port[i].Random[j] ^= pAC->Rlmt.Port[i].AddrPort->
|
|
CurrentMacAddress.a[SK_MAC_ADDR_LEN - 1 - j];
|
|
}
|
|
|
|
(void)SkAddrMcClear(pAC, IoC, i, SK_ADDR_PERMANENT | SK_MC_SW_ONLY);
|
|
|
|
/* Add RLMT MC address. */
|
|
(void)SkAddrMcAdd(pAC, IoC, i, &SkRlmtMcAddr, SK_ADDR_PERMANENT);
|
|
|
|
if (pAC->Rlmt.Net[0].RlmtMode & SK_RLMT_CHECK_SEG) {
|
|
/* Add BPDU MC address. */
|
|
(void)SkAddrMcAdd(pAC, IoC, i, &BridgeMcAddr, SK_ADDR_PERMANENT);
|
|
}
|
|
|
|
(void)SkAddrMcUpdate(pAC, IoC, i);
|
|
}
|
|
|
|
VirtualMacAddressSet = SK_FALSE;
|
|
/* Read virtual MAC address from Control Register File. */
|
|
for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
|
|
|
|
SK_IN8(IoC, B2_MAC_1 + j, &VirtualMacAddress.a[j]);
|
|
VirtualMacAddressSet |= VirtualMacAddress.a[j];
|
|
}
|
|
|
|
PhysicalAMacAddressSet = SK_FALSE;
|
|
/* Read physical MAC address for MAC A from Control Register File. */
|
|
for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
|
|
|
|
SK_IN8(IoC, B2_MAC_2 + j, &PhysicalAMacAddress.a[j]);
|
|
PhysicalAMacAddressSet |= PhysicalAMacAddress.a[j];
|
|
}
|
|
|
|
/* check if the two mac addresses contain reasonable values */
|
|
if (!VirtualMacAddressSet || !PhysicalAMacAddressSet) {
|
|
|
|
pAC->Rlmt.RlmtOff = SK_TRUE;
|
|
}
|
|
|
|
/* if the two mac addresses are equal switch off the RLMT_PRE_LOOKAHEAD
|
|
and the RLMT_LOOKAHEAD macros */
|
|
else if (SK_ADDR_EQUAL(PhysicalAMacAddress.a, VirtualMacAddress.a)) {
|
|
|
|
pAC->Rlmt.RlmtOff = SK_TRUE;
|
|
}
|
|
else {
|
|
pAC->Rlmt.RlmtOff = SK_FALSE;
|
|
}
|
|
break;
|
|
|
|
default: /* error */
|
|
break;
|
|
}
|
|
return;
|
|
} /* SkRlmtInit */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtBuildCheckChain - build the check chain
|
|
*
|
|
* Description:
|
|
* This routine builds the local check chain:
|
|
* - Each port that is up checks the next port.
|
|
* - The last port that is up checks the first port that is up.
|
|
*
|
|
* Notes:
|
|
* - Currently only local ports are considered when building the chain.
|
|
* - Currently the SuspectState is just reset;
|
|
* it would be better to save it ...
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtBuildCheckChain(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_U32 NetIdx) /* Net Number */
|
|
{
|
|
SK_U32 i;
|
|
SK_U32 NumMacsUp;
|
|
SK_RLMT_PORT * FirstMacUp;
|
|
SK_RLMT_PORT * PrevMacUp;
|
|
|
|
FirstMacUp = NULL;
|
|
PrevMacUp = NULL;
|
|
|
|
if (!(pAC->Rlmt.Net[NetIdx].RlmtMode & SK_RLMT_CHECK_LOC_LINK)) {
|
|
for (i = 0; i < pAC->Rlmt.Net[i].NumPorts; i++) {
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->PortsChecked = 0;
|
|
}
|
|
return; /* Done. */
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SkRlmtBuildCheckChain.\n"))
|
|
|
|
NumMacsUp = 0;
|
|
|
|
for (i = 0; i < pAC->Rlmt.Net[NetIdx].NumPorts; i++) {
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->PortsChecked = 0;
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->PortsSuspect = 0;
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->CheckingState &=
|
|
~(SK_RLMT_PCS_RX | SK_RLMT_PCS_TX);
|
|
|
|
/*
|
|
* If more than two links are detected we should consider
|
|
* checking at least two other ports:
|
|
* 1. the next port that is not LinkDown and
|
|
* 2. the next port that is not PortDown.
|
|
*/
|
|
if (!pAC->Rlmt.Net[NetIdx].Port[i]->LinkDown) {
|
|
if (NumMacsUp == 0) {
|
|
FirstMacUp = pAC->Rlmt.Net[NetIdx].Port[i];
|
|
}
|
|
else {
|
|
PrevMacUp->PortCheck[
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->PortsChecked].CheckAddr =
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->AddrPort->CurrentMacAddress;
|
|
PrevMacUp->PortCheck[
|
|
PrevMacUp->PortsChecked].SuspectTx = SK_FALSE;
|
|
PrevMacUp->PortsChecked++;
|
|
}
|
|
PrevMacUp = pAC->Rlmt.Net[NetIdx].Port[i];
|
|
NumMacsUp++;
|
|
}
|
|
}
|
|
|
|
if (NumMacsUp > 1) {
|
|
PrevMacUp->PortCheck[PrevMacUp->PortsChecked].CheckAddr =
|
|
FirstMacUp->AddrPort->CurrentMacAddress;
|
|
PrevMacUp->PortCheck[PrevMacUp->PortsChecked].SuspectTx =
|
|
SK_FALSE;
|
|
PrevMacUp->PortsChecked++;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
for (i = 0; i < pAC->Rlmt.Net[NetIdx].NumPorts; i++) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Port %d checks %d other ports: %2X.\n", i,
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->PortsChecked,
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->PortCheck[0].CheckAddr.a[5]))
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
return;
|
|
} /* SkRlmtBuildCheckChain */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtBuildPacket - build an RLMT packet
|
|
*
|
|
* Description:
|
|
* This routine sets up an RLMT packet.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* NULL or pointer to RLMT mbuf
|
|
*/
|
|
RLMT_STATIC SK_MBUF *SkRlmtBuildPacket(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 PortNumber, /* Sending port */
|
|
SK_U16 PacketType, /* RLMT packet type */
|
|
SK_MAC_ADDR *SrcAddr, /* Source address */
|
|
SK_MAC_ADDR *DestAddr) /* Destination address */
|
|
{
|
|
int i;
|
|
SK_U16 Length;
|
|
SK_MBUF *pMb;
|
|
SK_RLMT_PACKET *pPacket;
|
|
|
|
#ifdef DEBUG
|
|
SK_U8 CheckSrc = 0;
|
|
SK_U8 CheckDest = 0;
|
|
|
|
for (i = 0; i < SK_MAC_ADDR_LEN; ++i) {
|
|
CheckSrc |= SrcAddr->a[i];
|
|
CheckDest |= DestAddr->a[i];
|
|
}
|
|
|
|
if ((CheckSrc == 0) || (CheckDest == 0)) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_ERR,
|
|
("SkRlmtBuildPacket: Invalid %s%saddr.\n",
|
|
(CheckSrc == 0 ? "Src" : ""), (CheckDest == 0 ? "Dest" : "")))
|
|
}
|
|
#endif
|
|
|
|
if ((pMb = SkDrvAllocRlmtMbuf(pAC, IoC, SK_RLMT_MAX_PACKET_SIZE)) != NULL) {
|
|
pPacket = (SK_RLMT_PACKET*)pMb->pData;
|
|
for (i = 0; i < SK_MAC_ADDR_LEN; i++) {
|
|
pPacket->DstAddr[i] = DestAddr->a[i];
|
|
pPacket->SrcAddr[i] = SrcAddr->a[i];
|
|
}
|
|
pPacket->DSap = SK_RLMT_DSAP;
|
|
pPacket->SSap = SK_RLMT_SSAP;
|
|
pPacket->Ctrl = SK_RLMT_CTRL;
|
|
pPacket->Indicator[0] = SK_RLMT_INDICATOR0;
|
|
pPacket->Indicator[1] = SK_RLMT_INDICATOR1;
|
|
pPacket->Indicator[2] = SK_RLMT_INDICATOR2;
|
|
pPacket->Indicator[3] = SK_RLMT_INDICATOR3;
|
|
pPacket->Indicator[4] = SK_RLMT_INDICATOR4;
|
|
pPacket->Indicator[5] = SK_RLMT_INDICATOR5;
|
|
pPacket->Indicator[6] = SK_RLMT_INDICATOR6;
|
|
|
|
SK_U16_TO_NETWORK_ORDER(PacketType, &pPacket->RlmtPacketType[0]);
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
pPacket->Random[i] = pAC->Rlmt.Port[PortNumber].Random[i];
|
|
}
|
|
|
|
SK_U16_TO_NETWORK_ORDER(
|
|
SK_RLMT_PACKET_VERSION, &pPacket->RlmtPacketVersion[0]);
|
|
|
|
for (i = 0; i < SK_PACKET_DATA_LEN; i++) {
|
|
pPacket->Data[i] = 0x00;
|
|
}
|
|
|
|
Length = SK_RLMT_MAX_PACKET_SIZE; /* Or smaller. */
|
|
pMb->Length = Length;
|
|
pMb->PortIdx = PortNumber;
|
|
Length -= 14;
|
|
SK_U16_TO_NETWORK_ORDER(Length, &pPacket->TypeLen[0]);
|
|
|
|
if (PacketType == SK_PACKET_ALIVE) {
|
|
pAC->Rlmt.Port[PortNumber].TxHelloCts++;
|
|
}
|
|
}
|
|
|
|
return (pMb);
|
|
} /* SkRlmtBuildPacket */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtBuildSpanningTreePacket - build spanning tree check packet
|
|
*
|
|
* Description:
|
|
* This routine sets up a BPDU packet for spanning tree check.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* NULL or pointer to RLMT mbuf
|
|
*/
|
|
RLMT_STATIC SK_MBUF *SkRlmtBuildSpanningTreePacket(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 PortNumber) /* Sending port */
|
|
{
|
|
unsigned i;
|
|
SK_U16 Length;
|
|
SK_MBUF *pMb;
|
|
SK_SPTREE_PACKET *pSPacket;
|
|
|
|
if ((pMb = SkDrvAllocRlmtMbuf(pAC, IoC, SK_RLMT_MAX_PACKET_SIZE)) !=
|
|
NULL) {
|
|
pSPacket = (SK_SPTREE_PACKET*)pMb->pData;
|
|
for (i = 0; i < SK_MAC_ADDR_LEN; i++) {
|
|
pSPacket->DstAddr[i] = BridgeMcAddr.a[i];
|
|
pSPacket->SrcAddr[i] =
|
|
pAC->Addr.Port[PortNumber].CurrentMacAddress.a[i];
|
|
}
|
|
pSPacket->DSap = SK_RLMT_SPT_DSAP;
|
|
pSPacket->SSap = SK_RLMT_SPT_SSAP;
|
|
pSPacket->Ctrl = SK_RLMT_SPT_CTRL;
|
|
|
|
pSPacket->ProtocolId[0] = SK_RLMT_SPT_PROTOCOL_ID0;
|
|
pSPacket->ProtocolId[1] = SK_RLMT_SPT_PROTOCOL_ID1;
|
|
pSPacket->ProtocolVersionId = SK_RLMT_SPT_PROTOCOL_VERSION_ID;
|
|
pSPacket->BpduType = SK_RLMT_SPT_BPDU_TYPE;
|
|
pSPacket->Flags = SK_RLMT_SPT_FLAGS;
|
|
pSPacket->RootId[0] = SK_RLMT_SPT_ROOT_ID0;
|
|
pSPacket->RootId[1] = SK_RLMT_SPT_ROOT_ID1;
|
|
pSPacket->RootPathCost[0] = SK_RLMT_SPT_ROOT_PATH_COST0;
|
|
pSPacket->RootPathCost[1] = SK_RLMT_SPT_ROOT_PATH_COST1;
|
|
pSPacket->RootPathCost[2] = SK_RLMT_SPT_ROOT_PATH_COST2;
|
|
pSPacket->RootPathCost[3] = SK_RLMT_SPT_ROOT_PATH_COST3;
|
|
pSPacket->BridgeId[0] = SK_RLMT_SPT_BRIDGE_ID0;
|
|
pSPacket->BridgeId[1] = SK_RLMT_SPT_BRIDGE_ID1;
|
|
|
|
/*
|
|
* Use logical MAC address as bridge ID and filter these packets
|
|
* on receive.
|
|
*/
|
|
for (i = 0; i < SK_MAC_ADDR_LEN; i++) {
|
|
pSPacket->BridgeId[i + 2] = pSPacket->RootId[i + 2] =
|
|
pAC->Addr.Net[pAC->Rlmt.Port[PortNumber].Net->NetNumber].
|
|
CurrentMacAddress.a[i];
|
|
}
|
|
pSPacket->PortId[0] = SK_RLMT_SPT_PORT_ID0;
|
|
pSPacket->PortId[1] = SK_RLMT_SPT_PORT_ID1;
|
|
pSPacket->MessageAge[0] = SK_RLMT_SPT_MSG_AGE0;
|
|
pSPacket->MessageAge[1] = SK_RLMT_SPT_MSG_AGE1;
|
|
pSPacket->MaxAge[0] = SK_RLMT_SPT_MAX_AGE0;
|
|
pSPacket->MaxAge[1] = SK_RLMT_SPT_MAX_AGE1;
|
|
pSPacket->HelloTime[0] = SK_RLMT_SPT_HELLO_TIME0;
|
|
pSPacket->HelloTime[1] = SK_RLMT_SPT_HELLO_TIME1;
|
|
pSPacket->ForwardDelay[0] = SK_RLMT_SPT_FWD_DELAY0;
|
|
pSPacket->ForwardDelay[1] = SK_RLMT_SPT_FWD_DELAY1;
|
|
|
|
Length = SK_RLMT_MAX_PACKET_SIZE; /* Or smaller. */
|
|
pMb->Length = Length;
|
|
pMb->PortIdx = PortNumber;
|
|
Length -= 14;
|
|
SK_U16_TO_NETWORK_ORDER(Length, &pSPacket->TypeLen[0]);
|
|
|
|
pAC->Rlmt.Port[PortNumber].TxSpHelloReqCts++;
|
|
}
|
|
|
|
return (pMb);
|
|
} /* SkRlmtBuildSpanningTreePacket */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtSend - build and send check packets
|
|
*
|
|
* Description:
|
|
* Depending on the RLMT state and the checking state, several packets
|
|
* are sent through the indicated port.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* Nothing.
|
|
*/
|
|
RLMT_STATIC void SkRlmtSend(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 PortNumber) /* Sending port */
|
|
{
|
|
unsigned j;
|
|
SK_EVPARA Para;
|
|
SK_RLMT_PORT *pRPort;
|
|
|
|
pRPort = &pAC->Rlmt.Port[PortNumber];
|
|
if (pAC->Rlmt.Port[PortNumber].Net->RlmtMode & SK_RLMT_CHECK_LOC_LINK) {
|
|
if (pRPort->CheckingState & (SK_RLMT_PCS_TX | SK_RLMT_PCS_RX)) {
|
|
/* Port is suspicious. Send the RLMT packet to the RLMT mc addr. */
|
|
if ((Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC, PortNumber,
|
|
SK_PACKET_ALIVE, &pAC->Addr.Port[PortNumber].CurrentMacAddress,
|
|
&SkRlmtMcAddr)) != NULL) {
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
|
|
}
|
|
}
|
|
else {
|
|
/*
|
|
* Send a directed RLMT packet to all ports that are
|
|
* checked by the indicated port.
|
|
*/
|
|
for (j = 0; j < pRPort->PortsChecked; j++) {
|
|
if ((Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC, PortNumber,
|
|
SK_PACKET_ALIVE, &pAC->Addr.Port[PortNumber].CurrentMacAddress,
|
|
&pRPort->PortCheck[j].CheckAddr)) != NULL) {
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((pAC->Rlmt.Port[PortNumber].Net->RlmtMode & SK_RLMT_CHECK_SEG) &&
|
|
(pAC->Rlmt.Port[PortNumber].Net->CheckingState & SK_RLMT_RCS_SEND_SEG)) {
|
|
/*
|
|
* Send a BPDU packet to make a connected switch tell us
|
|
* the correct root bridge.
|
|
*/
|
|
if ((Para.pParaPtr =
|
|
SkRlmtBuildSpanningTreePacket(pAC, IoC, PortNumber)) != NULL) {
|
|
pAC->Rlmt.Port[PortNumber].Net->CheckingState &= ~SK_RLMT_RCS_SEND_SEG;
|
|
pRPort->RootIdSet = SK_FALSE;
|
|
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_TX,
|
|
("SkRlmtSend: BPDU Packet on Port %u.\n", PortNumber))
|
|
}
|
|
}
|
|
return;
|
|
} /* SkRlmtSend */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtPortReceives - check if port is (going) down and bring it up
|
|
*
|
|
* Description:
|
|
* This routine checks if a port who received a non-BPDU packet
|
|
* needs to go up or needs to be stopped going down.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* Nothing.
|
|
*/
|
|
RLMT_STATIC void SkRlmtPortReceives(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 PortNumber) /* Port to check */
|
|
{
|
|
SK_RLMT_PORT *pRPort;
|
|
SK_EVPARA Para;
|
|
|
|
pRPort = &pAC->Rlmt.Port[PortNumber];
|
|
pRPort->PortNoRx = SK_FALSE;
|
|
|
|
if ((pRPort->PortState == SK_RLMT_PS_DOWN) &&
|
|
!(pRPort->CheckingState & SK_RLMT_PCS_TX)) {
|
|
/*
|
|
* Port is marked down (rx), but received a non-BPDU packet.
|
|
* Bring it up.
|
|
*/
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Received on PortDown.\n"))
|
|
|
|
pRPort->PortState = SK_RLMT_PS_GOING_UP;
|
|
pRPort->GuTimeStamp = SkOsGetTime(pAC);
|
|
Para.Para32[0] = PortNumber;
|
|
Para.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pRPort->UpTimer, SK_RLMT_PORTUP_TIM_VAL,
|
|
SKGE_RLMT, SK_RLMT_PORTUP_TIM, Para);
|
|
pRPort->CheckingState &= ~SK_RLMT_PCS_RX;
|
|
/* pAC->Rlmt.CheckSwitch = SK_TRUE; */
|
|
SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
|
|
} /* PortDown && !SuspectTx */
|
|
else if (pRPort->CheckingState & SK_RLMT_PCS_RX) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Stop bringing port down.\n"))
|
|
SkTimerStop(pAC, IoC, &pRPort->DownRxTimer);
|
|
pRPort->CheckingState &= ~SK_RLMT_PCS_RX;
|
|
/* pAC->Rlmt.CheckSwitch = SK_TRUE; */
|
|
SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
|
|
} /* PortGoingDown */
|
|
|
|
return;
|
|
} /* SkRlmtPortReceives */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtPacketReceive - receive a packet for closer examination
|
|
*
|
|
* Description:
|
|
* This routine examines a packet more closely than SK_RLMT_LOOKAHEAD.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* Nothing.
|
|
*/
|
|
RLMT_STATIC void SkRlmtPacketReceive(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_MBUF *pMb) /* Received packet */
|
|
{
|
|
#ifdef xDEBUG
|
|
extern void DumpData(char *p, int size);
|
|
#endif /* DEBUG */
|
|
int i;
|
|
unsigned j;
|
|
SK_U16 PacketType;
|
|
SK_U32 PortNumber;
|
|
SK_ADDR_PORT *pAPort;
|
|
SK_RLMT_PORT *pRPort;
|
|
SK_RLMT_PACKET *pRPacket;
|
|
SK_SPTREE_PACKET *pSPacket;
|
|
SK_EVPARA Para;
|
|
|
|
PortNumber = pMb->PortIdx;
|
|
pAPort = &pAC->Addr.Port[PortNumber];
|
|
pRPort = &pAC->Rlmt.Port[PortNumber];
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: PortNumber == %d.\n", PortNumber))
|
|
|
|
pRPacket = (SK_RLMT_PACKET*)pMb->pData;
|
|
pSPacket = (SK_SPTREE_PACKET*)pRPacket;
|
|
|
|
#ifdef xDEBUG
|
|
DumpData((char *)pRPacket, 32);
|
|
#endif /* DEBUG */
|
|
|
|
if ((pRPort->PacketsPerTimeSlot - pRPort->BpduPacketsPerTimeSlot) != 0) {
|
|
SkRlmtPortReceives(pAC, IoC, PortNumber);
|
|
}
|
|
|
|
/* Check destination address. */
|
|
|
|
if (!SK_ADDR_EQUAL(pAPort->CurrentMacAddress.a, pRPacket->DstAddr) &&
|
|
!SK_ADDR_EQUAL(SkRlmtMcAddr.a, pRPacket->DstAddr) &&
|
|
!SK_ADDR_EQUAL(BridgeMcAddr.a, pRPacket->DstAddr)) {
|
|
|
|
/* Not sent to current MAC or registered MC address => Trash it. */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Not for me.\n"))
|
|
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
return;
|
|
}
|
|
else if (SK_ADDR_EQUAL(pAPort->CurrentMacAddress.a, pRPacket->SrcAddr)) {
|
|
|
|
/*
|
|
* Was sent by same port (may happen during port switching
|
|
* or in case of duplicate MAC addresses).
|
|
*/
|
|
|
|
/*
|
|
* Check for duplicate address here:
|
|
* If Packet.Random != My.Random => DupAddr.
|
|
*/
|
|
for (i = 3; i >= 0; i--) {
|
|
if (pRPort->Random[i] != pRPacket->Random[i]) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CAUTION: Do not check for duplicate MAC address in RLMT Alive Reply
|
|
* packets (they have the LLC_COMMAND_RESPONSE_BIT set in
|
|
* pRPacket->SSap).
|
|
*/
|
|
if (i >= 0 && pRPacket->DSap == SK_RLMT_DSAP &&
|
|
pRPacket->Ctrl == SK_RLMT_CTRL &&
|
|
pRPacket->SSap == SK_RLMT_SSAP &&
|
|
pRPacket->Indicator[0] == SK_RLMT_INDICATOR0 &&
|
|
pRPacket->Indicator[1] == SK_RLMT_INDICATOR1 &&
|
|
pRPacket->Indicator[2] == SK_RLMT_INDICATOR2 &&
|
|
pRPacket->Indicator[3] == SK_RLMT_INDICATOR3 &&
|
|
pRPacket->Indicator[4] == SK_RLMT_INDICATOR4 &&
|
|
pRPacket->Indicator[5] == SK_RLMT_INDICATOR5 &&
|
|
pRPacket->Indicator[6] == SK_RLMT_INDICATOR6) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Duplicate MAC Address.\n"))
|
|
|
|
/* Error Log entry. */
|
|
SK_ERR_LOG(pAC, SK_ERRCL_COMM, SKERR_RLMT_E006, SKERR_RLMT_E006_MSG);
|
|
}
|
|
else {
|
|
/* Simply trash it. */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Sent by me.\n"))
|
|
}
|
|
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
return;
|
|
}
|
|
|
|
/* Check SuspectTx entries. */
|
|
if (pRPort->PortsSuspect > 0) {
|
|
for (j = 0; j < pRPort->PortsChecked; j++) {
|
|
if (pRPort->PortCheck[j].SuspectTx &&
|
|
SK_ADDR_EQUAL(
|
|
pRPacket->SrcAddr, pRPort->PortCheck[j].CheckAddr.a)) {
|
|
pRPort->PortCheck[j].SuspectTx = SK_FALSE;
|
|
pRPort->PortsSuspect--;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Determine type of packet. */
|
|
if (pRPacket->DSap == SK_RLMT_DSAP &&
|
|
pRPacket->Ctrl == SK_RLMT_CTRL &&
|
|
(pRPacket->SSap & ~LLC_COMMAND_RESPONSE_BIT) == SK_RLMT_SSAP &&
|
|
pRPacket->Indicator[0] == SK_RLMT_INDICATOR0 &&
|
|
pRPacket->Indicator[1] == SK_RLMT_INDICATOR1 &&
|
|
pRPacket->Indicator[2] == SK_RLMT_INDICATOR2 &&
|
|
pRPacket->Indicator[3] == SK_RLMT_INDICATOR3 &&
|
|
pRPacket->Indicator[4] == SK_RLMT_INDICATOR4 &&
|
|
pRPacket->Indicator[5] == SK_RLMT_INDICATOR5 &&
|
|
pRPacket->Indicator[6] == SK_RLMT_INDICATOR6) {
|
|
|
|
/* It's an RLMT packet. */
|
|
PacketType = (SK_U16)((pRPacket->RlmtPacketType[0] << 8) |
|
|
pRPacket->RlmtPacketType[1]);
|
|
|
|
switch (PacketType) {
|
|
case SK_PACKET_ANNOUNCE: /* Not yet used. */
|
|
#if 0
|
|
/* Build the check chain. */
|
|
SkRlmtBuildCheckChain(pAC);
|
|
#endif /* 0 */
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Announce.\n"))
|
|
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
break;
|
|
|
|
case SK_PACKET_ALIVE:
|
|
if (pRPacket->SSap & LLC_COMMAND_RESPONSE_BIT) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Alive Reply.\n"))
|
|
|
|
if (!(pAC->Addr.Port[PortNumber].PromMode & SK_PROM_MODE_LLC) ||
|
|
SK_ADDR_EQUAL(
|
|
pRPacket->DstAddr, pAPort->CurrentMacAddress.a)) {
|
|
/* Obviously we could send something. */
|
|
if (pRPort->CheckingState & SK_RLMT_PCS_TX) {
|
|
pRPort->CheckingState &= ~SK_RLMT_PCS_TX;
|
|
SkTimerStop(pAC, IoC, &pRPort->DownTxTimer);
|
|
}
|
|
|
|
if ((pRPort->PortState == SK_RLMT_PS_DOWN) &&
|
|
!(pRPort->CheckingState & SK_RLMT_PCS_RX)) {
|
|
pRPort->PortState = SK_RLMT_PS_GOING_UP;
|
|
pRPort->GuTimeStamp = SkOsGetTime(pAC);
|
|
|
|
SkTimerStop(pAC, IoC, &pRPort->DownTxTimer);
|
|
|
|
Para.Para32[0] = PortNumber;
|
|
Para.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pRPort->UpTimer,
|
|
SK_RLMT_PORTUP_TIM_VAL, SKGE_RLMT,
|
|
SK_RLMT_PORTUP_TIM, Para);
|
|
}
|
|
}
|
|
|
|
/* Mark sending port as alive? */
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
}
|
|
else { /* Alive Request Packet. */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Alive Request.\n"))
|
|
|
|
pRPort->RxHelloCts++;
|
|
|
|
/* Answer. */
|
|
for (i = 0; i < SK_MAC_ADDR_LEN; i++) {
|
|
pRPacket->DstAddr[i] = pRPacket->SrcAddr[i];
|
|
pRPacket->SrcAddr[i] =
|
|
pAC->Addr.Port[PortNumber].CurrentMacAddress.a[i];
|
|
}
|
|
pRPacket->SSap |= LLC_COMMAND_RESPONSE_BIT;
|
|
|
|
Para.pParaPtr = pMb;
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
|
|
}
|
|
break;
|
|
|
|
case SK_PACKET_CHECK_TX:
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Check your tx line.\n"))
|
|
|
|
/* A port checking us requests us to check our tx line. */
|
|
pRPort->CheckingState |= SK_RLMT_PCS_TX;
|
|
|
|
/* Start PortDownTx timer. */
|
|
Para.Para32[0] = PortNumber;
|
|
Para.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pRPort->DownTxTimer,
|
|
SK_RLMT_PORTDOWN_TIM_VAL, SKGE_RLMT,
|
|
SK_RLMT_PORTDOWN_TX_TIM, Para);
|
|
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
|
|
if ((Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC, PortNumber,
|
|
SK_PACKET_ALIVE, &pAC->Addr.Port[PortNumber].CurrentMacAddress,
|
|
&SkRlmtMcAddr)) != NULL) {
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
|
|
}
|
|
break;
|
|
|
|
case SK_PACKET_ADDR_CHANGED:
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Address Change.\n"))
|
|
|
|
/* Build the check chain. */
|
|
SkRlmtBuildCheckChain(pAC, pRPort->Net->NetNumber);
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
break;
|
|
|
|
default:
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Unknown RLMT packet.\n"))
|
|
|
|
/* RA;:;: ??? */
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
}
|
|
}
|
|
else if (pSPacket->DSap == SK_RLMT_SPT_DSAP &&
|
|
pSPacket->Ctrl == SK_RLMT_SPT_CTRL &&
|
|
(pSPacket->SSap & ~LLC_COMMAND_RESPONSE_BIT) == SK_RLMT_SPT_SSAP) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: BPDU Packet.\n"))
|
|
|
|
/* Spanning Tree packet. */
|
|
pRPort->RxSpHelloCts++;
|
|
|
|
if (!SK_ADDR_EQUAL(&pSPacket->RootId[2], &pAC->Addr.Net[pAC->Rlmt.
|
|
Port[PortNumber].Net->NetNumber].CurrentMacAddress.a[0])) {
|
|
/*
|
|
* Check segmentation if a new root bridge is set and
|
|
* the segmentation check is not currently running.
|
|
*/
|
|
if (!SK_ADDR_EQUAL(&pSPacket->RootId[2], &pRPort->Root.Id[2]) &&
|
|
(pAC->Rlmt.Port[PortNumber].Net->LinksUp > 1) &&
|
|
(pAC->Rlmt.Port[PortNumber].Net->RlmtMode & SK_RLMT_CHECK_SEG)
|
|
!= 0 && (pAC->Rlmt.Port[PortNumber].Net->CheckingState &
|
|
SK_RLMT_RCS_SEG) == 0) {
|
|
pAC->Rlmt.Port[PortNumber].Net->CheckingState |=
|
|
SK_RLMT_RCS_START_SEG | SK_RLMT_RCS_SEND_SEG;
|
|
}
|
|
|
|
/* Store tree view of this port. */
|
|
for (i = 0; i < 8; i++) {
|
|
pRPort->Root.Id[i] = pSPacket->RootId[i];
|
|
}
|
|
pRPort->RootIdSet = SK_TRUE;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_DUMP,
|
|
("Root ID %d: %02x %02x %02x %02x %02x %02x %02x %02x.\n",
|
|
PortNumber,
|
|
pRPort->Root.Id[0], pRPort->Root.Id[1],
|
|
pRPort->Root.Id[2], pRPort->Root.Id[3],
|
|
pRPort->Root.Id[4], pRPort->Root.Id[5],
|
|
pRPort->Root.Id[6], pRPort->Root.Id[7]))
|
|
}
|
|
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
if ((pAC->Rlmt.Port[PortNumber].Net->CheckingState &
|
|
SK_RLMT_RCS_REPORT_SEG) != 0) {
|
|
SkRlmtCheckSeg(pAC, IoC, pAC->Rlmt.Port[PortNumber].Net->NetNumber);
|
|
}
|
|
}
|
|
else {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_RX,
|
|
("SkRlmtPacketReceive: Unknown Packet Type.\n"))
|
|
|
|
/* Unknown packet. */
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
}
|
|
return;
|
|
} /* SkRlmtPacketReceive */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtCheckPort - check if a port works
|
|
*
|
|
* Description:
|
|
* This routine checks if a port whose link is up received something
|
|
* and if it seems to transmit successfully.
|
|
*
|
|
* # PortState: PsInit, PsLinkDown, PsDown, PsGoingUp, PsUp
|
|
* # PortCheckingState (Bitfield): ChkTx, ChkRx, ChkSeg
|
|
* # RlmtCheckingState (Bitfield): ChkSeg, StartChkSeg, ReportSeg
|
|
*
|
|
* if (Rx - RxBpdu == 0) { # No rx.
|
|
* if (state == PsUp) {
|
|
* PortCheckingState |= ChkRx
|
|
* }
|
|
* if (ModeCheckSeg && (Timeout ==
|
|
* TO_SHORTEN(RLMT_DEFAULT_TIMEOUT))) {
|
|
* RlmtCheckingState |= ChkSeg)
|
|
* PortCheckingState |= ChkSeg
|
|
* }
|
|
* NewTimeout = TO_SHORTEN(Timeout)
|
|
* if (NewTimeout < RLMT_MIN_TIMEOUT) {
|
|
* NewTimeout = RLMT_MIN_TIMEOUT
|
|
* PortState = PsDown
|
|
* ...
|
|
* }
|
|
* }
|
|
* else { # something was received
|
|
* # Set counter to 0 at LinkDown?
|
|
* # No - rx may be reported after LinkDown ???
|
|
* PortCheckingState &= ~ChkRx
|
|
* NewTimeout = RLMT_DEFAULT_TIMEOUT
|
|
* if (RxAck == 0) {
|
|
* possible reasons:
|
|
* is my tx line bad? --
|
|
* send RLMT multicast and report
|
|
* back internally? (only possible
|
|
* between ports on same adapter)
|
|
* }
|
|
* if (RxChk == 0) {
|
|
* possible reasons:
|
|
* - tx line of port set to check me
|
|
* maybe bad
|
|
* - no other port/adapter available or set
|
|
* to check me
|
|
* - adapter checking me has a longer
|
|
* timeout
|
|
* ??? anything that can be done here?
|
|
* }
|
|
* }
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* New timeout value.
|
|
*/
|
|
RLMT_STATIC SK_U32 SkRlmtCheckPort(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 PortNumber) /* Port to check */
|
|
{
|
|
unsigned i;
|
|
SK_U32 NewTimeout;
|
|
SK_RLMT_PORT *pRPort;
|
|
SK_EVPARA Para;
|
|
|
|
pRPort = &pAC->Rlmt.Port[PortNumber];
|
|
|
|
if ((pRPort->PacketsPerTimeSlot - pRPort->BpduPacketsPerTimeSlot) == 0) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SkRlmtCheckPort %d: No (%d) receives in last time slot.\n",
|
|
PortNumber, pRPort->PacketsPerTimeSlot))
|
|
|
|
/*
|
|
* Check segmentation if there was no receive at least twice
|
|
* in a row (PortNoRx is already set) and the segmentation
|
|
* check is not currently running.
|
|
*/
|
|
|
|
if (pRPort->PortNoRx && (pAC->Rlmt.Port[PortNumber].Net->LinksUp > 1) &&
|
|
(pAC->Rlmt.Port[PortNumber].Net->RlmtMode & SK_RLMT_CHECK_SEG) &&
|
|
!(pAC->Rlmt.Port[PortNumber].Net->CheckingState & SK_RLMT_RCS_SEG)) {
|
|
pAC->Rlmt.Port[PortNumber].Net->CheckingState |=
|
|
SK_RLMT_RCS_START_SEG | SK_RLMT_RCS_SEND_SEG;
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SkRlmtCheckPort: PortsSuspect %d, PcsRx %d.\n",
|
|
pRPort->PortsSuspect, pRPort->CheckingState & SK_RLMT_PCS_RX))
|
|
|
|
if (pRPort->PortState != SK_RLMT_PS_DOWN) {
|
|
NewTimeout = TO_SHORTEN(pAC->Rlmt.Port[PortNumber].Net->TimeoutValue);
|
|
if (NewTimeout < SK_RLMT_MIN_TO_VAL) {
|
|
NewTimeout = SK_RLMT_MIN_TO_VAL;
|
|
}
|
|
|
|
if (!(pRPort->CheckingState & SK_RLMT_PCS_RX)) {
|
|
Para.Para32[0] = PortNumber;
|
|
pRPort->CheckingState |= SK_RLMT_PCS_RX;
|
|
|
|
/*
|
|
* What shall we do if the port checked by this one receives
|
|
* our request frames? What's bad - our rx line or his tx line?
|
|
*/
|
|
Para.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pRPort->DownRxTimer,
|
|
SK_RLMT_PORTDOWN_TIM_VAL, SKGE_RLMT,
|
|
SK_RLMT_PORTDOWN_RX_TIM, Para);
|
|
|
|
for (i = 0; i < pRPort->PortsChecked; i++) {
|
|
if (pRPort->PortCheck[i].SuspectTx) {
|
|
continue;
|
|
}
|
|
pRPort->PortCheck[i].SuspectTx = SK_TRUE;
|
|
pRPort->PortsSuspect++;
|
|
if ((Para.pParaPtr =
|
|
SkRlmtBuildPacket(pAC, IoC, PortNumber, SK_PACKET_CHECK_TX,
|
|
&pAC->Addr.Port[PortNumber].CurrentMacAddress,
|
|
&pRPort->PortCheck[i].CheckAddr)) != NULL) {
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else { /* PortDown -- or all partners suspect. */
|
|
NewTimeout = SK_RLMT_DEF_TO_VAL;
|
|
}
|
|
pRPort->PortNoRx = SK_TRUE;
|
|
}
|
|
else { /* A non-BPDU packet was received. */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SkRlmtCheckPort %d: %d (%d) receives in last time slot.\n",
|
|
PortNumber,
|
|
pRPort->PacketsPerTimeSlot - pRPort->BpduPacketsPerTimeSlot,
|
|
pRPort->PacketsPerTimeSlot))
|
|
|
|
SkRlmtPortReceives(pAC, IoC, PortNumber);
|
|
if (pAC->Rlmt.CheckSwitch) {
|
|
SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
|
|
}
|
|
|
|
NewTimeout = SK_RLMT_DEF_TO_VAL;
|
|
}
|
|
|
|
return (NewTimeout);
|
|
} /* SkRlmtCheckPort */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtSelectBcRx - select new active port, criteria 1 (CLP)
|
|
*
|
|
* Description:
|
|
* This routine selects the port that received a broadcast frame
|
|
* substantially later than all other ports.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* SK_BOOL
|
|
*/
|
|
RLMT_STATIC SK_BOOL SkRlmtSelectBcRx(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 Active, /* Active port */
|
|
SK_U32 PrefPort, /* Preferred port */
|
|
SK_U32 *pSelect) /* New active port */
|
|
{
|
|
SK_U64 BcTimeStamp;
|
|
SK_U32 i;
|
|
SK_BOOL PortFound;
|
|
|
|
BcTimeStamp = 0; /* Not totally necessary, but feeling better. */
|
|
PortFound = SK_FALSE;
|
|
|
|
/* Select port with the latest TimeStamp. */
|
|
for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("TimeStamp Port %d (Down: %d, NoRx: %d): %08x %08x.\n",
|
|
i,
|
|
pAC->Rlmt.Port[i].PortDown, pAC->Rlmt.Port[i].PortNoRx,
|
|
*((SK_U32*)(&pAC->Rlmt.Port[i].BcTimeStamp) + OFFS_HI32),
|
|
*((SK_U32*)(&pAC->Rlmt.Port[i].BcTimeStamp) + OFFS_LO32)))
|
|
|
|
if (!pAC->Rlmt.Port[i].PortDown && !pAC->Rlmt.Port[i].PortNoRx) {
|
|
if (!PortFound || pAC->Rlmt.Port[i].BcTimeStamp > BcTimeStamp) {
|
|
BcTimeStamp = pAC->Rlmt.Port[i].BcTimeStamp;
|
|
*pSelect = i;
|
|
PortFound = SK_TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PortFound) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Port %d received the last broadcast.\n", *pSelect))
|
|
|
|
/* Look if another port's time stamp is similar. */
|
|
for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
if (i == *pSelect) {
|
|
continue;
|
|
}
|
|
if (!pAC->Rlmt.Port[i].PortDown && !pAC->Rlmt.Port[i].PortNoRx &&
|
|
(pAC->Rlmt.Port[i].BcTimeStamp >
|
|
BcTimeStamp - SK_RLMT_BC_DELTA ||
|
|
pAC->Rlmt.Port[i].BcTimeStamp +
|
|
SK_RLMT_BC_DELTA > BcTimeStamp)) {
|
|
PortFound = SK_FALSE;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Port %d received a broadcast at a similar time.\n", i))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (PortFound) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SELECT_BCRX found Port %d receiving the substantially "
|
|
"latest broadcast (%u).\n",
|
|
*pSelect,
|
|
BcTimeStamp - pAC->Rlmt.Port[1 - *pSelect].BcTimeStamp))
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
return (PortFound);
|
|
} /* SkRlmtSelectBcRx */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtSelectNotSuspect - select new active port, criteria 2 (CLP)
|
|
*
|
|
* Description:
|
|
* This routine selects a good port (it is PortUp && !SuspectRx).
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* SK_BOOL
|
|
*/
|
|
RLMT_STATIC SK_BOOL SkRlmtSelectNotSuspect(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 Active, /* Active port */
|
|
SK_U32 PrefPort, /* Preferred port */
|
|
SK_U32 *pSelect) /* New active port */
|
|
{
|
|
SK_U32 i;
|
|
SK_BOOL PortFound;
|
|
|
|
PortFound = SK_FALSE;
|
|
|
|
/* Select first port that is PortUp && !SuspectRx. */
|
|
for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
if (!pAC->Rlmt.Port[i].PortDown &&
|
|
!(pAC->Rlmt.Port[i].CheckingState & SK_RLMT_PCS_RX)) {
|
|
*pSelect = i;
|
|
if (!pAC->Rlmt.Port[Active].PortDown &&
|
|
!(pAC->Rlmt.Port[Active].CheckingState & SK_RLMT_PCS_RX)) {
|
|
*pSelect = Active;
|
|
}
|
|
if (!pAC->Rlmt.Port[PrefPort].PortDown &&
|
|
!(pAC->Rlmt.Port[PrefPort].CheckingState & SK_RLMT_PCS_RX)) {
|
|
*pSelect = PrefPort;
|
|
}
|
|
PortFound = SK_TRUE;
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SELECT_NOTSUSPECT found Port %d up and not check RX.\n",
|
|
*pSelect))
|
|
break;
|
|
}
|
|
}
|
|
return (PortFound);
|
|
} /* SkRlmtSelectNotSuspect */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtSelectUp - select new active port, criteria 3, 4 (CLP)
|
|
*
|
|
* Description:
|
|
* This routine selects a port that is up.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* SK_BOOL
|
|
*/
|
|
RLMT_STATIC SK_BOOL SkRlmtSelectUp(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 Active, /* Active port */
|
|
SK_U32 PrefPort, /* Preferred port */
|
|
SK_U32 *pSelect, /* New active port */
|
|
SK_BOOL AutoNegDone) /* Successfully auto-negotiated? */
|
|
{
|
|
SK_U32 i;
|
|
SK_BOOL PortFound;
|
|
|
|
PortFound = SK_FALSE;
|
|
|
|
/* Select first port that is PortUp. */
|
|
for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
if (pAC->Rlmt.Port[i].PortState == SK_RLMT_PS_UP &&
|
|
pAC->GIni.GP[i].PAutoNegFail != AutoNegDone) {
|
|
*pSelect = i;
|
|
if (pAC->Rlmt.Port[Active].PortState == SK_RLMT_PS_UP &&
|
|
pAC->GIni.GP[Active].PAutoNegFail != AutoNegDone) {
|
|
*pSelect = Active;
|
|
}
|
|
if (pAC->Rlmt.Port[PrefPort].PortState == SK_RLMT_PS_UP &&
|
|
pAC->GIni.GP[PrefPort].PAutoNegFail != AutoNegDone) {
|
|
*pSelect = PrefPort;
|
|
}
|
|
PortFound = SK_TRUE;
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SELECT_UP found Port %d up.\n", *pSelect))
|
|
break;
|
|
}
|
|
}
|
|
return (PortFound);
|
|
} /* SkRlmtSelectUp */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtSelectGoingUp - select new active port, criteria 5, 6 (CLP)
|
|
*
|
|
* Description:
|
|
* This routine selects the port that is going up for the longest time.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* SK_BOOL
|
|
*/
|
|
RLMT_STATIC SK_BOOL SkRlmtSelectGoingUp(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 Active, /* Active port */
|
|
SK_U32 PrefPort, /* Preferred port */
|
|
SK_U32 *pSelect, /* New active port */
|
|
SK_BOOL AutoNegDone) /* Successfully auto-negotiated? */
|
|
{
|
|
SK_U64 GuTimeStamp;
|
|
SK_U32 i;
|
|
SK_BOOL PortFound;
|
|
|
|
GuTimeStamp = 0;
|
|
PortFound = SK_FALSE;
|
|
|
|
/* Select port that is PortGoingUp for the longest time. */
|
|
for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
if (pAC->Rlmt.Port[i].PortState == SK_RLMT_PS_GOING_UP &&
|
|
pAC->GIni.GP[i].PAutoNegFail != AutoNegDone) {
|
|
GuTimeStamp = pAC->Rlmt.Port[i].GuTimeStamp;
|
|
*pSelect = i;
|
|
PortFound = SK_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!PortFound) {
|
|
return (SK_FALSE);
|
|
}
|
|
|
|
for (i = *pSelect + 1; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
if (pAC->Rlmt.Port[i].PortState == SK_RLMT_PS_GOING_UP &&
|
|
pAC->Rlmt.Port[i].GuTimeStamp < GuTimeStamp &&
|
|
pAC->GIni.GP[i].PAutoNegFail != AutoNegDone) {
|
|
GuTimeStamp = pAC->Rlmt.Port[i].GuTimeStamp;
|
|
*pSelect = i;
|
|
}
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SELECT_GOINGUP found Port %d going up.\n", *pSelect))
|
|
return (SK_TRUE);
|
|
} /* SkRlmtSelectGoingUp */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtSelectDown - select new active port, criteria 7, 8 (CLP)
|
|
*
|
|
* Description:
|
|
* This routine selects a port that is down.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* SK_BOOL
|
|
*/
|
|
RLMT_STATIC SK_BOOL SkRlmtSelectDown(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 Active, /* Active port */
|
|
SK_U32 PrefPort, /* Preferred port */
|
|
SK_U32 *pSelect, /* New active port */
|
|
SK_BOOL AutoNegDone) /* Successfully auto-negotiated? */
|
|
{
|
|
SK_U32 i;
|
|
SK_BOOL PortFound;
|
|
|
|
PortFound = SK_FALSE;
|
|
|
|
/* Select first port that is PortDown. */
|
|
for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
if (pAC->Rlmt.Port[i].PortState == SK_RLMT_PS_DOWN &&
|
|
pAC->GIni.GP[i].PAutoNegFail != AutoNegDone) {
|
|
*pSelect = i;
|
|
if (pAC->Rlmt.Port[Active].PortState == SK_RLMT_PS_DOWN &&
|
|
pAC->GIni.GP[Active].PAutoNegFail != AutoNegDone) {
|
|
*pSelect = Active;
|
|
}
|
|
if (pAC->Rlmt.Port[PrefPort].PortState == SK_RLMT_PS_DOWN &&
|
|
pAC->GIni.GP[PrefPort].PAutoNegFail != AutoNegDone) {
|
|
*pSelect = PrefPort;
|
|
}
|
|
PortFound = SK_TRUE;
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SELECT_DOWN found Port %d down.\n", *pSelect))
|
|
break;
|
|
}
|
|
}
|
|
return (PortFound);
|
|
} /* SkRlmtSelectDown */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtCheckSwitch - select new active port and switch to it
|
|
*
|
|
* Description:
|
|
* This routine decides which port should be the active one and queues
|
|
* port switching if necessary.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* Nothing.
|
|
*/
|
|
RLMT_STATIC void SkRlmtCheckSwitch(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 NetIdx) /* Net index */
|
|
{
|
|
SK_EVPARA Para;
|
|
SK_U32 Active;
|
|
SK_U32 PrefPort;
|
|
SK_U32 i;
|
|
SK_BOOL PortFound;
|
|
|
|
Active = pAC->Rlmt.Net[NetIdx].ActivePort; /* Index of active port. */
|
|
PrefPort = pAC->Rlmt.Net[NetIdx].PrefPort; /* Index of preferred port. */
|
|
PortFound = SK_FALSE;
|
|
pAC->Rlmt.CheckSwitch = SK_FALSE;
|
|
|
|
#if 0 /* RW 2001/10/18 - active port becomes always prefered one */
|
|
if (pAC->Rlmt.Net[NetIdx].Preference == 0xFFFFFFFF) { /* Automatic */
|
|
/* disable auto-fail back */
|
|
PrefPort = Active;
|
|
}
|
|
#endif
|
|
|
|
if (pAC->Rlmt.Net[NetIdx].LinksUp == 0) {
|
|
/* Last link went down - shut down the net. */
|
|
pAC->Rlmt.Net[NetIdx].RlmtState = SK_RLMT_RS_NET_DOWN;
|
|
Para.Para32[0] = SK_RLMT_NET_DOWN_TEMP;
|
|
Para.Para32[1] = NetIdx;
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_NET_DOWN, Para);
|
|
|
|
Para.Para32[0] = pAC->Rlmt.Net[NetIdx].
|
|
Port[pAC->Rlmt.Net[NetIdx].ActivePort]->PortNumber;
|
|
Para.Para32[1] = NetIdx;
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_ACTIVE_DOWN, Para);
|
|
return;
|
|
} /* pAC->Rlmt.LinksUp == 0 */
|
|
else if (pAC->Rlmt.Net[NetIdx].LinksUp == 1 &&
|
|
pAC->Rlmt.Net[NetIdx].RlmtState == SK_RLMT_RS_NET_DOWN) {
|
|
/* First link came up - get the net up. */
|
|
pAC->Rlmt.Net[NetIdx].RlmtState = SK_RLMT_RS_NET_UP;
|
|
|
|
/*
|
|
* If pAC->Rlmt.ActivePort != Para.Para32[0],
|
|
* the DRV switches to the port that came up.
|
|
*/
|
|
for (i = 0; i < pAC->Rlmt.Net[NetIdx].NumPorts; i++) {
|
|
if (!pAC->Rlmt.Net[NetIdx].Port[i]->LinkDown) {
|
|
if (!pAC->Rlmt.Net[NetIdx].Port[Active]->LinkDown) {
|
|
i = Active;
|
|
}
|
|
if (!pAC->Rlmt.Net[NetIdx].Port[PrefPort]->LinkDown) {
|
|
i = PrefPort;
|
|
}
|
|
PortFound = SK_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (PortFound) {
|
|
Para.Para32[0] = pAC->Rlmt.Net[NetIdx].Port[i]->PortNumber;
|
|
Para.Para32[1] = NetIdx;
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_ACTIVE_UP, Para);
|
|
|
|
pAC->Rlmt.Net[NetIdx].ActivePort = i;
|
|
Para.Para32[0] = pAC->Rlmt.Net[NetIdx].Port[i]->PortNumber;
|
|
Para.Para32[1] = NetIdx;
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_NET_UP, Para);
|
|
|
|
if ((pAC->Rlmt.Net[NetIdx].RlmtMode & SK_RLMT_TRANSPARENT) == 0 &&
|
|
(Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC,
|
|
pAC->Rlmt.Net[NetIdx].Port[i]->PortNumber,
|
|
SK_PACKET_ANNOUNCE, &pAC->Addr.Net[NetIdx].
|
|
CurrentMacAddress, &SkRlmtMcAddr)) != NULL) {
|
|
/*
|
|
* Send announce packet to RLMT multicast address to force
|
|
* switches to learn the new location of the logical MAC address.
|
|
*/
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
|
|
}
|
|
}
|
|
else {
|
|
SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E007, SKERR_RLMT_E007_MSG);
|
|
}
|
|
|
|
return;
|
|
} /* LinksUp == 1 && RlmtState == SK_RLMT_RS_NET_DOWN */
|
|
else { /* Cannot be reached in dual-net mode. */
|
|
Para.Para32[0] = Active;
|
|
|
|
/*
|
|
* Preselection:
|
|
* If RLMT Mode != CheckLinkState
|
|
* select port that received a broadcast frame substantially later
|
|
* than all other ports
|
|
* else select first port that is not SuspectRx
|
|
* else select first port that is PortUp
|
|
* else select port that is PortGoingUp for the longest time
|
|
* else select first port that is PortDown
|
|
* else stop.
|
|
*
|
|
* For the preselected port:
|
|
* If ActivePort is equal in quality, select ActivePort.
|
|
*
|
|
* If PrefPort is equal in quality, select PrefPort.
|
|
*
|
|
* If ActivePort != SelectedPort,
|
|
* If old ActivePort is LinkDown,
|
|
* SwitchHard
|
|
* else
|
|
* SwitchSoft
|
|
*/
|
|
/* check of ChgBcPrio flag added */
|
|
if ((pAC->Rlmt.Net[0].RlmtMode != SK_RLMT_MODE_CLS) &&
|
|
(!pAC->Rlmt.Net[0].ChgBcPrio)) {
|
|
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectBcRx(
|
|
pAC, IoC, Active, PrefPort, &Para.Para32[1]);
|
|
}
|
|
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectNotSuspect(
|
|
pAC, IoC, Active, PrefPort, &Para.Para32[1]);
|
|
}
|
|
} /* pAC->Rlmt.RlmtMode != SK_RLMT_MODE_CLS */
|
|
|
|
/* with changed priority for last broadcast received */
|
|
if ((pAC->Rlmt.Net[0].RlmtMode != SK_RLMT_MODE_CLS) &&
|
|
(pAC->Rlmt.Net[0].ChgBcPrio)) {
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectNotSuspect(
|
|
pAC, IoC, Active, PrefPort, &Para.Para32[1]);
|
|
}
|
|
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectBcRx(
|
|
pAC, IoC, Active, PrefPort, &Para.Para32[1]);
|
|
}
|
|
} /* pAC->Rlmt.RlmtMode != SK_RLMT_MODE_CLS */
|
|
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectUp(
|
|
pAC, IoC, Active, PrefPort, &Para.Para32[1], AUTONEG_SUCCESS);
|
|
}
|
|
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectUp(
|
|
pAC, IoC, Active, PrefPort, &Para.Para32[1], AUTONEG_FAILED);
|
|
}
|
|
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectGoingUp(
|
|
pAC, IoC, Active, PrefPort, &Para.Para32[1], AUTONEG_SUCCESS);
|
|
}
|
|
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectGoingUp(
|
|
pAC, IoC, Active, PrefPort, &Para.Para32[1], AUTONEG_FAILED);
|
|
}
|
|
|
|
if (pAC->Rlmt.Net[0].RlmtMode != SK_RLMT_MODE_CLS) {
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectDown(pAC, IoC,
|
|
Active, PrefPort, &Para.Para32[1], AUTONEG_SUCCESS);
|
|
}
|
|
|
|
if (!PortFound) {
|
|
PortFound = SkRlmtSelectDown(pAC, IoC,
|
|
Active, PrefPort, &Para.Para32[1], AUTONEG_FAILED);
|
|
}
|
|
} /* pAC->Rlmt.RlmtMode != SK_RLMT_MODE_CLS */
|
|
|
|
if (PortFound) {
|
|
|
|
if (Para.Para32[1] != Active) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Active: %d, Para1: %d.\n", Active, Para.Para32[1]))
|
|
pAC->Rlmt.Net[NetIdx].ActivePort = Para.Para32[1];
|
|
Para.Para32[0] = pAC->Rlmt.Net[NetIdx].
|
|
Port[Para.Para32[0]]->PortNumber;
|
|
Para.Para32[1] = pAC->Rlmt.Net[NetIdx].
|
|
Port[Para.Para32[1]]->PortNumber;
|
|
SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[1], SK_LED_ACTIVE);
|
|
if (pAC->Rlmt.Port[Active].LinkDown) {
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_SWITCH_HARD, Para);
|
|
}
|
|
else {
|
|
SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[0], SK_LED_STANDBY);
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_SWITCH_SOFT, Para);
|
|
}
|
|
Para.Para32[1] = NetIdx;
|
|
Para.Para32[0] =
|
|
pAC->Rlmt.Net[NetIdx].Port[Para.Para32[0]]->PortNumber;
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_ACTIVE_DOWN, Para);
|
|
Para.Para32[0] = pAC->Rlmt.Net[NetIdx].
|
|
Port[pAC->Rlmt.Net[NetIdx].ActivePort]->PortNumber;
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_ACTIVE_UP, Para);
|
|
if ((pAC->Rlmt.Net[NetIdx].RlmtMode & SK_RLMT_TRANSPARENT) == 0 &&
|
|
(Para.pParaPtr = SkRlmtBuildPacket(pAC, IoC, Para.Para32[0],
|
|
SK_PACKET_ANNOUNCE, &pAC->Addr.Net[NetIdx].CurrentMacAddress,
|
|
&SkRlmtMcAddr)) != NULL) {
|
|
/*
|
|
* Send announce packet to RLMT multicast address to force
|
|
* switches to learn the new location of the logical
|
|
* MAC address.
|
|
*/
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para);
|
|
} /* (Para.pParaPtr = SkRlmtBuildPacket(...)) != NULL */
|
|
} /* Para.Para32[1] != Active */
|
|
} /* PortFound */
|
|
else {
|
|
SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E004, SKERR_RLMT_E004_MSG);
|
|
}
|
|
} /* LinksUp > 1 || LinksUp == 1 && RlmtState != SK_RLMT_RS_NET_DOWN */
|
|
return;
|
|
} /* SkRlmtCheckSwitch */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtCheckSeg - Report if segmentation is detected
|
|
*
|
|
* Description:
|
|
* This routine checks if the ports see different root bridges and reports
|
|
* segmentation in such a case.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* Nothing.
|
|
*/
|
|
RLMT_STATIC void SkRlmtCheckSeg(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 NetIdx) /* Net number */
|
|
{
|
|
SK_EVPARA Para;
|
|
SK_RLMT_NET *pNet;
|
|
SK_U32 i, j;
|
|
SK_BOOL Equal;
|
|
|
|
pNet = &pAC->Rlmt.Net[NetIdx];
|
|
pNet->RootIdSet = SK_FALSE;
|
|
Equal = SK_TRUE;
|
|
|
|
for (i = 0; i < pNet->NumPorts; i++) {
|
|
if (pNet->Port[i]->LinkDown || !pNet->Port[i]->RootIdSet) {
|
|
continue;
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_DUMP,
|
|
("Root ID %d: %02x %02x %02x %02x %02x %02x %02x %02x.\n", i,
|
|
pNet->Port[i]->Root.Id[0], pNet->Port[i]->Root.Id[1],
|
|
pNet->Port[i]->Root.Id[2], pNet->Port[i]->Root.Id[3],
|
|
pNet->Port[i]->Root.Id[4], pNet->Port[i]->Root.Id[5],
|
|
pNet->Port[i]->Root.Id[6], pNet->Port[i]->Root.Id[7]))
|
|
|
|
if (!pNet->RootIdSet) {
|
|
pNet->Root = pNet->Port[i]->Root;
|
|
pNet->RootIdSet = SK_TRUE;
|
|
continue;
|
|
}
|
|
|
|
for (j = 0; j < 8; j ++) {
|
|
Equal &= pNet->Port[i]->Root.Id[j] == pNet->Root.Id[j];
|
|
if (!Equal) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!Equal) {
|
|
SK_ERR_LOG(pAC, SK_ERRCL_COMM, SKERR_RLMT_E005, SKERR_RLMT_E005_MSG);
|
|
Para.Para32[0] = NetIdx;
|
|
Para.Para32[1] = (SK_U32)-1;
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_SEGMENTATION, Para);
|
|
|
|
pNet->CheckingState &= ~SK_RLMT_RCS_REPORT_SEG;
|
|
|
|
/* 2000-03-06 RA: New. */
|
|
Para.Para32[0] = NetIdx;
|
|
Para.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pNet->SegTimer, SK_RLMT_SEG_TO_VAL,
|
|
SKGE_RLMT, SK_RLMT_SEG_TIM, Para);
|
|
break;
|
|
}
|
|
} /* for (i = 0; i < pNet->NumPorts; i++) */
|
|
|
|
/* 2000-03-06 RA: Moved here. */
|
|
/* Segmentation check not running anymore. */
|
|
pNet->CheckingState &= ~SK_RLMT_RCS_SEG;
|
|
|
|
} /* SkRlmtCheckSeg */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtPortStart - initialize port variables and start port
|
|
*
|
|
* Description:
|
|
* This routine initializes a port's variables and issues a PORT_START
|
|
* to the HWAC module. This handles retries if the start fails or the
|
|
* link eventually goes down.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtPortStart(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 PortNumber) /* Port number */
|
|
{
|
|
SK_EVPARA Para;
|
|
|
|
pAC->Rlmt.Port[PortNumber].PortState = SK_RLMT_PS_LINK_DOWN;
|
|
pAC->Rlmt.Port[PortNumber].PortStarted = SK_TRUE;
|
|
pAC->Rlmt.Port[PortNumber].LinkDown = SK_TRUE;
|
|
pAC->Rlmt.Port[PortNumber].PortDown = SK_TRUE;
|
|
pAC->Rlmt.Port[PortNumber].CheckingState = 0;
|
|
pAC->Rlmt.Port[PortNumber].RootIdSet = SK_FALSE;
|
|
Para.Para32[0] = PortNumber;
|
|
Para.Para32[1] = (SK_U32)-1;
|
|
SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
|
|
} /* SkRlmtPortStart */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtPortStartTim - PORT_START_TIM
|
|
*
|
|
* Description:
|
|
* This routine handles PORT_START_TIM events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtPortStartTim(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 -1 */
|
|
{
|
|
SK_U32 i;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTSTART_TIMEOUT Port %d Event BEGIN.\n", Para.Para32[0]))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTSTART_TIMEOUT Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Used to start non-preferred ports if the preferred one
|
|
* does not come up.
|
|
* This timeout needs only be set when starting the first
|
|
* (preferred) port.
|
|
*/
|
|
if (pAC->Rlmt.Port[Para.Para32[0]].LinkDown) {
|
|
/* PORT_START failed. */
|
|
for (i = 0; i < pAC->Rlmt.Port[Para.Para32[0]].Net->NumPorts; i++) {
|
|
if (!pAC->Rlmt.Port[Para.Para32[0]].Net->Port[i]->PortStarted) {
|
|
SkRlmtPortStart(pAC, IoC,
|
|
pAC->Rlmt.Port[Para.Para32[0]].Net->Port[i]->PortNumber);
|
|
}
|
|
}
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTSTART_TIMEOUT Event END.\n"))
|
|
} /* SkRlmtEvtPortStartTim */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtLinkUp - LINK_UP
|
|
*
|
|
* Description:
|
|
* This routine handles LLINK_UP events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtLinkUp(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 Undefined */
|
|
{
|
|
SK_U32 i;
|
|
SK_RLMT_PORT *pRPort;
|
|
SK_EVPARA Para2;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_LINK_UP Port %d Event BEGIN.\n", Para.Para32[0]))
|
|
|
|
pRPort = &pAC->Rlmt.Port[Para.Para32[0]];
|
|
if (!pRPort->PortStarted) {
|
|
SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E008, SKERR_RLMT_E008_MSG);
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_LINK_UP Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (!pRPort->LinkDown) {
|
|
/* RA;:;: Any better solution? */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_LINK_UP Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
SkTimerStop(pAC, IoC, &pRPort->UpTimer);
|
|
SkTimerStop(pAC, IoC, &pRPort->DownRxTimer);
|
|
SkTimerStop(pAC, IoC, &pRPort->DownTxTimer);
|
|
|
|
/* Do something if timer already fired? */
|
|
|
|
pRPort->LinkDown = SK_FALSE;
|
|
pRPort->PortState = SK_RLMT_PS_GOING_UP;
|
|
pRPort->GuTimeStamp = SkOsGetTime(pAC);
|
|
pRPort->BcTimeStamp = 0;
|
|
pRPort->Net->LinksUp++;
|
|
if (pRPort->Net->LinksUp == 1) {
|
|
SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[0], SK_LED_ACTIVE);
|
|
}
|
|
else {
|
|
SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[0], SK_LED_STANDBY);
|
|
}
|
|
|
|
for (i = 0; i < pRPort->Net->NumPorts; i++) {
|
|
if (!pRPort->Net->Port[i]->PortStarted) {
|
|
SkRlmtPortStart(pAC, IoC, pRPort->Net->Port[i]->PortNumber);
|
|
}
|
|
}
|
|
|
|
SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
|
|
|
|
if (pRPort->Net->LinksUp >= 2) {
|
|
if (pRPort->Net->RlmtMode & SK_RLMT_CHECK_LOC_LINK) {
|
|
/* Build the check chain. */
|
|
SkRlmtBuildCheckChain(pAC, pRPort->Net->NetNumber);
|
|
}
|
|
}
|
|
|
|
/* If the first link comes up, start the periodical RLMT timeout. */
|
|
if (pRPort->Net->NumPorts > 1 && pRPort->Net->LinksUp == 1 &&
|
|
(pRPort->Net->RlmtMode & SK_RLMT_CHECK_OTHERS) != 0) {
|
|
Para2.Para32[0] = pRPort->Net->NetNumber;
|
|
Para2.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pRPort->Net->LocTimer,
|
|
pRPort->Net->TimeoutValue, SKGE_RLMT, SK_RLMT_TIM, Para2);
|
|
}
|
|
|
|
Para2 = Para;
|
|
Para2.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pRPort->UpTimer, SK_RLMT_PORTUP_TIM_VAL,
|
|
SKGE_RLMT, SK_RLMT_PORTUP_TIM, Para2);
|
|
|
|
/* Later: if (pAC->Rlmt.RlmtMode & SK_RLMT_CHECK_LOC_LINK) && */
|
|
if ((pRPort->Net->RlmtMode & SK_RLMT_TRANSPARENT) == 0 &&
|
|
(pRPort->Net->RlmtMode & SK_RLMT_CHECK_LINK) != 0 &&
|
|
(Para2.pParaPtr =
|
|
SkRlmtBuildPacket(pAC, IoC, Para.Para32[0], SK_PACKET_ANNOUNCE,
|
|
&pAC->Addr.Port[Para.Para32[0]].CurrentMacAddress, &SkRlmtMcAddr)
|
|
) != NULL) {
|
|
/* Send "new" packet to RLMT multicast address. */
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para2);
|
|
}
|
|
|
|
if (pRPort->Net->RlmtMode & SK_RLMT_CHECK_SEG) {
|
|
if ((Para2.pParaPtr =
|
|
SkRlmtBuildSpanningTreePacket(pAC, IoC, Para.Para32[0])) != NULL) {
|
|
pAC->Rlmt.Port[Para.Para32[0]].RootIdSet = SK_FALSE;
|
|
pRPort->Net->CheckingState |=
|
|
SK_RLMT_RCS_SEG | SK_RLMT_RCS_REPORT_SEG;
|
|
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para2);
|
|
|
|
Para.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pRPort->Net->SegTimer,
|
|
SK_RLMT_SEG_TO_VAL, SKGE_RLMT, SK_RLMT_SEG_TIM, Para);
|
|
}
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_LINK_UP Event END.\n"))
|
|
} /* SkRlmtEvtLinkUp */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtPortUpTim - PORT_UP_TIM
|
|
*
|
|
* Description:
|
|
* This routine handles PORT_UP_TIM events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtPortUpTim(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 -1 */
|
|
{
|
|
SK_RLMT_PORT *pRPort;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTUP_TIM Port %d Event BEGIN.\n", Para.Para32[0]))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTUP_TIM Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
pRPort = &pAC->Rlmt.Port[Para.Para32[0]];
|
|
if (pRPort->LinkDown || (pRPort->PortState == SK_RLMT_PS_UP)) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTUP_TIM Port %d Event EMPTY.\n", Para.Para32[0]))
|
|
return;
|
|
}
|
|
|
|
pRPort->PortDown = SK_FALSE;
|
|
pRPort->PortState = SK_RLMT_PS_UP;
|
|
pRPort->Net->PortsUp++;
|
|
if (pRPort->Net->RlmtState != SK_RLMT_RS_INIT) {
|
|
if (pAC->Rlmt.NumNets <= 1) {
|
|
SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
|
|
}
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_PORT_UP, Para);
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTUP_TIM Event END.\n"))
|
|
} /* SkRlmtEvtPortUpTim */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtPortDownTim - PORT_DOWN_*
|
|
*
|
|
* Description:
|
|
* This routine handles PORT_DOWN_* events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtPortDownX(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 Event, /* Event code */
|
|
SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 -1 */
|
|
{
|
|
SK_RLMT_PORT *pRPort;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTDOWN* Port %d Event (%d) BEGIN.\n",
|
|
Para.Para32[0], Event))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTDOWN* Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
pRPort = &pAC->Rlmt.Port[Para.Para32[0]];
|
|
if (!pRPort->PortStarted || (Event == SK_RLMT_PORTDOWN_TX_TIM &&
|
|
!(pRPort->CheckingState & SK_RLMT_PCS_TX))) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTDOWN* Event (%d) EMPTY.\n", Event))
|
|
return;
|
|
}
|
|
|
|
/* Stop port's timers. */
|
|
SkTimerStop(pAC, IoC, &pRPort->UpTimer);
|
|
SkTimerStop(pAC, IoC, &pRPort->DownRxTimer);
|
|
SkTimerStop(pAC, IoC, &pRPort->DownTxTimer);
|
|
|
|
if (pRPort->PortState != SK_RLMT_PS_LINK_DOWN) {
|
|
pRPort->PortState = SK_RLMT_PS_DOWN;
|
|
}
|
|
|
|
if (!pRPort->PortDown) {
|
|
pRPort->Net->PortsUp--;
|
|
pRPort->PortDown = SK_TRUE;
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_PORT_DOWN, Para);
|
|
}
|
|
|
|
pRPort->PacketsPerTimeSlot = 0;
|
|
/* pRPort->DataPacketsPerTimeSlot = 0; */
|
|
pRPort->BpduPacketsPerTimeSlot = 0;
|
|
pRPort->BcTimeStamp = 0;
|
|
|
|
/*
|
|
* RA;:;: To be checked:
|
|
* - actions at RLMT_STOP: We should not switch anymore.
|
|
*/
|
|
if (pRPort->Net->RlmtState != SK_RLMT_RS_INIT) {
|
|
if (Para.Para32[0] ==
|
|
pRPort->Net->Port[pRPort->Net->ActivePort]->PortNumber) {
|
|
/* Active Port went down. */
|
|
SkRlmtCheckSwitch(pAC, IoC, pRPort->Net->NetNumber);
|
|
}
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORTDOWN* Event (%d) END.\n", Event))
|
|
} /* SkRlmtEvtPortDownX */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtLinkDown - LINK_DOWN
|
|
*
|
|
* Description:
|
|
* This routine handles LINK_DOWN events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtLinkDown(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 Undefined */
|
|
{
|
|
SK_RLMT_PORT *pRPort;
|
|
|
|
pRPort = &pAC->Rlmt.Port[Para.Para32[0]];
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_LINK_DOWN Port %d Event BEGIN.\n", Para.Para32[0]))
|
|
|
|
if (!pAC->Rlmt.Port[Para.Para32[0]].LinkDown) {
|
|
pRPort->Net->LinksUp--;
|
|
pRPort->LinkDown = SK_TRUE;
|
|
pRPort->PortState = SK_RLMT_PS_LINK_DOWN;
|
|
SK_HWAC_LINK_LED(pAC, IoC, Para.Para32[0], SK_LED_OFF);
|
|
|
|
if ((pRPort->Net->RlmtMode & SK_RLMT_CHECK_LOC_LINK) != 0) {
|
|
/* Build the check chain. */
|
|
SkRlmtBuildCheckChain(pAC, pRPort->Net->NetNumber);
|
|
}
|
|
|
|
/* Ensure that port is marked down. */
|
|
Para.Para32[1] = -1;
|
|
(void)SkRlmtEvent(pAC, IoC, SK_RLMT_PORTDOWN, Para);
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_LINK_DOWN Event END.\n"))
|
|
} /* SkRlmtEvtLinkDown */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtPortAddr - PORT_ADDR
|
|
*
|
|
* Description:
|
|
* This routine handles PORT_ADDR events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtPortAddr(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 PortNumber; SK_U32 -1 */
|
|
{
|
|
SK_U32 i, j;
|
|
SK_RLMT_PORT *pRPort;
|
|
SK_MAC_ADDR *pOldMacAddr;
|
|
SK_MAC_ADDR *pNewMacAddr;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORT_ADDR Port %d Event BEGIN.\n", Para.Para32[0]))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORT_ADDR Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
/* Port's physical MAC address changed. */
|
|
pOldMacAddr = &pAC->Addr.Port[Para.Para32[0]].PreviousMacAddress;
|
|
pNewMacAddr = &pAC->Addr.Port[Para.Para32[0]].CurrentMacAddress;
|
|
|
|
/*
|
|
* NOTE: This is not scalable for solutions where ports are
|
|
* checked remotely. There, we need to send an RLMT
|
|
* address change packet - and how do we ensure delivery?
|
|
*/
|
|
for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
|
|
pRPort = &pAC->Rlmt.Port[i];
|
|
for (j = 0; j < pRPort->PortsChecked; j++) {
|
|
if (SK_ADDR_EQUAL(
|
|
pRPort->PortCheck[j].CheckAddr.a, pOldMacAddr->a)) {
|
|
pRPort->PortCheck[j].CheckAddr = *pNewMacAddr;
|
|
}
|
|
}
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PORT_ADDR Event END.\n"))
|
|
} /* SkRlmtEvtPortAddr */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtStart - START
|
|
*
|
|
* Description:
|
|
* This routine handles START events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtStart(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
|
|
{
|
|
SK_EVPARA Para2;
|
|
SK_U32 PortIdx;
|
|
SK_U32 PortNumber;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_START Net %d Event BEGIN.\n", Para.Para32[0]))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_START Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (Para.Para32[0] >= pAC->Rlmt.NumNets) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad NetNumber %d.\n", Para.Para32[0]))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_START Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (pAC->Rlmt.Net[Para.Para32[0]].RlmtState != SK_RLMT_RS_INIT) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_START Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (pAC->Rlmt.NetsStarted >= pAC->Rlmt.NumNets) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("All nets should have been started.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_START Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (pAC->Rlmt.Net[Para.Para32[0]].PrefPort >=
|
|
pAC->Rlmt.Net[Para.Para32[0]].NumPorts) {
|
|
SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E009, SKERR_RLMT_E009_MSG);
|
|
|
|
/* Change PrefPort to internal default. */
|
|
Para2.Para32[0] = 0xFFFFFFFF;
|
|
Para2.Para32[1] = Para.Para32[0];
|
|
(void)SkRlmtEvent(pAC, IoC, SK_RLMT_PREFPORT_CHANGE, Para2);
|
|
}
|
|
|
|
PortIdx = pAC->Rlmt.Net[Para.Para32[0]].PrefPort;
|
|
PortNumber = pAC->Rlmt.Net[Para.Para32[0]].Port[PortIdx]->PortNumber;
|
|
|
|
pAC->Rlmt.Net[Para.Para32[0]].LinksUp = 0;
|
|
pAC->Rlmt.Net[Para.Para32[0]].PortsUp = 0;
|
|
pAC->Rlmt.Net[Para.Para32[0]].CheckingState = 0;
|
|
pAC->Rlmt.Net[Para.Para32[0]].RlmtState = SK_RLMT_RS_NET_DOWN;
|
|
|
|
/* Start preferred port. */
|
|
SkRlmtPortStart(pAC, IoC, PortNumber);
|
|
|
|
/* Start Timer (for first port only). */
|
|
Para2.Para32[0] = PortNumber;
|
|
Para2.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pAC->Rlmt.Port[PortNumber].UpTimer,
|
|
SK_RLMT_PORTSTART_TIM_VAL, SKGE_RLMT, SK_RLMT_PORTSTART_TIM, Para2);
|
|
|
|
pAC->Rlmt.NetsStarted++;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_START Event END.\n"))
|
|
} /* SkRlmtEvtStart */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtStop - STOP
|
|
*
|
|
* Description:
|
|
* This routine handles STOP events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtStop(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
|
|
{
|
|
SK_EVPARA Para2;
|
|
SK_U32 PortNumber;
|
|
SK_U32 i;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STOP Net %d Event BEGIN.\n", Para.Para32[0]))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STOP Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (Para.Para32[0] >= pAC->Rlmt.NumNets) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad NetNumber %d.\n", Para.Para32[0]))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STOP Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (pAC->Rlmt.Net[Para.Para32[0]].RlmtState == SK_RLMT_RS_INIT) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STOP Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (pAC->Rlmt.NetsStarted == 0) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("All nets are stopped.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STOP Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
/* Stop RLMT timers. */
|
|
SkTimerStop(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[0]].LocTimer);
|
|
SkTimerStop(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[0]].SegTimer);
|
|
|
|
/* Stop net. */
|
|
pAC->Rlmt.Net[Para.Para32[0]].RlmtState = SK_RLMT_RS_INIT;
|
|
pAC->Rlmt.Net[Para.Para32[0]].RootIdSet = SK_FALSE;
|
|
Para2.Para32[0] = SK_RLMT_NET_DOWN_FINAL;
|
|
Para2.Para32[1] = Para.Para32[0]; /* Net# */
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_NET_DOWN, Para2);
|
|
|
|
/* Stop ports. */
|
|
for (i = 0; i < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; i++) {
|
|
PortNumber = pAC->Rlmt.Net[Para.Para32[0]].Port[i]->PortNumber;
|
|
if (pAC->Rlmt.Port[PortNumber].PortState != SK_RLMT_PS_INIT) {
|
|
SkTimerStop(pAC, IoC, &pAC->Rlmt.Port[PortNumber].UpTimer);
|
|
SkTimerStop(pAC, IoC, &pAC->Rlmt.Port[PortNumber].DownRxTimer);
|
|
SkTimerStop(pAC, IoC, &pAC->Rlmt.Port[PortNumber].DownTxTimer);
|
|
|
|
pAC->Rlmt.Port[PortNumber].PortState = SK_RLMT_PS_INIT;
|
|
pAC->Rlmt.Port[PortNumber].RootIdSet = SK_FALSE;
|
|
pAC->Rlmt.Port[PortNumber].PortStarted = SK_FALSE;
|
|
Para2.Para32[0] = PortNumber;
|
|
Para2.Para32[1] = (SK_U32)-1;
|
|
SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para2);
|
|
}
|
|
}
|
|
|
|
pAC->Rlmt.NetsStarted--;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STOP Event END.\n"))
|
|
} /* SkRlmtEvtStop */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtTim - TIM
|
|
*
|
|
* Description:
|
|
* This routine handles TIM events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtTim(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
|
|
{
|
|
SK_RLMT_PORT *pRPort;
|
|
SK_U32 Timeout;
|
|
SK_U32 NewTimeout;
|
|
SK_U32 PortNumber;
|
|
SK_U32 i;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_TIM Event BEGIN.\n"))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_TIM Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if ((pAC->Rlmt.Net[Para.Para32[0]].RlmtMode & SK_RLMT_CHECK_OTHERS) == 0 ||
|
|
pAC->Rlmt.Net[Para.Para32[0]].LinksUp == 0) {
|
|
/* Mode changed or all links down: No more link checking. */
|
|
return;
|
|
}
|
|
|
|
#if 0
|
|
pAC->Rlmt.SwitchCheckCounter--;
|
|
if (pAC->Rlmt.SwitchCheckCounter == 0) {
|
|
pAC->Rlmt.SwitchCheckCounter;
|
|
}
|
|
#endif /* 0 */
|
|
|
|
NewTimeout = SK_RLMT_DEF_TO_VAL;
|
|
for (i = 0; i < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; i++) {
|
|
PortNumber = pAC->Rlmt.Net[Para.Para32[0]].Port[i]->PortNumber;
|
|
pRPort = &pAC->Rlmt.Port[PortNumber];
|
|
if (!pRPort->LinkDown) {
|
|
Timeout = SkRlmtCheckPort(pAC, IoC, PortNumber);
|
|
if (Timeout < NewTimeout) {
|
|
NewTimeout = Timeout;
|
|
}
|
|
|
|
/*
|
|
* These counters should be set to 0 for all ports before the
|
|
* first frame is sent in the next loop.
|
|
*/
|
|
pRPort->PacketsPerTimeSlot = 0;
|
|
/* pRPort->DataPacketsPerTimeSlot = 0; */
|
|
pRPort->BpduPacketsPerTimeSlot = 0;
|
|
}
|
|
}
|
|
pAC->Rlmt.Net[Para.Para32[0]].TimeoutValue = NewTimeout;
|
|
|
|
if (pAC->Rlmt.Net[Para.Para32[0]].LinksUp > 1) {
|
|
/*
|
|
* If checking remote ports, also send packets if
|
|
* (LinksUp == 1) &&
|
|
* this port checks at least one (remote) port.
|
|
*/
|
|
|
|
/*
|
|
* Must be new loop, as SkRlmtCheckPort can request to
|
|
* check segmentation when e.g. checking the last port.
|
|
*/
|
|
for (i = 0; i < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; i++) {
|
|
if (!pAC->Rlmt.Net[Para.Para32[0]].Port[i]->LinkDown) {
|
|
SkRlmtSend(pAC, IoC,
|
|
pAC->Rlmt.Net[Para.Para32[0]].Port[i]->PortNumber);
|
|
}
|
|
}
|
|
}
|
|
|
|
SkTimerStart(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[0]].LocTimer,
|
|
pAC->Rlmt.Net[Para.Para32[0]].TimeoutValue, SKGE_RLMT, SK_RLMT_TIM,
|
|
Para);
|
|
|
|
if (pAC->Rlmt.Net[Para.Para32[0]].LinksUp > 1 &&
|
|
(pAC->Rlmt.Net[Para.Para32[0]].RlmtMode & SK_RLMT_CHECK_SEG) &&
|
|
(pAC->Rlmt.Net[Para.Para32[0]].CheckingState & SK_RLMT_RCS_START_SEG)) {
|
|
SkTimerStart(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[0]].SegTimer,
|
|
SK_RLMT_SEG_TO_VAL, SKGE_RLMT, SK_RLMT_SEG_TIM, Para);
|
|
pAC->Rlmt.Net[Para.Para32[0]].CheckingState &= ~SK_RLMT_RCS_START_SEG;
|
|
pAC->Rlmt.Net[Para.Para32[0]].CheckingState |=
|
|
SK_RLMT_RCS_SEG | SK_RLMT_RCS_REPORT_SEG;
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_TIM Event END.\n"))
|
|
} /* SkRlmtEvtTim */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtSegTim - SEG_TIM
|
|
*
|
|
* Description:
|
|
* This routine handles SEG_TIM events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtSegTim(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
|
|
{
|
|
#ifdef xDEBUG
|
|
int j;
|
|
#endif /* DEBUG */
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SEG_TIM Event BEGIN.\n"))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SEG_TIM Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
#ifdef xDEBUG
|
|
for (j = 0; j < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; j++) {
|
|
SK_ADDR_PORT *pAPort;
|
|
SK_U32 k;
|
|
SK_U16 *InAddr;
|
|
SK_U8 InAddr8[6];
|
|
|
|
InAddr = (SK_U16 *)&InAddr8[0];
|
|
pAPort = pAC->Rlmt.Net[Para.Para32[0]].Port[j]->AddrPort;
|
|
for (k = 0; k < pAPort->NextExactMatchRlmt; k++) {
|
|
/* Get exact match address k from port j. */
|
|
XM_INADDR(IoC, pAC->Rlmt.Net[Para.Para32[0]].Port[j]->PortNumber,
|
|
XM_EXM(k), InAddr);
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("MC address %d on Port %u: %02x %02x %02x %02x %02x %02x -- %02x %02x %02x %02x %02x %02x.\n",
|
|
k, pAC->Rlmt.Net[Para.Para32[0]].Port[j]->PortNumber,
|
|
InAddr8[0], InAddr8[1], InAddr8[2],
|
|
InAddr8[3], InAddr8[4], InAddr8[5],
|
|
pAPort->Exact[k].a[0], pAPort->Exact[k].a[1],
|
|
pAPort->Exact[k].a[2], pAPort->Exact[k].a[3],
|
|
pAPort->Exact[k].a[4], pAPort->Exact[k].a[5]))
|
|
}
|
|
}
|
|
#endif /* xDEBUG */
|
|
|
|
SkRlmtCheckSeg(pAC, IoC, Para.Para32[0]);
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SEG_TIM Event END.\n"))
|
|
} /* SkRlmtEvtSegTim */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtPacketRx - PACKET_RECEIVED
|
|
*
|
|
* Description:
|
|
* This routine handles PACKET_RECEIVED events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtPacketRx(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_MBUF *pMb */
|
|
{
|
|
SK_MBUF *pMb;
|
|
SK_MBUF *pNextMb;
|
|
SK_U32 NetNumber;
|
|
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PACKET_RECEIVED Event BEGIN.\n"))
|
|
|
|
/* Should we ignore frames during port switching? */
|
|
|
|
#ifdef DEBUG
|
|
pMb = Para.pParaPtr;
|
|
if (pMb == NULL) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL, ("No mbuf.\n"))
|
|
}
|
|
else if (pMb->pNext != NULL) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("More than one mbuf or pMb->pNext not set.\n"))
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
for (pMb = Para.pParaPtr; pMb != NULL; pMb = pNextMb) {
|
|
pNextMb = pMb->pNext;
|
|
pMb->pNext = NULL;
|
|
|
|
NetNumber = pAC->Rlmt.Port[pMb->PortIdx].Net->NetNumber;
|
|
if (pAC->Rlmt.Net[NetNumber].RlmtState == SK_RLMT_RS_INIT) {
|
|
SkDrvFreeRlmtMbuf(pAC, IoC, pMb);
|
|
}
|
|
else {
|
|
SkRlmtPacketReceive(pAC, IoC, pMb);
|
|
}
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PACKET_RECEIVED Event END.\n"))
|
|
} /* SkRlmtEvtPacketRx */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtStatsClear - STATS_CLEAR
|
|
*
|
|
* Description:
|
|
* This routine handles STATS_CLEAR events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtStatsClear(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
|
|
{
|
|
SK_U32 i;
|
|
SK_RLMT_PORT *pRPort;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STATS_CLEAR Event BEGIN.\n"))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STATS_CLEAR Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (Para.Para32[0] >= pAC->Rlmt.NumNets) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad NetNumber %d.\n", Para.Para32[0]))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STATS_CLEAR Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
/* Clear statistics for logical and physical ports. */
|
|
for (i = 0; i < pAC->Rlmt.Net[Para.Para32[0]].NumPorts; i++) {
|
|
pRPort =
|
|
&pAC->Rlmt.Port[pAC->Rlmt.Net[Para.Para32[0]].Port[i]->PortNumber];
|
|
pRPort->TxHelloCts = 0;
|
|
pRPort->RxHelloCts = 0;
|
|
pRPort->TxSpHelloReqCts = 0;
|
|
pRPort->RxSpHelloCts = 0;
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STATS_CLEAR Event END.\n"))
|
|
} /* SkRlmtEvtStatsClear */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtStatsUpdate - STATS_UPDATE
|
|
*
|
|
* Description:
|
|
* This routine handles STATS_UPDATE events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtStatsUpdate(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 NetNumber; SK_U32 -1 */
|
|
{
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STATS_UPDATE Event BEGIN.\n"))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STATS_UPDATE Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (Para.Para32[0] >= pAC->Rlmt.NumNets) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad NetNumber %d.\n", Para.Para32[0]))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STATS_UPDATE Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
/* Update statistics - currently always up-to-date. */
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_STATS_UPDATE Event END.\n"))
|
|
} /* SkRlmtEvtStatsUpdate */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtPrefportChange - PREFPORT_CHANGE
|
|
*
|
|
* Description:
|
|
* This routine handles PREFPORT_CHANGE events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtPrefportChange(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 PortIndex; SK_U32 NetNumber */
|
|
{
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PREFPORT_CHANGE to Port %d Event BEGIN.\n", Para.Para32[0]))
|
|
|
|
if (Para.Para32[1] >= pAC->Rlmt.NumNets) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad NetNumber %d.\n", Para.Para32[1]))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PREFPORT_CHANGE Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
/* 0xFFFFFFFF == auto-mode. */
|
|
if (Para.Para32[0] == 0xFFFFFFFF) {
|
|
pAC->Rlmt.Net[Para.Para32[1]].PrefPort = SK_RLMT_DEF_PREF_PORT;
|
|
}
|
|
else {
|
|
if (Para.Para32[0] >= pAC->Rlmt.Net[Para.Para32[1]].NumPorts) {
|
|
SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E010, SKERR_RLMT_E010_MSG);
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PREFPORT_CHANGE Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
pAC->Rlmt.Net[Para.Para32[1]].PrefPort = Para.Para32[0];
|
|
}
|
|
|
|
pAC->Rlmt.Net[Para.Para32[1]].Preference = Para.Para32[0];
|
|
|
|
if (pAC->Rlmt.Net[Para.Para32[1]].RlmtState != SK_RLMT_RS_INIT) {
|
|
SkRlmtCheckSwitch(pAC, IoC, Para.Para32[1]);
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_PREFPORT_CHANGE Event END.\n"))
|
|
} /* SkRlmtEvtPrefportChange */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtSetNets - SET_NETS
|
|
*
|
|
* Description:
|
|
* This routine handles SET_NETS events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtSetNets(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 NumNets; SK_U32 -1 */
|
|
{
|
|
int i;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SET_NETS Event BEGIN.\n"))
|
|
|
|
if (Para.Para32[1] != (SK_U32)-1) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad Parameter.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SET_NETS Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (Para.Para32[0] == 0 || Para.Para32[0] > SK_MAX_NETS ||
|
|
Para.Para32[0] > (SK_U32)pAC->GIni.GIMacsFound) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad number of nets: %d.\n", Para.Para32[0]))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SET_NETS Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (Para.Para32[0] == pAC->Rlmt.NumNets) { /* No change. */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SET_NETS Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
/* Entering and leaving dual mode only allowed while nets are stopped. */
|
|
if (pAC->Rlmt.NetsStarted > 0) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Changing dual mode only allowed while all nets are stopped.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SET_NETS Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
if (Para.Para32[0] == 1) {
|
|
if (pAC->Rlmt.NumNets > 1) {
|
|
/* Clear logical MAC addr from second net's active port. */
|
|
(void)SkAddrOverride(pAC, IoC, pAC->Rlmt.Net[1].Port[pAC->Addr.
|
|
Net[1].ActivePort]->PortNumber, NULL, SK_ADDR_CLEAR_LOGICAL);
|
|
pAC->Rlmt.Net[1].NumPorts = 0;
|
|
}
|
|
|
|
pAC->Rlmt.NumNets = Para.Para32[0];
|
|
for (i = 0; (SK_U32)i < pAC->Rlmt.NumNets; i++) {
|
|
pAC->Rlmt.Net[i].RlmtState = SK_RLMT_RS_INIT;
|
|
pAC->Rlmt.Net[i].RootIdSet = SK_FALSE;
|
|
pAC->Rlmt.Net[i].Preference = 0xFFFFFFFF; /* "Automatic" */
|
|
pAC->Rlmt.Net[i].PrefPort = SK_RLMT_DEF_PREF_PORT;
|
|
/* Just assuming. */
|
|
pAC->Rlmt.Net[i].ActivePort = pAC->Rlmt.Net[i].PrefPort;
|
|
pAC->Rlmt.Net[i].RlmtMode = SK_RLMT_DEF_MODE;
|
|
pAC->Rlmt.Net[i].TimeoutValue = SK_RLMT_DEF_TO_VAL;
|
|
pAC->Rlmt.Net[i].NetNumber = i;
|
|
}
|
|
|
|
pAC->Rlmt.Port[1].Net= &pAC->Rlmt.Net[0];
|
|
pAC->Rlmt.Net[0].NumPorts = pAC->GIni.GIMacsFound;
|
|
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_SET_NETS, Para);
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("RLMT: Changed to one net with two ports.\n"))
|
|
}
|
|
else if (Para.Para32[0] == 2) {
|
|
pAC->Rlmt.Port[1].Net= &pAC->Rlmt.Net[1];
|
|
pAC->Rlmt.Net[1].NumPorts = pAC->GIni.GIMacsFound - 1;
|
|
pAC->Rlmt.Net[0].NumPorts =
|
|
pAC->GIni.GIMacsFound - pAC->Rlmt.Net[1].NumPorts;
|
|
|
|
pAC->Rlmt.NumNets = Para.Para32[0];
|
|
for (i = 0; (SK_U32)i < pAC->Rlmt.NumNets; i++) {
|
|
pAC->Rlmt.Net[i].RlmtState = SK_RLMT_RS_INIT;
|
|
pAC->Rlmt.Net[i].RootIdSet = SK_FALSE;
|
|
pAC->Rlmt.Net[i].Preference = 0xFFFFFFFF; /* "Automatic" */
|
|
pAC->Rlmt.Net[i].PrefPort = SK_RLMT_DEF_PREF_PORT;
|
|
/* Just assuming. */
|
|
pAC->Rlmt.Net[i].ActivePort = pAC->Rlmt.Net[i].PrefPort;
|
|
pAC->Rlmt.Net[i].RlmtMode = SK_RLMT_DEF_MODE;
|
|
pAC->Rlmt.Net[i].TimeoutValue = SK_RLMT_DEF_TO_VAL;
|
|
|
|
pAC->Rlmt.Net[i].NetNumber = i;
|
|
}
|
|
|
|
/* Set logical MAC addr on second net's active port. */
|
|
(void)SkAddrOverride(pAC, IoC, pAC->Rlmt.Net[1].Port[pAC->Addr.
|
|
Net[1].ActivePort]->PortNumber, NULL, SK_ADDR_SET_LOGICAL);
|
|
|
|
SkEventQueue(pAC, SKGE_PNMI, SK_PNMI_EVT_RLMT_SET_NETS, Para);
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("RLMT: Changed to two nets with one port each.\n"))
|
|
}
|
|
else {
|
|
/* Not implemented for more than two nets. */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SetNets not implemented for more than two nets.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SET_NETS Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_SET_NETS Event END.\n"))
|
|
} /* SkRlmtSetNets */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvtModeChange - MODE_CHANGE
|
|
*
|
|
* Description:
|
|
* This routine handles MODE_CHANGE events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* Nothing
|
|
*/
|
|
RLMT_STATIC void SkRlmtEvtModeChange(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_EVPARA Para) /* SK_U32 NewMode; SK_U32 NetNumber */
|
|
{
|
|
SK_EVPARA Para2;
|
|
SK_U32 i;
|
|
SK_U32 PrevRlmtMode;
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_MODE_CHANGE Event BEGIN.\n"))
|
|
|
|
if (Para.Para32[1] >= pAC->Rlmt.NumNets) {
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Bad NetNumber %d.\n", Para.Para32[1]))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_MODE_CHANGE Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
Para.Para32[0] |= SK_RLMT_CHECK_LINK;
|
|
|
|
if ((pAC->Rlmt.Net[Para.Para32[1]].NumPorts == 1) &&
|
|
Para.Para32[0] != SK_RLMT_MODE_CLS) {
|
|
pAC->Rlmt.Net[Para.Para32[1]].RlmtMode = SK_RLMT_MODE_CLS;
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Forced RLMT mode to CLS on single port net.\n"))
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_MODE_CHANGE Event EMPTY.\n"))
|
|
return;
|
|
}
|
|
|
|
/* Update RLMT mode. */
|
|
PrevRlmtMode = pAC->Rlmt.Net[Para.Para32[1]].RlmtMode;
|
|
pAC->Rlmt.Net[Para.Para32[1]].RlmtMode = Para.Para32[0];
|
|
|
|
if ((PrevRlmtMode & SK_RLMT_CHECK_LOC_LINK) !=
|
|
(pAC->Rlmt.Net[Para.Para32[1]].RlmtMode & SK_RLMT_CHECK_LOC_LINK)) {
|
|
/* SK_RLMT_CHECK_LOC_LINK bit changed. */
|
|
if ((PrevRlmtMode & SK_RLMT_CHECK_OTHERS) == 0 &&
|
|
pAC->Rlmt.Net[Para.Para32[1]].NumPorts > 1 &&
|
|
pAC->Rlmt.Net[Para.Para32[1]].PortsUp >= 1) {
|
|
/* 20001207 RA: Was "PortsUp == 1". */
|
|
Para2.Para32[0] = Para.Para32[1];
|
|
Para2.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[1]].LocTimer,
|
|
pAC->Rlmt.Net[Para.Para32[1]].TimeoutValue,
|
|
SKGE_RLMT, SK_RLMT_TIM, Para2);
|
|
}
|
|
}
|
|
|
|
if ((PrevRlmtMode & SK_RLMT_CHECK_SEG) !=
|
|
(pAC->Rlmt.Net[Para.Para32[1]].RlmtMode & SK_RLMT_CHECK_SEG)) {
|
|
/* SK_RLMT_CHECK_SEG bit changed. */
|
|
for (i = 0; i < pAC->Rlmt.Net[Para.Para32[1]].NumPorts; i++) {
|
|
(void)SkAddrMcClear(pAC, IoC,
|
|
pAC->Rlmt.Net[Para.Para32[1]].Port[i]->PortNumber,
|
|
SK_ADDR_PERMANENT | SK_MC_SW_ONLY);
|
|
|
|
/* Add RLMT MC address. */
|
|
(void)SkAddrMcAdd(pAC, IoC,
|
|
pAC->Rlmt.Net[Para.Para32[1]].Port[i]->PortNumber,
|
|
&SkRlmtMcAddr, SK_ADDR_PERMANENT);
|
|
|
|
if ((pAC->Rlmt.Net[Para.Para32[1]].RlmtMode &
|
|
SK_RLMT_CHECK_SEG) != 0) {
|
|
/* Add BPDU MC address. */
|
|
(void)SkAddrMcAdd(pAC, IoC,
|
|
pAC->Rlmt.Net[Para.Para32[1]].Port[i]->PortNumber,
|
|
&BridgeMcAddr, SK_ADDR_PERMANENT);
|
|
|
|
if (pAC->Rlmt.Net[Para.Para32[1]].RlmtState != SK_RLMT_RS_INIT) {
|
|
if (!pAC->Rlmt.Net[Para.Para32[1]].Port[i]->LinkDown &&
|
|
(Para2.pParaPtr = SkRlmtBuildSpanningTreePacket(
|
|
pAC, IoC, i)) != NULL) {
|
|
pAC->Rlmt.Net[Para.Para32[1]].Port[i]->RootIdSet =
|
|
SK_FALSE;
|
|
SkEventQueue(pAC, SKGE_DRV, SK_DRV_RLMT_SEND, Para2);
|
|
}
|
|
}
|
|
}
|
|
(void)SkAddrMcUpdate(pAC, IoC,
|
|
pAC->Rlmt.Net[Para.Para32[1]].Port[i]->PortNumber);
|
|
} /* for ... */
|
|
|
|
if ((pAC->Rlmt.Net[Para.Para32[1]].RlmtMode & SK_RLMT_CHECK_SEG) != 0) {
|
|
Para2.Para32[0] = Para.Para32[1];
|
|
Para2.Para32[1] = (SK_U32)-1;
|
|
SkTimerStart(pAC, IoC, &pAC->Rlmt.Net[Para.Para32[1]].SegTimer,
|
|
SK_RLMT_SEG_TO_VAL, SKGE_RLMT, SK_RLMT_SEG_TIM, Para2);
|
|
}
|
|
} /* SK_RLMT_CHECK_SEG bit changed. */
|
|
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("SK_RLMT_MODE_CHANGE Event END.\n"))
|
|
} /* SkRlmtEvtModeChange */
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* SkRlmtEvent - a PORT- or an RLMT-specific event happened
|
|
*
|
|
* Description:
|
|
* This routine calls subroutines to handle PORT- and RLMT-specific events.
|
|
*
|
|
* Context:
|
|
* runtime, pageable?
|
|
* may be called after SK_INIT_IO
|
|
*
|
|
* Returns:
|
|
* 0
|
|
*/
|
|
int SkRlmtEvent(
|
|
SK_AC *pAC, /* Adapter Context */
|
|
SK_IOC IoC, /* I/O Context */
|
|
SK_U32 Event, /* Event code */
|
|
SK_EVPARA Para) /* Event-specific parameter */
|
|
{
|
|
switch (Event) {
|
|
|
|
/* ----- PORT events ----- */
|
|
|
|
case SK_RLMT_PORTSTART_TIM: /* From RLMT via TIME. */
|
|
SkRlmtEvtPortStartTim(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_LINK_UP: /* From SIRQ. */
|
|
SkRlmtEvtLinkUp(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_PORTUP_TIM: /* From RLMT via TIME. */
|
|
SkRlmtEvtPortUpTim(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_PORTDOWN: /* From RLMT. */
|
|
case SK_RLMT_PORTDOWN_RX_TIM: /* From RLMT via TIME. */
|
|
case SK_RLMT_PORTDOWN_TX_TIM: /* From RLMT via TIME. */
|
|
SkRlmtEvtPortDownX(pAC, IoC, Event, Para);
|
|
break;
|
|
case SK_RLMT_LINK_DOWN: /* From SIRQ. */
|
|
SkRlmtEvtLinkDown(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_PORT_ADDR: /* From ADDR. */
|
|
SkRlmtEvtPortAddr(pAC, IoC, Para);
|
|
break;
|
|
|
|
/* ----- RLMT events ----- */
|
|
|
|
case SK_RLMT_START: /* From DRV. */
|
|
SkRlmtEvtStart(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_STOP: /* From DRV. */
|
|
SkRlmtEvtStop(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_TIM: /* From RLMT via TIME. */
|
|
SkRlmtEvtTim(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_SEG_TIM:
|
|
SkRlmtEvtSegTim(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_PACKET_RECEIVED: /* From DRV. */
|
|
SkRlmtEvtPacketRx(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_STATS_CLEAR: /* From PNMI. */
|
|
SkRlmtEvtStatsClear(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_STATS_UPDATE: /* From PNMI. */
|
|
SkRlmtEvtStatsUpdate(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_PREFPORT_CHANGE: /* From PNMI. */
|
|
SkRlmtEvtPrefportChange(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_MODE_CHANGE: /* From PNMI. */
|
|
SkRlmtEvtModeChange(pAC, IoC, Para);
|
|
break;
|
|
case SK_RLMT_SET_NETS: /* From DRV. */
|
|
SkRlmtEvtSetNets(pAC, IoC, Para);
|
|
break;
|
|
|
|
/* ----- Unknown events ----- */
|
|
|
|
default: /* Create error log entry. */
|
|
SK_DBG_MSG(pAC, SK_DBGMOD_RLMT, SK_DBGCAT_CTRL,
|
|
("Unknown RLMT Event %d.\n", Event))
|
|
SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_RLMT_E003, SKERR_RLMT_E003_MSG);
|
|
break;
|
|
} /* switch() */
|
|
|
|
return (0);
|
|
} /* SkRlmtEvent */
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|