ndisdevice.c

MICREL 网卡驱动 FOR CE 5.0

#ifdef DBG_
    int       i;
#endif
#endif

    AcquireAdapter( pAdapter, FALSE );
    HardwareDisableInterrupt( pHardware );
    HardwareDisable( pHardware );
    ReleaseAdapter( pAdapter );

#ifndef UNDER_CE
#ifdef DBG_
    DbgPrint( "counters:\n" );
    for ( i = OID_COUNTER_FIRST; i < OID_COUNTER_LAST; i++ )
    {
        DbgPrint( "%u = %u\n", i, pHardware->m_cnCounter[ 0 ][ i ]);
    }
    DbgPrint( "wait delays:\n" );
    for ( i = WAIT_DELAY_FIRST; i < WAIT_DELAY_LAST; i++ )
    {
        DbgPrint( "%u = %u\n", i, pHardware->m_nWaitDelay[ i ]);
    }
    DbgPrint( "bad:\n" );
    for ( i = COUNT_BAD_FIRST; i < COUNT_BAD_LAST; i++ )
    {
        DbgPrint( "%u = %u\n", i, pHardware->m_nBad[ i ]);
    }
    DbgPrint( "good:\n" );
    for ( i = COUNT_GOOD_FIRST; i < COUNT_GOOD_LAST; i++ )
    {
        DbgPrint( "%u = %u\n", i, pHardware->m_nGood[ i ]);
    }
#endif
#endif
}  // ShutdownAdapter

/* -------------------------------------------------------------------------- */

/*
    MiniportSynchronizeISR

    Description:
        This function is used to do things not interruptable by software
        interrupt.

    Parameters:
        PVOID Context
            Pointer to hardware information structure.

    Return (BOOLEAN):
        TRUE if successful; otherwise, FALSE.
*/

BOOLEAN MiniportSynchronizeISR (
    IN  PVOID Context )
{
    PHARDWARE pHardware = ( PHARDWARE ) Context;

    HardwareDisableInterrupt( pHardware );
    return TRUE;
}  // MiniportSynchronizeISR


/*
    HardwareDisableInterruptSync

    Description:
        This function is used to disable hardware interrupt atomically so that
        the operation is not interrupted.

    Parameters:
        void* pHardware
            Pointer to hardware information structure.

    Return (BOOLEAN):
        TRUE if successful; otherwise, FALSE.
*/

void HardwareDisableInterruptSync (
    void* pHardware )
{
    PNDIS_ADAPTER pAdapter = ( PNDIS_ADAPTER )(( PHARDWARE ) pHardware )->
        m_pDevice;

    NdisMSynchronizeWithInterrupt( &pAdapter->m_Interrupt,
        MiniportSynchronizeISR, pHardware );
}  /* HardwareDisableInterruptSync */

/* -------------------------------------------------------------------------- */

#define ADAPTER_LOCK_TIMEOUT  100

/*
    AcquireAdapter

    Description:
        This function is used to acquire the adapter so that only one process
        has access to the adapter.

    Parameters:
        PNDIS_ADAPTER pAdapter
            Pointer to adapter information structure.

        BOOLEAN fWait
            Indicate whether to wait or not.  User functions should wait, while
            periodic timer routine should not.

    Return (BOOLEAN):
        TRUE if successful; otherwise, FALSE.
*/

BOOLEAN AcquireAdapter (
    IN  PNDIS_ADAPTER pAdapter,
    IN  BOOLEAN       fWait )
{
    PHARDWARE pHardware = &pAdapter->m_Hardware;
    int       cnTimeOut = ADAPTER_LOCK_TIMEOUT;

    while ( --cnTimeOut )
    {
        NdisAcquireSpinLock( &pAdapter->m_lockHardware );

        if ( !pHardware->m_bAcquire )
        {
            pHardware->m_bAcquire = TRUE;
            NdisReleaseSpinLock( &pAdapter->m_lockHardware );
            return TRUE;
        }
        NdisReleaseSpinLock( &pAdapter->m_lockHardware );
        NdisMSleep( 10 );
    }
    if ( fWait )
    {

    }
    return FALSE;
}  // AcquireAdapter


/*
    ReleaseAdapter

    Description:
        This routine is used to release the adapater so that other process can
        have access to the adapter.

    Parameters:
        PNDIS_ADAPTER pAdapter
            Pointer to adapter information structure.

    Return (None):
*/

void ReleaseAdapter (
    IN  PNDIS_ADAPTER pAdapter )
{
    PHARDWARE pHardware = &pAdapter->m_Hardware;

    NdisAcquireSpinLock( &pAdapter->m_lockHardware );
    pHardware->m_bAcquire = FALSE;
    NdisReleaseSpinLock( &pAdapter->m_lockHardware );
}  // ReleaseAdapter

/* -------------------------------------------------------------------------- */

