rtfast.c

xp sp2 rtl8139 网卡驱动程序。

    WritePortULONG(TSAD1, Adapter->TxBufReadPtr[Adapter->CurrentTxPacket]); 
    WritePortULONG(TSD1, Adapter->PacketTxStatus[Adapter->CurrentTxPacket] | Adapter->EarlyTxThreshold);
    return;
} 

/**/
VOID SyncCardStartXmit2 ( 
    IN PRTFAST_ADAPTER Adapter 
  ) 
{ 
    UCHAR NCC;
	NCC = (UCHAR)(0x0F & (ReadPortULONG(TSD2) >> 0x18)); 
    if(NCC){
        if(NCC == 1) 
            Adapter->FramesXmitOneCollision	  += 1;
        else
            Adapter->FramesXmitManyCollisions += 1;
    }

    WritePortULONG(TSAD2, Adapter->TxBufReadPtr[Adapter->CurrentTxPacket]); 
    WritePortULONG(TSD2, Adapter->PacketTxStatus[Adapter->CurrentTxPacket] | Adapter->EarlyTxThreshold);
    return;
} 

/**/
VOID SyncCardStartXmit3 ( 
    IN PRTFAST_ADAPTER Adapter 
  ) 
{ 
    UCHAR NCC;

	NCC = (UCHAR)(0x0F & (ReadPortULONG(TSD3) >> 0x18)); 
    if(NCC){
        if(NCC == 1) 
            Adapter->FramesXmitOneCollision	  += 1;
        else
            Adapter->FramesXmitManyCollisions += 1;
    }

    WritePortULONG(TSAD3, Adapter->TxBufReadPtr[Adapter->CurrentTxPacket]); 
    WritePortULONG(TSD3, Adapter->PacketTxStatus[Adapter->CurrentTxPacket] | Adapter->EarlyTxThreshold); //00380000
    return;
} 

VOID CardStartXmit ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
#if DBG
	DbgPrint("===>CardStartXmit\n");
#endif 
    if( Adapter->CurrentTxPacket <= 0x0F )
        Adapter->Packets[Adapter->CurrentTxPacket] = Adapter->TxPacket[Adapter->CurrentTxPacket];

    switch( Adapter->CurrentTxPacket & 3 ) 
    {
    case 0:
        NdisMSynchronizeWithInterrupt((PNDIS_MINIPORT_INTERRUPT)&Adapter->Interrupt, SyncCardStartXmit0, Adapter);  // interrupt
        break;
    case 1:
        NdisMSynchronizeWithInterrupt((PNDIS_MINIPORT_INTERRUPT)&Adapter->Interrupt, SyncCardStartXmit1, Adapter);  // interrupt
        break;
    case 2:
        NdisMSynchronizeWithInterrupt((PNDIS_MINIPORT_INTERRUPT)&Adapter->Interrupt, SyncCardStartXmit2, Adapter);  // interrupt
        break;
    case 3:
        NdisMSynchronizeWithInterrupt((PNDIS_MINIPORT_INTERRUPT)&Adapter->Interrupt, SyncCardStartXmit3, Adapter);  // interrupt
        break;
    }
#if DBG
	DbgPrint("<===CardStartXmit\n");
#endif 
    return;
} 

