rtsnt.c

虚拟网络驱动程序ndis for 数字电视 ip 数据接收

    if(Adapter->InitialNwayCheckingTimerInitialized)
    {
        //it is better to wait for timer to be canceled.
        NdisMCancelTimer(       &(Adapter->InitialNwayCheckingTimer),
                                &TimerCanceled  );
    }
*/
    NdisMCancelTimer(
            &(Adapter->ResetCheckingTimer),  // ResetCheckingTimer
            &TimerCanceled
            );  

    //
    // Pause, waiting for any DPC stuff to clear.
    //


    /*   
    for(i = 0; i < Rx_PACKETS; i++)
    {
        PacketListEntry = PacketRemoveHeadList( &(Adapter->RcvList) );
        if( PacketListEntry == NULL )
            break;
        pReserved = CONTAINING_RECORD( PacketListEntry, PACKET_RESERVED, ListElement );
        pPacket   = CONTAINING_RECORD( pReserved, NDIS_PACKET, ProtocolReserved );
        NdisUnchainBufferAtFront( pPacket, &pNdisBuffer );
        if(pNdisBuffer)
            NdisFreeBuffer(pNdisBuffer);
        NdisReinitializePacket( pPacket );
        NdisFreePacket( pPacket );
    }

    for(i = 0; i < Rx_PACKETS; i++) 
    {
        //if(Adapter->RxBufArray[i])
            NdisFreeMemory(Adapter->RxBufArray[i], Rx_BufLen, 0); 
    }

    NdisFreeSpinLock( &(Adapter->RcvQSpinLock) );
    NdisFreeBufferPool( Adapter->BufferPool );
    NdisFreePacketPool( Adapter->PacketPool );
    */

	/*
    NdisMFreeSharedMemory(
            Adapter->MiniportAdapterHandle,
            RX_BUF_SIZE,
            FALSE,
            (PVOID )(Adapter->RxVirtualSADTop),
            Adapter->pRxPhysicalSAD
            );

    NdisMFreeMapRegisters(Adapter->MiniportAdapterHandle);

    NdisMDeregisterIoPortRange(
            Adapter->MiniportAdapterHandle,
            (ULONG)Adapter->IoAddr,
            0x100,
            (PVOID)Adapter->IoAddr
            );
*/

	RTFast_Delay(250000, RTL_PASSIVE);
	
    FreeAllMPEchan(Adapter);

    NdisFreeSpinLock(&Adapter->RTFAST_SpinLock);
    NdisFreeSpinLock(&Adapter->MPEdecSpinLock);
    NdisFreeSpinLock(&Adapter->MPEListSpinLock);


    //
    // Remove the adapter from the global queue of adapters.
    //
	
////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
/*#if CREATE_MY_NEWDEVICE
    if(RTFast_MiniportBlock.NdisDeviceHandle)
	{
		Status=NdisMDeregisterDevice(RTFast_MiniportBlock.NdisDeviceHandle);
		DbgPrint("NdisMDeregisterDevice!\n");
	}
#endif*/
////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
	

	
    if(RTFast_MiniportBlock.AdapterQueue == Adapter)
    {
        RTFast_MiniportBlock.AdapterQueue = Adapter->NextAdapter;
    }
    else
    {
        PRTFAST_ADAPTER TmpAdapter = RTFast_MiniportBlock.AdapterQueue;
        while (TmpAdapter->NextAdapter != Adapter)
        {
            TmpAdapter = TmpAdapter->NextAdapter;
        }

        TmpAdapter->NextAdapter = TmpAdapter->NextAdapter->NextAdapter;
    }

    if(RTFast_MiniportBlock.CurAdapter == Adapter)
        RTFast_MiniportBlock.CurAdapter = RTFast_MiniportBlock.AdapterQueue;


//	RTFast_MiniportBlock.AdapterQueue = NULL;
//	RTFast_MiniportBlock.CurAdapter = NULL;

    //
    // Free up the memory
    //
    NdisFreeMemory(Adapter, sizeof(RTFAST_ADAPTER), 0);

	g_driverok = FALSE;

    DbgPrint(" PCI Modem NIC Halt\n");

    //return NDIS_STATUS_FAILURE;
}

BOOLEAN
RTFast_CheckForHang(
    IN NDIS_HANDLE MiniportAdapterContext
)
{
    PRTFAST_ADAPTER Adapter = (PRTFAST_ADAPTER)MiniportAdapterContext;
    ULONG MaskBit, ReadPtr = 0x1FFFF;
    BOOLEAN  bHang = FALSE;

//	DbgPrint("RTL8139:CheckForHang");


	return FALSE;
}

