e1000_fxhw.c

来自「COPE the first practical network coding 」· C语言 代码 · 共 1,021 行 · 第 1/2 页

    case FLOW_CONTROL_RECEIVE_PAUSE:

        CtrlRegValue &= (~E1000_CTRL_TFCE);
        CtrlRegValue |= E1000_CTRL_RFCE;
        break;

    case FLOW_CONTROL_TRANSMIT_PAUSE:

        CtrlRegValue &= (~E1000_CTRL_RFCE);
        CtrlRegValue |= E1000_CTRL_TFCE;
        break;

    case FLOW_CONTROL_FULL:

        CtrlRegValue |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
        break;

    default:

        DEBUGOUT("Flow control param set incorrectly\n");
        ASSERT(0);

        break;
    }

    if (Adapter->MacType == MAC_WISEMAN_2_0)
        CtrlRegValue &= (~E1000_CTRL_TFCE);

    E1000_WRITE_REG(Ctrl, CtrlRegValue);
}

VOID CheckForLink(PADAPTER_STRUCT Adapter)
 {
    UINT32 RxcwRegValue;
    UINT32 CtrlRegValue;
    UINT32 StatusRegValue;
    UINT16 PhyData;

    DEBUGFUNC("CheckForLink")

        CtrlRegValue = E1000_READ_REG(Ctrl);

    StatusRegValue = E1000_READ_REG(Status);

    RxcwRegValue = E1000_READ_REG(Rxcw);

    if (Adapter->MediaType == MEDIA_TYPE_COPPER && Adapter->GetLinkStatus) {

        PhyData = ReadPhyRegister(Adapter,
                                  PHY_MII_STATUS_REG, Adapter->PhyAddress);

        PhyData = ReadPhyRegister(Adapter,
                                  PHY_MII_STATUS_REG, Adapter->PhyAddress);

        if (PhyData & MII_SR_LINK_STATUS)
            Adapter->GetLinkStatus = FALSE;
        else {
            DEBUGOUT("**** CFL - No link detected. ****\r\n");
            return;
        }

        if (!Adapter->AutoNeg)
            return;

        switch (Adapter->PhyId) {
        case PAXSON_PHY_88E1000:
        case PAXSON_PHY_88E1000S:

            PhyData = ReadPhyRegister(Adapter,
                                      PXN_PHY_SPEC_STAT_REG,
                                      Adapter->PhyAddress);

            DEBUGOUT1("CFL - Auto-Neg complete.  PhyData = %x\r\n",
                      PhyData);
            ConfigureMacToPhySettings(Adapter, PhyData);

            ConfigFlowControlAfterLinkUp(Adapter);
            break;

        default:
            DEBUGOUT("CFL - Invalid PHY detected.\r\n");

        }
    }

    else

         if ((Adapter->MediaType == MEDIA_TYPE_FIBER) &&
             (!(StatusRegValue & E1000_STATUS_LU)) &&
             (!(CtrlRegValue & E1000_CTRL_SWDPIN1)) &&
             (!(RxcwRegValue & E1000_RXCW_C))) {
        if (Adapter->AutoNegFailed == 0) {
            Adapter->AutoNegFailed = 1;
            return;
        }

        DEBUGOUT("NOT RXing /C/, disable AutoNeg and force link.\r\n");

        E1000_WRITE_REG(Txcw, (Adapter->TxcwRegValue & ~E1000_TXCW_ANE));

        CtrlRegValue = E1000_READ_REG(Ctrl);
        CtrlRegValue |= (E1000_CTRL_SLU | E1000_CTRL_FD);
        E1000_WRITE_REG(Ctrl, CtrlRegValue);

        ConfigFlowControlAfterLinkUp(Adapter);

    }
        else if ((Adapter->MediaType == MEDIA_TYPE_FIBER) &&
                 (CtrlRegValue & E1000_CTRL_SLU) &&
                 (RxcwRegValue & E1000_RXCW_C)) {

        DEBUGOUT("RXing /C/, enable AutoNeg and stop forcing link.\r\n");

        E1000_WRITE_REG(Txcw, Adapter->TxcwRegValue);

        E1000_WRITE_REG(Ctrl, (CtrlRegValue & ~E1000_CTRL_SLU));
    }

    return;
}