BOOLEAN CardCopyDownPacket ( 
    IN PRTFAST_ADAPTER  Adapter,
    IN PNDIS_PACKET     packet
  ) 
{ 

	PNDIS_BUFFER curbuf;		//ebp-4
    UINT		bufLen;			//ebp-8
    PVOID		bufData;		//ebp-0Ch

	ULONG		PacketLength;	//ebp-10
	//SPIN_LOCK	a;				//ebp-14h

	PUCHAR      pTempBufPtr;	//ebp+8 recycled 
	PUCHAR      pVa = NULL;		//ebp+0Ch

#if DBG
	DbgPrint("===>CardCopyDownPacket\n");
#endif 
	NdisDprAcquireSpinLock(&Adapter->SpinLock);

    NdisQueryPacket(packet, NULL, NULL, &curbuf, &PacketLength);
    if(PacketLength == 0) 
    {
		NdisMSendComplete(Adapter->MiniportHandle, packet, NDIS_STATUS_SUCCESS);
        NdisDprReleaseSpinLock(&Adapter->SpinLock);
        return(TRUE);
    }

    if(Adapter->NextTxPacket < 0x10)
    {
        Adapter->TxPacket[Adapter->NextTxPacket] = packet;
        pVa	= Adapter->DMADataPa[Adapter->NextTxPacket];
        pTempBufPtr		= Adapter->DMADataVa[Adapter->NextTxPacket];
    } else {
        pTempBufPtr		= Adapter->DMADataPa[MAX_X_BUFS - 1];//Adapter->TxBufPtr;
    }
	
	while(curbuf)
	{
		NdisQueryBufferSafe(curbuf, &bufData, &bufLen, 0x10);
		if(bufLen > 0) { // how could it be?
			NdisMoveMemory(pTempBufPtr, bufData, bufLen);
			pTempBufPtr += bufLen;
		}
		NdisGetNextBuffer(curbuf, &curbuf);
	}

    NdisDprReleaseSpinLock(&Adapter->SpinLock);
	if(PacketLength < 0x3C)
	{
		NdisZeroMemory(pTempBufPtr, 0x3C - PacketLength);
		PacketLength = 0x3C;
	}

    Adapter->PacketTxStatus[Adapter->NextTxPacket] = PacketLength;
    Adapter->TxBufReadPtr[Adapter->NextTxPacket]   = pVa; 

    Adapter->HwUnFinTxPackets--;
    Adapter->NextTxPacket = 0x0F & (Adapter->NextTxPacket + 1);


    Adapter->RegXmitStatus = ReadPortUSHORT(TSAD); 
    if(Adapter->RegXmitStatus & 0xF0) //TABT of all 4
    {
        WritePortUCHAR(TCR, 1);   //CLRABT
        WritePortUSHORT(ISR, 8);  //TER 
    }

    while(Adapter->CurTxDesc > 0) 
    {
        if( Adapter->CurrentTxPacket ==  Adapter->NextTxPacket)
            break;

        CardStartXmit(Adapter);
        Adapter->CurTxDesc--;
        Adapter->CurrentTxPacket = 0x0F & (Adapter->CurrentTxPacket + 1);
    };

#if DBG
	DbgPrint("<===CardCopyDownPacket\n");
#endif 
	return(TRUE);
}

VOID RTFast_DoNextSend ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 

#if DBG
	DbgPrint("===>RTFast_DoNextSend\n");
#endif 
    while(Adapter->FirstPacket != NULL)
    {
        if(Adapter->HwUnFinTxPackets > 0 )
	        CardCopyDownPacket(Adapter, Deque(Adapter) ); 
    };

    while(Adapter->CurTxDesc > 0)
    {
        if(Adapter->CurrentTxPacket == Adapter->NextTxPacket) 
            break;

        CardStartXmit(Adapter); 
        Adapter->CurTxDesc--;
        Adapter->CurrentTxPacket = (Adapter->CurrentTxPacket + 1) & 0x0F;
    };

#if DBG
	DbgPrint("<===RTFast_DoNextSend\n");
#endif 
    return;
} 


VOID ProcessLinkChange ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
	USHORT x;

	x = Adapter->RegConnectStatus;
#if DBG
		DbgPrint("===>ProcessLinkChange con status: %04x\n", Adapter->RegConnectStatus);
#endif 
	if((x>>8) & 8) //??? Con_status
	{
#if DBG
		DbgPrint("<===ProcessLinkChange con BMSR:%04x\n", ReadPortUSHORT(BMSR));
#endif 
		return;
	}
	if(!((x>>8) & 4)) //??? Constatus_En
	{
		RTFast_DoNextSend(Adapter);
		Rtl8139set_param(Adapter, 5, 0);
#if DBG
		DbgPrint("<===ProcessLinkChange con_en BMCR:%04x\n", ReadPortUSHORT(BMCR));
#endif 
		return;
	}

	if(Adapter->ChipVersion == 0 || Adapter->ChipVersion == 1)
		WriteLinkParam(Adapter);

	x = ReadPortUSHORT(BMCR);
	if(0x10 & (x>>8)) //Auto Negotiation Enable(ANE)
	{
		WriteOurCapability(Adapter); 
		WritePortUSHORT(BMCR, 0x1200); 
        NdisSetTimer((PNDIS_TIMER)&Adapter->LnkChgReNwayTimer, 0x5DC); 

#if DBG
	DbgPrint("<===ProcessLinkChange start autoNeg BMCR: %04x\n", x);
#endif 
		return;
	}

	x = ReadPortUSHORT(ANER);
	if(1 & x)
	{

#if DBG
		DbgPrint("<===ProcessLinkChange ANER: %02x\n", x);
#endif 
		return;
	}
	switch(Adapter->DuplexMode)
	{
	case 1:
		x = 0x1000;
		break;

	case 2:
		x = 0;
		break;

	case 3:
		x = 0x100;
		break;

	case 4:
		x = 0x2000;
		break;

	case 5:
		x = 0x2100;
		break;
	default:
		x = (USHORT)Adapter->MiniportHandle;
	}
	WritePortUSHORT(BMCR, x); 