BOOLEAN
ResetAdapter(
    IN PRTFAST_ADAPTER Adapter
    )
{
    //UINT i;
    BOOLEAN             Status;


    SyncCardStop(Adapter);

    //
    // Clear the values for transmits, they will be reset these for after
    // the reset is completed.
    //CleanupSendedPackets(Adapter);

    Adapter->FramesXmitGood = 0;               // Good Frames Transmitted
    Adapter->FramesRcvGood = 0;                // Good Frames Received
    Adapter->FramesXmitBad = 0;                // Bad Frames Transmitted
    Adapter->FramesXmitOneCollision = 0;       // Frames Transmitted with one collision
    Adapter->FramesXmitManyCollisions = 0;     // Frames Transmitted with > 1 collision
    Adapter->FrameAlignmentErrors = 0;         // FAE errors counted
    Adapter->CrcErrors = 0;                    // CRC errors counted
    Adapter->MissedPackets = 0;                // missed packet counted

    // luke add
    RtlZeroLargeInteger(Adapter->TotalReceiveBytes);
    RtlZeroLargeInteger(Adapter->TotalTransmitBytes);
    //
    // Physically reset the card.
    //
    //Adapter->NicInterruptMask = IMR_RCV | IMR_XMIT | IMR_XMIT_ERR | IMR_OVERFLOW;
    //Adapter->NicInterruptMask = 0xe07F;

    // Reset software and register
    Adapter->NicPageStart  = (ULONG) Adapter->RxVirtualSAD;

    Status = CardReset(Adapter);

    if(Status)
		RTFast_EnableInterrupt(Adapter);

	return Status;
}

//0.5 second
#define RESET_INTERVAL  500

/*++

Routine Description:

    The RTL8139Reset request instructs the Miniport to issue a hardware reset
    to the network adapter.  The driver also resets its software state.  See
    the description of NdisMReset for a detailed description of this request.

Arguments:

    AddressingReset - Does the adapter need the addressing information reloaded.

    MiniportAdapterContext - Pointer to the adapter structure.

Return Value:

    The function value is the status of the operation.

--*/

NDIS_STATUS
RTFast_Reset(
    OUT PBOOLEAN AddressingReset,
    IN NDIS_HANDLE MiniportAdapterContext
    )
{
    PRTFAST_ADAPTER Adapter = (PRTFAST_ADAPTER)MiniportAdapterContext;

#if 1 // DBG
    DbgPrint("*** Enter RTFast_Reset !\n");
#endif


//    ResetAdapter(Adapter);
//    NdisMSetTimer( &(Adapter->ResetCheckingTimer), RESET_INTERVAL );       //check it every 50ms

    return NDIS_STATUS_PENDING;
    //return NDIS_STATUS_SUCCESS;
}

VOID
LinkHandler(
    IN PVOID            SystemSpecific1,
    IN PRTFAST_ADAPTER  Adapter,
    IN PVOID            SystemSpecific2,
    IN PVOID            SystemSpecific3
    )
{
    Adapter->InLinkCheckTimer = TRUE;
    // Just for test
    NdisMResetComplete(Adapter->MiniportAdapterHandle, NDIS_STATUS_SUCCESS, FALSE);
    RTFast_EnableInterrupt(Adapter);
    // ****

    NdisMIndicateStatus(
		Adapter->MiniportAdapterHandle,
		NDIS_STATUS_WAN_LINE_UP,
		NULL,
		0
		);

    RTFast_Delay(250000, RTL_PASSIVE);

    NdisMIndicateStatus(
		Adapter->MiniportAdapterHandle,
		NDIS_STATUS_MEDIA_CONNECT,
		NULL,
		0
		);
	NdisMIndicateStatusComplete(
		Adapter->MiniportAdapterHandle
		);

	Adapter->LinkStatus = LINK_CONNECT;

	Adapter->InLinkCheckTimer = FALSE;
}


/*++

Routine Description:

    The RTL8139QueryInformation process a Query request for
    NDIS_OIDs that are specific about the Driver.

Arguments:

    MiniportAdapterContext - a pointer to the adapter.

    Oid - the NDIS_OID to process.

    InformationBuffer -  a pointer into the
    NdisRequest->InformationBuffer into which store the result of the query.

    InformationBufferLength - a pointer to the number of bytes left in the
    InformationBuffer.

    BytesWritten - a pointer to the number of bytes written into the
    InformationBuffer.

    BytesNeeded - If there is not enough room in the information buffer
    then this will contain the number of bytes needed to complete the
    request.

Return Value:

    The function value is the status of the operation.

--*/