VOID ClearHwStatsCounters(PADAPTER_STRUCT Adapter)
 {
    volatile UINT32 RegisterContents;

    DEBUGFUNC("ClearHwStatsCounters")

        if (Adapter->AdapterStopped) {
        DEBUGOUT("Exiting because the adapter is stopped!!!\n");
        return;
    }

    RegisterContents = E1000_READ_REG(Crcerrs);
    RegisterContents = E1000_READ_REG(Symerrs);
    RegisterContents = E1000_READ_REG(Mpc);
    RegisterContents = E1000_READ_REG(Scc);
    RegisterContents = E1000_READ_REG(Ecol);
    RegisterContents = E1000_READ_REG(Mcc);
    RegisterContents = E1000_READ_REG(Latecol);
    RegisterContents = E1000_READ_REG(Colc);
    RegisterContents = E1000_READ_REG(Dc);
    RegisterContents = E1000_READ_REG(Sec);
    RegisterContents = E1000_READ_REG(Rlec);
    RegisterContents = E1000_READ_REG(Xonrxc);
    RegisterContents = E1000_READ_REG(Xontxc);
    RegisterContents = E1000_READ_REG(Xoffrxc);
    RegisterContents = E1000_READ_REG(Xofftxc);
    RegisterContents = E1000_READ_REG(Fcruc);
    RegisterContents = E1000_READ_REG(Prc64);
    RegisterContents = E1000_READ_REG(Prc127);
    RegisterContents = E1000_READ_REG(Prc255);
    RegisterContents = E1000_READ_REG(Prc511);
    RegisterContents = E1000_READ_REG(Prc1023);
    RegisterContents = E1000_READ_REG(Prc1522);
    RegisterContents = E1000_READ_REG(Gprc);
    RegisterContents = E1000_READ_REG(Bprc);
    RegisterContents = E1000_READ_REG(Mprc);
    RegisterContents = E1000_READ_REG(Gptc);
    RegisterContents = E1000_READ_REG(Gorl);
    RegisterContents = E1000_READ_REG(Gorh);
    RegisterContents = E1000_READ_REG(Gotl);
    RegisterContents = E1000_READ_REG(Goth);
    RegisterContents = E1000_READ_REG(Rnbc);
    RegisterContents = E1000_READ_REG(Ruc);
    RegisterContents = E1000_READ_REG(Rfc);
    RegisterContents = E1000_READ_REG(Roc);
    RegisterContents = E1000_READ_REG(Rjc);
    RegisterContents = E1000_READ_REG(Torl);
    RegisterContents = E1000_READ_REG(Torh);
    RegisterContents = E1000_READ_REG(Totl);
    RegisterContents = E1000_READ_REG(Toth);
    RegisterContents = E1000_READ_REG(Tpr);
    RegisterContents = E1000_READ_REG(Tpt);
    RegisterContents = E1000_READ_REG(Ptc64);
    RegisterContents = E1000_READ_REG(Ptc127);
    RegisterContents = E1000_READ_REG(Ptc255);
    RegisterContents = E1000_READ_REG(Ptc511);
    RegisterContents = E1000_READ_REG(Ptc1023);
    RegisterContents = E1000_READ_REG(Ptc1522);
    RegisterContents = E1000_READ_REG(Mptc);
    RegisterContents = E1000_READ_REG(Bptc);

    if (Adapter->MacType < MAC_LIVENGOOD)
        return;

    RegisterContents = E1000_READ_REG(Algnerrc);
    RegisterContents = E1000_READ_REG(Rxerrc);
    RegisterContents = E1000_READ_REG(Tuc);
    RegisterContents = E1000_READ_REG(Tncrs);
    RegisterContents = E1000_READ_REG(Cexterr);
    RegisterContents = E1000_READ_REG(Rutec);

    RegisterContents = E1000_READ_REG(Tsctc);
    RegisterContents = E1000_READ_REG(Tsctfc);

}