#if DBG
	DbgPrint("<===ProcessLinkChange BMCR: %04x\n", x);
#endif 
	return;
}


VOID ProcessLinkUp ( 
    IN PRTFAST_ADAPTER Adapter
    ) 
{ 
#if DBG
	DbgPrint("===>ProcessLinkUp\n");
#endif 
	if(Adapter->enableWOL & 1)
	{
		SetConfigBit(Adapter, CONFIG3, 0x10);  // LinkUp
	} else if(Adapter->enableWOL == 2){
		ClearConfigBit(Adapter, CONFIG3, 0x10);    
	}

	if(Adapter->connectStatus == NDIS_STATUS_MEDIA_CONNECT)
	{
		WritePortUCHAR(CONFIG5, 4 | ReadPortUCHAR(CONFIG5));
	} else {
		SetLDPS(Adapter, (Adapter->enableLDPS == 0)? 4 : 0); 
	}
#if DBG
	DbgPrint("<===ProcessLinkUp\n");
#endif 
	return;
}

VOID SET_POWER ( 
    IN PRTFAST_ADAPTER Adapter,
    IN PVOID InformationBuffer
  ) 
{ 
	UCHAR buf, x;

#if DBG
	DbgPrint("===>SET_POWER\n");
#endif 

    RTFast_DisableInterrupt(Adapter);
	buf = *(PUCHAR)InformationBuffer;
	Adapter->PowerSystemState = (ULONG)buf;
	if(buf != 1)
	{
		NdisReadPciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 0x50, (PVOID)&buf, 1);
		if(buf != 1)
		{
			x = 0;
			NdisWritePciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 0x54, (PVOID)&x, 1);
		}

		NdisReadPciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 0x55, (PVOID)&buf, 1);
		buf |= 0x80;
		NdisWritePciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 0x55, (PVOID)&buf, 1);

		if(Adapter->bWakeUpEnable == 2)
			ClearConfigBit(Adapter, CONFIG4, 0x40); 

        ResetAdapter(Adapter);  
        ProcessLinkUp(Adapter);  
        SetupLink(Adapter); 
	}

    if((Adapter->PowerSystemState != 4) || (Adapter->PowerSystemState != 3) || (Adapter->PowerSystemState != 2))
        return;

	if(Adapter->bWakeUpEnable == 2)
		SetConfigBit(Adapter, CONFIG4, 0x40); 

	if(Adapter->bWakeUpFrame == 2)
		ClearConfigBit(Adapter, CONFIG5, 0x10);  //linkup

	SetLDPS(Adapter, (Adapter->enableLDPS == 0)? 4 : 0); 

#if DBG
	DbgPrint("<===SET_POWER\n");
#endif 
	return;
}

VOID QUERY_POWER ( 
    IN PRTFAST_ADAPTER Adapter
    ) 
{ 
    Adapter->PowerDeviceState = 4;
} 


NDIS_STATUS NICGetStatsCounters( 
    IN  PRTFAST_ADAPTER  Adapter,
    IN  NDIS_OID  Oid,
    OUT PULONG64   pCounter
  ) 
{ 
    *pCounter = 0;
#if DBG
	DbgPrint("===>NICGetStatsCounters\n");
#endif 
    if(Oid > OID_GEN_RCV_NO_BUFFER) {
        if(Oid==OID_GEN_RCV_CRC_ERROR) {
            *pCounter   = Adapter->CrcErrors;
            return NDIS_STATUS_SUCCESS;
        } else {
            if(Oid==OID_802_3_RCV_ERROR_ALIGNMENT) {
                *pCounter   = Adapter->FrameAlignmentErrors;
                return NDIS_STATUS_SUCCESS;
            }

            if(Oid==OID_802_3_XMIT_ONE_COLLISION) {
                *pCounter   = Adapter->FramesXmitOneCollision;
                return NDIS_STATUS_SUCCESS;
            }

            if(Oid==OID_802_3_XMIT_MORE_COLLISIONS) {
                *pCounter   = Adapter->FramesXmitManyCollisions;
                return NDIS_STATUS_SUCCESS;
            }
            return STATUS_NOT_SUPPORTED;
        }
    } 

    if(Oid==OID_GEN_RCV_NO_BUFFER) {
        *pCounter   = Adapter->MissedPackets;
        return NDIS_STATUS_SUCCESS;
    }

    if(Oid==OID_GEN_XMIT_OK) {
        *pCounter   = Adapter->FramesXmitGood;
        return NDIS_STATUS_SUCCESS; 
    }

    if(Oid==OID_GEN_RCV_OK) {
        *pCounter   = Adapter->FramesRcvGood;
        return NDIS_STATUS_SUCCESS; 
    }

    if(Oid==OID_GEN_XMIT_ERROR) {
        *pCounter   = Adapter->FramesXmitBad;
        return NDIS_STATUS_SUCCESS; 
    }

    //if(Oid!=OID_GEN_RCV_ERROR) {
    //    return STATUS_NOT_SUPPORTED;
    //}

    //*pCounter   = Adapter->CrcErrors;
    //return NDIS_STATUS_SUCCESS;


#if DBG
	DbgPrint("<===NICGetStatsCounters\n");
#endif 
    return STATUS_NOT_SUPPORTED;
} 