NDIS_STATUS
RTFast_QueryInformation(
    IN NDIS_HANDLE MiniportAdapterContext,
    IN NDIS_OID Oid,
    IN PVOID InformationBuffer,
    IN ULONG InformationBufferLength,
    OUT PULONG BytesWritten,
    OUT PULONG BytesNeeded
)
{
    //
    // Pointer to the adapter structure.
    //

    PRTFAST_ADAPTER Adapter = (PRTFAST_ADAPTER)MiniportAdapterContext;

    //
    //   General Algorithm:
    //
    //      Switch(Request)
    //         Get requested information
    //         Store results in a common variable.
    //      default:
    //         Try protocol query information
    //         If that fails, fail query.
    //
    //      Copy result in common variable to result buffer.
    //   Finish processing

    UINT BytesLeft = InformationBufferLength;
    PUCHAR InfoBuffer = (PUCHAR)(InformationBuffer);
    NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
    NDIS_HARDWARE_STATUS HardwareStatus = NdisHardwareStatusReady;
    NDIS_MEDIUM Medium = NdisMedium802_3;

    //
    // This variable holds result of query
    //
    ULONG GenericULong;
    USHORT GenericUShort;
    UCHAR GenericArray[6];
    UINT MoveBytes = sizeof(ULONG);
    PVOID MoveSource = (PVOID)(&GenericULong);
    //ULONG TmpUchar, TmpUchar1, MaskBit;

#if NDIS50_MINIPORT
    //NDIS_PNP_CAPABILITIES    Power_Management_Capabilities;
#endif
    //
    // Make sure that int is 4 bytes.  Else GenericULong must change
    // to something of size 4.
    //

    ASSERT(sizeof(ULONG) == 4);
    //
    // Switch on request type
    //


//	DbgPrint("2830S*** Query Information!\n");

//	return STATUS_UNSUCCESSFUL;

    *BytesNeeded = *BytesWritten = 0;
    switch (Oid)
    {
        case OID_GEN_MAC_OPTIONS:
#if DBG
            //DbgPrint("*** OID_GEN_MAC_OPTIONS !\n");
#endif

//kinston.1998.5.4
/*
            NdisRawReadPortUchar(
                    Adapter->IoAddr+NIC_MII0+1,
                    &TmpUchar
                    );

            MaskBit = BIT0;        //FUDUP bit
            TmpUchar = TmpUchar & MaskBit;

            if(TmpUchar == 0x01)
            {
                GenericULong = (ULONG)(NDIS_MAC_OPTION_TRANSFERS_NOT_PEND  |
                                   NDIS_MAC_OPTION_RECEIVE_SERIALIZED  |
                                   NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
                                   NDIS_MAC_OPTION_NO_LOOPBACK         |
                                   NDIS_MAC_OPTION_FULL_DUPLEX
                                   );
            }
            else
            {
                GenericULong = (ULONG)(NDIS_MAC_OPTION_TRANSFERS_NOT_PEND  |
                                   NDIS_MAC_OPTION_RECEIVE_SERIALIZED  |
                                   NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
                                   NDIS_MAC_OPTION_NO_LOOPBACK
                                   );
            }
*/
            GenericULong = (ULONG)(NDIS_MAC_OPTION_TRANSFERS_NOT_PEND  |
                               NDIS_MAC_OPTION_RECEIVE_SERIALIZED  |
                               NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
                               NDIS_MAC_OPTION_NO_LOOPBACK
                               );

            break;

        case OID_GEN_SUPPORTED_LIST:
#if DBG
            //DbgPrint("*** OID_GEN_SUPPORTED_LIST !\n");
#endif

            MoveSource = (PVOID)(RTFast_SupportedOids);
            MoveBytes = sizeof(RTFast_SupportedOids);
            break;

        case OID_GEN_HARDWARE_STATUS:
#if DBG
            //DbgPrint("*** OID_GEN_HARDWARE_STATUS !\n");
#endif
            HardwareStatus = NdisHardwareStatusReady;
            MoveSource = (PVOID)(&HardwareStatus);
            MoveBytes = sizeof(NDIS_HARDWARE_STATUS);
            break;

        case OID_GEN_MEDIA_SUPPORTED:
        case OID_GEN_MEDIA_IN_USE:
#if DBG
            //DbgPrint("*** OID_GEN_MEDIA_IN_USE !\n");
#endif
            MoveSource = (PVOID) (&Medium);
            MoveBytes = sizeof(NDIS_MEDIUM);
            break;

        case OID_GEN_MAXIMUM_LOOKAHEAD:
#if DBG
            //DbgPrint("*** OID_GEN_MAXIMUM_LOOKAHEAD !\n");
#endif
            GenericULong = RTFAST_MAX_LOOKAHEAD;

            break;

        case OID_GEN_MAXIMUM_FRAME_SIZE:
#if DBG
            //DbgPrint("*** OID_GEN_MAXIMUM_FRAME_SIZE !\n");
#endif
            GenericULong = (ULONG)(1514 - RTFAST_HEADER_SIZE);
            break;

        case OID_GEN_MAXIMUM_TOTAL_SIZE:
#if DBG
            //DbgPrint("*** OID_GEN_MAXIMUM_TOTAL_SIZE !\n");
#endif
            GenericULong = (ULONG)(1514);
            break;

        case OID_GEN_LINK_SPEED:
			/*
			{
				NdisRawReadPortUchar(Adapter->IoAddr+0x58, &TmpUchar);
				if( TmpUchar & 0x08)
				{   //10M
					GenericULong = (ULONG)(100000);
				}
				else
				{
					GenericULong = (ULONG)(1000000);