lan91c96.c

Intel XScale PXA255 引导Linux的Redboot 版bootloader源代码！

    // Get the transmit status.
    WriteWord(LAN91C96_PTR_READ, &ioRegsP[LAN91C96_POINTER]);
    resultCode = ReadWord(&ioRegsP[LAN91C96_DATA_HIGH]);

    // Select Bank 0.
    WriteByte(BANK0, &ioRegsP[LAN91C96_BANK_SELECT]);
    // Clear the statistics register.
    ReadWord(&ioRegsP[LAN91C96_COUNTER]);
    // Re-enable TXENA in the Transmit Control Register.
    WriteWord(LAN91C96_TCR_TXENA, &ioRegsP[LAN91C96_TCR]);

    // Select Bank 2
    WriteByte(BANK2, &ioRegsP[LAN91C96_BANK_SELECT]);
    // Release the memory in the buffer for the frame that failed.
    WriteWord(LAN91C96_MMUCR_RELEASE_TX, &ioRegsP[LAN91C96_MMU]);

    // Prepare for timeout by getting the initial time interval.
    hal_clock_read(&start) ;//ostCtxP->getTimer_fnp(ostCtxP);

    // Wait for the request to complete by monitoring the NO BUSY bit in
    // the MMU Command Register.
    while (!ReadWord(&ioRegsP[LAN91C96_MMU]) & LAN91C96_MMUCR_NO_BUSY)
    {
        // Get the current time interval.
				hal_clock_read(&currTimerValue) ;
        if(hal_elapsed_ticks((unsigned long *)&start) > timeout)
        {
          //printf("timeout during DeallocateTxPacket\n") ;
					// Report timeout error.
					return (-1);
        }
    }

    // Get the Interrupt Status Register.
    intStatus = ReadByte(&ioRegsP[LAN91C96_INT_STATS]);
    // Enable transmit interrupt if set.
    if (intStatus & LAN91C96_IST_TX_INT)
    {
        // Acknowledge the Transmit interrupt.
        WriteByte(LAN91C96_ACK_TX_INT, &ioRegsP[LAN91C96_INT_ACK]);
    }

    return (0);
}

/*
*******************************************************************************
*
* FUNCTION:
*    LAN91C96LoopBack
*
* DESCRIPTION:
*    Enable/Disable internal loopback.
*
* INPUT PARAMETERS:
*    LAN91C96_ContextT *ctxP - Pointer to the LAN91C96 Device Context Structure
*    INT flag = 0 = disable loopback, 1 = enable loopback.
*
* RETURNS:
*    0 - Success
*    non-zero - Error
*
* GLOBAL EFFECTS:
*    LAN91C96 left in desired state.
*
* ASSUMPTIONS:
*    None.
*
* CALLS:
*    WriteByte - To write a byte to either the attribute or I/O space.
*    WriteWord - To write a word to either the attribute or I/O space.
*    ReadWord - Read a word from either the attribute or I/O space.
*
* CALLED BY:
*    Test code.
*
* PROTOTYPE:
*    INT LAN91C96LoopBack(LAN91C96_ContextT *ctxP, INT flag);
*
*******************************************************************************
*/
INT LAN91C96LoopBack(LAN91C96_ContextT *ctxP, INT flag)
{
    PVUINT32 ioRegsP = ctxP->LAN91C96IoP;     // Get pointer to I/O space
    UINT16 TCR;

    // Select Bank 0
    WriteByte(BANK0, &ioRegsP[LAN91C96_BANK_SELECT]);
    // Get the Transmit Control Register.
    TCR = ReadWord(&ioRegsP[LAN91C96_TCR]);

    // Non-zero flag indicate internal loopback desired.
    if (flag)
    {
        // Set internal loopback.
        TCR |= (LAN91C96_TCR_LOOP | LAN91C96_TCR_FDUPLX);
    }
    else
    {
        // Clear internal loopback.
        TCR &= ~(LAN91C96_TCR_LOOP | LAN91C96_TCR_FDUPLX);
        // Force a reset when coming out of internal loopback.
        ctxP->setupFlag = FALSE;
    }

    // Update the Transmit Control Register.
    WriteWord(TCR, &ioRegsP[LAN91C96_TCR]);

    return (0);
}