VOID
GetSpeedAndDuplex(PADAPTER_STRUCT Adapter, PUINT16 Speed, PUINT16 Duplex)
 {
    UINT32 DeviceStatusReg;
    UINT16 PhyData;

    DEBUGFUNC("GetSpeedAndDuplex")

        if (Adapter->AdapterStopped) {
        *Speed = 0;
        *Duplex = 0;
        return;
    }

    if (Adapter->MacType >= MAC_LIVENGOOD) {
        DEBUGOUT("Livengood MAC\n");
        DeviceStatusReg = E1000_READ_REG(Status);
        if (DeviceStatusReg & E1000_STATUS_SPEED_1000) {
            *Speed = SPEED_1000;
            DEBUGOUT("   1000 Mbs\n");
        } else if (DeviceStatusReg & E1000_STATUS_SPEED_100) {
            *Speed = SPEED_100;
            DEBUGOUT("   100 Mbs\n");
        } else {
            *Speed = SPEED_10;
            DEBUGOUT("   10 Mbs\n");
        }

        if (DeviceStatusReg & E1000_STATUS_FD) {
            *Duplex = FULL_DUPLEX;
            DEBUGOUT("   Full Duplex\r\n");
        } else {
            *Duplex = HALF_DUPLEX;
            DEBUGOUT("   Half Duplex\r\n");
        }
    } else {
        DEBUGOUT("Wiseman MAC - 1000 Mbs, Full Duplex\r\n");
        *Speed = SPEED_1000;
        *Duplex = FULL_DUPLEX;
    }

    return;
}

UINT16 ReadEepromWord(PADAPTER_STRUCT Adapter, UINT16 Reg)
 {
    UINT16 Data;

    ASSERT(Reg < EEPROM_WORD_SIZE);

    E1000_WRITE_REG(Eecd, E1000_EECS);

    ShiftOutBits(Adapter, EEPROM_READ_OPCODE, 3);
    ShiftOutBits(Adapter, Reg, 6);

    Data = ShiftInBits(Adapter);

    EepromCleanup(Adapter);
    return (Data);
}

STATIC
    VOID ShiftOutBits(PADAPTER_STRUCT Adapter, UINT16 Data, UINT16 Count)
 {
    UINT32 EecdRegValue;
    UINT32 Mask;

    Mask = 0x01 << (Count - 1);

    EecdRegValue = E1000_READ_REG(Eecd);

    EecdRegValue &= ~(E1000_EEDO | E1000_EEDI);

    do {

        EecdRegValue &= ~E1000_EEDI;

        if (Data & Mask)
            EecdRegValue |= E1000_EEDI;

        E1000_WRITE_REG(Eecd, EecdRegValue);

        DelayInMicroseconds(50);

        RaiseClock(Adapter, &EecdRegValue);
        LowerClock(Adapter, &EecdRegValue);

        Mask = Mask >> 1;

    } while (Mask);

    EecdRegValue &= ~E1000_EEDI;

    E1000_WRITE_REG(Eecd, EecdRegValue);
}

STATIC VOID RaiseClock(PADAPTER_STRUCT Adapter, UINT32 * EecdRegValue)
 {

    *EecdRegValue = *EecdRegValue | E1000_EESK;

    E1000_WRITE_REG(Eecd, *EecdRegValue);

    DelayInMicroseconds(50);
}

STATIC VOID LowerClock(PADAPTER_STRUCT Adapter, UINT32 * EecdRegValue)
 {

    *EecdRegValue = *EecdRegValue & ~E1000_EESK;

    E1000_WRITE_REG(Eecd, *EecdRegValue);

    DelayInMicroseconds(50);
}

STATIC UINT16 ShiftInBits(PADAPTER_STRUCT Adapter)
 {
    UINT32 EecdRegValue;
    UINT i;
    UINT16 Data;

    EecdRegValue = E1000_READ_REG(Eecd);

    EecdRegValue &= ~(E1000_EEDO | E1000_EEDI);
    Data = 0;

    for (i = 0; i < 16; i++) {
        Data = Data << 1;
        RaiseClock(Adapter, &EecdRegValue);

        EecdRegValue = E1000_READ_REG(Eecd);

        EecdRegValue &= ~(E1000_EEDI);
        if (EecdRegValue & E1000_EEDO)
            Data |= 1;

        LowerClock(Adapter, &EecdRegValue);
    }

    return (Data);
}

STATIC VOID EepromCleanup(PADAPTER_STRUCT Adapter)
 {
    UINT32 EecdRegValue;

    EecdRegValue = E1000_READ_REG(Eecd);

    EecdRegValue &= ~(E1000_EECS | E1000_EEDI);

    E1000_WRITE_REG(Eecd, EecdRegValue);

    RaiseClock(Adapter, &EecdRegValue);
    LowerClock(Adapter, &EecdRegValue);
}

BOOLEAN ValidateEepromChecksum(PADAPTER_STRUCT Adapter)
 {
    UINT16 Checksum = 0;
    UINT16 Iteration;

    for (Iteration = 0; Iteration < (EEPROM_CHECKSUM_REG + 1); Iteration++)
        Checksum += ReadEepromWord(Adapter, Iteration);

    if (Checksum == (UINT16) EEPROM_SUM)
        return (TRUE);
    else
        return (FALSE);
}

