rtsnt.c

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

*/
}

NDIS_STATUS
ReadRegistry(
    IN PRTFAST_ADAPTER Adapter,
    IN NDIS_HANDLE ConfigurationHandle
)
{

    NDIS_INTERFACE_TYPE IfType;
    //
    // The handle for reading from the registry.
    //
    NDIS_HANDLE ConfigHandle;

    //
    // The value read from the registry.
    //
    PNDIS_CONFIGURATION_PARAMETER ReturnedValue;

    //
    NDIS_STATUS Status;

    // String names of all the parameters that will be read.
    //
    NDIS_ENVIRONMENT_TYPE MyEnvironment = NdisEnvironmentWindows;
    NDIS_STRING MaxMulticastListStr     = NDIS_STRING_CONST("MAXMULTICAST");
    NDIS_STRING NetworkAddressStr       = NDIS_STRING_CONST("NETADDRESS");
    NDIS_STRING EnvironmentStr          = NDIS_STRING_CONST("Environment");
    NDIS_STRING AdapterSlotNoStr        = NDIS_STRING_CONST("SlotNumber");
    //NDIS_STRING EarlyTxThresholdStr     = NDIS_STRING_CONST("EarlyTxThreshold");
    //NDIS_STRING ChipOnCardbusStr        = NDIS_STRING_CONST("ChipOnCardbus");
    //NDIS_STRING SpeedDuplexModeStr      = NDIS_STRING_CONST("DuplexMode");
    //NDIS_STRING WIN98APM                = NDIS_STRING_CONST("WIN98APM");
    //NDIS_STRING TxMaxDMABurstStr        = NDIS_STRING_CONST("TxMaxDMABurst");
    //NDIS_STRING RxMaxDMABurstStr        = NDIS_STRING_CONST("RxMaxDMABurst");
    //NDIS_STRING EarlyRxThresholdStr     = NDIS_STRING_CONST("EarlyRxThreshold");
    //NDIS_STRING TxInterFrameGapStr      = NDIS_STRING_CONST("TxInterFrameGap");
    //NDIS_STRING LinkUp                  = NDIS_STRING_CONST("LinkUp");
    //NDIS_STRING WakeUpFrame             = NDIS_STRING_CONST("WakeUpFrame");
    // The network address the adapter should use instead of the
    // the default burned in address.
    //
    PVOID       NetAddress;
    ULONG       Length;
    UINT        MaxMulticastList;
    //UCHAR       tmpInterruptNum;
    //UCHAR       TmpUchar;

	

    // Open the configuration space.
    NdisOpenConfiguration(
            &Status,
            &ConfigHandle,
            ConfigurationHandle
            );

    if(Status != NDIS_STATUS_SUCCESS)
    {
        return (Status);
    }

    NdisReadConfiguration(
	        &Status,
            &ReturnedValue,
            ConfigHandle,
            &EnvironmentStr,
            NdisParameterInteger
	        );

    if(Status == NDIS_STATUS_SUCCESS)           //  If found ...
    {
        Adapter->Environment = (ULONG)(ReturnedValue->ParameterData.IntegerData);
#if DBG
        DbgPrint ("*** Environment: hex: %X  ", Adapter->Environment);
        if(Adapter->Environment == NdisEnvironmentWindowsNt)
            DbgPrint ("is WinNT\n");
        else
            DbgPrint ("is Win9x\n");
#endif
    }
    else
    {   //what to do if this is not found?
    }

#if DBG 
    DbgPrint("*** Adapter->SlotNumber = %x\n", Adapter->SlotNumber);
#endif

    NdisReadConfiguration (
                   &Status,
                   &ReturnedValue,
                   ConfigHandle,
                   &AdapterSlotNoStr,
                   NdisParameterHexInteger
                   );

    if(Status == NDIS_STATUS_SUCCESS)
    { 
           Adapter->SlotNumber = ReturnedValue->ParameterData.IntegerData;

		   DbgPrint("*** Adapter->SlotNumber = %x\n", Adapter->SlotNumber);
    }



/*
    NdisReadConfiguration(
          &Status,
          &ReturnedValue,
          ConfigHandle,
          &SpeedDuplexModeStr,
          NdisParameterInteger
    );

    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->SpeedDuplexMode = ReturnedValue->ParameterData.IntegerData;
    }
#if NDIS50_MINIPORT
    NdisReadConfiguration(
          &Status,
          &ReturnedValue,
          ConfigHandle,
          &WIN98APM,
          NdisParameterInteger
    );


    if(Status == NDIS_STATUS_SUCCESS)
    {
        if(ReturnedValue->ParameterData.IntegerData == 1)
        {
            TmpUchar |= 0x01;                        // Set PME_En
            Adapter->WOL = 1;
            NdisWritePciSlotInformation(
               Adapter,
               Adapter->SlotNumber,
               0x55,
               (PVOID)&TmpUchar,
               1);

        }
        else
            Adapter->WOL = 2;
    }

#endif

    NdisReadConfiguration(
              &Status,
              &ReturnedValue,
              ConfigHandle,
              &LinkUp,
              NdisParameterInteger
    );

    if(Status == NDIS_STATUS_SUCCESS)
    {
        if(ReturnedValue->ParameterData.IntegerData == 1)
            Adapter->LinkUp = 1;
        else
            Adapter->LinkUp = 2;
    }



    NdisReadConfiguration(
              &Status,
              &ReturnedValue,
              ConfigHandle,
              &WakeUpFrame,
              NdisParameterInteger
    );

    if(Status == NDIS_STATUS_SUCCESS)
    {
        if(ReturnedValue->ParameterData.IntegerData == 1)
            Adapter->AddWakeUpFrame = DISABLE;    //disable WakeUp Frame
        else
            Adapter->AddWakeUpFrame = ENABLE;    //enable WakeUp Frame
    }
    else
    {
        Adapter->AddWakeUpFrame = ENABLE;    //enable WakeUp Frame
    }


*/
    //
    // Read net address
    //
    NdisReadNetworkAddress(
                &Status,
                &NetAddress,
                &Length,
                ConfigHandle
                );

    if((Length == RTFAST_LENGTH_OF_ADDRESS) && (Status == NDIS_STATUS_SUCCESS))
    {
        // Save the address that should be used.
        NdisMoveMemory(
                Adapter->StationAddress,
                NetAddress,
                RTFAST_LENGTH_OF_ADDRESS  );

		DbgPrint("net addr %x-%x-%x-%x-%x-%x\n", Adapter->StationAddress[0], Adapter->StationAddress[1], Adapter->StationAddress[2], Adapter->StationAddress[3], Adapter->StationAddress[4], Adapter->StationAddress[5]);
    }


//	DbgPrint("MaxMulticastList= %x\n", MaxMulticastList);
    // Read MaxMulticastList
    NdisReadConfiguration(
            &Status,
            &ReturnedValue,
            ConfigHandle,
            &MaxMulticastListStr,
            NdisParameterInteger
            );

    if(Status == NDIS_STATUS_SUCCESS)
    {
        MaxMulticastList = ReturnedValue->ParameterData.IntegerData;
        if(ReturnedValue->ParameterData.IntegerData <= MAX_IP_FILTERPID_NUM)
        {
            MaxMulticastList = ReturnedValue->ParameterData.IntegerData;
        }
		DbgPrint("MaxMulticastList= %x\n", MaxMulticastList);
    }

/*	Adapter->PermanentAddress[0] = 0x00;
    Adapter->PermanentAddress[1] = 0x01;
    Adapter->PermanentAddress[2] = 0x4c;
    Adapter->PermanentAddress[3] = 0x39;
    Adapter->PermanentAddress[4] = 0x00;
    Adapter->PermanentAddress[5] = 0xf0;

	Adapter->StationAddress[0] = 0x00;
    Adapter->StationAddress[1] = 0x01;
    Adapter->StationAddress[2] = 0x4c;
    Adapter->StationAddress[3] = 0x39;
    Adapter->StationAddress[4] = 0x00;
    Adapter->StationAddress[5] = 0xf0;  */


    Adapter->ChipOnCardbus = 0;

    //
    // First close the configuration space.
    //
    NdisCloseConfiguration(ConfigHandle);

	// Added by hanney on 21th Jan 2005
    // register our adapter object with the OS as a PCI adapter
    IfType = NdisInterfacePci;

    // call NdisMSetAttributesEx in order to let NDIS know
    // what kind of driver and features we support
/*    NdisMSetAttributesEx(
        Adapter->MiniportAdapterHandle,
        (NDIS_HANDLE) Adapter,
        0,
        (ULONG)
        NDIS_ATTRIBUTE_DESERIALIZE | NDIS_ATTRIBUTE_BUS_MASTER,
        IfType
        );  */

			NdisMSetAttributesEx(Adapter->MiniportAdapterHandle,
 							(NDIS_HANDLE) Adapter,
 							0,										// CheckForHangTimeInSeconds
 							NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT	|
								NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT|
								NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER |
								NDIS_ATTRIBUTE_DESERIALIZE |
								NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND,
 							0);

    return NDIS_STATUS_SUCCESS;
}