/*
*******************************************************************************
*
* FUNCTION:
*    LAN91C96DumpFrame
*
* DESCRIPTION:
*    Display the Ethernet frame.
*
* INPUT PARAMETERS:
*    LAN91C96_ContextT *ctxP - Pointer to the LAN91C96 Device Context Structure
*    UINT PDUFlag = 0 - display header only, 1 - display header and PDU
*    PUCHAR frame - Pointer to the Ethernet frame.
*    UINT length - Number of bytes in frame.
*
* RETURNS:
*    None.
*
* GLOBAL EFFECTS:
*    None.
*
* ASSUMPTIONS:
*    None.
*
* CALLS:
*    DM_Printf
*
* CALLED BY:
*    Test code, LAN91C96TransmitPacket, LAN91C96ReceivePacket
*
* PROTOTYPE:
*    VOID LAN91C96DumpFrame(LAN91C96_ContextT *ctxP, INT PDUFlag,
*                           PUCHAR frame, UINT16 length);
*
*******************************************************************************
*/
VOID LAN91C96DumpFrame(LAN91C96_ContextT *ctxP, INT PDUFlag,
                       PUCHAR frame, UINT16 length)
{
    UINT x;

    if (PDUFlag)
    {
        printf("Frame Buffer Address: 0x%x", *frame);
    }

    /*DM_Printf("To: %02x:%02x:%02x:%02x:%02x:%02x",
              frame[0], frame[1], frame[2],
              frame[3], frame[4], frame[5]);
    DM_Printf("From: %02x:%02x:%02x:%02x:%02x:%02x",
              frame[6], frame[7], frame[8],
              frame[9], frame[10], frame[11]);
    DM_Printf("Type: 0x%x, Length: %u",
              ntohs(*((PUINT16)(frame + 12))), length);*/

    if (PDUFlag)
    {
        for (x = 14; x < length; x += 8)
        {
            /*DM_Printf("%02x %02x %02x %02x %02x %02x %02x %02x",
                      frame[x],
                      frame[x + 1],
                      frame[x + 2],
                      frame[x + 3],
                      frame[x + 4],
                      frame[x + 5],
                      frame[x + 6],
                      frame[x + 7]);*/
        }
    }
}