VOID UpdateEepromChecksum(PADAPTER_STRUCT Adapter)
 {
    UINT16 Checksum = 0;
    UINT16 Iteration;

    for (Iteration = 0; Iteration < EEPROM_CHECKSUM_REG; Iteration++)
        Checksum += ReadEepromWord(Adapter, Iteration);

    Checksum = (UINT16) EEPROM_SUM - Checksum;

    WriteEepromWord(Adapter, EEPROM_CHECKSUM_REG, Checksum);
}

BOOLEAN WriteEepromWord(PADAPTER_STRUCT Adapter, UINT16 Reg, UINT16 Data)
 {

    E1000_WRITE_REG(Eecd, E1000_EECS);

    ShiftOutBits(Adapter, EEPROM_EWEN_OPCODE, 5);
    ShiftOutBits(Adapter, Reg, 4);

    StandBy(Adapter);

    ShiftOutBits(Adapter, EEPROM_ERASE_OPCODE, 3);
    ShiftOutBits(Adapter, Reg, 6);

    if (!WaitEepromCommandDone(Adapter))
        return (FALSE);

    ShiftOutBits(Adapter, EEPROM_WRITE_OPCODE, 3);
    ShiftOutBits(Adapter, Reg, 6);
    ShiftOutBits(Adapter, Data, 16);

    if (!WaitEepromCommandDone(Adapter))
        return (FALSE);

    ShiftOutBits(Adapter, EEPROM_EWDS_OPCODE, 5);
    ShiftOutBits(Adapter, Reg, 4);

    EepromCleanup(Adapter);

    return (TRUE);
}

STATIC UINT16 WaitEepromCommandDone(PADAPTER_STRUCT Adapter)
 {
    UINT32 EecdRegValue;
    UINT i;

    StandBy(Adapter);

    for (i = 0; i < 200; i++) {
        EecdRegValue = E1000_READ_REG(Eecd);

        if (EecdRegValue & E1000_EEDO)
            return (TRUE);

        DelayInMicroseconds(5);
    }

    return (FALSE);
}

STATIC VOID StandBy(PADAPTER_STRUCT Adapter)
 {
    UINT32 EecdRegValue;

    EecdRegValue = E1000_READ_REG(Eecd);

    EecdRegValue &= ~(E1000_EECS | E1000_EESK);

    E1000_WRITE_REG(Eecd, EecdRegValue);

    DelayInMicroseconds(5);

    EecdRegValue |= E1000_EECS;

    E1000_WRITE_REG(Eecd, EecdRegValue);
}

BOOLEAN ReadPartNumber(PADAPTER_STRUCT Adapter, PUINT PartNumber)
{
    UINT16 EepromWordValue;

    DEBUGFUNC("ReadPartNumber")

        if (Adapter->AdapterStopped) {
        *PartNumber = 0;
        return (FALSE);
    }

    EepromWordValue = ReadEepromWord(Adapter,
                                     (UINT16) (EEPROM_PBA_BYTE_1));

    DEBUGOUT("Read first part number word\n");

    *PartNumber = (UINT32) EepromWordValue;
    *PartNumber = *PartNumber << 16;

    EepromWordValue = ReadEepromWord(Adapter,
                                     (UINT16) (EEPROM_PBA_BYTE_1 + 1));

    DEBUGOUT("Read second part number word\n");

    *PartNumber |= EepromWordValue;

    return (TRUE);

}

VOID IdLedOn(PADAPTER_STRUCT Adapter)
{
    UINT32 CtrlRegValue;

    if (Adapter->AdapterStopped) {
        return;
    }

    CtrlRegValue = E1000_READ_REG(Ctrl);

    CtrlRegValue |= E1000_CTRL_SWDPIO0 | E1000_CTRL_SWDPIN0;
    E1000_WRITE_REG(Ctrl, CtrlRegValue);

}

VOID IdLedOff(PADAPTER_STRUCT Adapter)
{
    UINT32 CtrlRegValue;

    if (Adapter->AdapterStopped) {
        return;
    }

    CtrlRegValue = E1000_READ_REG(Ctrl);

    CtrlRegValue |= E1000_CTRL_SWDPIO0;

    CtrlRegValue &= ~E1000_CTRL_SWDPIN0;

    E1000_WRITE_REG(Ctrl, CtrlRegValue);
}