/*
    AdapterCheckForHang

    Description:
        This function checks the adapter is working properly.

    Parameters:
        PNDIS_ADAPTER pAdapter
            Pointer to adapter information structure.

    Return (BOOLEAN):
        TRUE if adapter is not working; FALSE if working properly.
*/

BOOLEAN AdapterCheckForHang (
    IN  PNDIS_ADAPTER pAdapter )
{
    return FALSE;
}  // AdapterCheckForHang


/*
    AdapterGetDescription

    Description:
        This routine returns the adapter description.

    Parameters:
        PNDIS_ADAPTER pAdapter
            Pointer to adapter information structure.

    Return (None):
*/

VOID AdapterGetDescription (
    PVOID* ppSource,
    PUINT  puiLength )
{
#ifdef DEF_KS8841
    static char gszDescription[] = "KS8841 PCI Ethernet";

#else
    static char gszDescription[] = "KS8842 PCI Ethernet";
#endif

    *ppSource = gszDescription;
    *puiLength = strlen( gszDescription );
}  // AdapterGetDescription


/*
    AdapterReadCounter

    Description:
        This function retrieves the statistics counter value.

    Parameters:
        PNDIS_ADAPTER pAdapter
            Pointer to adapter information structure.

        EOidCounter OidCounter
            The counter index.

    Return (ULONGLONG):
        The counter value.
*/

ULONGLONG AdapterReadCounter (
    PNDIS_ADAPTER pAdapter,
    EOidCounter   OidCounter )
{
    PHARDWARE    pHardware = &pAdapter->m_Hardware;
    PPORT_CONFIG pPort = &pHardware->m_Port[ MAIN_PORT ];
    ULONGLONG    qCounter = pHardware->m_cnCounter[ MAIN_PORT ][ OidCounter ];

    switch ( OidCounter )
    {
        case OID_COUNTER_XMIT_OK:

#if 0
#if defined( DEF_KS8842 )
            pPort = &pHardware->m_Port[ HOST_PORT ];
            qCounter = pPort->cnCounter[ MIB_COUNTER_RX_BROADCAST ] +
                pPort->cnCounter[ MIB_COUNTER_RX_MULTICAST ] +
                pPort->cnCounter[ MIB_COUNTER_RX_UNICAST ];

#else
            qCounter = pPort->cnCounter[ MIB_COUNTER_TX_BROADCAST ] +
                pPort->cnCounter[ MIB_COUNTER_TX_MULTICAST ] +
                pPort->cnCounter[ MIB_COUNTER_TX_UNICAST ];
#endif
#endif
#if DBG
            DBG_PRINT( "xmit ok: %u"NEWLINE, ( ULONG ) qCounter );
#endif
            break;
        case OID_COUNTER_RCV_OK:

#if 0
#if defined( DEF_KS8842 )
            pPort = &pHardware->m_Port[ HOST_PORT ];
            qCounter = pPort->cnCounter[ MIB_COUNTER_TX_BROADCAST ] +
                pPort->cnCounter[ MIB_COUNTER_TX_UNICAST ];

#else
            qCounter = pPort->cnCounter[ MIB_COUNTER_RX_BROADCAST ] +
                pPort->cnCounter[ MIB_COUNTER_RX_UNICAST ];
#endif
#endif
#if DBG
            DBG_PRINT( "rcv ok: %u"NEWLINE, ( ULONG ) qCounter );
#endif
            break;
        case OID_COUNTER_DIRECTED_FRAMES_XMIT:

#if defined( DEF_KS8842 )
            pPort = &pHardware->m_Port[ HOST_PORT ];
            qCounter = pPort->cnCounter[ MIB_COUNTER_RX_UNICAST ];

#else
            qCounter = pPort->cnCounter[ MIB_COUNTER_TX_UNICAST ];
#endif
#if DBG
            DBG_PRINT( "xmit frames: %u"NEWLINE, ( ULONG ) qCounter );
#endif
            break;
        case OID_COUNTER_BROADCAST_FRAME_XMIT:

#if defined( DEF_KS8842 )
            pPort = &pHardware->m_Port[ HOST_PORT ];
            qCounter = pPort->cnCounter[ MIB_COUNTER_RX_BROADCAST ];

#else
            qCounter = pPort->cnCounter[ MIB_COUNTER_TX_BROADCAST ];
#endif
#if DBG
            DBG_PRINT( "broadcast frames: %u"NEWLINE, ( ULONG ) qCounter );
#endif
            break;
        case OID_COUNTER_DIRECTED_FRAMES_RCV:

#if defined( DEF_KS8842 )
            pPort = &pHardware->m_Port[ HOST_PORT ];
            qCounter = pPort->cnCounter[ MIB_COUNTER_TX_UNICAST ];

#else
            qCounter = pPort->cnCounter[ MIB_COUNTER_RX_UNICAST ];
#endif
#if DBG
            DBG_PRINT( "rcv frames: %u"NEWLINE, ( ULONG ) qCounter );
#endif
            break;
        case OID_COUNTER_BROADCAST_FRAMES_RCV:

#if defined( DEF_KS8842 )
            pPort = &pHardware->m_Port[ HOST_PORT ];
            qCounter = pPort->cnCounter[ MIB_COUNTER_TX_BROADCAST ];

#else
            qCounter = pPort->cnCounter[ MIB_COUNTER_RX_BROADCAST ];
#endif
#if DBG
            DBG_PRINT( "rcv broadcast frames: %u"NEWLINE, ( ULONG ) qCounter );
#endif
            break;
        case OID_COUNTER_RCV_ERROR_CRC:
            qCounter = pPort->cnCounter[ MIB_COUNTER_RX_CRC_ERR ];

#if defined( DEF_KS8842 )
            pPort = &pHardware->m_Port[ OTHER_PORT ];
            qCounter += pPort->cnCounter[ MIB_COUNTER_RX_CRC_ERR ];
#endif
            break;
    }

#ifndef UNDER_CE
#ifdef DBG
    switch ( OidCounter )
    {
        case OID_COUNTER_DIRECTED_BYTES_XMIT:
            DBG_PRINT( "xmit bytes: %u"NEWLINE, ( ULONG ) qCounter );
            break;
        case OID_COUNTER_BROADCAST_BYTES_XMIT:
            DBG_PRINT( "broadcast bytes: %u"NEWLINE, ( ULONG ) qCounter );
            break;
        case OID_COUNTER_DIRECTED_BYTES_RCV:
            DBG_PRINT( "rcv bytes: %u"NEWLINE, ( ULONG ) qCounter );
            break;
        case OID_COUNTER_BROADCAST_BYTES_RCV:
            DBG_PRINT( "rcv broadcast: %u"NEWLINE, ( ULONG ) qCounter );
            break;
    }
#endif
#endif

    return( qCounter );
}  // AdapteReadCounter


