开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
skaddr.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：34k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

skaddr.c：源码内容
  1. /******************************************************************************
  2.  *
  3.  * Name: skaddr.c
  4.  * Project: GEnesis, PCI Gigabit Ethernet Adapter
  5.  * Version: $Revision: 1.40 $
  6.  * Date: $Date: 2001/02/14 14:04:59 $
  7.  * Purpose: Manage Addresses (Multicast and Unicast) and Promiscuous Mode.
  8.  *
  9.  ******************************************************************************/
  11. /******************************************************************************
  12.  *
  13.  * (C)Copyright 1998-2001 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.  ******************************************************************************/
  24. /******************************************************************************
  25.  *
  26.  * History:
  27.  *
  28.  * $Log: skaddr.c,v $
  29.  * Revision 1.40  2001/02/14 14:04:59  rassmann
  30.  * Editorial changes.
  31.  *
  32.  * Revision 1.39  2001/01/30 10:30:04  rassmann
  33.  * Editorial changes.
  34.  *
  35.  * Revision 1.38  2001/01/25 16:26:52  rassmann
  36.  * Ensured that logical address overrides are done on net's active port.
  37.  *
  38.  * Revision 1.37  2001/01/22 13:41:34  rassmann
  39.  * Supporting two nets on dual-port adapters.
  40.  *
  41.  * Revision 1.36  2000/08/07 11:10:39  rassmann
  42.  * Editorial changes.
  43.  *
  44.  * Revision 1.35  2000/05/04 09:38:41  rassmann
  45.  * Editorial changes.
  46.  * Corrected multicast address hashing.
  47.  *
  48.  * Revision 1.34  1999/11/22 13:23:44  cgoos
  49.  * Changed license header to GPL.
  50.  *
  51.  * Revision 1.33  1999/05/28 10:56:06  rassmann
  52.  * Editorial changes.
  53.  *
  54.  * Revision 1.32  1999/03/31 10:59:20  rassmann
  55.  * Returning Success instead of DupAddr if address shall be overridden
  56.  * with same value.
  57.  *
  58.  * Revision 1.31  1999/01/14 16:18:17  rassmann
  59.  * Corrected multicast initialization.
  60.  *
  61.  * Revision 1.30  1999/01/04 10:30:35  rassmann
  62.  * SkAddrOverride only possible after SK_INIT_IO phase.
  63.  *
  64.  * Revision 1.29  1998/12/29 13:13:10  rassmann
  65.  * An address override is now preserved in the SK_INIT_IO phase.
  66.  * All functions return an int now.
  67.  * Extended parameter checking.
  68.  *
  69.  * Revision 1.28  1998/12/01 11:45:53  rassmann
  70.  * Code cleanup.
  71.  *
  72.  * Revision 1.27  1998/12/01 09:22:49  rassmann
  73.  * SkAddrMcAdd and SkAddrMcUpdate returned SK_MC_FILTERING_INEXACT
  74.  * too often.
  75.  *
  76.  * Revision 1.26  1998/11/24 12:39:44  rassmann
  77.  * Reserved multicast entry for BPDU address.
  78.  * 13 multicast entries left for protocol.
  79.  *
  80.  * Revision 1.25  1998/11/17 16:54:23  rassmann
  81.  * Using exact match for up to 14 multicast addresses.
  82.  * Still receiving all multicasts if more addresses are added.
  83.  *
  84.  * Revision 1.24  1998/11/13 17:24:31  rassmann
  85.  * Changed return value of SkAddrOverride to int.
  86.  *
  87.  * Revision 1.23  1998/11/13 16:56:18  rassmann
  88.  * Added macro SK_ADDR_COMPARE.
  89.  * Changed return type of SkAddrOverride to SK_BOOL.
  90.  *
  91.  * Revision 1.22  1998/11/04 17:06:17  rassmann
  92.  * Corrected McUpdate and PromiscuousChange functions.
  93.  *
  94.  * Revision 1.21  1998/10/29 14:34:04  rassmann
  95.  * Clearing SK_ADDR struct at startup.
  96.  *
  97.  * Revision 1.20  1998/10/28 18:16:34  rassmann
  98.  * Avoiding I/Os before SK_INIT_RUN level.
  99.  * Aligning InexactFilter.
  100.  *
  101.  * Revision 1.19  1998/10/28 11:29:28  rassmann
  102.  * Programming physical address in SkAddrMcUpdate.
  103.  * Corrected programming of exact match entries.
  104.  *
  105.  * Revision 1.18  1998/10/28 10:34:48  rassmann
  106.  * Corrected reading of physical addresses.
  107.  *
  108.  * Revision 1.17  1998/10/28 10:26:13  rassmann
  109.  * Getting ports' current MAC addresses from EPROM now.
  110.  * Added debug output.
  111.  *
  112.  * Revision 1.16  1998/10/27 16:20:12  rassmann
  113.  * Reading MAC address byte by byte.
  114.  *
  115.  * Revision 1.15  1998/10/22 11:39:09  rassmann
  116.  * Corrected signed/unsigned mismatches.
  117.  *
  118.  * Revision 1.14  1998/10/19 17:12:35  rassmann
  119.  * Syntax corrections.
  120.  *
  121.  * Revision 1.13  1998/10/19 17:02:19  rassmann
  122.  * Now reading permanent MAC addresses from CRF.
  123.  *
  124.  * Revision 1.12  1998/10/15 15:15:48  rassmann
  125.  * Changed Flags Parameters from SK_U8 to int.
  126.  * Checked with lint.
  127.  *
  128.  * Revision 1.11  1998/09/24 19:15:12  rassmann
  129.  * Code cleanup.
  130.  *
  131.  * Revision 1.10  1998/09/18 20:18:54  rassmann
  132.  * Added HW access.
  133.  * Implemented swapping.
  134.  *
  135.  * Revision 1.9  1998/09/16 11:32:00  rassmann
  136.  * Including skdrv1st.h again. :(
  137.  *
  138.  * Revision 1.8  1998/09/16 11:09:34  rassmann
  139.  * Syntax corrections.
  140.  *
  141.  * Revision 1.7  1998/09/14 17:06:34  rassmann
  142.  * Minor changes.
  143.  *
  144.  * Revision 1.6  1998/09/07 08:45:41  rassmann
  145.  * Syntax corrections.
  146.  *
  147.  * Revision 1.5  1998/09/04 19:40:19  rassmann
  148.  * Interface enhancements.
  149.  *
  150.  * Revision 1.4  1998/09/04 12:14:12  rassmann
  151.  * Interface cleanup.
  152.  *
  153.  * Revision 1.3  1998/09/02 16:56:40  rassmann
  154.  * Updated interface.
  155.  *
  156.  * Revision 1.2  1998/08/27 14:26:09  rassmann
  157.  * Updated interface.
  158.  *
  159.  * Revision 1.1  1998/08/21 08:30:22  rassmann
  160.  * First public version.
  161.  *
  162.  ******************************************************************************/
  164. /******************************************************************************
  165.  *
  166.  * Description:
  167.  *
  168.  * This module is intended to manage multicast addresses, address override,
  169.  * and promiscuous mode on GEnesis adapters.
  170.  *
  171.  * Address Layout:
  172.  * port address: physical MAC address
  173.  * 1st exact match: logical MAC address
  174.  * 2nd exact match: RLMT multicast
  175.  * exact match 3-13: OS-specific multicasts
  176.  *
  177.  * Include File Hierarchy:
  178.  *
  179.  * "skdrv1st.h"
  180.  * "skdrv2nd.h"
  181.  *
  182.  ******************************************************************************/
  184. #ifndef lint
  185. static const char SysKonnectFileId[] =
  186. "@(#) $Id: skaddr.c,v 1.40 2001/02/14 14:04:59 rassmann Exp $ (C) SysKonnect.";
  187. #endif /* !defined(lint) */
  189. #define __SKADDR_C
  191. #ifdef __cplusplus
  192. #error C++ is not yet supported.
  193. extern "C" {
  194. #endif /* cplusplus */
  196. #include "h/skdrv1st.h"
  197. #include "h/skdrv2nd.h"
  199. /* defines ********************************************************************/
  202. #define HASH_BITS 6 /* #bits in hash */
  203. #define SK_MC_BIT 0x01
  205. /* Error numbers and messages. */
  207. #define SKERR_ADDR_E001 (SK_ERRBASE_ADDR + 0)
  208. #define SKERR_ADDR_E001MSG "Bad Flags."
  209. #define SKERR_ADDR_E002 (SKERR_ADDR_E001 + 1)
  210. #define SKERR_ADDR_E002MSG "New Error."
  212. /* typedefs *******************************************************************/
  214. /* None. */
  216. /* global variables ***********************************************************/
  218. /* 64-bit hash values with all bits set. */
  220. SK_U16 OnesHash[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
  222. /* local variables ************************************************************/
  224. #ifdef DEBUG
  225. static int Next0[SK_MAX_MACS] = {0, 0};
  226. #endif /* DEBUG */
  228. /* functions ******************************************************************/
  230. /******************************************************************************
  231.  *
  232.  * SkAddrInit - initialize data, set state to init
  233.  *
  234.  * Description:
  235.  *
  236.  * SK_INIT_DATA
  237.  * ============
  238.  *
  239.  * This routine clears the multicast tables and resets promiscuous mode.
  240.  * Some entries are reserved for the "logical MAC address", the
  241.  * SK-RLMT multicast address, and the BPDU multicast address.
  242.  *
  243.  *
  244.  * SK_INIT_IO
  245.  * ==========
  246.  *
  247.  * All permanent MAC addresses are read from EPROM.
  248.  * If the current MAC addresses are not already set in software,
  249.  * they are set to the values of the permanent addresses.
  250.  * The current addresses are written to the corresponding XMAC.
  251.  *
  252.  *
  253.  * SK_INIT_RUN
  254.  * ===========
  255.  *
  256.  * Nothing.
  257.  *
  258.  * Context:
  259.  * init, pageable
  260.  *
  261.  * Returns:
  262.  * SK_ADDR_SUCCESS
  263.  */
  264. int SkAddrInit(
  265. SK_AC *pAC, /* the adapter context */
  266. SK_IOC IoC, /* I/O context */
  267. int Level) /* initialization level */
  268. {
  269. int j;
  270. SK_U32 i;
  271. SK_U8 *InAddr;
  272. SK_U16 *OutAddr;
  273. SK_ADDR_PORT *pAPort;
  275. switch (Level) {
  276. case SK_INIT_DATA:
  277. SK_MEMSET((char *)&pAC->Addr, 0, sizeof(SK_ADDR));
  279. for (i = 0; i < SK_MAX_MACS; i++) {
  280. pAPort = &pAC->Addr.Port[i];
  281. pAPort->PromMode = SK_PROM_MODE_NONE;
  283. pAPort->FirstExactMatchRlmt = SK_ADDR_FIRST_MATCH_RLMT;
  284. pAPort->FirstExactMatchDrv = SK_ADDR_FIRST_MATCH_DRV;
  285. pAPort->NextExactMatchRlmt = SK_ADDR_FIRST_MATCH_RLMT;
  286. pAPort->NextExactMatchDrv = SK_ADDR_FIRST_MATCH_DRV;
  288. #if 0
  289. /* Don't do this here ... */
  291. /* Reset Promiscuous mode. */
  292. (void)SkAddrPromiscuousChange(
  293. pAC,
  294. IoC,
  295. i,
  296. SK_PROM_MODE_NONE);
  297. #endif /* 0 */
  298. }
  300. #ifdef DEBUG
  301. for (i = 0; i < SK_MAX_MACS; i++) {
  302. if (pAC->Addr.Port[i].NextExactMatchRlmt <
  303. SK_ADDR_FIRST_MATCH_RLMT) {
  304. Next0[i] |= 4;
  305. }
  306. }
  307. #endif /* DEBUG */
  309. /* pAC->Addr.InitDone = SK_INIT_DATA; */
  310. break;
  312. case SK_INIT_IO:
  313. for (i = 0; i < SK_MAX_NETS; i++) {
  314. pAC->Addr.Net[i].ActivePort = pAC->Rlmt.Net[i].ActivePort;
  315. }
  317. #ifdef DEBUG
  318. for (i = 0; i < SK_MAX_MACS; i++) {
  319. if (pAC->Addr.Port[i].NextExactMatchRlmt <
  320. SK_ADDR_FIRST_MATCH_RLMT) {
  321. Next0[i] |= 8;
  322. }
  323. }
  324. #endif /* DEBUG */
  326. /* Read permanent logical MAC address from Control Register File. */
  327. for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
  328. InAddr = (SK_U8 *)&pAC->Addr.Net[0].PermanentMacAddress.a[j];
  329. SK_IN8(IoC, B2_MAC_1 + j, InAddr);
  330. }
  332. if (!pAC->Addr.Net[0].CurrentMacAddressSet) {
  333. /* Set the current logical MAC address to the permanent one. */
  334. pAC->Addr.Net[0].CurrentMacAddress =
  335. pAC->Addr.Net[0].PermanentMacAddress;
  336. pAC->Addr.Net[0].CurrentMacAddressSet = SK_TRUE;
  337. }
  339. /* Set the current logical MAC address. */
  340. pAC->Addr.Port[pAC->Addr.Net[0].ActivePort].Exact[0] =
  341. pAC->Addr.Net[0].CurrentMacAddress;
  343. #if SK_MAX_NETS > 1
  344. /* Set logical MAC address for net 2 to (log | 3). */
  345. if (!pAC->Addr.Net[1].CurrentMacAddressSet) {
  346. pAC->Addr.Net[1].PermanentMacAddress =
  347. pAC->Addr.Net[0].PermanentMacAddress;
  348. pAC->Addr.Net[1].PermanentMacAddress.a[5] |= 3;
  349. /* Set the current logical MAC address to the permanent one. */
  350. pAC->Addr.Net[1].CurrentMacAddress =
  351. pAC->Addr.Net[1].PermanentMacAddress;
  352. pAC->Addr.Net[1].CurrentMacAddressSet = SK_TRUE;
  353. }
  354. #endif /* SK_MAX_NETS > 1 */
  356. #ifdef xDEBUG
  357. SK_DBG_MSG(
  358. pAC,
  359. SK_DBGMOD_ADDR,
  360. SK_DBGCAT_INIT,
  361. ("Permanent MAC Address: %02X %02X %02X %02X %02X %02Xn",
  362. pAC->Addr.PermanentMacAddress.a[0],
  363. pAC->Addr.PermanentMacAddress.a[1],
  364. pAC->Addr.PermanentMacAddress.a[2],
  365. pAC->Addr.PermanentMacAddress.a[3],
  366. pAC->Addr.PermanentMacAddress.a[4],
  367. pAC->Addr.PermanentMacAddress.a[5]))
  368. SK_DBG_MSG(
  369. pAC,
  370. SK_DBGMOD_ADDR,
  371. SK_DBGCAT_INIT,
  372. ("Logical MAC Address: %02X %02X %02X %02X %02X %02Xn",
  373. pAC->Addr.CurrentMacAddress.a[0],
  374. pAC->Addr.CurrentMacAddress.a[1],
  375. pAC->Addr.CurrentMacAddress.a[2],
  376. pAC->Addr.CurrentMacAddress.a[3],
  377. pAC->Addr.CurrentMacAddress.a[4],
  378. pAC->Addr.CurrentMacAddress.a[5]))
  379. #endif /* DEBUG */
  381. #if 0
  382. /* Don't do this here ... */
  384. (void)SkAddrMcUpdate(pAC, IoC, pAC->Addr.ActivePort);
  385. #endif /* 0 */
  387. for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
  388. pAPort = &pAC->Addr.Port[i];
  390. /* Read permanent port addresses from Control Register File. */
  391. for (j = 0; j < SK_MAC_ADDR_LEN; j++) {
  392. InAddr = (SK_U8 *)&pAPort->PermanentMacAddress.a[j];
  393. SK_IN8(IoC, B2_MAC_2 + 8 * i + j, InAddr);
  394. }
  396. if (!pAPort->CurrentMacAddressSet) {
  397. /*
  398.  * Set the current and previous physical MAC address
  399.  * of this port to its permanent MAC address.
  400.  */
  401. pAPort->CurrentMacAddress = pAPort->PermanentMacAddress;
  402. pAPort->PreviousMacAddress = pAPort->PermanentMacAddress;
  403. pAPort->CurrentMacAddressSet = SK_TRUE;
  404. }
  406. /* Set port's current MAC addresses. */
  407. OutAddr = (SK_U16 *)&pAPort->CurrentMacAddress.a[0];
  408. XM_OUTADDR(IoC, i, XM_SA, OutAddr);
  410. #ifdef xDEBUG
  411. SK_DBG_MSG(
  412. pAC,
  413. SK_DBGMOD_ADDR,
  414. SK_DBGCAT_INIT,
  415. ("Permanent Physical MAC Address: %02X %02X %02X %02X %02X %02Xn",
  416. pAPort->PermanentMacAddress.a[0],
  417. pAPort->PermanentMacAddress.a[1],
  418. pAPort->PermanentMacAddress.a[2],
  419. pAPort->PermanentMacAddress.a[3],
  420. pAPort->PermanentMacAddress.a[4],
  421. pAPort->PermanentMacAddress.a[5]))
  422. SK_DBG_MSG(
  423. pAC,
  424. SK_DBGMOD_ADDR,
  425. SK_DBGCAT_INIT,
  426. ("Phsical MAC Address: %02X %02X %02X %02X %02X %02Xn",
  427. pAPort->CurrentMacAddress.a[0],
  428. pAPort->CurrentMacAddress.a[1],
  429. pAPort->CurrentMacAddress.a[2],
  430. pAPort->CurrentMacAddress.a[3],
  431. pAPort->CurrentMacAddress.a[4],
  432. pAPort->CurrentMacAddress.a[5]))
  433. #endif /* DEBUG */
  434. }
  435. /* pAC->Addr.InitDone = SK_INIT_IO; */
  436. break;
  438. case SK_INIT_RUN:
  439. #ifdef DEBUG
  440. for (i = 0; i < SK_MAX_MACS; i++) {
  441. if (pAC->Addr.Port[i].NextExactMatchRlmt <
  442. SK_ADDR_FIRST_MATCH_RLMT) {
  443. Next0[i] |= 16;
  444. }
  445. }
  446. #endif /* DEBUG */
  448. /* pAC->Addr.InitDone = SK_INIT_RUN; */
  449. break;
  451. default: /* error */
  452. break;
  453. }
  455. return (SK_ADDR_SUCCESS);
  456. } /* SkAddrInit */
  459. /******************************************************************************
  460.  *
  461.  * SkAddrMcClear - clear the multicast table
  462.  *
  463.  * Description:
  464.  * This routine clears the multicast table
  465.  * (either entry 2 or entries 3-16 and InexactFilter) of the given port.
  466.  * If not suppressed by Flag SK_MC_SW_ONLY, the hardware is updated
  467.  * immediately.
  468.  *
  469.  * Context:
  470.  * runtime, pageable
  471.  * may be called starting with SK_INIT_DATA with flag SK_MC_SW_ONLY
  472.  * may be called after SK_INIT_IO without limitation
  473.  *
  474.  * Returns:
  475.  * SK_ADDR_SUCCESS
  476.  * SK_ADDR_ILLEGAL_PORT
  477.  */
  478. int SkAddrMcClear(
  479. SK_AC *pAC, /* adapter context */
  480. SK_IOC IoC, /* I/O context */
  481. SK_U32 PortNumber, /* Index of affected port */
  482. int Flags) /* permanent/non-perm, sw-only */
  483. {
  484. int i;
  486. if (PortNumber >= (SK_U32)pAC->GIni.GIMacsFound) {
  487. return (SK_ADDR_ILLEGAL_PORT);
  488. }
  490. if (Flags & SK_ADDR_PERMANENT) {
  492. /* Clear RLMT multicast addresses. */
  493. pAC->Addr.Port[PortNumber].NextExactMatchRlmt = SK_ADDR_FIRST_MATCH_RLMT;
  494. }
  495. else { /* not permanent => DRV */
  497. /* Clear InexactFilter. */
  499. for (i = 0; i < 8; i++) {
  500. pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] = 0;
  501. }
  503. /* Clear DRV multicast addresses. */
  505. pAC->Addr.Port[PortNumber].NextExactMatchDrv = SK_ADDR_FIRST_MATCH_DRV;
  506. }
  508. if (!(Flags & SK_MC_SW_ONLY)) {
  509. (void)SkAddrMcUpdate(pAC, IoC, PortNumber);
  510. }
  512. return (SK_ADDR_SUCCESS);
  513. } /* SkAddrMcClear */
  515. #ifndef SK_ADDR_CHEAT
  517. /******************************************************************************
  518.  *
  519.  * SkCrc32McHash - hash multicast address
  520.  *
  521.  * Description:
  522.  * This routine computes the hash value for a multicast address.
  523.  *
  524.  * Notes:
  525.  * The code was adapted from the XaQti data sheet.
  526.  *
  527.  * Context:
  528.  * runtime, pageable
  529.  *
  530.  * Returns:
  531.  * Hash value of multicast address.
  532.  */
  533. unsigned SkCrc32McHash(
  534. unsigned char *pMc) /* Multicast address */
  535. {
  536. u32 Crc;
  538. Crc = ether_crc_le(SK_MAC_ADDR_LEN, pMc);
  540. return (Crc & ((1 << HASH_BITS) - 1));
  541. } /* SkCrc32McHash */
  543. #endif /* not SK_ADDR_CHEAT */
  545. /******************************************************************************
  546.  *
  547.  * SkAddrMcAdd - add a multicast address to a port
  548.  *
  549.  * Description:
  550.  * This routine enables reception for a given address on the given port.
  551.  *
  552.  * Notes:
  553.  * The return code is only valid for SK_PROM_MODE_NONE.
  554.  *
  555.  * In the current version, only RLMT may add addresses to the non-active
  556.  * port.
  557.  *
  558.  * The multicast bit is only checked if there are no free exact match
  559.  * entries.
  560.  *
  561.  * Context:
  562.  * runtime, pageable
  563.  * may be called after SK_INIT_DATA
  564.  *
  565.  * Returns:
  566.  * SK_MC_FILTERING_EXACT
  567.  * SK_MC_FILTERING_INEXACT
  568.  * SK_MC_ILLEGAL_ADDRESS
  569.  * SK_MC_ILLEGAL_PORT
  570.  * SK_MC_RLMT_OVERFLOW
  571.  */
  572. int SkAddrMcAdd(
  573. SK_AC *pAC, /* adapter context */
  574. SK_IOC IoC, /* I/O context */
  575. SK_U32 PortNumber, /* Port Number */
  576. SK_MAC_ADDR *pMc, /* multicast address to be added */
  577. int Flags) /* permanent/non-permanent */
  578. {
  579. int i;
  580. SK_U8 Inexact;
  581. #ifndef SK_ADDR_CHEAT
  582. unsigned HashBit;
  583. #endif /* !defined(SK_ADDR_CHEAT) */
  585. if (PortNumber >= (SK_U32)pAC->GIni.GIMacsFound) {
  586. return (SK_ADDR_ILLEGAL_PORT);
  587. }
  589. if (Flags & SK_ADDR_PERMANENT) {
  590. #ifdef DEBUG
  591. if (pAC->Addr.Port[PortNumber].NextExactMatchRlmt <
  592. SK_ADDR_FIRST_MATCH_RLMT) {
  593. Next0[PortNumber] |= 1;
  594. return (SK_MC_RLMT_OVERFLOW);
  595. }
  596. #endif /* DEBUG */
  598. if (pAC->Addr.Port[PortNumber].NextExactMatchRlmt >
  599. SK_ADDR_LAST_MATCH_RLMT) {
  600. return (SK_MC_RLMT_OVERFLOW);
  601. }
  603. /* Set an RLMT multicast address. */
  605. pAC->Addr.Port[PortNumber].Exact[
  606. pAC->Addr.Port[PortNumber].NextExactMatchRlmt++] = *pMc;
  608. return (SK_MC_FILTERING_EXACT);
  609. }
  611. #if 0
  612. /* Not PERMANENT => DRV */
  613. if (PortNumber != pAC->Addr.ActivePort) {
  614. /* Only RLMT is allowed to do this. */
  615. return (SK_MC_ILLEGAL_PORT);
  616. }
  617. #endif /* 0 */
  619. #ifdef DEBUG
  620. if (pAC->Addr.Port[PortNumber].NextExactMatchDrv <
  621. SK_ADDR_FIRST_MATCH_DRV) {
  622. Next0[PortNumber] |= 2;
  623. return (SK_MC_RLMT_OVERFLOW);
  624. }
  625. #endif /* DEBUG */
  627. if (pAC->Addr.Port[PortNumber].NextExactMatchDrv <= SK_ADDR_LAST_MATCH_DRV) {
  629. /* Set exact match entry. */
  630. pAC->Addr.Port[PortNumber].Exact[
  631. pAC->Addr.Port[PortNumber].NextExactMatchDrv++] = *pMc;
  633. /* Clear InexactFilter. */
  634. for (i = 0; i < 8; i++) {
  635. pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] = 0;
  636. }
  637. }
  638. else {
  639. if (!(pMc->a[0] & SK_MC_BIT)) {
  640. /*
  641.  * Hashing only possible with
  642.  * multicast addresses.
  643.  */
  644. return (SK_MC_ILLEGAL_ADDRESS);
  645. }
  646. #ifndef SK_ADDR_CHEAT
  647. /* Compute hash value of address. */
  648. HashBit = 63 - SkCrc32McHash(&pMc->a[0]);
  650. /* Add bit to InexactFilter. */
  651. pAC->Addr.Port[PortNumber].InexactFilter.Bytes[HashBit / 8] |=
  652. 1 << (HashBit % 8);
  653. #else /* SK_ADDR_CHEAT */
  654. /* Set all bits in InexactFilter. */
  655. for (i = 0; i < 8; i++) {
  656. pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i] = 0xFF;
  657. }
  658. #endif /* SK_ADDR_CHEAT */
  659. }
  661. for (Inexact = 0, i = 0; i < 8; i++) {
  662. Inexact |= pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i];
  663. }
  665. if (Inexact == 0 && pAC->Addr.Port[PortNumber].PromMode == 0) {
  666. return (SK_MC_FILTERING_EXACT);
  667. }
  668. else {
  669. return (SK_MC_FILTERING_INEXACT);
  670. }
  671. } /* SkAddrMcAdd */
  674. /******************************************************************************
  675.  *
  676.  * SkAddrMcUpdate - update the HW MC address table and set the MAC address
  677.  *
  678.  * Description:
  679.  * This routine enables reception of the addresses contained in a local
  680.  * table for a given port.
  681.  * It also programs the port's current physical MAC address.
  682.  *
  683.  * Notes:
  684.  * The return code is only valid for SK_PROM_MODE_NONE.
  685.  *
  686.  * Context:
  687.  * runtime, pageable
  688.  * may be called after SK_INIT_IO
  689.  *
  690.  * Returns:
  691.  * SK_MC_FILTERING_EXACT
  692.  * SK_MC_FILTERING_INEXACT
  693.  * SK_ADDR_ILLEGAL_PORT
  694.  */
  695. int SkAddrMcUpdate(
  696. SK_AC *pAC, /* adapter context */
  697. SK_IOC IoC, /* I/O context */
  698. SK_U32 PortNumber) /* Port Number */
  699. {
  700. SK_U32 i;
  701. SK_U8 Inexact;
  702. SK_U16 *OutAddr;
  703. SK_U16 LoMode; /* Lower 16 bits of XMAC Mode Reg. */
  704. SK_ADDR_PORT *pAPort;
  706. if (PortNumber >= (SK_U32)pAC->GIni.GIMacsFound) {
  707. return (SK_ADDR_ILLEGAL_PORT);
  708. }
  710. SK_DBG_MSG(
  711. pAC,
  712. SK_DBGMOD_ADDR,
  713. SK_DBGCAT_CTRL,
  714. ("SkAddrMcUpdate on Port %u.n", PortNumber))
  716. pAPort = &pAC->Addr.Port[PortNumber];
  718. #ifdef DEBUG
  719. SK_DBG_MSG(
  720. pAC,
  721. SK_DBGMOD_ADDR,
  722. SK_DBGCAT_CTRL,
  723. ("Next0 on Port %d: %dn", PortNumber, Next0[PortNumber]))
  724. #endif /* DEBUG */
  726. /* Start with 0 to also program the logical MAC address. */
  727. for (i = 0; i < pAPort->NextExactMatchRlmt; i++) {
  728. /* Set exact match address i on HW. */
  729. OutAddr = (SK_U16 *)&pAPort->Exact[i].a[0];
  730. XM_OUTADDR(IoC, PortNumber, XM_EXM(i), OutAddr);
  731. }
  733. /* Clear other permanent exact match addresses on HW. */
  734. if (pAPort->NextExactMatchRlmt <= SK_ADDR_LAST_MATCH_RLMT) {
  735. SkXmClrExactAddr(
  736. pAC,
  737. IoC,
  738. PortNumber,
  739. pAPort->NextExactMatchRlmt,
  740. SK_ADDR_LAST_MATCH_RLMT);
  741. }
  743. for (i = pAPort->FirstExactMatchDrv; i < pAPort->NextExactMatchDrv; i++) {
  744. OutAddr = (SK_U16 *)&pAPort->Exact[i].a[0];
  745. XM_OUTADDR(IoC, PortNumber, XM_EXM(i), OutAddr);
  746. }
  748. /* Clear other non-permanent exact match addresses on HW. */
  749. if (pAPort->NextExactMatchDrv <= SK_ADDR_LAST_MATCH_DRV) {
  750. SkXmClrExactAddr(
  751. pAC,
  752. IoC,
  753. PortNumber,
  754. pAPort->NextExactMatchDrv,
  755. SK_ADDR_LAST_MATCH_DRV);
  756. }
  758. for (Inexact = 0, i = 0; i < 8; i++) {
  759. Inexact |= pAPort->InexactFilter.Bytes[i];
  760. }
  762. if (pAPort->PromMode & SK_PROM_MODE_ALL_MC) {
  763. /* Set all bits in 64-bit hash register. */
  764. XM_OUTHASH(IoC, PortNumber, XM_HSM, &OnesHash);
  766. /* Set bit 15 in mode register. */
  767. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  768. LoMode |= XM_MD_ENA_HSH;
  769. XM_OUT16(IoC, PortNumber, XM_MODE, LoMode);
  770. }
  771. else if (Inexact != 0) {
  772. /* Set 64-bit hash register to InexactFilter. */
  773. XM_OUTHASH(IoC, PortNumber, XM_HSM, &pAPort->InexactFilter.Bytes[0]);
  775. /* Set bit 15 in mode register. */
  776. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  777. LoMode |= XM_MD_ENA_HSH;
  778. XM_OUT16(IoC, PortNumber, XM_MODE, LoMode);
  779. }
  780. else {
  781. /* Clear bit 15 in mode register. */
  782. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  783. LoMode &= ~XM_MD_ENA_HSH;
  784. XM_OUT16(IoC, PortNumber, XM_MODE, LoMode);
  785. }
  787. if (pAPort->PromMode != SK_PROM_MODE_NONE) {
  788. (void)SkAddrPromiscuousChange(pAC, IoC, PortNumber, pAPort->PromMode);
  789. }
  791. /* Set port's current MAC address. */
  792. OutAddr = (SK_U16 *)&pAPort->CurrentMacAddress.a[0];
  793. XM_OUTADDR(IoC, PortNumber, XM_SA, OutAddr);
  795. #ifdef xDEBUG
  796. for (i = 0; i < pAPort->NextExactMatchRlmt; i++) {
  797. SK_U8 InAddr8[6];
  798. SK_U16 *InAddr;
  800. /* Get exact match address i from port PortNumber. */
  801. InAddr = (SK_U16 *)&InAddr8[0];
  802. XM_INADDR(IoC, PortNumber, XM_EXM(i), InAddr);
  803. SK_DBG_MSG(
  804. pAC,
  805. SK_DBGMOD_ADDR,
  806. SK_DBGCAT_CTRL,
  807. ("MC address %d on Port %u: %02x %02x %02x %02x %02x %02x --  %02x %02x %02x %02x %02x %02x.n",
  808. i,
  809. PortNumber,
  810. InAddr8[0],
  811. InAddr8[1],
  812. InAddr8[2],
  813. InAddr8[3],
  814. InAddr8[4],
  815. InAddr8[5],
  816. pAPort->Exact[i].a[0],
  817. pAPort->Exact[i].a[1],
  818. pAPort->Exact[i].a[2],
  819. pAPort->Exact[i].a[3],
  820. pAPort->Exact[i].a[4],
  821. pAPort->Exact[i].a[5]))
  822. }
  823. #endif /* DEBUG */
  825. /* Determine return value. */
  826. if (Inexact == 0 && pAPort->PromMode == 0) {
  827. return (SK_MC_FILTERING_EXACT);
  828. }
  829. else {
  830. return (SK_MC_FILTERING_INEXACT);
  831. }
  832. } /* SkAddrMcUpdate */
  835. /******************************************************************************
  836.  *
  837.  * SkAddrOverride - override a port's MAC address
  838.  *
  839.  * Description:
  840.  * This routine overrides the MAC address of one port.
  841.  *
  842.  * Context:
  843.  * runtime, pageable
  844.  * may be called after SK_INIT_IO
  845.  *
  846.  * Returns:
  847.  * SK_ADDR_SUCCESS if successful.
  848.  * SK_ADDR_DUPLICATE_ADDRESS if duplicate MAC address.
  849.  * SK_ADDR_MULTICAST_ADDRESS if multicast or broadcast address.
  850.  * SK_ADDR_TOO_EARLY if SK_INIT_IO was not executed before.
  851.  */
  852. int SkAddrOverride(
  853. SK_AC *pAC, /* adapter context */
  854. SK_IOC IoC, /* I/O context */
  855. SK_U32 PortNumber, /* Port Number */
  856. SK_MAC_ADDR *pNewAddr, /* new MAC address */
  857. int Flags) /* logical/physical MAC address */
  858. {
  859. SK_EVPARA Para;
  860. SK_U32 NetNumber;
  861. SK_U32 i;
  862. SK_U16 *OutAddr;
  864. NetNumber = pAC->Rlmt.Port[PortNumber].Net->NetNumber;
  866. if (PortNumber >= (SK_U32)pAC->GIni.GIMacsFound) {
  867. return (SK_ADDR_ILLEGAL_PORT);
  868. }
  870. if (pNewAddr != NULL && (pNewAddr->a[0] & SK_MC_BIT) != 0) {
  871. return (SK_ADDR_MULTICAST_ADDRESS);
  872. }
  874. if (!pAC->Addr.Net[NetNumber].CurrentMacAddressSet) {
  875. return (SK_ADDR_TOO_EARLY);
  876. }
  878. if (Flags & SK_ADDR_SET_LOGICAL) { /* Activate logical MAC address. */
  879. /* Parameter *pNewAddr is ignored. */
  880. for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
  881. if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
  882. return (SK_ADDR_TOO_EARLY);
  883. }
  884. }
  886. /* Set PortNumber to number of net's active port. */
  887. PortNumber = pAC->Rlmt.Net[NetNumber].
  888. Port[pAC->Addr.Net[NetNumber].ActivePort]->PortNumber;
  890. pAC->Addr.Port[PortNumber].Exact[0] =
  891. pAC->Addr.Net[NetNumber].CurrentMacAddress;
  893. /* Write address to first exact match entry of active port. */
  894. (void)SkAddrMcUpdate(pAC, IoC, PortNumber);
  895. }
  896. else if (Flags & SK_ADDR_CLEAR_LOGICAL) {
  897. /* Deactivate logical MAC address. */
  898. /* Parameter *pNewAddr is ignored. */
  899. for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
  900. if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
  901. return (SK_ADDR_TOO_EARLY);
  902. }
  903. }
  905. /* Set PortNumber to number of net's active port. */
  906. PortNumber = pAC->Rlmt.Net[NetNumber].
  907. Port[pAC->Addr.Net[NetNumber].ActivePort]->PortNumber;
  909. for (i = 0; i < SK_MAC_ADDR_LEN; i++ ) {
  910. pAC->Addr.Port[PortNumber].Exact[0].a[i] = 0;
  911. }
  913. /* Write address to first exact match entry of active port. */
  914. (void)SkAddrMcUpdate(pAC, IoC, PortNumber);
  915. }
  916. else if (Flags & SK_ADDR_PHYSICAL_ADDRESS) { /* Physical MAC address. */
  917. if (SK_ADDR_EQUAL(pNewAddr->a,
  918. pAC->Addr.Net[NetNumber].CurrentMacAddress.a)) {
  919. return (SK_ADDR_DUPLICATE_ADDRESS);
  920. }
  922. for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
  923. if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
  924. return (SK_ADDR_TOO_EARLY);
  925. }
  927. if (SK_ADDR_EQUAL(pNewAddr->a,
  928. pAC->Addr.Port[i].CurrentMacAddress.a)) {
  929. if (i == PortNumber) {
  930. return (SK_ADDR_SUCCESS);
  931. }
  932. else {
  933. return (SK_ADDR_DUPLICATE_ADDRESS);
  934. }
  935. }
  936. }
  938. pAC->Addr.Port[PortNumber].PreviousMacAddress =
  939. pAC->Addr.Port[PortNumber].CurrentMacAddress;
  940. pAC->Addr.Port[PortNumber].CurrentMacAddress = *pNewAddr;
  942. /* Change port's address. */
  943. OutAddr = (SK_U16 *)pNewAddr;
  944. XM_OUTADDR(IoC, PortNumber, XM_SA, OutAddr);
  946. /* Report address change to RLMT. */
  947. Para.Para32[0] = PortNumber;
  948. Para.Para32[0] = -1;
  949. SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_PORT_ADDR, Para);
  950. }
  951. else { /* Logical MAC address. */
  952. if (SK_ADDR_EQUAL(pNewAddr->a,
  953. pAC->Addr.Net[NetNumber].CurrentMacAddress.a)) {
  954. return (SK_ADDR_SUCCESS);
  955. }
  957. for (i = 0; i < (SK_U32)pAC->GIni.GIMacsFound; i++) {
  958. if (!pAC->Addr.Port[i].CurrentMacAddressSet) {
  959. return (SK_ADDR_TOO_EARLY);
  960. }
  962. if (SK_ADDR_EQUAL(pNewAddr->a,
  963. pAC->Addr.Port[i].CurrentMacAddress.a)) {
  964. return (SK_ADDR_DUPLICATE_ADDRESS);
  965. }
  966. }
  968. /* Set PortNumber to number of net's active port. */
  969. PortNumber = pAC->Rlmt.Net[NetNumber].
  970. Port[pAC->Addr.Net[NetNumber].ActivePort]->PortNumber;
  972. pAC->Addr.Net[NetNumber].CurrentMacAddress = *pNewAddr;
  973. pAC->Addr.Port[PortNumber].Exact[0] = *pNewAddr;
  975. #ifdef DEBUG
  976. SK_DBG_MSG(
  977. pAC,
  978. SK_DBGMOD_ADDR,
  979. SK_DBGCAT_CTRL,
  980. ("Permanent MAC Address: %02X %02X %02X %02X %02X %02Xn",
  981. pAC->Addr.Net[NetNumber].PermanentMacAddress.a[0],
  982. pAC->Addr.Net[NetNumber].PermanentMacAddress.a[1],
  983. pAC->Addr.Net[NetNumber].PermanentMacAddress.a[2],
  984. pAC->Addr.Net[NetNumber].PermanentMacAddress.a[3],
  985. pAC->Addr.Net[NetNumber].PermanentMacAddress.a[4],
  986. pAC->Addr.Net[NetNumber].PermanentMacAddress.a[5]))
  987. SK_DBG_MSG(
  988. pAC,
  989. SK_DBGMOD_ADDR,
  990. SK_DBGCAT_CTRL,
  991. ("New logical MAC Address: %02X %02X %02X %02X %02X %02Xn",
  992. pAC->Addr.Net[NetNumber].CurrentMacAddress.a[0],
  993. pAC->Addr.Net[NetNumber].CurrentMacAddress.a[1],
  994. pAC->Addr.Net[NetNumber].CurrentMacAddress.a[2],
  995. pAC->Addr.Net[NetNumber].CurrentMacAddress.a[3],
  996. pAC->Addr.Net[NetNumber].CurrentMacAddress.a[4],
  997. pAC->Addr.Net[NetNumber].CurrentMacAddress.a[5]))
  998. #endif /* DEBUG */
  1000. /* Write address to first exact match entry of active port. */
  1001. (void)SkAddrMcUpdate(pAC, IoC, PortNumber);
  1002. }
  1004. return (SK_ADDR_SUCCESS);
  1005. } /* SkAddrOverride */
  1008. /******************************************************************************
  1009.  *
  1010.  * SkAddrPromiscuousChange - set promiscuous mode for given port
  1011.  *
  1012.  * Description:
  1013.  * This routine manages promiscuous mode:
  1014.  * - none
  1015.  * - all LLC frames
  1016.  * - all MC frames
  1017.  *
  1018.  * Context:
  1019.  * runtime, pageable
  1020.  * may be called after SK_INIT_IO
  1021.  *
  1022.  * Returns:
  1023.  * SK_ADDR_SUCCESS
  1024.  * SK_ADDR_ILLEGAL_PORT
  1025.  */
  1026. int SkAddrPromiscuousChange(
  1027. SK_AC *pAC, /* adapter context */
  1028. SK_IOC IoC, /* I/O context */
  1029. SK_U32 PortNumber, /* port whose promiscuous mode changes */
  1030. int NewPromMode) /* new promiscuous mode */
  1031. {
  1032. int i;
  1033. SK_BOOL InexactModeBit;
  1034. SK_U8 Inexact;
  1035. SK_U8 HwInexact;
  1036. SK_FILTER64 HwInexactFilter;
  1037. SK_U16 LoMode; /* Lower 16 bits of XMAC Mode Register. */
  1038. int CurPromMode = SK_PROM_MODE_NONE;
  1040. if (PortNumber >= (SK_U32)pAC->GIni.GIMacsFound) {
  1041. return (SK_ADDR_ILLEGAL_PORT);
  1042. }
  1044. /* Read CurPromMode from Hardware. */
  1045. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  1047. if (LoMode & XM_MD_ENA_PROM) {
  1048. CurPromMode |= SK_PROM_MODE_LLC;
  1049. }
  1051. for (Inexact = 0xFF, i = 0; i < 8; i++) {
  1052. Inexact &= pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i];
  1053. }
  1054. if (Inexact == 0xFF) {
  1055. CurPromMode |= (pAC->Addr.Port[PortNumber].PromMode & SK_PROM_MODE_ALL_MC);
  1056. }
  1057. else {
  1058. /* Read InexactModeBit (bit 15 in mode register). */
  1059. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  1061. InexactModeBit = (LoMode & XM_MD_ENA_HSH) != 0;
  1063. /* Read 64-bit hash register from HW. */
  1064. XM_INHASH(IoC, PortNumber, XM_HSM, &HwInexactFilter.Bytes[0]);
  1066. for (HwInexact = 0xFF, i = 0; i < 8; i++) {
  1067. HwInexact &= HwInexactFilter.Bytes[i];
  1068. }
  1070. if (InexactModeBit && (HwInexact == 0xFF)) {
  1071. CurPromMode |= SK_PROM_MODE_ALL_MC;
  1072. }
  1073. }
  1075. pAC->Addr.Port[PortNumber].PromMode = NewPromMode;
  1077. if (NewPromMode == CurPromMode) {
  1078. return (SK_ADDR_SUCCESS);
  1079. }
  1081. if ((NewPromMode & SK_PROM_MODE_ALL_MC) &&
  1082. !(CurPromMode & SK_PROM_MODE_ALL_MC)) { /* All MC. */
  1083. /* Set all bits in 64-bit hash register. */
  1084. XM_OUTHASH(IoC, PortNumber, XM_HSM, &OnesHash);
  1086. /* Set bit 15 in mode register. */
  1087. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  1088. LoMode |= XM_MD_ENA_HSH;
  1089. XM_OUT16(IoC, PortNumber, XM_MODE, LoMode);
  1090. }
  1091. else if ((CurPromMode & SK_PROM_MODE_ALL_MC) &&
  1092. !(NewPromMode & SK_PROM_MODE_ALL_MC)) { /* Norm MC. */
  1093. for (Inexact = 0, i = 0; i < 8; i++) {
  1094. Inexact |= pAC->Addr.Port[PortNumber].InexactFilter.Bytes[i];
  1095. }
  1096. if (Inexact == 0) {
  1097. /* Clear bit 15 in mode register. */
  1098. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  1099. LoMode &= ~XM_MD_ENA_HSH;
  1100. XM_OUT16(IoC, PortNumber, XM_MODE, LoMode);
  1101. }
  1102. else {
  1103. /* Set 64-bit hash register to InexactFilter. */
  1104. XM_OUTHASH(
  1105. IoC,
  1106. PortNumber,
  1107. XM_HSM,
  1108. &pAC->Addr.Port[PortNumber].InexactFilter.Bytes[0]);
  1110. /* Set bit 15 in mode register. */
  1111. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  1112. LoMode |= XM_MD_ENA_HSH;
  1113. XM_OUT16(IoC, PortNumber, XM_MODE, LoMode);
  1114. }
  1115. }
  1117. if ((NewPromMode & SK_PROM_MODE_LLC) &&
  1118. !(CurPromMode & SK_PROM_MODE_LLC)) { /* Prom. LLC */
  1119. /* Set promiscuous bit in mode register. */
  1120. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  1122. #if 0
  1123. /* Receive MAC frames. */
  1124. LoMode |= XM_MD_RX_MCTRL;
  1125. #endif /* 0 */
  1127. LoMode |= XM_MD_ENA_PROM;
  1128. XM_OUT16(IoC, PortNumber, XM_MODE, LoMode);
  1129. }
  1130. else if ((CurPromMode & SK_PROM_MODE_LLC) &&
  1131. !(NewPromMode & SK_PROM_MODE_LLC)) { /* Norm. LLC. */
  1132. /* Clear promiscuous bit in mode register. */
  1133. XM_IN16(IoC, PortNumber, XM_MODE, &LoMode);
  1135. #if 0
  1136. /* Don't receive MAC frames. */
  1137. LoMode &= ~XM_MD_RX_MCTRL;
  1138. #endif /* 0 */
  1140. LoMode &= ~XM_MD_ENA_PROM;
  1141. XM_OUT16(IoC, PortNumber, XM_MODE, LoMode);
  1142. }
  1144. return (SK_ADDR_SUCCESS);
  1145. } /* SkAddrPromiscuousChange */
  1148. /******************************************************************************
  1149.  *
  1150.  * SkAddrSwap - swap address info
  1151.  *
  1152.  * Description:
  1153.  * This routine swaps address info of two ports.
  1154.  *
  1155.  * Context:
  1156.  * runtime, pageable
  1157.  * may be called after SK_INIT_IO
  1158.  *
  1159.  * Returns:
  1160.  * SK_ADDR_SUCCESS
  1161.  * SK_ADDR_ILLEGAL_PORT
  1162.  */
  1163. int SkAddrSwap(
  1164. SK_AC *pAC, /* adapter context */
  1165. SK_IOC IoC, /* I/O context */
  1166. SK_U32 FromPortNumber, /* Port1 Index */
  1167. SK_U32 ToPortNumber) /* Port2 Index */
  1168. {
  1169. int i;
  1170. SK_U8 Byte;
  1171. SK_MAC_ADDR MacAddr;
  1172. SK_U32 DWord;
  1174. if (FromPortNumber >= (SK_U32)pAC->GIni.GIMacsFound) {
  1175. return (SK_ADDR_ILLEGAL_PORT);
  1176. }
  1178. if (ToPortNumber >= (SK_U32)pAC->GIni.GIMacsFound) {
  1179. return (SK_ADDR_ILLEGAL_PORT);
  1180. }
  1182. if (pAC->Rlmt.Port[FromPortNumber].Net != pAC->Rlmt.Port[ToPortNumber].Net) {
  1183. return (SK_ADDR_ILLEGAL_PORT);
  1184. }
  1186. /*
  1187.  * Swap
  1188.  * - Exact Match Entries
  1189.  * - FirstExactMatchRlmt;
  1190.  * - NextExactMatchRlmt;
  1191.  * - FirstExactMatchDrv;
  1192.  * - NextExactMatchDrv;
  1193.  * - 64-bit filter
  1194.  * - Promiscuous Mode
  1195.  * of ports.
  1196.  */
  1198. for (i = 0; i < SK_ADDR_EXACT_MATCHES; i++) {
  1199. MacAddr = pAC->Addr.Port[FromPortNumber].Exact[i];
  1200. pAC->Addr.Port[FromPortNumber].Exact[i] =
  1201. pAC->Addr.Port[ToPortNumber].Exact[i];
  1202. pAC->Addr.Port[ToPortNumber].Exact[i] = MacAddr;
  1203. }
  1205. for (i = 0; i < 8; i++) {
  1206. Byte = pAC->Addr.Port[FromPortNumber].InexactFilter.Bytes[i];
  1207. pAC->Addr.Port[FromPortNumber].InexactFilter.Bytes[i] =
  1208. pAC->Addr.Port[ToPortNumber].InexactFilter.Bytes[i];
  1209. pAC->Addr.Port[ToPortNumber].InexactFilter.Bytes[i] = Byte;
  1210. }
  1212. i = pAC->Addr.Port[FromPortNumber].PromMode;
  1213. pAC->Addr.Port[FromPortNumber].PromMode = pAC->Addr.Port[ToPortNumber].PromMode;
  1214. pAC->Addr.Port[ToPortNumber].PromMode = i;
  1216. DWord = pAC->Addr.Port[FromPortNumber].FirstExactMatchRlmt;
  1217. pAC->Addr.Port[FromPortNumber].FirstExactMatchRlmt =
  1218. pAC->Addr.Port[ToPortNumber].FirstExactMatchRlmt;
  1219. pAC->Addr.Port[ToPortNumber].FirstExactMatchRlmt = DWord;
  1221. DWord = pAC->Addr.Port[FromPortNumber].NextExactMatchRlmt;
  1222. pAC->Addr.Port[FromPortNumber].NextExactMatchRlmt =
  1223. pAC->Addr.Port[ToPortNumber].NextExactMatchRlmt;
  1224. pAC->Addr.Port[ToPortNumber].NextExactMatchRlmt = DWord;
  1226. DWord = pAC->Addr.Port[FromPortNumber].FirstExactMatchDrv;
  1227. pAC->Addr.Port[FromPortNumber].FirstExactMatchDrv =
  1228. pAC->Addr.Port[ToPortNumber].FirstExactMatchDrv;
  1229. pAC->Addr.Port[ToPortNumber].FirstExactMatchDrv = DWord;
  1231. DWord = pAC->Addr.Port[FromPortNumber].NextExactMatchDrv;
  1232. pAC->Addr.Port[FromPortNumber].NextExactMatchDrv =
  1233. pAC->Addr.Port[ToPortNumber].NextExactMatchDrv;
  1234. pAC->Addr.Port[ToPortNumber].NextExactMatchDrv = DWord;
  1236. /* CAUTION: Solution works if only ports of one adapter are in use. */
  1237. for (i = 0; (SK_U32)i < pAC->Rlmt.Net[pAC->Rlmt.Port[ToPortNumber].
  1238. Net->NetNumber].NumPorts; i++) {
  1239. if (pAC->Rlmt.Net[pAC->Rlmt.Port[ToPortNumber].Net->NetNumber].
  1240. Port[i]->PortNumber == ToPortNumber) {
  1241. pAC->Addr.Net[pAC->Rlmt.Port[ToPortNumber].Net->NetNumber].
  1242. ActivePort = i;
  1243. /* 20001207 RA: Was "ToPortNumber;". */
  1245. }
  1246. }
  1247. (void)SkAddrMcUpdate(pAC, IoC, FromPortNumber);
  1248. (void)SkAddrMcUpdate(pAC, IoC, ToPortNumber);
  1250. return (SK_ADDR_SUCCESS);
  1251. } /* SkAddrSwap */
  1253. #ifdef __cplusplus
  1254. }
  1255. #endif /* __cplusplus */