VOID
InitSoftwareVariable(
    IN PRTFAST_ADAPTER Adapter
    )
{
    //UCHAR   TmpUchar,ii,jj;
	UCHAR   ii, jj;
    ULONG   ulTemp;

    NdisMAllocateSharedMemory( Adapter->MiniportAdapterHandle,
               RX_BUF_SIZE,
               FALSE,
               (PVOID )&Adapter->RxVirtualSADTop,
               &(Adapter->pRxPhysicalSAD)
               );

    //NdisZeroMemory(Adapter->RxVirtualSADTop, RX_BUF_SIZE);
    //DbgPrint("*** Adapter->RxVirtualSADTop = %8x\n", Adapter->RxVirtualSADTop);

    Adapter->RxVirtualSAD = Adapter->RxVirtualSADTop;
    Adapter->RxPhysicalSAD  = NdisGetPhysicalAddressHigh(Adapter->pRxPhysicalSAD)*(2^32)
                     + NdisGetPhysicalAddressLow(Adapter->pRxPhysicalSAD);
  
    ulTemp = Adapter->RxPhysicalSAD;
    Adapter->RxPhysicalSAD = 0xFFFFC000 & (Adapter->RxPhysicalSAD+0x4000);

    ulTemp = Adapter->RxPhysicalSAD-ulTemp;

    Adapter->RxVirtualSAD = (PVOID)((ULONG)Adapter->RxVirtualSAD + ulTemp);

//#if DBG
    DbgPrint(" Adapter RxPhysicalSAD = 0x%X\n", Adapter->RxPhysicalSAD);
    DbgPrint(" Adapter RxVirtualSAD = 0x%X\n", Adapter->RxVirtualSAD);
//#endif

    // initizlize variable need only initialize once, for RTL8139(k) only
    // receceive variable
    Adapter->NicPageStart = (ULONG)Adapter->RxVirtualSAD;
    Adapter->RxBufBoundary = (ULONG)(Adapter->RxVirtualSAD) + RX_BUF_RING;

    /*
    // Initialize Configuration variable
    Adapter->NicReceiveConfig =
                Adapter->RxMaxDMABurst |           //
                ERXTH |                         // No Early interrupt
                Adapter->EarlyRxThreshold |     // Early Receive Threshold
                (RCR_RBLEN3|                    // rx buffer size = 16k
                 RCR_BROADCAST|RCR_APM|RCR_MULTICAST);  //accept broadcast, physical match, multicast

    Adapter->NicTransmitConfig =
                Adapter->TxMaxDMABurst |        // Tx DMA burst size
                Adapter->TxInterFrameGap ;      // Tx Intrframe gap
    */

    Adapter->InLinkCheckTimer = FALSE;

#if CREATE_MY_NEWDEVICE
    for(ii = 0; ii < MaxIRPQueue; ii++)
    {
        for(jj = 0; jj < MaxFilterPID; jj++)
            Adapter->wFilterPID[ii][jj] = 0x1FFF;
    }

    for(ii = 0; ii < MaxIRPQueue; ii++)
        InitializeListHead( &Adapter->ReadIRPList[ii] );
    KeInitializeSpinLock( &Adapter->ReadIRPQueueSpinLock );
#endif

    NdisInitializeListHead(&Adapter->ListMPEdec);
    NdisAllocateSpinLock(&Adapter->RTFAST_SpinLock);
    NdisAllocateSpinLock(&Adapter->MPEdecSpinLock);
    NdisAllocateSpinLock(&Adapter->MPEListSpinLock);
}