/*
    AdapterReset

    Description:
        This function resets the adapter.

    Parameters:
        PNDIS_ADAPTER pAdapter
            Pointer to adapter information structure.

    Return (BOOLEAN):
        TRUE if successful; otherwise, FALSE.
*/

BOOLEAN AdapterReset (
    PNDIS_ADAPTER pAdapter )
{
    PHARDWARE pHardware = &pAdapter->m_Hardware;

    AcquireAdapter( pAdapter, FALSE );
    HardwareDisableInterrupt( pHardware );
    HardwareDisable( pHardware );

    if ( HardwareReset( pHardware ) )
    {
        pHardware->m_ulHardwareState = MediaStateDisconnected;

        /* Initialize to invalid value so that link detection is done. */
        pHardware->m_PortInfo[ MAIN_PORT ].bLinkPartner = 0xFF;
        pHardware->m_PortInfo[ MAIN_PORT ].ulHardwareState =
            MediaStateDisconnected;

#ifdef DEF_KS8842
        pHardware->m_PortInfo[ OTHER_PORT ].bLinkPartner = 0xFF;
        pHardware->m_PortInfo[ OTHER_PORT ].ulHardwareState =
            MediaStateDisconnected;
#endif

        HardwareSetup( pHardware );
        HardwareSwitchSetup( pHardware );
        HardwareSetDescriptorBase( pHardware,
            pHardware->m_TxDescInfo.ulRing,
            pHardware->m_RxDescInfo.ulRing );

        /* Reset may wipe out these registers. */
        if ( pHardware->m_bMacOverrideAddr )
            HardwareSetAddress( pHardware );
        if ( pHardware->m_bMulticastListSize )
            HardwareSetGroupAddress( pHardware );

        TransmitReset( pAdapter );
        HardwareResetRxPackets( pHardware );
        HardwareResetTxPackets( pHardware );

#ifndef UNDER_CE
        NdisInterlockedFlushSList( &pAdapter->m_RxBufInfo.listHead );
        NdisInterlockedFlushSList( &pAdapter->m_TxBufInfo.listHead );
#endif
        InitBuffers( &pAdapter->m_RxBufInfo );
        InitBuffers( &pAdapter->m_TxBufInfo );
        InitMapRegisters( pAdapter );
        InitReceiveBuffers( pAdapter );

        memset(( void* ) pHardware->m_cnCounter[ MAIN_PORT ], 0,
            ( sizeof( ULONGLONG ) * OID_COUNTER_LAST ) );
        PortInitCounters( pHardware, MAIN_PORT );

#if defined( DEF_KS8842 )  &&  !defined( TWO_NETWORK_INTERFACE )
        PortInitCounters( pHardware, OTHER_PORT );
#endif
        PortInitCounters( pHardware, HOST_PORT );

        HardwareEnable( pHardware );
        HardwareEnableInterrupt( pHardware );
        ReleaseAdapter( pAdapter );
        return TRUE;
    }
    ReleaseAdapter( pAdapter );
    return FALSE;
}  // AdapterReset

/* -----------------------------------------------------------