patch-2.3.29 linux/drivers/net/sk98lin/skaddr.c
Next file: linux/drivers/net/sk98lin/skcsum.c
Previous file: linux/drivers/net/sk98lin/h/xmac_ii.h
Back to the patch index
Back to the overall index
- Lines: 1301
- Date:
Tue Nov 23 10:15:42 1999
- Orig file:
v2.3.28/linux/drivers/net/sk98lin/skaddr.c
- Orig date:
Wed Dec 31 16:00:00 1969
diff -u --recursive --new-file v2.3.28/linux/drivers/net/sk98lin/skaddr.c linux/drivers/net/sk98lin/skaddr.c
@@ -0,0 +1,1300 @@
+/******************************************************************************
+ *
+ * Name: skaddr.c
+ * Project: GEnesis, PCI Gigabit Ethernet Adapter
+ * Version: $Revision: 1.33 $
+ * Date: $Date: 1999/05/28 10:56:06 $
+ * Purpose: Manage Addresses (Multicast and Unicast) and Promiscuous Mode
+ *
+ ******************************************************************************/
+
+/******************************************************************************
+ *
+ * (C)Copyright 1998,1999 SysKonnect,
+ * a business unit of Schneider & Koch & Co. Datensysteme GmbH.
+ *
+ * See the file "skge.c" for further information.
+ *
+ * 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: skaddr.c,v $
+ * Revision 1.33 1999/05/28 10:56:06 rassmann
+ * Editorial changes.
+ *
+ * Revision 1.32 1999/03/31 10:59:20 rassmann
+ * Returning Success instead of DupAddr if address shall be overridden
+ * with same value.
+ *
+ * Revision 1.31 1999/01/14 16:18:17 rassmann
+ * Corrected multicast initialization.
+ *
+ * Revision 1.30 1999/01/04 10:30:35 rassmann
+ * SkAddrOverride only possible after SK_INIT_IO phase.
+ *
+ * Revision 1.29 1998/12/29 13:13:10 rassmann
+ * An address override is now preserved in the SK_INIT_IO phase.
+ * All functions return an int now.
+ * Extended parameter checking.
+ *
+ * Revision 1.28 1998/12/01 11:45:53 rassmann
+ * Code cleanup.
+ *
+ * Revision 1.27 1998/12/01 09:22:49 rassmann
+ * SkAddrMcAdd and SkAddrMcUpdate returned SK_MC_FILTERING_INEXACT
+ * too often.
+ *
+ * Revision 1.26 1998/11/24 12:39:44 rassmann
+ * Reserved multicast entry for BPDU address.
+ * 13 multicast entries left for protocol.
+ *
+ * Revision 1.25 1998/11/17 16:54:23 rassmann
+ * Using exact match for up to 14 multicast addresses.
+ * Still receiving all multicasts if more addresses are added.
+ *
+ * Revision 1.24 1998/11/13 17:24:31 rassmann
+ * Changed return value of SkAddrOverride to int.
+ *
+ * Revision 1.23 1998/11/13 16:56:18 rassmann
+ * Added macro SK_ADDR_COMPARE.
+ * Changed return type of SkAddrOverride to SK_BOOL.
+ *
+ * Revision 1.22 1998/11/04 17:06:17 rassmann
+ * Corrected McUpdate and PromiscuousChange functions.
+ *
+ * Revision 1.21 1998/10/29 14:34:04 rassmann
+ * Clearing SK_ADDR struct at startup.
+ *
+ * Revision 1.20 1998/10/28 18:16:34 rassmann
+ * Avoiding I/Os before SK_INIT_RUN level.
+ * Aligning InexactFilter.
+ *
+ * Revision 1.19 1998/10/28 11:29:28 rassmann
+ * Programming physical address in SkAddrMcUpdate.
+ * Corrected programming of exact match entries.
+ *
+ * Revision 1.18 1998/10/28 10:34:48 rassmann
+ * Corrected reading of physical addresses.
+ *
+ * Revision 1.17 1998/10/28 10:26:13 rassmann
+ * Getting ports' current MAC addresses from EPROM now.
+ * Added debug output.
+ *
+ * Revision 1.16 1998/10/27 16:20:12 rassmann
+ * Reading MAC address byte by byte.
+ *
+ * Revision 1.15 1998/10/22 11:39:09 rassmann
+ * Corrected signed/unsigned mismatches.
+ *
+ * Revision 1.14 1998/10/19 17:12:35 rassmann
+ * Syntax corrections.
+ *
+ * Revision 1.13 1998/10/19 17:02:19 rassmann
+ * Now reading permanent MAC addresses from CRF.
+ *
+ * Revision 1.12 1998/10/15 15:15:48 rassmann
+ * Changed Flags Parameters from SK_U8 to int.
+ * Checked with lint.
+ *
+ * Revision 1.11 1998/09/24 19:15:12 rassmann
+ * Code cleanup.
+ *
+ * Revision 1.10 1998/09/18 20:18:54 rassmann
+ * Added HW access.
+ * Implemented swapping.
+ *
+ * Revision 1.9 1998/09/16 11:32:00 rassmann
+ * Including skdrv1st.h again. :(
+ *
+ * Revision 1.8 1998/09/16 11:09:34 rassmann
+ * Syntax corrections.
+ *
+ * Revision 1.7 1998/09/14 17:06:34 rassmann
+ * Minor changes.
+ *
+ * Revision 1.6 1998/09/07 08:45:41 rassmann
+ * Syntax corrections.
+ *
+ * Revision 1.5 1998/09/04 19:40:19 rassmann
+ * Interface enhancements.
+ *
+ * Revision 1.4 1998/09/04 12:14:12 rassmann
+ * Interface cleanup.
+ *
+ * Revision 1.3 1998/09/02 16:56:40 rassmann
+ * Updated interface.
+ *
+ * Revision 1.2 1998/08/27 14:26:09 rassmann
+ * Updated interface.
+ *
+ * Revision 1.1 1998/08/21 08:30:22 rassmann
+ * First public version.
+ *
+ ******************************************************************************/
+
+/******************************************************************************
+ *
+ * Description:
+ *
+ * This module is intended to manage multicast addresses, address override,
+ * and promiscuous mode on GEnesis adapters.
+ *
+ * Address Layout:
+ * port address: physical MAC address
+ * 1st exact match: logical MAC address
+ * 2nd exact match: RLMT multicast
+ * exact match 3-13: OS-specific multicasts
+ *
+ * Include File Hierarchy:
+ *
+ * "skdrv1st.h"
+ * "skdrv2nd.h"
+ *
+ ******************************************************************************/
+
+#ifndef lint
+static const char SysKonnectFileId[] =
+ "@(#) $Id: skaddr.c,v 1.33 1999/05/28 10:56:06 rassmann Exp $ (C) SysKonnect.";
+#endif /* !defined(lint) */
+
+#define __SKADDR_C
+
+#ifdef __cplusplus
+xxxx /* not supported yet - force error */
+extern "C" {
+#endif /* cplusplus */
+
+#include "h/skdrv1st.h"
+#include "h/skdrv2nd.h"
+
+/* defines ********************************************************************/
+
+#define SK_ADDR_CHEAT YES /* Cheat. */
+
+/*
+ * G32:
+ * POLY equ 04C11DB6h ; CRC polynominal term
+ * bit-reversed: 6DB88320
+ */
+
+#define CRC32_POLY 0xEDB88320UL /* CRC32-Poly - XMAC: Little Endian */
+#if 0
+#define CRC32_POLY 0x6DB88320UL /* CRC32-Poly - XMAC: Little Endian */
+#endif /* 0 */
+#define HASH_BITS 6 /* #bits in hash */
+#define SK_MC_BIT 0x01
+
+/* Error numbers and messages. */
+
+#define SKERR_ADDR_E001 (SK_ERRBASE_ADDR + 0)
+#define SKERR_ADDR_E001MSG "Bad Flags."
+#define SKERR_ADDR_E002 (SKERR_ADDR_E001 + 1)
+#define SKERR_ADDR_E002MSG "New Error."
+
+/* typedefs *******************************************************************/
+
+/* None. */
+
+/* global variables ***********************************************************/
+
+/* 64-bit hash values with all bits set. */
+
+SK_U16 OnesHash[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
+
+/* local variables ************************************************************/
+
+#ifdef DEBUG
+static int Next0[SK_MAX_MACS] = {0, 0};
+#endif /* DEBUG */
+
+/* functions ******************************************************************/
+
+#if 0
+void SkAddrDummy(void)
+{
+ SkAddrInit(NULL, NULL, 0);
+} /* SkAddrDummy */
+#endif /* 0 */
+
+/******************************************************************************
+ *
+ * SkAddrInit - initialize data, set state to init
+ *
+ * Description:
+ *
+ * SK_INIT_DATA
+ * ============
+ *
+ * This routine clears the multicast tables and resets promiscuous mode.
+ * Some entries are reserved for the "logical board address", the
+ * SK-RLMT multicast address, and the BPDU multicast address.
+ *
+ *
+ * SK_INIT_IO
+ * ==========
+ *
+ * All permanent MAC addresses are read from EPROM.
+ * If the current MAC addresses are not already set in software,
+ * they are set to the values of the permanent addresses.
+ * The current addresses are written to the corresponding XMAC.
+ *
+ *
+ * SK_INIT_RUN
+ * ===========
+ *
+ * Nothing.
+ *
+ * Context:
+ * init, pageable
+ *
+ * Returns:
+ * SK_ADDR_SUCCESS
+ */
+int SkAddrInit(
+SK_AC *pAC, /* the adapter context */
+SK_IOC IoC, /* I/O context */
+int Level) /* initialization level */
+{
+ int j;
+ SK_U32 i;
+ SK_U8 *InAddr;
+ SK_U16 *OutAddr;
+ SK_ADDR_PORT *pAPort;
+
+ switch (Level) {
+ case SK_INIT_DATA:
+ SK_MEMSET((char *)&pAC->Addr, 0, sizeof(SK_ADDR));
+
+ for (i = 0; i < SK_MAX_MACS; i++) {
+ pAPort = &pAC->Addr.Port[i];
+ pAPort->PromMode = SK_PROM_MODE_NONE;
+
+ pAPort->FirstExactMatchRlmt =
+ SK_ADDR_FIRST_MATCH_RLMT;
+ pAPort->FirstExactMatchDrv =
+ SK_ADDR_FIRST_MATCH_DRV;
+ pAPort->NextExactMatchRlmt =
+ SK_ADDR_FIRST_MATCH_RLMT;
+ pAPort->NextExactMatchDrv =
+ SK_ADDR_FIRST_MATCH_DRV;
+
+#if 0
+ /* Not here ... */
+
+ /* Reset Promiscuous mode. */
+
+ (void)SkAddrPromiscuousChange(
+ pAC,
+ IoC,
+ i,
+ SK_PROM_MODE_NONE);
+#endif /* 0 */
+ }
+
+#ifdef DEBUG
+ for (i = 0; i < SK_MAX_MACS; i++) {
+ if (pAC->Addr.Port[i].NextExactMatchRlmt <
+ SK_ADDR_FIRST_MATCH_RLMT) {
+ Next0[i] |= 4;
+ }
+ }
+#endif /* DEBUG */
+
+ /* pAC->Addr.InitDone = SK_INIT_DATA; */
+ break;
+
+ case SK_INIT_IO:
+ pAC->Addr.ActivePort = pAC->Rlmt.MacActive;
+
+#ifdef DEBUG
+ for (i = 0; i < SK_MAX_MACS; i++) {
+ if (pAC->Addr.Port[i].NextExactMatchRlmt <
+ SK_ADDR_FIRST_MATCH_RLMT) {
+ Next0[i] |= 8;
+ }
+ }
+#endif /* DEBUG */
+
+ /* Read permanent virtual address from Control Register File. */
+
+ for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
+ InAddr = (SK_U8 *)&pAC->Addr.PermanentMacAddress.a[j];
+ SK_IN8(IoC, B2_MAC_1 + j, InAddr);
+ }
+
+ if (!pAC->Addr.CurrentMacAddressSet) {
+ /*
+ * Set the current virtual MAC address
+ * to the permanent one.
+ */
+
+ pAC->Addr.CurrentMacAddress =
+ pAC->Addr.PermanentMacAddress;
+ pAC->Addr.CurrentMacAddressSet = SK_TRUE;
+ }
+
+ /* Set the current virtual MAC address. */
+
+ pAC->Addr.Port[pAC->Addr.ActivePort].Exact[0] =
+ pAC->Addr.CurrentMacAddress;
+
+#ifdef xDEBUG
+ SK_DBG_MSG(
+ pAC,
+ SK_DBGMOD_ADDR,
+ SK_DBGCAT_INIT,
+ ("Permanent MAC Address: %02X %02X %02X %02X %02X %02X\n",
+ pAC->Addr.PermanentMacAddress.a[0],
+ pAC->Addr.PermanentMacAddress.a[1],
+ pAC->Addr.PermanentMacAddress.a[2],
+ pAC->Addr.PermanentMacAddress.a[3],
+ pAC->Addr.PermanentMacAddress.a[4],
+ pAC->Addr.PermanentMacAddress.a[5]))
+ SK_DBG_MSG(
+ pAC,
+ SK_DBGMOD_ADDR,
+ SK_DBGCAT_INIT,
+ ("Virtual MAC Address: %02X %02X %02X %02X %02X %02X\n",
+ pAC->Addr.CurrentMacAddress.a[0],
+ pAC->Addr.CurrentMacAddress.a[1],
+ pAC->Addr.CurrentMacAddress.a[2],
+ pAC->Addr.CurrentMacAddress.a[3],
+ pAC->Addr.CurrentMacAddress.a[4],
+ pAC->Addr.CurrentMacAddress.a[5]))
+#endif /* DEBUG */
+
+#if 0
+ /* Not here ... */
+
+ (void)SkAddrMcUpdate(pAC, IoC, pAC->Addr.ActivePort);
+#endif /* 0 */
+
+ for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
+ pAPort = &pAC->Addr.Port[i];
+
+ /*
+ * Read permanent port addresses from
+ * Control Register File.
+ */
+
+ for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
+ InAddr = (SK_U8 *)
+ &pAPort->PermanentMacAddress.a[j];
+ SK_IN8(IoC, B2_MAC_2 + 8 * i + j, InAddr);
+ }
+
+ if (!pAPort->CurrentMacAddressSet) {
+ /*
+ * Set the current and previous physical
+ * MAC address of this port to its permanent
+ * MAC address.
+ */
+
+ pAPort->CurrentMacAddress =
+ pAPort->PermanentMacAddress;
+ pAPort->PreviousMacAddress =
+ pAPort->PermanentMacAddress;
+ pAPort->CurrentMacAddressSet = SK_TRUE;
+ }
+
+ /* Set port's current MAC addresses. */
+
+ OutAddr = (SK_U16 *)&pAPort->CurrentMacAddress.a[0];
+ XM_OUTADDR(IoC, i, XM_SA, OutAddr);
+
+#ifdef xDEBUG
+ SK_DBG_MSG(
+ pAC,
+ SK_DBGMOD_ADDR,
+ SK_DBGCAT_INIT,
+ ("Permanent Physical MAC Address: %02X %02X %02X %02X %02X %02X\n",
+ pAPort->PermanentMacAddress.a[0],
+ pAPort->PermanentMacAddress.a[1],
+ pAPort->PermanentMacAddress.a[2],
+ pAPort->PermanentMacAddress.a[3],
+ pAPort->PermanentMacAddress.a[4],
+ pAPort->PermanentMacAddress.a[5]))
+ SK_DBG_MSG(
+ pAC,
+ SK_DBGMOD_ADDR,
+ SK_DBGCAT_INIT,
+ ("Phsical MAC Address: %02X %02X %02X %02X %02X %02X\n",
+ pAPort->CurrentMacAddress.a[0],
+ pAPort->CurrentMacAddress.a[1],
+ pAPort->CurrentMacAddress.a[2],
+ pAPort->CurrentMacAddress.a[3],
+ pAPort->CurrentMacAddress.a[4],
+ pAPort->CurrentMacAddress.a[5]))
+#endif /* DEBUG */
+ }
+ /* pAC->Addr.InitDone = SK_INIT_IO; */
+ break;
+
+ case SK_INIT_RUN:
+#ifdef DEBUG
+ for (i = 0; i < SK_MAX_MACS; i++) {
+ if (pAC->Addr.Port[i].NextExactMatchRlmt <
+ SK_ADDR_FIRST_MATCH_RLMT) {
+ Next0[i] |= 16;
+ }
+ }
+#endif /* DEBUG */
+
+ /* pAC->Addr.InitDone = SK_INIT_RUN; */
+ break;
+
+ default: /* error */
+ break;
+ }
+
+ return (SK_ADDR_SUCCESS);
+} /* SkAddrInit */
+
+
+/******************************************************************************
+ *
+ * SkAddrMcClear - clear the multicast table
+ *
+ * Description:
+ * This routine clears the multicast table
+ * (either entry 2 or entries 3-16 and InexactFilter) of the given port.
+ * If not suppressed by Flag SK_MC_SW_ONLY, the hardware is updated
+ * immediately.
+ *
+ * Context:
+ * runtime, pageable
+ * may be called starting with SK_INIT_DATA with flag SK_MC_SW_ONLY
+ * may be called after SK_INIT_IO without limitation
+ *
+ * Returns:
+ * SK_ADDR_SUCCESS
+ * SK_ADDR_ILLEGAL_PORT
+ */
+int SkAddrMcClear(
+SK_AC *pAC, /* adapter context */
+SK_IOC IoC, /* I/O context */
+SK_U32 PortIdx, /* Index of affected port */
+int Flags) /* permanent/non-perm, sw-only */
+{
+ int i;
+
+ if (PortIdx >= (SK_U32)pAC->GIni.GIMacsFound) {
+ return (SK_ADDR_ILLEGAL_PORT);
+ }
+
+ if (Flags & SK_ADDR_PERMANENT) {
+
+ /* Clear RLMT multicast addresses. */
+
+ pAC->Addr.Port[PortIdx].NextExactMatchRlmt =
+ SK_ADDR_FIRST_MATCH_RLMT;
+ }
+ else { /* not permanent => DRV */
+
+ /* Clear InexactFilter. */
+
+ for (i = 0; i < 8; i++) {
+ pAC->Addr.Port[PortIdx].InexactFilter.Bytes[i] = 0;
+ }
+
+ /* Clear DRV multicast addresses. */
+
+ pAC->Addr.Port[PortIdx].NextExactMatchDrv =
+ SK_ADDR_FIRST_MATCH_DRV;
+ }
+
+ if (!(Flags & SK_MC_SW_ONLY)) {
+ (void)SkAddrMcUpdate(pAC, IoC, PortIdx);
+ }
+
+ return (SK_ADDR_SUCCESS);
+} /* SkAddrMcClear */
+
+#ifndef SK_ADDR_CHEAT
+// RA;:;:
+/******************************************************************************
+ *
+ * SkCrc32McHash - hash multicast address
+ *
+ * Description:
+ * This routine computes the hash value for a multicast address.
+ *
+ * Notes:
+ * The code was adapted from the XaQti data sheet.
+ *
+ * Context:
+ * runtime, pageable
+ *
+ * Returns:
+ * Hash value of multicast address.
+ */
+unsigned SkCrc32McHash(
+unsigned char *pMc) /* Multicast address */
+{
+ unsigned Idx;
+ unsigned Bit;
+ unsigned Data;
+ unsigned Crc;
+
+ Crc = 0xFFFFFFFFUL;
+ for (Idx = 0; Idx < SK_MAC_ADDR_LEN; Idx++) {
+ Data = *pMc++;
+ for (Bit = 0; Bit < 8; Bit++, Data >>= 1) {
+ Crc = (Crc >> 1) ^
+ (((Crc ^ Data) & 1) ? CRC32_POLY : 0);
+ }
+ }
+
+ return (Crc & ((1 << HASH_BITS) - 1));
+
+} /* SkCrc32McHash */
+
+#endif /* not SK_ADDR_CHEAT */
+
+/******************************************************************************
+ *
+ * SkAddrMcAdd - add a multicast address to a port
+ *
+ * Description:
+ * This routine enables reception for a given address on the given port.
+ *
+ * Notes:
+ * The return code is only valid for SK_PROM_MODE_NONE.
+ *
+ * In the current version, only RLMT may add addresses to the non-active
+ * port.
+ *
+ * The multicast bit is only checked if there are no free exact match
+ * entries.
+ *
+ * Context:
+ * runtime, pageable
+ * may be called after SK_INIT_DATA
+ *
+ * Returns:
+ * SK_MC_FILTERING_EXACT
+ * SK_MC_FILTERING_INEXACT
+ * SK_MC_ILLEGAL_ADDRESS
+ * SK_MC_ILLEGAL_PORT
+ * SK_MC_RLMT_OVERFLOW
+ */
+int SkAddrMcAdd(
+SK_AC *pAC, /* adapter context */
+SK_IOC IoC, /* I/O context */
+SK_U32 PortIdx, /* Port Index */
+SK_MAC_ADDR *pMc, /* multicast address to be added */
+int Flags) /* permanent/non-permanent */
+{
+ int i;
+ SK_U8 Inexact;
+#ifndef SK_ADDR_CHEAT
+ unsigned HashBit;
+#endif /* !defined(SK_ADDR_CHEAT) */
+
+ if (PortIdx >= (SK_U32)pAC->GIni.GIMacsFound) {
+ return (SK_ADDR_ILLEGAL_PORT);
+ }
+
+ if (Flags & SK_ADDR_PERMANENT) {
+#ifdef DEBUG
+ if (pAC->Addr.Port[PortIdx].NextExactMatchRlmt <
+ SK_ADDR_FIRST_MATCH_RLMT) {
+ Next0[PortIdx] |= 1;
+ return (SK_MC_RLMT_OVERFLOW);
+ }
+#endif /* DEBUG */
+
+ if (pAC->Addr.Port[PortIdx].NextExactMatchRlmt >
+ SK_ADDR_LAST_MATCH_RLMT) {
+ return (SK_MC_RLMT_OVERFLOW);
+ }
+
+ /* Set an RLMT multicast address. */
+
+ pAC->Addr.Port[PortIdx].Exact[
+ pAC->Addr.Port[PortIdx].NextExactMatchRlmt++] = *pMc;
+
+ return (SK_MC_FILTERING_EXACT);
+ }
+
+ /* Not PERMANENT => DRV */
+
+ if (PortIdx != pAC->Addr.ActivePort) {
+
+ /* Only RLMT is allowed to do this. */
+
+ return (SK_MC_ILLEGAL_PORT);
+ }
+
+#ifdef DEBUG
+ if (pAC->Addr.Port[PortIdx].NextExactMatchDrv <
+ SK_ADDR_FIRST_MATCH_DRV) {
+ Next0[PortIdx] |= 2;
+ return (SK_MC_RLMT_OVERFLOW);
+ }
+#endif /* DEBUG */
+
+ if (pAC->Addr.Port[PortIdx].NextExactMatchDrv <= SK_ADDR_LAST_MATCH_DRV) {
+
+ /* Set exact match entry. */
+
+ pAC->Addr.Port[PortIdx].Exact[
+ pAC->Addr.Port[PortIdx].NextExactMatchDrv++] = *pMc;
+
+ /* Clear InexactFilter. */
+
+ for (i = 0; i < 8; i++) {
+ pAC->Addr.Port[PortIdx
+ ].InexactFilter.Bytes[i] = 0;
+ }
+ }
+ else {
+ if (!(pMc->a[0] & SK_MC_BIT)) {
+
+ /*
+ * Hashing only possible with
+ * multicast addresses.
+ */
+
+ return (SK_MC_ILLEGAL_ADDRESS);
+ }
+#ifndef SK_ADDR_CHEAT
+ /* Compute hash value of address. */
+RA;:;: untested
+ HashBit = SkCrc32McHash(&pMc->a[0]);
+
+ /* Add bit to InexactFilter. */
+
+ pAC->Addr.Port[PortIdx].InexactFilter.Bytes[HashBit / 8] |=
+ 1 << (HashBit % 8);
+
+#else /* SK_ADDR_CHEAT */
+
+ /* Set all bits in InexactFilter. */
+
+ for (i = 0; i < 8; i++) {
+ pAC->Addr.Port[PortIdx].InexactFilter.Bytes[i] = 0xFF;
+ }
+#endif /* SK_ADDR_CHEAT */
+ }
+
+ for (Inexact = 0, i = 0; i < 8; i++) {
+ Inexact |= pAC->Addr.Port[PortIdx].InexactFilter.Bytes[i];
+ }
+
+ if (Inexact == 0 && pAC->Addr.Port[PortIdx].PromMode == 0) {
+ return (SK_MC_FILTERING_EXACT);
+ }
+ else {
+ return (SK_MC_FILTERING_INEXACT);
+ }
+} /* SkAddrMcAdd */
+
+
+/******************************************************************************
+ *
+ * SkAddrMcUpdate - update the HW MC address table and set the MAC address
+ *
+ * Description:
+ * This routine enables reception of the addresses contained in a local
+ * table for a given port.
+ * It also programs the port's current physical MAC address.
+ *
+ * Notes:
+ * The return code is only valid for SK_PROM_MODE_NONE.
+ *
+ * Context:
+ * runtime, pageable
+ * may be called after SK_INIT_IO
+ *
+ * Returns:
+ * SK_MC_FILTERING_EXACT
+ * SK_MC_FILTERING_INEXACT
+ * SK_ADDR_ILLEGAL_PORT
+ */
+int SkAddrMcUpdate(
+SK_AC *pAC, /* adapter context */
+SK_IOC IoC, /* I/O context */
+SK_U32 PortIdx) /* Port Index */
+{
+ SK_U32 i;
+ SK_U8 Inexact;
+ SK_U16 *OutAddr;
+ SK_U16 LoMode; /* Lower 16 bits of XMAC Mode Reg. */
+ SK_ADDR_PORT *pAPort;
+
+ if (PortIdx >= (SK_U32)pAC->GIni.GIMacsFound) {
+ return (SK_ADDR_ILLEGAL_PORT);
+ }
+
+ SK_DBG_MSG(
+ pAC,
+ SK_DBGMOD_ADDR,
+ SK_DBGCAT_CTRL,
+ ("SkAddrMcUpdate on Port %u.\n", PortIdx))
+
+ pAPort = &pAC->Addr.Port[PortIdx];
+
+#ifdef DEBUG
+ SK_DBG_MSG(
+ pAC,
+ SK_DBGMOD_ADDR,
+ SK_DBGCAT_CTRL,
+ ("Next0 on Port %d: %d\n", PortIdx, Next0[PortIdx]))
+#endif /* DEBUG */
+
+ for (i = 0; /* Also program the virtual address. */
+ i < pAPort->NextExactMatchRlmt;
+ i++) {
+
+ /* Set exact match address i on HW. */
+
+ OutAddr = (SK_U16 *)&pAPort->Exact[i].a[0];
+ XM_OUTADDR(IoC, PortIdx, XM_EXM(i), OutAddr);
+ }
+
+ /* Clear other permanent exact match addresses on HW. */
+
+ if (pAPort->NextExactMatchRlmt <= SK_ADDR_LAST_MATCH_RLMT) {
+ SkXmClrExactAddr(
+ pAC,
+ IoC,
+ PortIdx,
+ pAPort->NextExactMatchRlmt,
+ SK_ADDR_LAST_MATCH_RLMT);
+ }
+
+ for (i = pAPort->FirstExactMatchDrv;
+ i < pAPort->NextExactMatchDrv;
+ i++) {
+
+ OutAddr = (SK_U16 *)&pAPort->Exact[i].a[0];
+ XM_OUTADDR(IoC, PortIdx, XM_EXM(i), OutAddr);
+
+ }
+
+ /* Clear other non-permanent exact match addresses on HW. */
+
+ if (pAPort->NextExactMatchDrv <= SK_ADDR_LAST_MATCH_DRV) {
+ SkXmClrExactAddr(
+ pAC,
+ IoC,
+ PortIdx,
+ pAPort->NextExactMatchDrv,
+ SK_ADDR_LAST_MATCH_DRV);
+ }
+
+ for (Inexact = 0xFF, i = 0; i < 8; i++) {
+ Inexact &= pAPort->InexactFilter.Bytes[i];
+ }
+ if (pAPort->PromMode & SK_PROM_MODE_ALL_MC) {
+
+ /* Set all bits in 64-bit hash register. */
+
+ XM_OUTHASH(IoC, PortIdx, XM_HSM, &OnesHash);
+
+ /* Set bit 15 in mode register. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+ LoMode |= XM_MD_ENA_HSH;
+ XM_OUT16(IoC, PortIdx, XM_MODE, LoMode);
+ }
+ else if (Inexact != 0xFF) {
+
+ /* Clear bit 15 in mode register. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+ LoMode &= ~XM_MD_ENA_HSH;
+ XM_OUT16(IoC, PortIdx, XM_MODE, LoMode);
+ }
+ else {
+ /* Set 64-bit hash register to InexactFilter. */
+
+ XM_OUTHASH(
+ IoC,
+ PortIdx,
+ XM_HSM,
+ &pAPort->InexactFilter.Bytes[0]);
+
+ /* Set bit 15 in mode register. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+ LoMode |= XM_MD_ENA_HSH;
+ XM_OUT16(IoC, PortIdx, XM_MODE, LoMode);
+ }
+
+ if (pAPort->PromMode != SK_PROM_MODE_NONE) {
+ (void)SkAddrPromiscuousChange(
+ pAC,
+ IoC,
+ PortIdx,
+ pAPort->PromMode);
+ }
+
+ /* Set port's current MAC address. */
+
+ OutAddr = (SK_U16 *)&pAPort->CurrentMacAddress.a[0];
+ XM_OUTADDR(IoC, PortIdx, XM_SA, OutAddr);
+
+#ifdef DEBUG
+ for (i = 0; /* Also program the virtual address. */
+ i < pAPort->NextExactMatchRlmt;
+ i++) {
+ SK_U8 InAddr8[6];
+ SK_U16 *InAddr;
+
+ /* Get exact match address i from port PortIdx. */
+
+ InAddr = (SK_U16 *)&InAddr8[0];
+ XM_INADDR(IoC, PortIdx, XM_EXM(i), 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",
+ i,
+ PortIdx,
+ InAddr8[0],
+ InAddr8[1],
+ InAddr8[2],
+ InAddr8[3],
+ InAddr8[4],
+ InAddr8[5],
+ pAPort->Exact[i].a[0],
+ pAPort->Exact[i].a[1],
+ pAPort->Exact[i].a[2],
+ pAPort->Exact[i].a[3],
+ pAPort->Exact[i].a[4],
+ pAPort->Exact[i].a[5]))
+ }
+#endif /* DEBUG */
+
+ /* Determine return value. */
+
+ for (Inexact = 0, i = 0; i < 8; i++) {
+ Inexact |= pAPort->InexactFilter.Bytes[i];
+ }
+ if (Inexact == 0 && pAPort->PromMode == 0) {
+ return (SK_MC_FILTERING_EXACT);
+ }
+ else {
+ return (SK_MC_FILTERING_INEXACT);
+ }
+} /* SkAddrMcUpdate */
+
+
+/******************************************************************************
+ *
+ * SkAddrOverride - override a port's MAC address
+ *
+ * Description:
+ * This routine overrides the MAC address of one port.
+ *
+ * Context:
+ * runtime, pageable
+ * may be called after SK_INIT_IO
+ *
+ * Returns:
+ * SK_ADDR_SUCCESS if successful.
+ * SK_ADDR_DUPLICATE_ADDRESS if duplicate MAC address.
+ * SK_ADDR_MULTICAST_ADDRESS if multicast or broadcast address.
+ * SK_ADDR_TOO_EARLY if SK_INIT_IO was not executed before.
+ */
+int SkAddrOverride(
+SK_AC *pAC, /* adapter context */
+SK_IOC IoC, /* I/O context */
+SK_U32 PortIdx, /* Port Index */
+SK_MAC_ADDR *pNewAddr, /* new MAC address */
+int Flags) /* logical/physical address */
+{
+ SK_U32 i;
+ SK_U16 *OutAddr;
+ SK_EVPARA Para;
+#if 0
+ SK_MAC_ADDR NewAddr; /* new MAC address */
+ SK_U8 AddrBits;
+#endif /* 0 */
+
+ if (PortIdx >= (SK_U32)pAC->GIni.GIMacsFound) {
+ return (SK_ADDR_ILLEGAL_PORT);
+ }
+
+ if (pNewAddr->a[0] & SK_MC_BIT) {
+ return (SK_ADDR_MULTICAST_ADDRESS);
+ }
+
+#if 0
+DANGEROUS!
+ if (Flags & SK_ADDR_PHYSICAL_ADDRESS) { /* Physical address. */
+ if (!pAC->Addr.Port[PortIdx].CurrentMacAddressSet) {
+ pAC->Addr.Port[PortIdx].PreviousMacAddress = *pNewAddr;
+ pAC->Addr.Port[PortIdx].CurrentMacAddress = *pNewAddr;
+ pAC->Addr.Port[PortIdx].CurrentMacAddressSet = SK_TRUE;
+ return (SK_ADDR_SUCCESS);
+ }
+ }
+ else {
+ if (!pAC->Addr.CurrentMacAddressSet) {
+ pAC->Addr.CurrentMacAddress = *pNewAddr;
+ pAC->Addr.CurrentMacAddressSet = SK_TRUE;
+ return (SK_ADDR_SUCCESS);
+ }
+ }
+DANGEROUS!
+#endif /* 0 */
+
+ if (!pAC->Addr.CurrentMacAddressSet) {
+ return (SK_ADDR_TOO_EARLY);
+ }
+
+ if (Flags & SK_ADDR_PHYSICAL_ADDRESS) { /* Physical address. */
+ if (SK_ADDR_EQUAL(pNewAddr->a, pAC->Addr.CurrentMacAddress.a)) {
+ return (SK_ADDR_DUPLICATE_ADDRESS);
+ }
+
+ for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
+ if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
+ return (SK_ADDR_TOO_EARLY);
+ }
+
+ if (SK_ADDR_EQUAL(
+ pNewAddr->a,
+ pAC->Addr.Port[i].CurrentMacAddress.a)) {
+ if (i == PortIdx) {
+ return (SK_ADDR_SUCCESS);
+ }
+ else {
+ return (SK_ADDR_DUPLICATE_ADDRESS);
+ }
+ }
+ }
+
+ pAC->Addr.Port[PortIdx].PreviousMacAddress =
+ pAC->Addr.Port[PortIdx].CurrentMacAddress;
+ pAC->Addr.Port[PortIdx].CurrentMacAddress = *pNewAddr;
+
+ /* Change port's address. */
+
+ OutAddr = (SK_U16 *)pNewAddr;
+ XM_OUTADDR(IoC, PortIdx, XM_SA, OutAddr);
+
+ /* Report address change to RLMT. */
+
+ Para.Para32[0] = PortIdx;
+ SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_PORT_ADDR, Para);
+ }
+ else { /* Logical Address. */
+ if (SK_ADDR_EQUAL(pNewAddr->a, pAC->Addr.CurrentMacAddress.a)) {
+ return (SK_ADDR_SUCCESS);
+ }
+
+ for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
+ if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
+ return (SK_ADDR_TOO_EARLY);
+ }
+
+ if (SK_ADDR_EQUAL(
+ pNewAddr->a,
+ pAC->Addr.Port[i].CurrentMacAddress.a)) {
+ return (SK_ADDR_DUPLICATE_ADDRESS);
+ }
+ }
+
+ pAC->Addr.CurrentMacAddress = *pNewAddr;
+ pAC->Addr.Port[PortIdx].Exact[0] = *pNewAddr;
+
+#ifdef DEBUG
+ SK_DBG_MSG(
+ pAC,
+ SK_DBGMOD_ADDR,
+ SK_DBGCAT_CTRL,
+ ("Permanent MAC Address: %02X %02X %02X %02X %02X %02X\n",
+ pAC->Addr.PermanentMacAddress.a[0],
+ pAC->Addr.PermanentMacAddress.a[1],
+ pAC->Addr.PermanentMacAddress.a[2],
+ pAC->Addr.PermanentMacAddress.a[3],
+ pAC->Addr.PermanentMacAddress.a[4],
+ pAC->Addr.PermanentMacAddress.a[5]))
+ SK_DBG_MSG(
+ pAC,
+ SK_DBGMOD_ADDR,
+ SK_DBGCAT_CTRL,
+ ("New Virtual MAC Address: %02X %02X %02X %02X %02X %02X\n",
+ pAC->Addr.CurrentMacAddress.a[0],
+ pAC->Addr.CurrentMacAddress.a[1],
+ pAC->Addr.CurrentMacAddress.a[2],
+ pAC->Addr.CurrentMacAddress.a[3],
+ pAC->Addr.CurrentMacAddress.a[4],
+ pAC->Addr.CurrentMacAddress.a[5]))
+#endif /* DEBUG */
+
+ /* Write address to first exact match entry of active port. */
+
+ (void)SkAddrMcUpdate(pAC, IoC, PortIdx);
+ }
+
+ return (SK_ADDR_SUCCESS);
+} /* SkAddrOverride */
+
+
+/******************************************************************************
+ *
+ * SkAddrPromiscuousChange - set promiscuous mode for given port
+ *
+ * Description:
+ * This routine manages promiscuous mode:
+ * - none
+ * - all LLC frames
+ * - all MC frames
+ *
+ * Context:
+ * runtime, pageable
+ * may be called after SK_INIT_IO
+ *
+ * Returns:
+ * SK_ADDR_SUCCESS
+ * SK_ADDR_ILLEGAL_PORT
+ */
+int SkAddrPromiscuousChange(
+SK_AC *pAC, /* adapter context */
+SK_IOC IoC, /* I/O context */
+SK_U32 PortIdx, /* port whose promiscuous mode changes */
+int NewPromMode) /* new promiscuous mode */
+{
+ int i;
+ SK_BOOL InexactModeBit;
+ SK_U8 Inexact;
+ SK_U8 HwInexact;
+ SK_FILTER64 HwInexactFilter;
+ SK_U16 LoMode; /* Lower 16 bits of XMAC Mode Register. */
+ int CurPromMode = SK_PROM_MODE_NONE;
+
+ if (PortIdx >= (SK_U32)pAC->GIni.GIMacsFound) {
+ return (SK_ADDR_ILLEGAL_PORT);
+ }
+
+ /* Read CurPromMode from Hardware. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+
+ if (LoMode & XM_MD_ENA_PROM) {
+ CurPromMode |= SK_PROM_MODE_LLC;
+ }
+
+ for (Inexact = 0xFF, i = 0; i < 8; i++) {
+ Inexact &= pAC->Addr.Port[PortIdx].InexactFilter.Bytes[i];
+ }
+ if (Inexact == 0xFF) {
+ CurPromMode |= (pAC->Addr.Port[PortIdx].PromMode &
+ SK_PROM_MODE_ALL_MC);
+ }
+ else {
+ /* Read InexactModeBit (bit 15 in mode register). */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+
+ InexactModeBit = (LoMode & XM_MD_ENA_HSH) != 0;
+
+ /* Read 64-bit hash register from HW. */
+
+ XM_INHASH(IoC, PortIdx, XM_HSM, &HwInexactFilter.Bytes[0]);
+
+ for (HwInexact = 0xFF, i = 0; i < 8; i++) {
+ HwInexact &= HwInexactFilter.Bytes[i];
+ }
+
+ if (InexactModeBit && (HwInexact == 0xFF)) {
+ CurPromMode |= SK_PROM_MODE_ALL_MC;
+ }
+ }
+
+ pAC->Addr.Port[PortIdx].PromMode = NewPromMode;
+
+ if (NewPromMode == CurPromMode) {
+ return (SK_ADDR_SUCCESS);
+ }
+
+ if ((NewPromMode & SK_PROM_MODE_ALL_MC) &&
+ !(CurPromMode & SK_PROM_MODE_ALL_MC)) { /* All MC. */
+
+ /* Set all bits in 64-bit hash register. */
+
+ XM_OUTHASH(IoC, PortIdx, XM_HSM, &OnesHash);
+
+ /* Set bit 15 in mode register. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+ LoMode |= XM_MD_ENA_HSH;
+ XM_OUT16(IoC, PortIdx, XM_MODE, LoMode);
+ }
+ else if ((CurPromMode & SK_PROM_MODE_ALL_MC) &&
+ !(NewPromMode & SK_PROM_MODE_ALL_MC)) { /* Norm MC. */
+
+ for (Inexact = 0, i = 0; i < 8; i++) {
+ Inexact |=
+ pAC->Addr.Port[PortIdx].InexactFilter.Bytes[i];
+ }
+ if (Inexact == 0) {
+ /* Clear bit 15 in mode register. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+ LoMode &= ~XM_MD_ENA_HSH;
+ XM_OUT16(IoC, PortIdx, XM_MODE, LoMode);
+ }
+ else {
+ /* Set 64-bit hash register to InexactFilter. */
+
+ XM_OUTHASH(
+ IoC,
+ PortIdx,
+ XM_HSM,
+ &pAC->Addr.Port[PortIdx
+ ].InexactFilter.Bytes[0]);
+
+ /* Set bit 15 in mode register. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+ LoMode |= XM_MD_ENA_HSH;
+ XM_OUT16(IoC, PortIdx, XM_MODE, LoMode);
+ }
+ }
+
+ if ((NewPromMode & SK_PROM_MODE_LLC) &&
+ !(CurPromMode & SK_PROM_MODE_LLC)) { /* Prom. LLC */
+
+ /* Set promiscuous bit in mode register. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+#if 0
+ /* Receive MAC frames. */
+
+ LoMode |= XM_MD_RX_MCTRL;
+#endif /* 0 */
+ LoMode |= XM_MD_ENA_PROM;
+ XM_OUT16(IoC, PortIdx, XM_MODE, LoMode);
+ }
+ else if ((CurPromMode & SK_PROM_MODE_LLC) &&
+ !(NewPromMode & SK_PROM_MODE_LLC)) { /* Norm. LLC. */
+
+ /* Clear promiscuous bit in mode register. */
+
+ XM_IN16(IoC, PortIdx, XM_MODE, &LoMode);
+#if 0
+ /* Don't receive MAC frames. */
+
+ LoMode &= ~XM_MD_RX_MCTRL;
+#endif /* 0 */
+ LoMode &= ~XM_MD_ENA_PROM;
+ XM_OUT16(IoC, PortIdx, XM_MODE, LoMode);
+ }
+
+ return (SK_ADDR_SUCCESS);
+} /* SkAddrPromiscuousChange */
+
+
+/******************************************************************************
+ *
+ * SkAddrSwap - swap address info
+ *
+ * Description:
+ * This routine swaps address info of two ports.
+ *
+ * Context:
+ * runtime, pageable
+ * may be called after SK_INIT_IO
+ *
+ * Returns:
+ * SK_ADDR_SUCCESS
+ * SK_ADDR_ILLEGAL_PORT
+ */
+int SkAddrSwap(
+SK_AC *pAC, /* adapter context */
+SK_IOC IoC, /* I/O context */
+SK_U32 FromPortIdx, /* Port1 Index */
+SK_U32 ToPortIdx) /* Port2 Index */
+{
+ int i;
+ SK_U8 Byte;
+ SK_MAC_ADDR MacAddr;
+ SK_U32 DWord;
+
+ if (FromPortIdx >= (SK_U32)pAC->GIni.GIMacsFound) {
+ return (SK_ADDR_ILLEGAL_PORT);
+ }
+
+ if (ToPortIdx >= (SK_U32)pAC->GIni.GIMacsFound) {
+ return (SK_ADDR_ILLEGAL_PORT);
+ }
+
+ /*
+ * Swap
+ * - Exact Match Entries
+ * - FirstExactMatchRlmt;
+ * - NextExactMatchRlmt;
+ * - FirstExactMatchDrv;
+ * - NextExactMatchDrv;
+ * - 64-bit filter
+ * - Promiscuous Mode
+ * of ports.
+ */
+
+ for (i = 0; i < SK_ADDR_EXACT_MATCHES; i++) {
+ MacAddr = pAC->Addr.Port[FromPortIdx].Exact[i];
+ pAC->Addr.Port[FromPortIdx].Exact[i] =
+ pAC->Addr.Port[ToPortIdx].Exact[i];
+ pAC->Addr.Port[ToPortIdx].Exact[i] = MacAddr;
+ }
+
+ for (i = 0; i < 8; i++) {
+ Byte = pAC->Addr.Port[FromPortIdx].InexactFilter.Bytes[i];
+ pAC->Addr.Port[FromPortIdx].InexactFilter.Bytes[i] =
+ pAC->Addr.Port[ToPortIdx].InexactFilter.Bytes[i];
+ pAC->Addr.Port[ToPortIdx].InexactFilter.Bytes[i] = Byte;
+ }
+
+ i = pAC->Addr.Port[FromPortIdx].PromMode;
+ pAC->Addr.Port[FromPortIdx].PromMode =
+ pAC->Addr.Port[ToPortIdx].PromMode;
+ pAC->Addr.Port[ToPortIdx].PromMode = i;
+
+ DWord = pAC->Addr.Port[FromPortIdx].FirstExactMatchRlmt;
+ pAC->Addr.Port[FromPortIdx].FirstExactMatchRlmt =
+ pAC->Addr.Port[ToPortIdx].FirstExactMatchRlmt;
+ pAC->Addr.Port[ToPortIdx].FirstExactMatchRlmt = DWord;
+
+ DWord = pAC->Addr.Port[FromPortIdx].NextExactMatchRlmt;
+ pAC->Addr.Port[FromPortIdx].NextExactMatchRlmt =
+ pAC->Addr.Port[ToPortIdx].NextExactMatchRlmt;
+ pAC->Addr.Port[ToPortIdx].NextExactMatchRlmt = DWord;
+
+ DWord = pAC->Addr.Port[FromPortIdx].FirstExactMatchDrv;
+ pAC->Addr.Port[FromPortIdx].FirstExactMatchDrv =
+ pAC->Addr.Port[ToPortIdx].FirstExactMatchDrv;
+ pAC->Addr.Port[ToPortIdx].FirstExactMatchDrv = DWord;
+
+ DWord = pAC->Addr.Port[FromPortIdx].NextExactMatchDrv;
+ pAC->Addr.Port[FromPortIdx].NextExactMatchDrv =
+ pAC->Addr.Port[ToPortIdx].NextExactMatchDrv;
+ pAC->Addr.Port[ToPortIdx].NextExactMatchDrv = DWord;
+
+ pAC->Addr.ActivePort = ToPortIdx;
+
+ (void)SkAddrMcUpdate(pAC, IoC, FromPortIdx);
+ (void)SkAddrMcUpdate(pAC, IoC, ToPortIdx);
+
+ return (SK_ADDR_SUCCESS);
+} /* SkAddrSwap */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)