NDIS_STATUS ReadRegistry ( 
    IN  PRTFAST_ADAPTER  Adapter,
    IN NDIS_HANDLE Context
  ) 
{ 
    NDIS_STATUS Status;
    PNDIS_CONFIGURATION_PARAMETER cfgPara;
    NDIS_HANDLE  ConfigurationHandle;

    NDIS_STRING Environment             = NDIS_STRING_CONST("Environment");
    NDIS_STRING SlotNumber              = NDIS_STRING_CONST("SlotNumber");
    NDIS_STRING WIN98APM                = NDIS_STRING_CONST("WIN98APM");
    NDIS_STRING DuplexMode              = NDIS_STRING_CONST("DuplexMode");
    NDIS_STRING LinkUp                  = NDIS_STRING_CONST("LinkUp");
    NDIS_STRING WakeUpFrame             = NDIS_STRING_CONST("WakeUpFrame");
    NDIS_STRING PME                     = NDIS_STRING_CONST("PME");
    NDIS_STRING MAXMULTICAST            = NDIS_STRING_CONST("MAXMULTICAST");
    NDIS_STRING EarlyTxThreshold        = NDIS_STRING_CONST("EarlyTxThreshold");
    NDIS_STRING ChipOnCardbus           = NDIS_STRING_CONST("ChipOnCardbus");
    NDIS_STRING TxMaxDMABurst           = NDIS_STRING_CONST("TxMaxDMABurst");
    NDIS_STRING RxMaxDMABurst           = NDIS_STRING_CONST("RxMaxDMABurst");
    NDIS_STRING EarlyRxThreshold        = NDIS_STRING_CONST("EarlyRxThreshold");
    NDIS_STRING TxInterFrameGap         = NDIS_STRING_CONST("TxInterFrameGap");
    NDIS_STRING EnableLDPS              = NDIS_STRING_CONST("EnableLDPS");
    NDIS_STRING WakeOnLan               = NDIS_STRING_CONST("WakeOnLan");
    NDIS_STRING MassBrowse              = NDIS_STRING_CONST("MassBrowse");
    NDIS_STRING RxBufLen                = NDIS_STRING_CONST("RxBufLen");

    UCHAR        buffer;
    ULONG        maclength = 0;
    UCHAR        NetworkAddress[MAC_LENGTH];

#if DBG
	DbgPrint("===>ReadRegistry\n");
#endif 
    NdisOpenConfiguration(&Status, &ConfigurationHandle, Context);
    if(Status != NDIS_STATUS_SUCCESS)
        return Status;

    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&Environment, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
        Adapter->dwEnviron = cfgPara->ParameterData.IntegerData;

    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&SlotNumber, NdisParameterHexInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
        Adapter->slotnum = cfgPara->ParameterData.IntegerData;

    Adapter->DuplexMode = 1;

    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&DuplexMode, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
        Adapter->DuplexMode = cfgPara->ParameterData.IntegerData;
    //else
    //    Adapter->DuplexMode = 1;

    Adapter->bWIN98APM = 1;   
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&WIN98APM, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        if(cfgPara->ParameterData.IntegerData == 1) 
        {
			buffer = 0;
            NdisWritePciSlotInformation(ConfigurationHandle, 
				Adapter->slotnum, 0x55, &buffer, 1);
        }
        Adapter->bWIN98APM = 2;   
    }