/*
*******************************************************************************
*
* FUNCTION:
*    LAN91C96DumpRegisters
*
* DESCRIPTION:
*    This routine display internal information about the LAN91C96.
*
* INPUT PARAMETERS:
*    LAN91C96_ContextT *ctxP - Pointer to the LAN91C96 Device Context Structure
*
* RETURNS:
*    None.
*
* GLOBAL EFFECTS:
*    None.
*
* ASSUMPTIONS:
*    None.
*
* CALLS:
*    ReadWord - Read a word from either the attribute or I/O space.
*    WriteWord - To write a word to either the attribute or I/O space.
*    DM_Printf - Display text string.
*
* CALLED BY:
*    Application or test code.
*
* PROTOTYPE:
*    VOID LAN91C96DumpRegisters(LAN91C96_ContextT *ctxP);
*
*******************************************************************************
*/
VOID LAN91C96DumpRegisters(LAN91C96_ContextT *ctxP)
{
    PVUINT32 ioRegsP = ctxP->LAN91C96IoP;     // Get pointer to I/O space
    UINT16 bankSelect, bank0, bank1, bank2, bank3, bank4;
    int x;

    /*DM_Printf("LAN91C96 Bank Registers:");
    DM_Printf("Offset Bank0 Bank1 Bank2 Bank3 Bank4");*/

    // Read current bank select register.
    bankSelect = ReadWord(&ioRegsP[LAN91C96_BANK_SELECT]);

    for (x = 0; x < 16; x += 2)
    {
        // Select bank 0 register.
        WriteWord(0, &ioRegsP[LAN91C96_BANK_SELECT]);
        // Read register contains.
        bank0 = ReadWord(&ioRegsP[x]);
        // Select bank 1 register.
        WriteWord(1, &ioRegsP[LAN91C96_BANK_SELECT]);
        // Read register contains.
        bank1 = ReadWord(&ioRegsP[x]);
        // Select bank 2 register.
        WriteWord(2, &ioRegsP[LAN91C96_BANK_SELECT]);
        // Read register contains.
        bank2 = ReadWord(&ioRegsP[x]);
        // Select bank 3 register.
        WriteWord(3, &ioRegsP[LAN91C96_BANK_SELECT]);
        // Read register contains.
        bank3 = ReadWord(&ioRegsP[x]);
        // Select bank 4 register.
        WriteWord(4, &ioRegsP[LAN91C96_BANK_SELECT]);
        // Read register contains.
        bank4 = ReadWord(&ioRegsP[x]);

        /*DM_Printf("%02X     %04X  %04X  %04X  %04X  %04X",
                  x, bank0, bank1, bank2, bank3, bank4);*/
    }

    // Restore bank select register.
    WriteWord(bankSelect, &ioRegsP[LAN91C96_BANK_SELECT]);

    /*DM_Printf("LAN91C96 Registers Complete\n");*/
}

/*
*******************************************************************************
*
* FUNCTION:
*    LAN91C96GetInfo
*
* DESCRIPTION:
*    This routines returns MAC address.
*
* INPUT PARAMETERS:
*    LAN91C96_ContextT *ctxP - Pointer to the LAN91C96 Device Context Structure
*    DM_NetworkInfo_T *info - Pointer to info structure.
*
* RETURNS:
*    The MAC address in DM_NetworkInfo_T.
*
* GLOBAL EFFECTS:
*    None.
*
* ASSUMPTIONS:
*    None.
*
* CALLS:
*    memcpy - copy one buffer to another.
*
* CALLED BY:
*    Application or test code.
*
* PROTOTYPE:
*   VOID LAN91C96GetInfo(LAN91C96_ContextT *ctxP, DM_NetworkInfo_T *info);
*
*******************************************************************************
*/
VOID LAN91C96GetInfo(LAN91C96_ContextT *ctxP, DM_NetworkInfo_T *info)
{
    // Return the MAC address.
    memcpy(info->mac, ctxP->MACAddress, 6);
}