void
RTFast_Shutdown(
    IN NDIS_HANDLE MiniportAdapterContext
)
{
    PRTFAST_ADAPTER Adapter;
    //UCHAR TmpUchar;
    Adapter = PRTFAST_ADAPTER_FROM_CONTEXT_HANDLE(MiniportAdapterContext);

    RTFast_DisableInterrupt(Adapter);


    // Abort the Receive unit. so we don't continue to receive packets.  If
    // we didn't abort the Receive unit we could still DMA receive packets
    // into host memory after a warm boot, and that would be very bad!
    SyncCardStop(Adapter);

    RTFast_Delay(30, 0);

    // Reset the PHY chip.  We do this so that after a warm boot, the PHY will
    // be in a known state, with auto-negotiation enabled.
    //ResetPhy(Adapter);
}


/*++
Routine Description:

    RTL8139Halt removes an adapter that was previously initialized.
Arguments:
    MiniportAdapterContext - The context value that the Miniport returned
        from Rtl8139Initialize; actually as pointer to an RTL8139_ADAPTER.
Return Value:
    None.
--*/
extern
VOID
RTFast_Halt(
    IN NDIS_HANDLE MiniportAdapterContext
    )
{
    PRTFAST_ADAPTER Adapter;
	BOOLEAN TimerCanceled;
    //BOOLEAN ResetPHY = FALSE,Cancel,TimerCanceled;
    //UCHAR TmpUchar, TmpUchar2,PowerState;
    //ULONG i;
    //PNDIS_BUFFER pNdisBuffer;
    //PPACKET_RESERVED pReserved;
    //PLIST_ENTRY         PacketListEntry;
    //PNDIS_PACKET         pPacket;
    NDIS_STATUS Status;

	DbgPrint("2830S*** RTFast_Halt!\n");
	

    Adapter = PRTFAST_ADAPTER_FROM_CONTEXT_HANDLE(MiniportAdapterContext);

	

    //RTFast_DisableInterrupt(Adapter);
    //RTFast_Delay(100000, RTL_PASSIVE);  /* 0.1 sec */

    //
    // Shut down the chip.
    //
//    CardStop(Adapter);
    //CardWriteEthernetAddress(Adapter);
/*
// Set power down mode to D3 hot
#ifndef NDIS50_MINIPORT
    NdisReadPciSlotInformation(                    // check if Power management enabled?
               Adapter->MiniportAdapterHandle,
               Adapter->SlotNumber,
               0x50,
               (PVOID)&TmpUchar,
               1);
    if( TmpUchar & 0x01 )
    {
        PowerState=0x03;                           // if enabled, set power state to D3 hot
        NdisWritePciSlotInformation(
               Adapter->MiniportAdapterHandle,
               Adapter->SlotNumber,
               0x54,
               (PVOID)&PowerState,
               1);
    }


#endif
*/

    //
    // Disconnect the interrupt line.
    //
//    NdisMDeregisterInterrupt(&Adapter->Interrupt);

    // deregister shutdown handler because we are halting now, and don't
    // want to have a bugcheck handler registered any more
    NdisMDeregisterAdapterShutdownHandler(Adapter->MiniportAdapterHandle); 

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