* actually reflects a system physical memory back to the system memory      * address. The sysBusToLocal here in this driver is NOT used for mapping      * PCI device's memory (e.g. PCI device's control/status registers)      * to the host address space.       */      pBoard->sysLocalToBus = NULL;     /* for 1:1 mapping */     pBoard->sysBusToLocal = NULL;     /* for 1:1 mapping */     /* specify the interrupt connect/disconnect routines to be used */    pBoard->intConnect    = (FUNCPTR) pciIntConnect;    pBoard->intDisConnect = (FUNCPTR) pciIntDisconnect;    /* get the ICW1 and ICW2 stored in EEPROM */    pBoard->eeprom_icw1   = pReso->eeprom_icw1;    pBoard->eeprom_icw2   = pReso->eeprom_icw2;    /* copy Ether address */    memcpy (&pBoard->enetAddr[0], &(pReso->enetAddr[0]),             ETHER_ADDRESS_SIZE);    /* we finish adaptor initialization */    pReso->iniStatus = OK;    /* enable adaptor interrupt */    sysIntEnablePIC (pRsrc->irq);    return (OK);    }/*************************************************************************** sysGei82546DynaTimerSetup - setup device internal timer value dynamically* * This routine will be called every 2 seconds by default if GEI_END_SET_TIMER* flag is set. The available timers to adjust include RDTR(unit of ns), * RADV(unit of us), and ITR(unit of 256ns). Based on CPU's and/or tasks' * usuage on system, user can tune the device's performace dynamically. * This routine would be called in the tNetTask context, and is only * available for 82540/82545/82546 MACs. Any timer value greater than* 0xffff won't be used to change corresponding timer register.** RETURNS: TRUE if timer value should change, or FALSE */LOCAL BOOL sysGei82546DynaTimerSetup     (    ADAPTOR_INFO * pBoard     /* board information for the GEI driver */    )    {    /* user's specific code to decide what value should be used.     * For example, depending on      * 1: CPU usuage on system and/or,     * 2: specific application task's usuage and/or,     * 3: RX/TX packet processing per second, and/or      * 4: RX/TX interrupt counter per second, and/or     * 5: RX packet processing for each calling gei82543RxTxIntHandle(),     * users can choose optimal timer values from a predefined table to      * reduce interrupt rates. The statistic of 3,4,and 5 items above      * may be obtained from pBoard->devDrvStat.      *     * NOTE:     * ITR:  Interrupt throttling register (unit of 256ns)      *       inter-interupt delay between chip's interrupts        *     * RADV: receive interrupt absolute delay timer register (unit of 1.024us)      *       a RX interrupt will absolutely occur at this defined value      *       after the first packet is received.       *     * RDTR: receive delay timer register (unit of 1.024us)     *       a RX interrupt will occur if device has not received a subsequent     *       packet within this defined value.     */        /* value > 0xffff would not be used for corresponding timer registers */    /* pBoard->devTimerUpdate.rdtrVal = 0xffffffff; /@ unit of 1.024ns */    /* pBoard->devTimerUpdate.radvVal = 0xffffffff; /@ unit of 1.024us */    /* pBoard->devTimerUpdate.itrVal  = 0xffffffff; /@ unit of 256 ns */    /* pBoard->devTimerUpdate.watchDogIntVal = 2;   /@ 2 second default */      /* retuen TRUE; */    return FALSE;    }/*************************************************************************** sysGei82546InitTimerSetup - initially setup device internal timer value* * The device's internal timers include RDTR(unit of ns), * RADV(unit of us), and ITR(unit of 256ns). The function is * called before device starts up, and it is only available for * 82540/82545/82546 MACs. Any timer value greater than 0xffff will * be discarded.** RETURNS: TRUE if timer value should change, or FALSE */LOCAL BOOL sysGei82546InitTimerSetup     (    ADAPTOR_INFO * pBoard     /* board information for the GEI driver */    )     {    /* value > 0xffff would not change corresponding timer registers */    /* pBoard->devTimerUpdate.rdtrVal = 0xffffffff; /@ unit of 1.024ns */    /* pBoard->devTimerUpdate.radvVal = 0xffffffff; /@ unit of 1.024us */    /* pBoard->devTimerUpdate.itrVal  = 0xffffffff; /@ unit of 256 ns  */    /* pBoard->devTimerUpdate.watchDogIntVal = 2;   /@ 2 second default */    /* return TRUE; */    return FALSE;    }/*************************************************************************** sys543eepromReadBits - read bits from EEPROM** This routine reads bit data from EEPROM** RETURNS: value in WORD size*/LOCAL UINT16 sys543eepromReadBits    (    int      unit,    int      bitsNum    )    {    int      count;    UINT32   ix;    UINT16   val = 0;    UINT16   reqBit = 0;    PCI_BOARD_RESOURCE * pRsrc;    pRsrc = &geiPciResources[unit];    if (pRsrc->boardType == PRO1000_546_BOARD)        reqBit = EECD_REQ_BIT;            for (ix = 0; ix < bitsNum; ix++)        {        /* raise the clk */         GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD,                                 (EECD_CS_BIT | EECD_SK_BIT | reqBit));        /* wait 2000ns */        for (count = 0; count < 3; count++)             sysDelay ();        val = ( val << 1) |           ((GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD) & EECD_DO_BIT)? 1 : 0);        /* lower the clk */        GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, (EECD_CS_BIT | reqBit));        /* wait 2000 ns */        for (count = 0; count < 3; count++)             sysDelay ();           }          return (val);    }/*************************************************************************** sys543eepromWriteBits - write bits out to EEPROM** This routine writes bits out to EEPROM** RETURNS: N/A*/LOCAL void sys543eepromWriteBits    (    int          unit,    UINT16       value,    UINT16       bitNum    )    {    int             count;    volatile UINT16 data;    UINT16          reqBit = 0;    PCI_BOARD_RESOURCE * pRsrc;    pRsrc = &geiPciResources[unit];    if (pRsrc->boardType == PRO1000_546_BOARD)        reqBit = EECD_REQ_BIT;            if (bitNum == 0)        return;    while (bitNum--)        {        data = (value & (0x1 << bitNum )) ? EECD_DI_BIT : 0;        data |=  EECD_CS_BIT;        /* write the data */        GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, (data | reqBit));            /* wait 1000ns */        for (count = 0; count < 2; count++)            sysDelay ();            /* raise the clk */         GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, (data | EECD_SK_BIT | reqBit));        /* wait 1000ns */        for (count = 0; count < 2; count++)            sysDelay ();        /* lower the clk */        GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, (data | reqBit));        /* wait 1000ns */        for (count = 0; count < 2; count++)            sysDelay ();           }    }/*************************************************************************** sys543eepromReadWord - Read a word from EEPROM** RETURNS: value in WORD size*/LOCAL UINT16 sys543eepromReadWord    (    int     unit,    UINT32  index    )    {    int     count;    UINT16  val;    UINT32  tmp;    PCI_BOARD_RESOURCE * pRsrc;    pRsrc = &geiPciResources[unit];       if (pRsrc->boardType == PRO1000_546_BOARD)      {      int  ix = 0;       BOOL accessGet = FALSE;      tmp = GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD);      tmp |= EECD_REQ_BIT;     /* request EEPROM access */      GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, tmp);      do {         /* wait 2us */         for (count = 0; count < 3; count++)              sysDelay ();         if ((tmp = GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD)) & EECD_GNT_BIT)	     {             accessGet = TRUE;             break;             }         } while (ix++ < 500000);      if (!accessGet) 	{	/* timeout in a second */        printf ("ERROR: timeout to grant access to gei unit %d EEPROM\n", unit);        return 0;        }      }    if (index >= geiResources[(unit)].eepromSize)        {        printf ("ERROR: gei unit %d Invalid index %d to EEPROM\n", unit, index);        return 0;        }    tmp = GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD);    GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, EECD_CS_BIT);    /* wait 1000ns */    for (count = 0; count < 2; count++)         sysDelay ();    /* write the opcode out */    sys543eepromWriteBits (unit, EEPROM_READ_OPCODE, EEPROM_CMD_BITS);    /* write the index out */    if (geiResources[(unit)].eepromSize == 64)        sys543eepromWriteBits (unit, index, 6);    else if (geiResources[(unit)].eepromSize == 256)        sys543eepromWriteBits (unit, index, 8);     else /* unsupported, but still try 64 words */        {        sys543eepromWriteBits (unit, index, 6);        printf ("ERROR: gei unit %d unsupported EEPROM size\n", unit);       }    GEI_SYS_READ_REG(unit, INTEL_82543GC_EECD);        /* read the data */    val = sys543eepromReadBits (unit, EEPROM_DATA_BITS);    /* clean up access to EEPROM */          if (pRsrc->boardType == PRO1000_546_BOARD)       tmp &= ~(EECD_DI_BIT | EECD_DO_BIT | EECD_CS_BIT | EECD_REQ_BIT);    else       tmp &= ~(EECD_DI_BIT | EECD_DO_BIT | EECD_CS_BIT);    GEI_SYS_WRITE_REG(unit, INTEL_82543GC_EECD, tmp);    return val;    }/*************************************************************************** sys543EtherAdrGet - Get Ethernet address from EEPROM** This routine get an Ethernet address from EEPROM** RETURNS: OK or ERROR*/LOCAL STATUS sys543EtherAdrGet    (    int    unit    )    {    UINT32 ix;    UINT32 count = 0;    UINT16 val;    UCHAR  adr [ETHER_ADDRESS_SIZE];    GEI_RESOURCE * pReso = (GEI_RESOURCE *)(geiPciResources[unit].pExtended);    for (ix = 0; ix < ETHER_ADDRESS_SIZE / sizeof(UINT16); ix++)         {        /* get word i from EEPROM */        val = sys543eepromReadWord (unit, (UINT16)(EEPROM_IA_ADDRESS + ix));        adr [count++] = (UCHAR)val;        adr [count++] = (UCHAR) (val >> 8);        }    memcpy (&(pReso->enetAddr[0]), adr, ETHER_ADDRESS_SIZE);    /* check IA is UCAST  */