drivers/sk98lin/skaddr.c

   1 /******************************************************************************
   2  *
   3  * Name:        skaddr.c
   4  * Project:     GEnesis, PCI Gigabit Ethernet Adapter
   5  * Version:     $Revision: 1.48 $
   6  * Date:        $Date: 2003/02/12 17:09:37 $
   7  * Purpose:     Manage Addresses (Multicast and Unicast) and Promiscuous Mode.
   8  *
   9  ******************************************************************************/
  10
  11 /******************************************************************************
  12  *
  13  *      (C)Copyright 1998-2002 SysKonnect GmbH.
  14  *
  15  *      This program is free software; you can redistribute it and/or modify
  16  *      it under the terms of the GNU General Public License as published by
  17  *      the Free Software Foundation; either version 2 of the License, or
  18  *      (at your option) any later version.
  19  *
  20  *      The information in this file is provided "AS IS" without warranty.
  21  *
  22  ******************************************************************************/
  23
  24 /******************************************************************************
  25  *
  26  * History:
  27  *
  28  *      $Log: skaddr.c,v $
  29  *      Revision 1.48  2003/02/12 17:09:37  tschilli
  30  *      Fix in SkAddrOverride() to set both (physical and logical) MAC addresses
  31  *      in case that both addresses are identical.
  32  *
  33  *      Revision 1.47  2002/09/17 06:31:10  tschilli
  34  *      Handling of SK_PROM_MODE_ALL_MC flag in SkAddrGmacMcUpdate()
  35  *      and SkAddrGmacPromiscuousChange() fixed.
  36  *      Editorial changes.
  37  *
  38  *      Revision 1.46  2002/08/22 07:55:41  tschilli
  39  *      New function SkGmacMcHash() for GMAC multicast hashing algorithm added.
  40  *      Editorial changes.
  41  *
  42  *      Revision 1.45  2002/08/15 12:29:35  tschilli
  43  *      SkAddrGmacMcUpdate() and SkAddrGmacPromiscuousChange() changed.
  44  *
  45  *      Revision 1.44  2002/08/14 12:18:03  rschmidt
  46  *      Replaced direct handling of MAC Hashing (XMAC and GMAC)
  47  *      with routine SkMacHashing().
  48  *      Replaced wrong 3rd para 'i' with 'PortNumber' in SkMacPromiscMode().
  49  *
  50  *      Revision 1.43  2002/08/13 09:37:43  rschmidt
  51  *      Corrected some SK_DBG_MSG outputs.
  52  *      Replaced wrong 2nd para pAC with IoC in SkMacPromiscMode().
  53  *      Editorial changes.
  54  *
  55  *      Revision 1.42  2002/08/12 11:24:36  rschmidt
  56  *      Remove setting of logical MAC address GM_SRC_ADDR_2 in SkAddrInit().
  57  *      Replaced direct handling of MAC Promiscuous Mode (XMAC and GMAC)
  58  *      with routine SkMacPromiscMode().
  59  *      Editorial changes.
  60  *
  61  *      Revision 1.41  2002/06/10 13:52:18  tschilli
  62  *      Changes for handling YUKON.
  63  *      All changes are internally and not visible to the programmer
  64  *      using this module.
  65  *
  66  *      Revision 1.40  2001/02/14 14:04:59  rassmann
  67  *      Editorial changes.
  68  *
  69  *      Revision 1.39  2001/01/30 10:30:04  rassmann
  70  *      Editorial changes.
  71  *
  72  *      Revision 1.38  2001/01/25 16:26:52  rassmann
  73  *      Ensured that logical address overrides are done on net's active port.
  74  *
  75  *      Revision 1.37  2001/01/22 13:41:34  rassmann
  76  *      Supporting two nets on dual-port adapters.
  77  *
  78  *      Revision 1.36  2000/08/07 11:10:39  rassmann
  79  *      Editorial changes.
  80  *
  81  *      Revision 1.35  2000/05/04 09:38:41  rassmann
  82  *      Editorial changes.
  83  *      Corrected multicast address hashing.
  84  *
  85  *      Revision 1.34  1999/11/22 13:23:44  cgoos
  86  *      Changed license header to GPL.
  87  *
  88  *      Revision 1.33  1999/05/28 10:56:06  rassmann
  89  *      Editorial changes.
  90  *
  91  *      Revision 1.32  1999/03/31 10:59:20  rassmann
  92  *      Returning Success instead of DupAddr if address shall be overridden
  93  *      with same value.
  94  *
  95  *      Revision 1.31  1999/01/14 16:18:17  rassmann
  96  *      Corrected multicast initialization.
  97  *
  98  *      Revision 1.30  1999/01/04 10:30:35  rassmann
  99  *      SkAddrOverride only possible after SK_INIT_IO phase.
 100  *
 101  *      Revision 1.29  1998/12/29 13:13:10  rassmann
 102  *      An address override is now preserved in the SK_INIT_IO phase.
 103  *      All functions return an int now.
 104  *      Extended parameter checking.
 105  *
 106  *      Revision 1.28  1998/12/01 11:45:53  rassmann
 107  *      Code cleanup.
 108  *
 109  *      Revision 1.27  1998/12/01 09:22:49  rassmann
 110  *      SkAddrMcAdd and SkAddrMcUpdate returned SK_MC_FILTERING_INEXACT
 111  *      too often.
 112  *
 113  *      Revision 1.26  1998/11/24 12:39:44  rassmann
 114  *      Reserved multicast entry for BPDU address.
 115  *      13 multicast entries left for protocol.
 116  *
 117  *      Revision 1.25  1998/11/17 16:54:23  rassmann
 118  *      Using exact match for up to 14 multicast addresses.
 119  *      Still receiving all multicasts if more addresses are added.
 120  *
 121  *      Revision 1.24  1998/11/13 17:24:31  rassmann
 122  *      Changed return value of SkAddrOverride to int.
 123  *
 124  *      Revision 1.23  1998/11/13 16:56:18  rassmann
 125  *      Added macro SK_ADDR_COMPARE.
 126  *      Changed return type of SkAddrOverride to SK_BOOL.
 127  *
 128  *      Revision 1.22  1998/11/04 17:06:17  rassmann
 129  *      Corrected McUpdate and PromiscuousChange functions.
 130  *
 131  *      Revision 1.21  1998/10/29 14:34:04  rassmann
 132  *      Clearing SK_ADDR struct at startup.
 133  *
 134  *      Revision 1.20  1998/10/28 18:16:34  rassmann
 135  *      Avoiding I/Os before SK_INIT_RUN level.
 136  *      Aligning InexactFilter.
 137  *
 138  *      Revision 1.19  1998/10/28 11:29:28  rassmann
 139  *      Programming physical address in SkAddrMcUpdate.
 140  *      Corrected programming of exact match entries.
 141  *
 142  *      Revision 1.18  1998/10/28 10:34:48  rassmann
 143  *      Corrected reading of physical addresses.
 144  *
 145  *      Revision 1.17  1998/10/28 10:26:13  rassmann
 146  *      Getting ports' current MAC addresses from EPROM now.
 147  *      Added debug output.
 148  *
 149  *      Revision 1.16  1998/10/27 16:20:12  rassmann
 150  *      Reading MAC address byte by byte.
 151  *
 152  *      Revision 1.15  1998/10/22 11:39:09  rassmann
 153  *      Corrected signed/unsigned mismatches.
 154  *
 155  *      Revision 1.14  1998/10/19 17:12:35  rassmann
 156  *      Syntax corrections.
 157  *
 158  *      Revision 1.13  1998/10/19 17:02:19  rassmann
 159  *      Now reading permanent MAC addresses from CRF.
 160  *
 161  *      Revision 1.12  1998/10/15 15:15:48  rassmann
 162  *      Changed Flags Parameters from SK_U8 to int.
 163  *      Checked with lint.
 164  *
 165  *      Revision 1.11  1998/09/24 19:15:12  rassmann
 166  *      Code cleanup.
 167  *
 168  *      Revision 1.10  1998/09/18 20:18:54  rassmann
 169  *      Added HW access.
 170  *      Implemented swapping.
 171  *
 172  *      Revision 1.9  1998/09/16 11:32:00  rassmann
 173  *      Including skdrv1st.h again. :(
 174  *
 175  *      Revision 1.8  1998/09/16 11:09:34  rassmann
 176  *      Syntax corrections.
 177  *
 178  *      Revision 1.7  1998/09/14 17:06:34  rassmann
 179  *      Minor changes.
 180  *
 181  *      Revision 1.6  1998/09/07 08:45:41  rassmann
 182  *      Syntax corrections.
 183  *
 184  *      Revision 1.5  1998/09/04 19:40:19  rassmann
 185  *      Interface enhancements.
 186  *
 187  *      Revision 1.4  1998/09/04 12:14:12  rassmann
 188  *      Interface cleanup.
 189  *
 190  *      Revision 1.3  1998/09/02 16:56:40  rassmann
 191  *      Updated interface.
 192  *
 193  *      Revision 1.2  1998/08/27 14:26:09  rassmann
 194  *      Updated interface.
 195  *
 196  *      Revision 1.1  1998/08/21 08:30:22  rassmann
 197  *      First public version.
 198  *
 199  ******************************************************************************/
 200
 201 /******************************************************************************
 202  *
 203  * Description:
 204  *
 205  * This module is intended to manage multicast addresses, address override,
 206  * and promiscuous mode on GEnesis and Yukon adapters.
 207  *
 208  * Address Layout:
 209  *      port address:           physical MAC address
 210  *      1st exact match:        logical MAC address (GEnesis only)
 211  *      2nd exact match:        RLMT multicast (GEnesis only)
 212  *      exact match 3-13:       OS-specific multicasts (GEnesis only)
 213  *
 214  * Include File Hierarchy:
 215  *
 216  *      "skdrv1st.h"
 217  *      "skdrv2nd.h"
 218  *
 219  ******************************************************************************/
 220
 221 #include <config.h>
 222
 223 #ifdef CONFIG_SK98
 224
 225 #ifndef lint
 226 static const char SysKonnectFileId[] =
 227         "@(#) $Id: skaddr.c,v 1.48 2003/02/12 17:09:37 tschilli Exp $ (C) SysKonnect.";
 228 #endif  /* !defined(lint) */
 229
 230 #define __SKADDR_C
 231
 232 #ifdef __cplusplus
 233 #error C++ is not yet supported.
 234 extern "C" {
 235 #endif  /* cplusplus */
 236
 237 #include "h/skdrv1st.h"
 238 #include "h/skdrv2nd.h"
 239
 240 /* defines ********************************************************************/
 241
 242
 243 #define XMAC_POLY       0xEDB88320UL    /* CRC32-Poly - XMAC: Little Endian */
 244 #define GMAC_POLY       0x04C11DB7L     /* CRC16-Poly - GMAC: Little Endian */
 245 #define HASH_BITS       6                               /* #bits in hash */
 246 #define SK_MC_BIT       0x01
 247
 248 /* Error numbers and messages. */
 249
 250 #define SKERR_ADDR_E001         (SK_ERRBASE_ADDR + 0)
 251 #define SKERR_ADDR_E001MSG      "Bad Flags."
 252 #define SKERR_ADDR_E002         (SKERR_ADDR_E001 + 1)
 253 #define SKERR_ADDR_E002MSG      "New Error."
 254
 255 /* typedefs *******************************************************************/
 256
 257 /* None. */
 258
 259 /* global variables ***********************************************************/
 260
 261 /* 64-bit hash values with all bits set. */
 262
 263 SK_U16  OnesHash[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
 264
 265 /* local variables ************************************************************/
 266
 267 #ifdef DEBUG
 268 static int      Next0[SK_MAX_MACS] = {0, 0};
 269 #endif  /* DEBUG */
 270
 271 /* functions ******************************************************************/
 272
 273 /******************************************************************************
 274  *
 275  *      SkAddrInit - initialize data, set state to init
 276  *
 277  * Description:
 278  *
 279  *      SK_INIT_DATA
 280  *      ============
 281  *
 282  *      This routine clears the multicast tables and resets promiscuous mode.
 283  *      Some entries are reserved for the "logical MAC address", the
 284  *      SK-RLMT multicast address, and the BPDU multicast address.
 285  *
 286  *
 287  *      SK_INIT_IO
 288  *      ==========
 289  *
 290  *      All permanent MAC addresses are read from EPROM.
 291  *      If the current MAC addresses are not already set in software,
 292  *      they are set to the values of the permanent addresses.
 293  *      The current addresses are written to the corresponding MAC.
 294  *
 295  *
 296  *      SK_INIT_RUN
 297  *      ===========
 298  *
 299  *      Nothing.
 300  *
 301  * Context:
 302  *      init, pageable
 303  *
 304  * Returns:
 305  *      SK_ADDR_SUCCESS
 306  */
 307 int     SkAddrInit(
 308 SK_AC   *pAC,   /* the adapter context */
 309 SK_IOC  IoC,    /* I/O context */
 310 int             Level)  /* initialization level */
 311 {
 312         int                     j;
 313         SK_U32          i;
 314         SK_U8           *InAddr;
 315         SK_U16          *OutAddr;
 316         SK_ADDR_PORT    *pAPort;
 317
 318         switch (Level) {
 319         case SK_INIT_DATA:
 320                 SK_MEMSET((char *) &pAC->Addr, 0, sizeof(SK_ADDR));
 321
 322                 for (i = 0; i < SK_MAX_MACS; i++) {
 323                         pAPort = &pAC->Addr.Port[i];
 324                         pAPort->PromMode = SK_PROM_MODE_NONE;
 325
 326                         pAPort->FirstExactMatchRlmt = SK_ADDR_FIRST_MATCH_RLMT;
 327                         pAPort->FirstExactMatchDrv = SK_ADDR_FIRST_MATCH_DRV;
 328                         pAPort->NextExactMatchRlmt = SK_ADDR_FIRST_MATCH_RLMT;
 329                         pAPort->NextExactMatchDrv = SK_ADDR_FIRST_MATCH_DRV;
 330                 }
 331 #ifdef xDEBUG
 332                 for (i = 0; i < SK_MAX_MACS; i++) {
 333                         if (pAC->Addr.Port[i].NextExactMatchRlmt <
 334                                 SK_ADDR_FIRST_MATCH_RLMT) {
 335                                 Next0[i] |= 4;
 336                         }
 337                 }
 338 #endif  /* DEBUG */
 339                 /* pAC->Addr.InitDone = SK_INIT_DATA; */
 340                 break;
 341
 342         case SK_INIT_IO:
 343                 for (i = 0; i < SK_MAX_NETS; i++) {
 344                         pAC->Addr.Net[i].ActivePort = pAC->Rlmt.Net[i].ActivePort;
 345                 }
 346 #ifdef xDEBUG
 347                 for (i = 0; i < SK_MAX_MACS; i++) {
 348                         if (pAC->Addr.Port[i].NextExactMatchRlmt <
 349                                 SK_ADDR_FIRST_MATCH_RLMT) {
 350                                 Next0[i] |= 8;
 351                         }
 352                 }
 353 #endif  /* DEBUG */
 354
 355                 /* Read permanent logical MAC address from Control Register File. */
 356                 for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
 357                         InAddr = (SK_U8 *) &pAC->Addr.Net[0].PermanentMacAddress.a[j];
 358                         SK_IN8(IoC, B2_MAC_1 + j, InAddr);
 359                 }
 360
 361                 if (!pAC->Addr.Net[0].CurrentMacAddressSet) {
 362                         /* Set the current logical MAC address to the permanent one. */
 363                         pAC->Addr.Net[0].CurrentMacAddress =
 364                                 pAC->Addr.Net[0].PermanentMacAddress;
 365                         pAC->Addr.Net[0].CurrentMacAddressSet = SK_TRUE;
 366                 }
 367
 368                 /* Set the current logical MAC address. */
 369                 pAC->Addr.Port[pAC->Addr.Net[0].ActivePort].Exact[0] =
 370                         pAC->Addr.Net[0].CurrentMacAddress;
 371 #if SK_MAX_NETS > 1
 372                 /* Set logical MAC address for net 2 to (log | 3). */
 373                 if (!pAC->Addr.Net[1].CurrentMacAddressSet) {
 374                         pAC->Addr.Net[1].PermanentMacAddress =
 375                                 pAC->Addr.Net[0].PermanentMacAddress;
 376                         pAC->Addr.Net[1].PermanentMacAddress.a[5] |= 3;
 377                         /* Set the current logical MAC address to the permanent one. */
 378                         pAC->Addr.Net[1].CurrentMacAddress =
 379                                 pAC->Addr.Net[1].PermanentMacAddress;
 380                         pAC->Addr.Net[1].CurrentMacAddressSet = SK_TRUE;
 381                 }
 382 #endif  /* SK_MAX_NETS > 1 */
 383
 384 #ifdef DEBUG
 385                 for (i = 0; i < (SK_U32) pAC->GIni.GIMacsFound; i++) {
 386                         SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_INIT,
 387                                 ("Permanent MAC Address (Net%d): %02X %02X %02X %02X %02X %02X\n",
 388                                         i,
 389                                         pAC->Addr.Net[i].PermanentMacAddress.a[0],
 390                                         pAC->Addr.Net[i].PermanentMacAddress.a[1],
 391                                         pAC->Addr.Net[i].PermanentMacAddress.a[2],
 392                                         pAC->Addr.Net[i].PermanentMacAddress.a[3],
 393                                         pAC->Addr.Net[i].PermanentMacAddress.a[4],
 394                                         pAC->Addr.Net[i].PermanentMacAddress.a[5]))
 395
 396                         SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_INIT,
 397                                 ("Logical MAC Address (Net%d): %02X %02X %02X %02X %02X %02X\n",
 398                                         i,
 399                                         pAC->Addr.Net[i].CurrentMacAddress.a[0],
 400                                         pAC->Addr.Net[i].CurrentMacAddress.a[1],
 401                                         pAC->Addr.Net[i].CurrentMacAddress.a[2],
 402                                         pAC->Addr.Net[i].CurrentMacAddress.a[3],
 403                                         pAC->Addr.Net[i].CurrentMacAddress.a[4],
 404                                         pAC->Addr.Net[i].CurrentMacAddress.a[5]))
 405                 }
 406 #endif  /* DEBUG */
 407
 408                 for (i = 0; i < (SK_U32) pAC->GIni.GIMacsFound; i++) {
 409                         pAPort = &pAC->Addr.Port[i];
 410
 411                         /* Read permanent port addresses from Control Register File. */
 412                         for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
 413                                 InAddr = (SK_U8 *) &pAPort->PermanentMacAddress.a[j];
 414                                 SK_IN8(IoC, B2_MAC_2 + 8 * i + j, InAddr);
 415                         }
 416
 417                         if (!pAPort->CurrentMacAddressSet) {
 418                                 /*
 419                                  * Set the current and previous physical MAC address
 420                                  * of this port to its permanent MAC address.
 421                                  */
 422                                 pAPort->CurrentMacAddress = pAPort->PermanentMacAddress;
 423                                 pAPort->PreviousMacAddress = pAPort->PermanentMacAddress;
 424                                 pAPort->CurrentMacAddressSet = SK_TRUE;
 425                         }
 426
 427                         /* Set port's current physical MAC address. */
 428                         OutAddr = (SK_U16 *) &pAPort->CurrentMacAddress.a[0];
 429
 430                         if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
 431                                 XM_OUTADDR(IoC, i, XM_SA, OutAddr);
 432                         }
 433                         else {
 434                                 GM_OUTADDR(IoC, i, GM_SRC_ADDR_1L, OutAddr);
 435                         }
 436 #ifdef DEBUG
 437                         SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_INIT,
 438                                 ("SkAddrInit: Permanent Physical MAC Address: %02X %02X %02X %02X %02X %02X\n",
 439                                         pAPort->PermanentMacAddress.a[0],
 440                                         pAPort->PermanentMacAddress.a[1],
 441                                         pAPort->PermanentMacAddress.a[2],
 442                                         pAPort->PermanentMacAddress.a[3],
 443                                         pAPort->PermanentMacAddress.a[4],
 444                                         pAPort->PermanentMacAddress.a[5]))
 445
 446                         SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_INIT,
 447                                 ("SkAddrInit: Physical MAC Address: %02X %02X %02X %02X %02X %02X\n",
 448                                         pAPort->CurrentMacAddress.a[0],
 449                                         pAPort->CurrentMacAddress.a[1],
 450                                         pAPort->CurrentMacAddress.a[2],
 451                                         pAPort->CurrentMacAddress.a[3],
 452                                         pAPort->CurrentMacAddress.a[4],
 453                                         pAPort->CurrentMacAddress.a[5]))
 454 #endif  /* DEBUG */
 455                 }
 456                 /* pAC->Addr.InitDone = SK_INIT_IO; */
 457                 break;
 458
 459         case SK_INIT_RUN:
 460 #ifdef xDEBUG
 461                 for (i = 0; i < SK_MAX_MACS; i++) {
 462                         if (pAC->Addr.Port[i].NextExactMatchRlmt <
 463                                 SK_ADDR_FIRST_MATCH_RLMT) {
 464                                 Next0[i] |= 16;
 465                         }
 466                 }
 467 #endif  /* DEBUG */
 468
 469                 /* pAC->Addr.InitDone = SK_INIT_RUN; */
 470                 break;
 471
 472         default:        /* error */
 473                 break;
 474         }
 475
 476         return (SK_ADDR_SUCCESS);
 477
 478 }       /* SkAddrInit */
 479
 480
 481 /******************************************************************************
 482  *
 483  *      SkAddrMcClear - clear the multicast table
 484  *
 485  * Description:
 486  *      This routine clears the multicast table.
 487  *
 488  *      If not suppressed by Flag SK_MC_SW_ONLY, the hardware is updated
 489  *      immediately.
 490  *
 491  *      It calls either SkAddrXmacMcClear or SkAddrGmacMcClear, according
 492  *      to the adapter in use. The real work is done there.
 493  *
 494  * Context:
 495  *      runtime, pageable
 496  *      may be called starting with SK_INIT_DATA with flag SK_MC_SW_ONLY
 497  *      may be called after SK_INIT_IO without limitation
 498  *
 499  * Returns:
 500  *      SK_ADDR_SUCCESS
 501  *      SK_ADDR_ILLEGAL_PORT
 502  */
 503 int     SkAddrMcClear(
 504 SK_AC   *pAC,           /* adapter context */
 505 SK_IOC  IoC,            /* I/O context */
 506 SK_U32  PortNumber,     /* Index of affected port */
 507 int             Flags)          /* permanent/non-perm, sw-only */
 508 {
 509         int ReturnCode;
 510
 511         if (PortNumber >= (SK_U32) pAC->GIni.GIMacsFound) {
 512                 return (SK_ADDR_ILLEGAL_PORT);
 513         }
 514
 515         if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
 516                 ReturnCode = SkAddrXmacMcClear(pAC, IoC, PortNumber, Flags);
 517         }
 518         else {
 519                 ReturnCode = SkAddrGmacMcClear(pAC, IoC, PortNumber, Flags);
 520         }
 521
 522         return (ReturnCode);
 523
 524 }       /* SkAddrMcClear */
 525
 526
 527 /******************************************************************************
 528  *
 529  *      SkAddrXmacMcClear - clear the multicast table
 530  *
 531  * Description:
 532  *      This routine clears the multicast table
 533  *      (either entry 2 or entries 3-16 and InexactFilter) of the given port.
 534  *      If not suppressed by Flag SK_MC_SW_ONLY, the hardware is updated
 535  *      immediately.
 536  *
 537  * Context:
 538  *      runtime, pageable
 539  *      may be called starting with SK_INIT_DATA with flag SK_MC_SW_ONLY
 540  *      may be called after SK_INIT_IO without limitation
 541  *
 542  * Returns:
 543  *      SK_ADDR_SUCCESS
 544  *      SK_ADDR_ILLEGAL_PORT
 545  */
 546 int     SkAddrXmacMcClear(
 547 SK_AC   *pAC,           /* adapter context */
 548 SK_IOC  IoC,            /* I/O context */
 549 SK_U32  PortNumber,     /* Index of affected port */
 550 int             Flags)          /* permanent/non-perm, sw-only */
 551 {
 552         int i;
 553
 554         if (Flags & SK_ADDR_PERMANENT) {        /* permanent => RLMT */
 555
 556                 /* Clear RLMT multicast addresses. */
 557                 pAC->Addr.Port[PortNumber].NextExactMatchRlmt = SK_ADDR_FIRST_MATCH_RLMT;
 558         }
 559         else {  /* not permanent => DRV */
 560
 561                 /* Clear InexactFilter */
 562                 for (i = 0; i < 8; i++) {
 563                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] = 0;
 564                 }
 565
 566                 /* Clear DRV multicast addresses. */
 567
 568                 pAC->Addr.Port[PortNumber].NextExactMatchDrv = SK_ADDR_FIRST_MATCH_DRV;
 569         }
 570
 571         if (!(Flags & SK_MC_SW_ONLY)) {
 572                 (void) SkAddrXmacMcUpdate(pAC, IoC, PortNumber);
 573         }
 574
 575         return (SK_ADDR_SUCCESS);
 576
 577 }       /* SkAddrXmacMcClear */
 578
 579
 580 /******************************************************************************
 581  *
 582  *      SkAddrGmacMcClear - clear the multicast table
 583  *
 584  * Description:
 585  *      This routine clears the multicast hashing table (InexactFilter)
 586  *      (either the RLMT or the driver bits) of the given port.
 587  *
 588  *      If not suppressed by Flag SK_MC_SW_ONLY, the hardware is updated
 589  *      immediately.
 590  *
 591  * Context:
 592  *      runtime, pageable
 593  *      may be called starting with SK_INIT_DATA with flag SK_MC_SW_ONLY
 594  *      may be called after SK_INIT_IO without limitation
 595  *
 596  * Returns:
 597  *      SK_ADDR_SUCCESS
 598  *      SK_ADDR_ILLEGAL_PORT
 599  */
 600 int     SkAddrGmacMcClear(
 601 SK_AC   *pAC,           /* adapter context */
 602 SK_IOC  IoC,            /* I/O context */
 603 SK_U32  PortNumber,     /* Index of affected port */
 604 int             Flags)          /* permanent/non-perm, sw-only */
 605 {
 606         int i;
 607
 608 #ifdef DEBUG
 609         SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
 610                 ("GMAC InexactFilter (not cleared): %02X %02X %02X %02X %02X %02X %02X %02X\n",
 611                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[0],
 612                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[1],
 613                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[2],
 614                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[3],
 615                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[4],
 616                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[5],
 617                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[6],
 618                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[7]))
 619 #endif  /* DEBUG */
 620
 621         /* Clear InexactFilter */
 622         for (i = 0; i < 8; i++) {
 623                 pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] = 0;
 624         }
 625
 626         if (Flags & SK_ADDR_PERMANENT) {        /* permanent => RLMT */
 627
 628                 /* Copy DRV bits to InexactFilter. */
 629                 for (i = 0; i < 8; i++) {
 630                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] |=
 631                                 pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[i];
 632
 633                         /* Clear InexactRlmtFilter. */
 634                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[i] = 0;
 635
 636                 }
 637         }
 638         else {  /* not permanent => DRV */
 639
 640                 /* Copy RLMT bits to InexactFilter. */
 641                 for (i = 0; i < 8; i++) {
 642                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] |=
 643                                 pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[i];
 644
 645                         /* Clear InexactDrvFilter. */
 646                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[i] = 0;
 647                 }
 648         }
 649
 650 #ifdef DEBUG
 651         SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
 652                 ("GMAC InexactFilter (cleared): %02X %02X %02X %02X %02X %02X %02X %02X\n",
 653                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[0],
 654                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[1],
 655                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[2],
 656                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[3],
 657                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[4],
 658                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[5],
 659                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[6],
 660                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[7]))
 661 #endif  /* DEBUG */
 662
 663         if (!(Flags & SK_MC_SW_ONLY)) {
 664                 (void) SkAddrGmacMcUpdate(pAC, IoC, PortNumber);
 665         }
 666
 667         return (SK_ADDR_SUCCESS);
 668
 669 }       /* SkAddrGmacMcClear */
 670
 671 #ifndef SK_ADDR_CHEAT
 672
 673 /******************************************************************************
 674  *
 675  *      SkXmacMcHash - hash multicast address
 676  *
 677  * Description:
 678  *      This routine computes the hash value for a multicast address.
 679  *      A CRC32 algorithm is used.
 680  *
 681  * Notes:
 682  *      The code was adapted from the XaQti data sheet.
 683  *
 684  * Context:
 685  *      runtime, pageable
 686  *
 687  * Returns:
 688  *      Hash value of multicast address.
 689  */
 690 SK_U32 SkXmacMcHash(
 691 unsigned char *pMc)     /* Multicast address */
 692 {
 693         SK_U32 Idx;
 694         SK_U32 Bit;
 695         SK_U32 Data;
 696         SK_U32 Crc;
 697
 698         Crc = 0xFFFFFFFFUL;
 699         for (Idx = 0; Idx < SK_MAC_ADDR_LEN; Idx++) {
 700                 Data = *pMc++;
 701                 for (Bit = 0; Bit < 8; Bit++, Data >>= 1) {
 702                         Crc = (Crc >> 1) ^ (((Crc ^ Data) & 1) ? XMAC_POLY : 0);
 703                 }
 704         }
 705
 706         return (Crc & ((1 << HASH_BITS) - 1));
 707
 708 }       /* SkXmacMcHash */
 709
 710
 711 /******************************************************************************
 712  *
 713  *      SkGmacMcHash - hash multicast address
 714  *
 715  * Description:
 716  *      This routine computes the hash value for a multicast address.
 717  *      A CRC16 algorithm is used.
 718  *
 719  * Notes:
 720  *
 721  *
 722  * Context:
 723  *      runtime, pageable
 724  *
 725  * Returns:
 726  *      Hash value of multicast address.
 727  */
 728 SK_U32 SkGmacMcHash(
 729 unsigned char *pMc)     /* Multicast address */
 730 {
 731         SK_U32 Data;
 732         SK_U32 TmpData;
 733         SK_U32 Crc;
 734         int Byte;
 735         int Bit;
 736
 737         Crc = 0xFFFFFFFFUL;
 738         for (Byte = 0; Byte < 6; Byte++) {
 739                 /* Get next byte. */
 740                 Data = (SK_U32) pMc[Byte];
 741
 742                 /* Change bit order in byte. */
 743                 TmpData = Data;
 744                 for (Bit = 0; Bit < 8; Bit++) {
 745                         if (TmpData & 1L) {
 746                                 Data |=  1L << (7 - Bit);
 747                         }
 748                         else {
 749                                 Data &= ~(1L << (7 - Bit));
 750                         }
 751                         TmpData >>= 1;
 752                 }
 753
 754                 Crc ^= (Data << 24);
 755                 for (Bit = 0; Bit < 8; Bit++) {
 756                         if (Crc & 0x80000000) {
 757                                 Crc = (Crc << 1) ^ GMAC_POLY;
 758                         }
 759                         else {
 760                                 Crc <<= 1;
 761                         }
 762                 }
 763         }
 764
 765         return (Crc & ((1 << HASH_BITS) - 1));
 766
 767 }       /* SkGmacMcHash */
 768
 769 #endif  /* not SK_ADDR_CHEAT */
 770
 771 /******************************************************************************
 772  *
 773  *      SkAddrMcAdd - add a multicast address to a port
 774  *
 775  * Description:
 776  *      This routine enables reception for a given address on the given port.
 777  *
 778  *      It calls either SkAddrXmacMcAdd or SkAddrGmacMcAdd, according to the
 779  *      adapter in use. The real work is done there.
 780  *
 781  * Notes:
 782  *      The return code is only valid for SK_PROM_MODE_NONE.
 783  *
 784  * Context:
 785  *      runtime, pageable
 786  *      may be called after SK_INIT_DATA
 787  *
 788  * Returns:
 789  *      SK_MC_FILTERING_EXACT
 790  *      SK_MC_FILTERING_INEXACT
 791  *      SK_MC_ILLEGAL_ADDRESS
 792  *      SK_MC_ILLEGAL_PORT
 793  *      SK_MC_RLMT_OVERFLOW
 794  */
 795 int     SkAddrMcAdd(
 796 SK_AC           *pAC,           /* adapter context */
 797 SK_IOC          IoC,            /* I/O context */
 798 SK_U32          PortNumber,     /* Port Number */
 799 SK_MAC_ADDR     *pMc,           /* multicast address to be added */
 800 int                     Flags)          /* permanent/non-permanent */
 801 {
 802         int ReturnCode;
 803
 804         if (PortNumber >= (SK_U32) pAC->GIni.GIMacsFound) {
 805                 return (SK_ADDR_ILLEGAL_PORT);
 806         }
 807
 808         if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
 809                 ReturnCode = SkAddrXmacMcAdd(pAC, IoC, PortNumber, pMc, Flags);
 810         }
 811         else {
 812                 ReturnCode = SkAddrGmacMcAdd(pAC, IoC, PortNumber, pMc, Flags);
 813         }
 814
 815         return (ReturnCode);
 816
 817 }       /* SkAddrMcAdd */
 818
 819
 820 /******************************************************************************
 821  *
 822  *      SkAddrXmacMcAdd - add a multicast address to a port
 823  *
 824  * Description:
 825  *      This routine enables reception for a given address on the given port.
 826  *
 827  * Notes:
 828  *      The return code is only valid for SK_PROM_MODE_NONE.
 829  *
 830  *      The multicast bit is only checked if there are no free exact match
 831  *      entries.
 832  *
 833  * Context:
 834  *      runtime, pageable
 835  *      may be called after SK_INIT_DATA
 836  *
 837  * Returns:
 838  *      SK_MC_FILTERING_EXACT
 839  *      SK_MC_FILTERING_INEXACT
 840  *      SK_MC_ILLEGAL_ADDRESS
 841  *      SK_MC_RLMT_OVERFLOW
 842  */
 843 int     SkAddrXmacMcAdd(
 844 SK_AC           *pAC,           /* adapter context */
 845 SK_IOC          IoC,            /* I/O context */
 846 SK_U32          PortNumber,     /* Port Number */
 847 SK_MAC_ADDR     *pMc,           /* multicast address to be added */
 848 int             Flags)          /* permanent/non-permanent */
 849 {
 850         int     i;
 851         SK_U8   Inexact;
 852 #ifndef SK_ADDR_CHEAT
 853         SK_U32 HashBit;
 854 #endif  /* !defined(SK_ADDR_CHEAT) */
 855
 856         if (Flags & SK_ADDR_PERMANENT) {        /* permanent => RLMT */
 857 #ifdef xDEBUG
 858                 if (pAC->Addr.Port[PortNumber].NextExactMatchRlmt <
 859                         SK_ADDR_FIRST_MATCH_RLMT) {
 860                         Next0[PortNumber] |= 1;
 861                         return (SK_MC_RLMT_OVERFLOW);
 862                 }
 863 #endif  /* DEBUG */
 864
 865                 if (pAC->Addr.Port[PortNumber].NextExactMatchRlmt >
 866                         SK_ADDR_LAST_MATCH_RLMT) {
 867                         return (SK_MC_RLMT_OVERFLOW);
 868                 }
 869
 870                 /* Set a RLMT multicast address. */
 871
 872                 pAC->Addr.Port[PortNumber].Exact[
 873                         pAC->Addr.Port[PortNumber].NextExactMatchRlmt++] = *pMc;
 874
 875                 return (SK_MC_FILTERING_EXACT);
 876         }
 877
 878 #ifdef xDEBUG
 879         if (pAC->Addr.Port[PortNumber].NextExactMatchDrv <
 880                 SK_ADDR_FIRST_MATCH_DRV) {
 881                         Next0[PortNumber] |= 2;
 882                 return (SK_MC_RLMT_OVERFLOW);
 883         }
 884 #endif  /* DEBUG */
 885
 886         if (pAC->Addr.Port[PortNumber].NextExactMatchDrv <= SK_ADDR_LAST_MATCH_DRV) {
 887
 888                 /* Set exact match entry. */
 889                 pAC->Addr.Port[PortNumber].Exact[
 890                         pAC->Addr.Port[PortNumber].NextExactMatchDrv++] = *pMc;
 891
 892                 /* Clear InexactFilter */
 893                 for (i = 0; i < 8; i++) {
 894                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] = 0;
 895                 }
 896         }
 897         else {
 898                 if (!(pMc->a[0] & SK_MC_BIT)) {
 899                         /* Hashing only possible with multicast addresses. */
 900                         return (SK_MC_ILLEGAL_ADDRESS);
 901                 }
 902 #ifndef SK_ADDR_CHEAT
 903                 /* Compute hash value of address. */
 904                 HashBit = 63 - SkXmacMcHash(&pMc->a[0]);
 905
 906                 /* Add bit to InexactFilter. */
 907                 pAC->Addr.Port[PortNumber].InexactFilter.Bytes[HashBit / 8] |=
 908                         1 << (HashBit % 8);
 909 #else   /* SK_ADDR_CHEAT */
 910                 /* Set all bits in InexactFilter. */
 911                 for (i = 0; i < 8; i++) {
 912                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] = 0xFF;
 913                 }
 914 #endif  /* SK_ADDR_CHEAT */
 915         }
 916
 917         for (Inexact = 0, i = 0; i < 8; i++) {
 918                 Inexact |= pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i];
 919         }
 920
 921         if (Inexact == 0 && pAC->Addr.Port[PortNumber].PromMode == 0) {
 922                 return (SK_MC_FILTERING_EXACT);
 923         }
 924         else {
 925                 return (SK_MC_FILTERING_INEXACT);
 926         }
 927
 928 }       /* SkAddrXmacMcAdd */
 929
 930
 931 /******************************************************************************
 932  *
 933  *      SkAddrGmacMcAdd - add a multicast address to a port
 934  *
 935  * Description:
 936  *      This routine enables reception for a given address on the given port.
 937  *
 938  * Notes:
 939  *      The return code is only valid for SK_PROM_MODE_NONE.
 940  *
 941  * Context:
 942  *      runtime, pageable
 943  *      may be called after SK_INIT_DATA
 944  *
 945  * Returns:
 946  *      SK_MC_FILTERING_INEXACT
 947  *      SK_MC_ILLEGAL_ADDRESS
 948  */
 949 int     SkAddrGmacMcAdd(
 950 SK_AC           *pAC,           /* adapter context */
 951 SK_IOC          IoC,            /* I/O context */
 952 SK_U32          PortNumber,     /* Port Number */
 953 SK_MAC_ADDR     *pMc,           /* multicast address to be added */
 954 int             Flags)          /* permanent/non-permanent */
 955 {
 956         int     i;
 957 #ifndef SK_ADDR_CHEAT
 958         SK_U32 HashBit;
 959 #endif  /* !defined(SK_ADDR_CHEAT) */
 960
 961         if (!(pMc->a[0] & SK_MC_BIT)) {
 962                 /* Hashing only possible with multicast addresses. */
 963                 return (SK_MC_ILLEGAL_ADDRESS);
 964         }
 965
 966 #ifndef SK_ADDR_CHEAT
 967
 968         /* Compute hash value of address. */
 969         HashBit = SkGmacMcHash(&pMc->a[0]);
 970
 971         if (Flags & SK_ADDR_PERMANENT) {        /* permanent => RLMT */
 972
 973                 /* Add bit to InexactRlmtFilter. */
 974                 pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[HashBit / 8] |=
 975                         1 << (HashBit % 8);
 976
 977                 /* Copy bit to InexactFilter. */
 978                 for (i = 0; i < 8; i++) {
 979                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] |=
 980                                 pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[i];
 981                 }
 982 #ifdef DEBUG
 983                 SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
 984                 ("GMAC InexactRlmtFilter: %02X %02X %02X %02X %02X %02X %02X %02X\n",
 985                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[0],
 986                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[1],
 987                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[2],
 988                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[3],
 989                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[4],
 990                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[5],
 991                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[6],
 992                         pAC->Addr.Port[PortNumber].InexactRlmtFilter.Bytes[7]))
 993 #endif  /* DEBUG */
 994         }
 995         else {  /* not permanent => DRV */
 996
 997                 /* Add bit to InexactDrvFilter. */
 998                 pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[HashBit / 8] |=
 999                         1 << (HashBit % 8);
1000
1001                 /* Copy bit to InexactFilter. */
1002                 for (i = 0; i < 8; i++) {
1003                         pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] |=
1004                                 pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[i];
1005                 }
1006 #ifdef DEBUG
1007                 SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1008                 ("GMAC InexactDrvFilter: %02X %02X %02X %02X %02X %02X %02X %02X\n",
1009                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[0],
1010                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[1],
1011                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[2],
1012                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[3],
1013                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[4],
1014                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[5],
1015                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[6],
1016                         pAC->Addr.Port[PortNumber].InexactDrvFilter.Bytes[7]))
1017 #endif  /* DEBUG */
1018         }
1019
1020 #else   /* SK_ADDR_CHEAT */
1021
1022         /* Set all bits in InexactFilter. */
1023         for (i = 0; i < 8; i++) {
1024                 pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] = 0xFF;
1025         }
1026 #endif  /* SK_ADDR_CHEAT */
1027
1028         return (SK_MC_FILTERING_INEXACT);
1029
1030 }       /* SkAddrGmacMcAdd */
1031
1032
1033 /******************************************************************************
1034  *
1035  *      SkAddrMcUpdate - update the HW MC address table and set the MAC address
1036  *
1037  * Description:
1038  *      This routine enables reception of the addresses contained in a local
1039  *      table for a given port.
1040  *      It also programs the port's current physical MAC address.
1041  *
1042  *      It calls either SkAddrXmacMcUpdate or SkAddrGmacMcUpdate, according
1043  *      to the adapter in use. The real work is done there.
1044  *
1045  * Notes:
1046  *      The return code is only valid for SK_PROM_MODE_NONE.
1047  *
1048  * Context:
1049  *      runtime, pageable
1050  *      may be called after SK_INIT_IO
1051  *
1052  * Returns:
1053  *      SK_MC_FILTERING_EXACT
1054  *      SK_MC_FILTERING_INEXACT
1055  *      SK_ADDR_ILLEGAL_PORT
1056  */
1057 int     SkAddrMcUpdate(
1058 SK_AC   *pAC,           /* adapter context */
1059 SK_IOC  IoC,            /* I/O context */
1060 SK_U32  PortNumber)     /* Port Number */
1061 {
1062         int ReturnCode;
1063
1064         if (PortNumber >= (SK_U32) pAC->GIni.GIMacsFound) {
1065                 return (SK_ADDR_ILLEGAL_PORT);
1066         }
1067
1068         if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
1069                 ReturnCode = SkAddrXmacMcUpdate(pAC, IoC, PortNumber);
1070         }
1071         else {
1072                 ReturnCode = SkAddrGmacMcUpdate(pAC, IoC, PortNumber);
1073         }
1074
1075         return (ReturnCode);
1076
1077 }       /* SkAddrMcUpdate */
1078
1079
1080 /******************************************************************************
1081  *
1082  *      SkAddrXmacMcUpdate - update the HW MC address table and set the MAC address
1083  *
1084  * Description:
1085  *      This routine enables reception of the addresses contained in a local
1086  *      table for a given port.
1087  *      It also programs the port's current physical MAC address.
1088  *
1089  * Notes:
1090  *      The return code is only valid for SK_PROM_MODE_NONE.
1091  *
1092  * Context:
1093  *      runtime, pageable
1094  *      may be called after SK_INIT_IO
1095  *
1096  * Returns:
1097  *      SK_MC_FILTERING_EXACT
1098  *      SK_MC_FILTERING_INEXACT
1099  *      SK_ADDR_ILLEGAL_PORT
1100  */
1101 int     SkAddrXmacMcUpdate(
1102 SK_AC   *pAC,           /* adapter context */
1103 SK_IOC  IoC,            /* I/O context */
1104 SK_U32  PortNumber)     /* Port Number */
1105 {
1106         SK_U32          i;
1107         SK_U8           Inexact;
1108         SK_U16          *OutAddr;
1109         SK_ADDR_PORT    *pAPort;
1110
1111         SK_DBG_MSG(pAC,SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1112                 ("SkAddrXmacMcUpdate on Port %u.\n", PortNumber))
1113
1114         pAPort = &pAC->Addr.Port[PortNumber];
1115
1116 #ifdef DEBUG
1117         SK_DBG_MSG(pAC,SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1118                 ("Next0 on Port %d: %d\n", PortNumber, Next0[PortNumber]))
1119 #endif  /* DEBUG */
1120
1121         /* Start with 0 to also program the logical MAC address. */
1122         for (i = 0; i < pAPort->NextExactMatchRlmt; i++) {
1123                 /* Set exact match address i on XMAC */
1124                 OutAddr = (SK_U16 *) &pAPort->Exact[i].a[0];
1125                 XM_OUTADDR(IoC, PortNumber, XM_EXM(i), OutAddr);
1126         }
1127
1128         /* Clear other permanent exact match addresses on XMAC */
1129         if (pAPort->NextExactMatchRlmt <= SK_ADDR_LAST_MATCH_RLMT) {
1130
1131                 SkXmClrExactAddr(pAC, IoC, PortNumber, pAPort->NextExactMatchRlmt,
1132                         SK_ADDR_LAST_MATCH_RLMT);
1133         }
1134
1135         for (i = pAPort->FirstExactMatchDrv; i < pAPort->NextExactMatchDrv; i++) {
1136                 OutAddr = (SK_U16 *) &pAPort->Exact[i].a[0];
1137                 XM_OUTADDR(IoC, PortNumber, XM_EXM(i), OutAddr);
1138         }
1139
1140         /* Clear other non-permanent exact match addresses on XMAC */
1141         if (pAPort->NextExactMatchDrv <= SK_ADDR_LAST_MATCH_DRV) {
1142
1143                 SkXmClrExactAddr(pAC, IoC, PortNumber, pAPort->NextExactMatchDrv,
1144                         SK_ADDR_LAST_MATCH_DRV);
1145         }
1146
1147         for (Inexact = 0, i = 0; i < 8; i++) {
1148                 Inexact |= pAPort->InexactFilter.Bytes[i];
1149         }
1150
1151         if (pAPort->PromMode & SK_PROM_MODE_ALL_MC) {
1152
1153                 /* Set all bits in 64-bit hash register. */
1154                 XM_OUTHASH(IoC, PortNumber, XM_HSM, &OnesHash);
1155
1156                 /* Enable Hashing */
1157                 SkMacHashing(pAC, IoC, PortNumber, SK_TRUE);
1158         }
1159         else if (Inexact != 0) {
1160
1161                 /* Set 64-bit hash register to InexactFilter. */
1162                 XM_OUTHASH(IoC, PortNumber, XM_HSM, &pAPort->InexactFilter.Bytes[0]);
1163
1164                 /* Enable Hashing */
1165                 SkMacHashing(pAC, IoC, PortNumber, SK_TRUE);
1166         }
1167         else {
1168                 /* Disable Hashing */
1169                 SkMacHashing(pAC, IoC, PortNumber, SK_FALSE);
1170         }
1171
1172         if (pAPort->PromMode != SK_PROM_MODE_NONE) {
1173                 (void) SkAddrXmacPromiscuousChange(pAC, IoC, PortNumber, pAPort->PromMode);
1174         }
1175
1176         /* Set port's current physical MAC address. */
1177         OutAddr = (SK_U16 *) &pAPort->CurrentMacAddress.a[0];
1178
1179         XM_OUTADDR(IoC, PortNumber, XM_SA, OutAddr);
1180
1181 #ifdef xDEBUG
1182         for (i = 0; i < pAPort->NextExactMatchRlmt; i++) {
1183                 SK_U8           InAddr8[6];
1184                 SK_U16          *InAddr;
1185
1186                 /* Get exact match address i from port PortNumber. */
1187                 InAddr = (SK_U16 *) &InAddr8[0];
1188
1189                 XM_INADDR(IoC, PortNumber, XM_EXM(i), InAddr);
1190
1191                 SK_DBG_MSG(pAC,SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1192                         ("SkAddrXmacMcUpdate: MC address %d on Port %u: ",
1193                          "%02x %02x %02x %02x %02x %02x -- %02x %02x %02x %02x %02x %02x\n",
1194                                 i,
1195                                 PortNumber,
1196                                 InAddr8[0],
1197                                 InAddr8[1],
1198                                 InAddr8[2],
1199                                 InAddr8[3],
1200                                 InAddr8[4],
1201                                 InAddr8[5],
1202                                 pAPort->Exact[i].a[0],
1203                                 pAPort->Exact[i].a[1],
1204                                 pAPort->Exact[i].a[2],
1205                                 pAPort->Exact[i].a[3],
1206                                 pAPort->Exact[i].a[4],
1207                                 pAPort->Exact[i].a[5]))
1208         }
1209 #endif  /* DEBUG */
1210
1211         /* Determine return value. */
1212         if (Inexact == 0 && pAPort->PromMode == 0) {
1213                 return (SK_MC_FILTERING_EXACT);
1214         }
1215         else {
1216                 return (SK_MC_FILTERING_INEXACT);
1217         }
1218
1219 }       /* SkAddrXmacMcUpdate */
1220
1221
1222 /******************************************************************************
1223  *
1224  *      SkAddrGmacMcUpdate - update the HW MC address table and set the MAC address
1225  *
1226  * Description:
1227  *      This routine enables reception of the addresses contained in a local
1228  *      table for a given port.
1229  *      It also programs the port's current physical MAC address.
1230  *
1231  * Notes:
1232  *      The return code is only valid for SK_PROM_MODE_NONE.
1233  *
1234  * Context:
1235  *      runtime, pageable
1236  *      may be called after SK_INIT_IO
1237  *
1238  * Returns:
1239  *      SK_MC_FILTERING_EXACT
1240  *      SK_MC_FILTERING_INEXACT
1241  *      SK_ADDR_ILLEGAL_PORT
1242  */
1243 int     SkAddrGmacMcUpdate(
1244 SK_AC   *pAC,           /* adapter context */
1245 SK_IOC  IoC,            /* I/O context */
1246 SK_U32  PortNumber)     /* Port Number */
1247 {
1248         SK_U32          i;
1249         SK_U8           Inexact;
1250         SK_U16          *OutAddr;
1251         SK_ADDR_PORT    *pAPort;
1252
1253         SK_DBG_MSG(pAC,SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1254                 ("SkAddrGmacMcUpdate on Port %u.\n", PortNumber))
1255
1256         pAPort = &pAC->Addr.Port[PortNumber];
1257
1258 #ifdef DEBUG
1259         SK_DBG_MSG(pAC,SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1260                 ("Next0 on Port %d: %d\n", PortNumber, Next0[PortNumber]))
1261 #endif  /* DEBUG */
1262
1263         for (Inexact = 0, i = 0; i < 8; i++) {
1264                 Inexact |= pAPort->InexactFilter.Bytes[i];
1265         }
1266
1267         /* Set 64-bit hash register to InexactFilter. */
1268         GM_OUTHASH(IoC, PortNumber, GM_MC_ADDR_H1,
1269                 &pAPort->InexactFilter.Bytes[0]);
1270
1271         if (pAPort->PromMode & SK_PROM_MODE_ALL_MC) {
1272
1273                 /* Set all bits in 64-bit hash register. */
1274                 GM_OUTHASH(IoC, PortNumber, GM_MC_ADDR_H1, &OnesHash);
1275
1276                 /* Enable Hashing */
1277                 SkMacHashing(pAC, IoC, PortNumber, SK_TRUE);
1278         }
1279         else {
1280                 /* Enable Hashing. */
1281                 SkMacHashing(pAC, IoC, PortNumber, SK_TRUE);
1282         }
1283
1284         if (pAPort->PromMode != SK_PROM_MODE_NONE) {
1285                 (void) SkAddrGmacPromiscuousChange(pAC, IoC, PortNumber, pAPort->PromMode);
1286         }
1287
1288         /* Set port's current physical MAC address. */
1289         OutAddr = (SK_U16 *) &pAPort->CurrentMacAddress.a[0];
1290         GM_OUTADDR(IoC, PortNumber, GM_SRC_ADDR_1L, OutAddr);
1291
1292         /* Set port's current logical MAC address. */
1293         OutAddr = (SK_U16 *) &pAPort->Exact[0].a[0];
1294         GM_OUTADDR(IoC, PortNumber, GM_SRC_ADDR_2L, OutAddr);
1295
1296 #ifdef DEBUG
1297         SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1298                 ("SkAddrGmacMcUpdate: Permanent Physical MAC Address: %02X %02X %02X %02X %02X %02X\n",
1299                         pAPort->Exact[0].a[0],
1300                         pAPort->Exact[0].a[1],
1301                         pAPort->Exact[0].a[2],
1302                         pAPort->Exact[0].a[3],
1303                         pAPort->Exact[0].a[4],
1304                         pAPort->Exact[0].a[5]))
1305
1306         SK_DBG_MSG(pAC, SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1307                 ("SkAddrGmacMcUpdate: Physical MAC Address: %02X %02X %02X %02X %02X %02X\n",
1308                         pAPort->CurrentMacAddress.a[0],
1309                         pAPort->CurrentMacAddress.a[1],
1310                         pAPort->CurrentMacAddress.a[2],
1311                         pAPort->CurrentMacAddress.a[3],
1312                         pAPort->CurrentMacAddress.a[4],
1313                         pAPort->CurrentMacAddress.a[5]))
1314 #endif  /* DEBUG */
1315
1316         /* Determine return value. */
1317         if (Inexact == 0 && pAPort->PromMode == 0) {
1318                 return (SK_MC_FILTERING_EXACT);
1319         }
1320         else {
1321                 return (SK_MC_FILTERING_INEXACT);
1322         }
1323
1324 }       /* SkAddrGmacMcUpdate */
1325
1326
1327 /******************************************************************************
1328  *
1329  *      SkAddrOverride - override a port's MAC address
1330  *
1331  * Description:
1332  *      This routine overrides the MAC address of one port.
1333  *
1334  * Context:
1335  *      runtime, pageable
1336  *      may be called after SK_INIT_IO
1337  *
1338  * Returns:
1339  *      SK_ADDR_SUCCESS if successful.
1340  *      SK_ADDR_DUPLICATE_ADDRESS if duplicate MAC address.
1341  *      SK_ADDR_MULTICAST_ADDRESS if multicast or broadcast address.
1342  *      SK_ADDR_TOO_EARLY if SK_INIT_IO was not executed before.
1343  */
1344 int     SkAddrOverride(
1345 SK_AC           *pAC,           /* adapter context */
1346 SK_IOC          IoC,            /* I/O context */
1347 SK_U32          PortNumber,     /* Port Number */
1348 SK_MAC_ADDR     *pNewAddr,      /* new MAC address */
1349 int                     Flags)          /* logical/physical MAC address */
1350 {
1351         SK_EVPARA       Para;
1352         SK_U32          NetNumber;
1353         SK_U32          i;
1354         SK_U16          *OutAddr;
1355
1356         NetNumber = pAC->Rlmt.Port[PortNumber].Net->NetNumber;
1357
1358         if (PortNumber >= (SK_U32) pAC->GIni.GIMacsFound) {
1359                 return (SK_ADDR_ILLEGAL_PORT);
1360         }
1361
1362         if (pNewAddr != NULL && (pNewAddr->a[0] & SK_MC_BIT) != 0) {
1363                 return (SK_ADDR_MULTICAST_ADDRESS);
1364         }
1365
1366         if (!pAC->Addr.Net[NetNumber].CurrentMacAddressSet) {
1367                 return (SK_ADDR_TOO_EARLY);
1368         }
1369
1370         if (Flags & SK_ADDR_SET_LOGICAL) {      /* Activate logical MAC address. */
1371                 /* Parameter *pNewAddr is ignored. */
1372                 for (i = 0; i < (SK_U32) pAC->GIni.GIMacsFound; i++) {
1373                         if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
1374                                 return (SK_ADDR_TOO_EARLY);
1375                         }
1376                 }
1377
1378                 /* Set PortNumber to number of net's active port. */
1379                 PortNumber = pAC->Rlmt.Net[NetNumber].
1380                         Port[pAC->Addr.Net[NetNumber].ActivePort]->PortNumber;
1381
1382                 pAC->Addr.Port[PortNumber].Exact[0] =
1383                         pAC->Addr.Net[NetNumber].CurrentMacAddress;
1384
1385                 /* Write address to first exact match entry of active port. */
1386                 (void) SkAddrMcUpdate(pAC, IoC, PortNumber);
1387         }
1388         else if (Flags & SK_ADDR_CLEAR_LOGICAL) {
1389                 /* Deactivate logical MAC address. */
1390                 /* Parameter *pNewAddr is ignored. */
1391                 for (i = 0; i < (SK_U32) pAC->GIni.GIMacsFound; i++) {
1392                         if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
1393                                 return (SK_ADDR_TOO_EARLY);
1394                         }
1395                 }
1396
1397                 /* Set PortNumber to number of net's active port. */
1398                 PortNumber = pAC->Rlmt.Net[NetNumber].
1399                         Port[pAC->Addr.Net[NetNumber].ActivePort]->PortNumber;
1400
1401                 for (i = 0; i < SK_MAC_ADDR_LEN; i++ ) {
1402                         pAC->Addr.Port[PortNumber].Exact[0].a[i] = 0;
1403                 }
1404
1405                 /* Write address to first exact match entry of active port. */
1406                 (void) SkAddrMcUpdate(pAC, IoC, PortNumber);
1407         }
1408         else if (Flags & SK_ADDR_PHYSICAL_ADDRESS) {    /* Physical MAC address. */
1409                 if (SK_ADDR_EQUAL(pNewAddr->a,
1410                         pAC->Addr.Net[NetNumber].CurrentMacAddress.a)) {
1411                         return (SK_ADDR_DUPLICATE_ADDRESS);
1412                 }
1413
1414                 for (i = 0; i < (SK_U32) pAC->GIni.GIMacsFound; i++) {
1415                         if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
1416                                 return (SK_ADDR_TOO_EARLY);
1417                         }
1418
1419                         if (SK_ADDR_EQUAL(pNewAddr->a,
1420                                 pAC->Addr.Port[i].CurrentMacAddress.a)) {
1421                                 if (i == PortNumber) {
1422                                         return (SK_ADDR_SUCCESS);
1423                                 }
1424                                 else {
1425                                         return (SK_ADDR_DUPLICATE_ADDRESS);
1426                                 }
1427                         }
1428                 }
1429
1430                 pAC->Addr.Port[PortNumber].PreviousMacAddress =
1431                         pAC->Addr.Port[PortNumber].CurrentMacAddress;
1432                 pAC->Addr.Port[PortNumber].CurrentMacAddress = *pNewAddr;
1433
1434                 /* Change port's physical MAC address. */
1435                 OutAddr = (SK_U16 *) pNewAddr;
1436
1437                 if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
1438                         XM_OUTADDR(IoC, PortNumber, XM_SA, OutAddr);
1439                 }
1440                 else {
1441                         GM_OUTADDR(IoC, PortNumber, GM_SRC_ADDR_1L, OutAddr);
1442                 }
1443
1444                 /* Report address change to RLMT. */
1445                 Para.Para32[0] = PortNumber;
1446                 Para.Para32[0] = -1;
1447                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_PORT_ADDR, Para);
1448         }
1449         else {  /* Logical MAC address. */
1450                 if (SK_ADDR_EQUAL(pNewAddr->a,
1451                         pAC->Addr.Net[NetNumber].CurrentMacAddress.a)) {
1452                         return (SK_ADDR_SUCCESS);
1453                 }
1454
1455                 for (i = 0; i < (SK_U32) pAC->GIni.GIMacsFound; i++) {
1456                         if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
1457                                 return (SK_ADDR_TOO_EARLY);
1458                         }
1459
1460                         if (SK_ADDR_EQUAL(pNewAddr->a,
1461                                 pAC->Addr.Port[i].CurrentMacAddress.a)) {
1462                                 return (SK_ADDR_DUPLICATE_ADDRESS);
1463                         }
1464                 }
1465
1466                 /*
1467                  * In case that the physical and the logical MAC addresses are equal
1468                  * we must also change the physical MAC address here.
1469                  * In this case we have an adapter which initially was programmed with
1470                  * two identical MAC addresses.
1471                  */
1472                 if (SK_ADDR_EQUAL(pAC->Addr.Port[PortNumber].CurrentMacAddress.a,
1473                                 pAC->Addr.Port[PortNumber].Exact[0].a)) {
1474
1475                         pAC->Addr.Port[PortNumber].PreviousMacAddress =
1476                                 pAC->Addr.Port[PortNumber].CurrentMacAddress;
1477                         pAC->Addr.Port[PortNumber].CurrentMacAddress = *pNewAddr;
1478
1479                         /* Report address change to RLMT. */
1480                         Para.Para32[0] = PortNumber;
1481                         Para.Para32[0] = -1;
1482                         SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_PORT_ADDR, Para);
1483                 }
1484
1485                 /* Set PortNumber to number of net's active port. */
1486                 PortNumber = pAC->Rlmt.Net[NetNumber].
1487                         Port[pAC->Addr.Net[NetNumber].ActivePort]->PortNumber;
1488
1489                 pAC->Addr.Net[NetNumber].CurrentMacAddress = *pNewAddr;
1490                 pAC->Addr.Port[PortNumber].Exact[0] = *pNewAddr;
1491 #ifdef DEBUG
1492                 SK_DBG_MSG(pAC,SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1493                         ("SkAddrOverride: Permanent MAC Address: %02X %02X %02X %02X %02X %02X\n",
1494                                 pAC->Addr.Net[NetNumber].PermanentMacAddress.a[0],
1495                                 pAC->Addr.Net[NetNumber].PermanentMacAddress.a[1],
1496                                 pAC->Addr.Net[NetNumber].PermanentMacAddress.a[2],
1497                                 pAC->Addr.Net[NetNumber].PermanentMacAddress.a[3],
1498                                 pAC->Addr.Net[NetNumber].PermanentMacAddress.a[4],
1499                                 pAC->Addr.Net[NetNumber].PermanentMacAddress.a[5]))
1500
1501                 SK_DBG_MSG(pAC,SK_DBGMOD_ADDR, SK_DBGCAT_CTRL,
1502                         ("SkAddrOverride: New logical MAC Address: %02X %02X %02X %02X %02X %02X\n",
1503                                 pAC->Addr.Net[NetNumber].CurrentMacAddress.a[0],
1504                                 pAC->Addr.Net[NetNumber].CurrentMacAddress.a[1],
1505                                 pAC->Addr.Net[NetNumber].CurrentMacAddress.a[2],
1506                                 pAC->Addr.Net[NetNumber].CurrentMacAddress.a[3],
1507                                 pAC->Addr.Net[NetNumber].CurrentMacAddress.a[4],
1508                                 pAC->Addr.Net[NetNumber].CurrentMacAddress.a[5]))
1509 #endif  /* DEBUG */
1510
1511         /* Write address to first exact match entry of active port. */
1512                 (void) SkAddrMcUpdate(pAC, IoC, PortNumber);
1513         }
1514
1515         return (SK_ADDR_SUCCESS);
1516
1517 }       /* SkAddrOverride */
1518
1519
1520 /******************************************************************************
1521  *
1522  *      SkAddrPromiscuousChange - set promiscuous mode for given port
1523  *
1524  * Description:
1525  *      This routine manages promiscuous mode:
1526  *      - none
1527  *      - all LLC frames
1528  *      - all MC frames
1529  *
1530  *      It calls either SkAddrXmacPromiscuousChange or
1531  *      SkAddrGmacPromiscuousChange, according to the adapter in use.
1532  *      The real work is done there.
1533  *
1534  * Context:
1535  *      runtime, pageable
1536  *      may be called after SK_INIT_IO
1537  *
1538  * Returns:
1539  *      SK_ADDR_SUCCESS
1540  *      SK_ADDR_ILLEGAL_PORT
1541  */
1542 int     SkAddrPromiscuousChange(
1543 SK_AC   *pAC,                   /* adapter context */
1544 SK_IOC  IoC,                    /* I/O context */
1545 SK_U32  PortNumber,             /* port whose promiscuous mode changes */
1546 int             NewPromMode)    /* new promiscuous mode */
1547 {
1548         int ReturnCode;
1549
1550         if (PortNumber >= (SK_U32) pAC->GIni.GIMacsFound) {
1551                 return (SK_ADDR_ILLEGAL_PORT);
1552         }
1553
1554         if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
1555                 ReturnCode = SkAddrXmacPromiscuousChange(pAC, IoC, PortNumber, NewPromMode);
1556         }
1557         else {
1558                 ReturnCode = SkAddrGmacPromiscuousChange(pAC, IoC, PortNumber, NewPromMode);
1559         }
1560
1561         return (ReturnCode);
1562
1563 }       /* SkAddrPromiscuousChange */
1564
1565
1566 /******************************************************************************
1567  *
1568  *      SkAddrXmacPromiscuousChange - set promiscuous mode for given port
1569  *
1570  * Description:
1571  *      This routine manages promiscuous mode:
1572  *      - none
1573  *      - all LLC frames
1574  *      - all MC frames
1575  *
1576  * Context:
1577  *      runtime, pageable
1578  *      may be called after SK_INIT_IO
1579  *
1580  * Returns:
1581  *      SK_ADDR_SUCCESS
1582  *      SK_ADDR_ILLEGAL_PORT
1583  */
1584 int     SkAddrXmacPromiscuousChange(
1585 SK_AC   *pAC,                   /* adapter context */
1586 SK_IOC  IoC,                    /* I/O context */
1587 SK_U32  PortNumber,             /* port whose promiscuous mode changes */
1588 int             NewPromMode)    /* new promiscuous mode */
1589 {
1590         int                     i;
1591         SK_BOOL         InexactModeBit;
1592         SK_U8           Inexact;
1593         SK_U8           HwInexact;
1594         SK_FILTER64     HwInexactFilter;
1595         SK_U16          LoMode;         /* Lower 16 bits of XMAC Mode Register. */
1596         int                     CurPromMode = SK_PROM_MODE_NONE;
1597
1598         /* Read CurPromMode from Hardware. */
1599         XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
1600
1601         if ((LoMode & XM_MD_ENA_PROM) != 0) {
1602                 /* Promiscuous mode! */
1603                 CurPromMode |= SK_PROM_MODE_LLC;
1604         }
1605
1606         for (Inexact = 0xFF, i = 0; i < 8; i++) {
1607                 Inexact &= pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i];
1608         }
1609         if (Inexact == 0xFF) {
1610                 CurPromMode |= (pAC->Addr.Port[PortNumber].PromMode & SK_PROM_MODE_ALL_MC);
1611         }
1612         else {
1613                 /* Get InexactModeBit (bit XM_MD_ENA_HASH in mode register) */
1614                 XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
1615
1616                 InexactModeBit = (LoMode & XM_MD_ENA_HASH) != 0;
1617
1618                 /* Read 64-bit hash register from XMAC */
1619                 XM_INHASH(IoC, PortNumber, XM_HSM, &HwInexactFilter.Bytes[0]);
1620
1621                 for (HwInexact = 0xFF, i = 0; i < 8; i++) {
1622                         HwInexact &= HwInexactFilter.Bytes[i];
1623                 }
1624
1625                 if (InexactModeBit && (HwInexact == 0xFF)) {
1626                         CurPromMode |= SK_PROM_MODE_ALL_MC;
1627                 }
1628         }
1629
1630         pAC->Addr.Port[PortNumber].PromMode = NewPromMode;
1631
1632         if (NewPromMode == CurPromMode) {
1633                 return (SK_ADDR_SUCCESS);
1634         }
1635
1636         if ((NewPromMode & SK_PROM_MODE_ALL_MC) &&
1637                 !(CurPromMode & SK_PROM_MODE_ALL_MC)) { /* All MC. */
1638
1639                 /* Set all bits in 64-bit hash register. */
1640                 XM_OUTHASH(IoC, PortNumber, XM_HSM, &OnesHash);
1641
1642                 /* Enable Hashing */
1643                 SkMacHashing(pAC, IoC, PortNumber, SK_TRUE);
1644         }
1645         else if ((CurPromMode & SK_PROM_MODE_ALL_MC) &&
1646                 !(NewPromMode & SK_PROM_MODE_ALL_MC)) { /* Norm MC. */
1647                 for (Inexact = 0, i = 0; i < 8; i++) {
1648                         Inexact |= pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i];
1649                 }
1650                 if (Inexact == 0) {
1651                         /* Disable Hashing */
1652                         SkMacHashing(pAC, IoC, PortNumber, SK_FALSE);
1653                 }
1654                 else {
1655                         /* Set 64-bit hash register to InexactFilter. */
1656                         XM_OUTHASH(IoC, PortNumber, XM_HSM,
1657                                 &pAC->Addr.Port[PortNumber].InexactFilter.Bytes[0]);
1658
1659                         /* Enable Hashing */
1660                         SkMacHashing(pAC, IoC, PortNumber, SK_TRUE);
1661                 }
1662         }
1663
1664         if ((NewPromMode & SK_PROM_MODE_LLC) &&
1665                 !(CurPromMode & SK_PROM_MODE_LLC)) {    /* Prom. LLC */
1666                 /* Set the MAC in Promiscuous Mode */
1667                 SkMacPromiscMode(pAC, IoC, PortNumber, SK_TRUE);
1668         }
1669         else if ((CurPromMode & SK_PROM_MODE_LLC) &&
1670                 !(NewPromMode & SK_PROM_MODE_LLC)) {    /* Norm. LLC. */
1671                 /* Clear Promiscuous Mode */
1672                 SkMacPromiscMode(pAC, IoC, PortNumber, SK_FALSE);
1673         }
1674
1675         return (SK_ADDR_SUCCESS);
1676
1677 }       /* SkAddrXmacPromiscuousChange */
1678
1679
1680 /******************************************************************************
1681  *
1682  *      SkAddrGmacPromiscuousChange - set promiscuous mode for given port
1683  *
1684  * Description:
1685  *      This routine manages promiscuous mode:
1686  *      - none
1687  *      - all LLC frames
1688  *      - all MC frames
1689  *
1690  * Context:
1691  *      runtime, pageable
1692  *      may be called after SK_INIT_IO
1693  *
1694  * Returns:
1695  *      SK_ADDR_SUCCESS
1696  *      SK_ADDR_ILLEGAL_PORT
1697  */
1698 int     SkAddrGmacPromiscuousChange(
1699 SK_AC   *pAC,                   /* adapter context */
1700 SK_IOC  IoC,                    /* I/O context */
1701 SK_U32  PortNumber,             /* port whose promiscuous mode changes */
1702 int             NewPromMode)    /* new promiscuous mode */
1703 {
1704         SK_U16          ReceiveControl; /* GMAC Receive Control Register */
1705         int             CurPromMode = SK_PROM_MODE_NONE;
1706
1707         /* Read CurPromMode from Hardware. */
1708         GM_IN16(IoC, PortNumber, GM_RX_CTRL, &ReceiveControl);
1709
1710         if ((ReceiveControl & (GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA)) == 0) {
1711                 /* Promiscuous mode! */
1712                 CurPromMode |= SK_PROM_MODE_LLC;
1713         }
1714
1715         if ((ReceiveControl & GM_RXCR_MCF_ENA) == 0) {
1716                 /* All Multicast mode! */
1717                 CurPromMode |= (pAC->Addr.Port[PortNumber].PromMode & SK_PROM_MODE_ALL_MC);
1718         }
1719
1720         pAC->Addr.Port[PortNumber].PromMode = NewPromMode;
1721
1722         if (NewPromMode == CurPromMode) {
1723                 return (SK_ADDR_SUCCESS);
1724         }
1725
1726         if ((NewPromMode & SK_PROM_MODE_ALL_MC) &&
1727                 !(CurPromMode & SK_PROM_MODE_ALL_MC)) { /* All MC */
1728
1729                 /* Set all bits in 64-bit hash register. */
1730                 GM_OUTHASH(IoC, PortNumber, GM_MC_ADDR_H1, &OnesHash);
1731
1732                 /* Enable Hashing */
1733                 SkMacHashing(pAC, IoC, PortNumber, SK_TRUE);
1734         }
1735
1736         if ((CurPromMode & SK_PROM_MODE_ALL_MC) &&
1737                 !(NewPromMode & SK_PROM_MODE_ALL_MC)) { /* Norm. MC */
1738
1739                 /* Set 64-bit hash register to InexactFilter. */
1740                 GM_OUTHASH(IoC, PortNumber, GM_MC_ADDR_H1,
1741                         &pAC->Addr.Port[PortNumber].InexactFilter.Bytes[0]);
1742
1743                 /* Enable Hashing. */
1744                 SkMacHashing(pAC, IoC, PortNumber, SK_TRUE);
1745         }
1746
1747         if ((NewPromMode & SK_PROM_MODE_LLC) &&
1748                 !(CurPromMode & SK_PROM_MODE_LLC)) {    /* Prom. LLC */
1749
1750                 /* Set the MAC to Promiscuous Mode. */
1751                 SkMacPromiscMode(pAC, IoC, PortNumber, SK_TRUE);
1752         }
1753         else if ((CurPromMode & SK_PROM_MODE_LLC) &&
1754                 !(NewPromMode & SK_PROM_MODE_LLC)) {    /* Norm. LLC */
1755
1756                 /* Clear Promiscuous Mode. */
1757                 SkMacPromiscMode(pAC, IoC, PortNumber, SK_FALSE);
1758         }
1759
1760         return (SK_ADDR_SUCCESS);
1761
1762 }       /* SkAddrGmacPromiscuousChange */
1763
1764
1765 /******************************************************************************
1766  *
1767  *      SkAddrSwap - swap address info
1768  *
1769  * Description:
1770  *      This routine swaps address info of two ports.
1771  *
1772  * Context:
1773  *      runtime, pageable
1774  *      may be called after SK_INIT_IO
1775  *
1776  * Returns:
1777  *      SK_ADDR_SUCCESS
1778  *      SK_ADDR_ILLEGAL_PORT
1779  */
1780 int     SkAddrSwap(
1781 SK_AC   *pAC,                   /* adapter context */
1782 SK_IOC  IoC,                    /* I/O context */
1783 SK_U32  FromPortNumber,         /* Port1 Index */
1784 SK_U32  ToPortNumber)           /* Port2 Index */
1785 {
1786         int                     i;
1787         SK_U8           Byte;
1788         SK_MAC_ADDR     MacAddr;
1789         SK_U32          DWord;
1790
1791         if (FromPortNumber >= (SK_U32) pAC->GIni.GIMacsFound) {
1792                 return (SK_ADDR_ILLEGAL_PORT);
1793         }
1794
1795         if (ToPortNumber >= (SK_U32) pAC->GIni.GIMacsFound) {
1796                 return (SK_ADDR_ILLEGAL_PORT);
1797         }
1798
1799         if (pAC->Rlmt.Port[FromPortNumber].Net != pAC->Rlmt.Port[ToPortNumber].Net) {
1800                 return (SK_ADDR_ILLEGAL_PORT);
1801         }
1802
1803         /*
1804          * Swap:
1805          * - Exact Match Entries (GEnesis and Yukon)
1806          *   Yukon uses first entry for the logical MAC
1807          *   address (stored in the second GMAC register).
1808          * - FirstExactMatchRlmt (GEnesis only)
1809          * - NextExactMatchRlmt (GEnesis only)
1810          * - FirstExactMatchDrv (GEnesis only)
1811          * - NextExactMatchDrv (GEnesis only)
1812          * - 64-bit filter (InexactFilter)
1813          * - Promiscuous Mode
1814          * of ports.
1815          */
1816
1817         for (i = 0; i < SK_ADDR_EXACT_MATCHES; i++) {
1818                 MacAddr = pAC->Addr.Port[FromPortNumber].Exact[i];
1819                 pAC->Addr.Port[FromPortNumber].Exact[i] =
1820                         pAC->Addr.Port[ToPortNumber].Exact[i];
1821                 pAC->Addr.Port[ToPortNumber].Exact[i] = MacAddr;
1822         }
1823
1824         for (i = 0; i < 8; i++) {
1825                 Byte = pAC->Addr.Port[FromPortNumber].InexactFilter.Bytes[i];
1826                 pAC->Addr.Port[FromPortNumber].InexactFilter.Bytes[i] =
1827                         pAC->Addr.Port[ToPortNumber].InexactFilter.Bytes[i];
1828                 pAC->Addr.Port[ToPortNumber].InexactFilter.Bytes[i] = Byte;
1829         }
1830
1831         i = pAC->Addr.Port[FromPortNumber].PromMode;
1832         pAC->Addr.Port[FromPortNumber].PromMode = pAC->Addr.Port[ToPortNumber].PromMode;
1833         pAC->Addr.Port[ToPortNumber].PromMode = i;
1834
1835         if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
1836                 DWord = pAC->Addr.Port[FromPortNumber].FirstExactMatchRlmt;
1837                 pAC->Addr.Port[FromPortNumber].FirstExactMatchRlmt =
1838                         pAC->Addr.Port[ToPortNumber].FirstExactMatchRlmt;
1839                 pAC->Addr.Port[ToPortNumber].FirstExactMatchRlmt = DWord;
1840
1841                 DWord = pAC->Addr.Port[FromPortNumber].NextExactMatchRlmt;
1842                 pAC->Addr.Port[FromPortNumber].NextExactMatchRlmt =
1843                         pAC->Addr.Port[ToPortNumber].NextExactMatchRlmt;
1844                 pAC->Addr.Port[ToPortNumber].NextExactMatchRlmt = DWord;
1845
1846                 DWord = pAC->Addr.Port[FromPortNumber].FirstExactMatchDrv;
1847                 pAC->Addr.Port[FromPortNumber].FirstExactMatchDrv =
1848                         pAC->Addr.Port[ToPortNumber].FirstExactMatchDrv;
1849                 pAC->Addr.Port[ToPortNumber].FirstExactMatchDrv = DWord;
1850
1851                 DWord = pAC->Addr.Port[FromPortNumber].NextExactMatchDrv;
1852                 pAC->Addr.Port[FromPortNumber].NextExactMatchDrv =
1853                         pAC->Addr.Port[ToPortNumber].NextExactMatchDrv;
1854                 pAC->Addr.Port[ToPortNumber].NextExactMatchDrv = DWord;
1855         }
1856
1857         /* CAUTION: Solution works if only ports of one adapter are in use. */
1858         for (i = 0; (SK_U32) i < pAC->Rlmt.Net[pAC->Rlmt.Port[ToPortNumber].
1859                 Net->NetNumber].NumPorts; i++) {
1860                 if (pAC->Rlmt.Net[pAC->Rlmt.Port[ToPortNumber].Net->NetNumber].
1861                         Port[i]->PortNumber == ToPortNumber) {
1862                         pAC->Addr.Net[pAC->Rlmt.Port[ToPortNumber].Net->NetNumber].
1863                                 ActivePort = i;
1864                         /* 20001207 RA: Was "ToPortNumber;". */
1865                 }
1866         }
1867
1868         (void) SkAddrMcUpdate(pAC, IoC, FromPortNumber);
1869         (void) SkAddrMcUpdate(pAC, IoC, ToPortNumber);
1870
1871         return (SK_ADDR_SUCCESS);
1872
1873 }       /* SkAddrSwap */
1874
1875 #ifdef __cplusplus
1876 }
1877 #endif  /* __cplusplus */
1878
1879 #endif /* CONFIG_SK98 */