/*
*******************************************************************************
*
* FUNCTION:
*    LAN91C96TransmitPacket
*
* DESCRIPTION:
*    This routine transmits the specified packet.
*
* INPUT PARAMETERS:
*    LAN91C96_ContextT *ctxP - Pointer to the LAN91C96 Device Context Structure
*    PUINT16 buffer - Pointer to the buffer to transmit.
*    INT length - Size of the transmit buffer.
*
* RETURNS:
*    0 - Success
*    non-zero - Error
*
* GLOBAL EFFECTS:
*    None.
*
* ASSUMPTIONS:
*    None.
*
* CALLS:
*    AllocateTxPacket - Get a transmit packet from the LAN91C96.
*    DeallocateTxPacket - Return the transmit packet back to the LAN91C96.
*    WriteByte - To write a byte to either the attribute or I/O space.
*    WriteWord - To write a word to either the attribute or I/O space.
*    ReadByte - Read a byte from either the attribute or I/O space.
*    ReadWord - Read a word from either the attribute or I/O space.
*    GetTimeStamp - Get a tick count.
*    GetDeltaTimeStamp - Get the time delta.
*    DM_Printf - Display text string.
*    DM_ErrPrintf - Display error string.
*    LAN91C96DumpFrame - Display packet.
*    DisplayTxStatus - Display the transmit status register.
*    LOGERROR - Logs errors encountered.
*
* CALLED BY:
*    Application or test code.
*
* PROTOTYPE:
*    INT LAN91C96TransmitPacket(LAN91C96_ContextT *ctxP,
*                               PUINT16 buffer, INT length);
*
*******************************************************************************
*/
INT LAN91C96TransmitPacket(LAN91C96_ContextT *ctxP, PUINT16 buffer, INT length)
{
    PVUINT32 ioRegsP = ctxP->LAN91C96IoP;     // Get pointer to I/O space
    UINT start, currTimerValue ;
    UINT timeout = (UINT)((LAN91C96_TO_TRANSMIT * 3686400) >> 20);
    UCHAR intStatus;
    UINT16 bufferSize, resultCode, x;
    UINT16 frameHandle = 0; 
    PUINT16 dataP = buffer;

    // Get a time reference.
    GetTimeStamp(ctxP);

    // Clear the error log.
    ctxP->loggedError = 0;

    // Check dump flag.
    if (ctxP->dumpFlag)
    {
        // Display transmit frame.
        //printf("Transmit Packet:");
        LAN91C96DumpFrame(ctxP, 0, (PUCHAR)buffer, length);
    }

    // Allocate a transmit frame from the LAN91C96.
    if (AllocateTxPacket(ctxP, length, &frameHandle))
    {
      //printf("AllocateTxPacket in LAN91C96TransmitPacket failed\n") ;
      return (ctxP->loggedError);
    }

    // Calculate the memory needed. This includes the status word, byte count
    // data and control rounded up.
    bufferSize = sizeof(UINT16) + sizeof(UINT16) + length + 1;
    if (bufferSize & 1)
    {
        // Round the size up.
        bufferSize++;
    }

    // Write the allocated packet number into the Packet Number Register.
    WriteWord(frameHandle, &ioRegsP[LAN91C96_PNR]);
    // Set the Auto Increment bit in the Pointer Register to increment the
    // internal address on access to the data register.
    WriteWord(LAN91C96_PTR_AUTO_INCR, &ioRegsP[LAN91C96_POINTER]);

    // Write the status word. See page 36 of the LAN91C96 specification.
    WriteWord(0, &ioRegsP[LAN91C96_DATA_HIGH]);
    // Write the byte count.
    WriteWord(bufferSize, &ioRegsP[LAN91C96_DATA_HIGH]);
    // Copy the data to the LAN91C96.

    for (x = 0; x < (length >> 1); x++)
    {
        // Write the data.
        WriteWord(*dataP++, &ioRegsP[LAN91C96_DATA_HIGH]);
    }

    // Now check for an odd number of bytes.
    if (length & 1)
    {
        // Write the control byte and last data byte.
        WriteWord((((LAN91C96_CONTROL_CRC | 
										LAN91C96_CONTROL_ODD) << 8) |
													(*(dataP) & 0xFF)), &ioRegsP[LAN91C96_DATA_HIGH]);
    }
    else
    {
        // Write just the control byte.
        WriteWord((LAN91C96_CONTROL_CRC << 8), &ioRegsP[LAN91C96_DATA_HIGH]);
    }

    // Enqueue the frame number into the TX FIFO.
    WriteWord(LAN91C96_MMUCR_ENQUEUE, &ioRegsP[LAN91C96_MMU]);

    // Prepare for timeout by getting the initial time interval.
    hal_clock_read(&start) ;

    // Check the Interrupt Status Register for Transmit Empty.
    while (!((intStatus = ReadByte(&ioRegsP[LAN91C96_INT_STATS])) &
																							LAN91C96_IST_TX_EMPTY_INT))
    {    
				hal_clock_read(&currTimerValue) ;
        if (hal_elapsed_ticks((unsigned long *)&start) > timeout)
        {