rtfast.c

xp sp2 rtl8139 网卡驱动程序。

    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&LinkUp, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        if(cfgPara->ParameterData.IntegerData != 1) 
            cfgPara->ParameterData.IntegerData = 1;

        cfgPara->ParameterData.IntegerData += 1;
        Adapter->enableWOL = (BOOLEAN)cfgPara->ParameterData.IntegerData;
    }        

    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&WakeUpFrame, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        if(cfgPara->ParameterData.IntegerData == 0) 
            cfgPara->ParameterData.IntegerData = 1;

        cfgPara->ParameterData.IntegerData += 1;
        Adapter->bWakeUpFrame = (BOOLEAN)cfgPara->ParameterData.IntegerData;
    } else {
        Adapter->bWakeUpFrame = 1;
    }

    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&PME, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        if(cfgPara->ParameterData.IntegerData == 0 ) 
            Adapter->bPME = 2;
        if(cfgPara->ParameterData.IntegerData == 1 ) 
            Adapter->bPME = 1;
    } 

    NdisReadNetworkAddress(&Status, (PVOID)&NetworkAddress[0], 
		&maclength, ConfigurationHandle); 
    if( maclength == MAC_LENGTH || Status == NDIS_STATUS_SUCCESS) 
        NdisMoveMemory((PVOID)&Adapter->StationAddress, NetworkAddress, MAC_LENGTH);

    //????
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&MAXMULTICAST, NdisParameterInteger); 

    Adapter->EarlyTxThreshold = 0x380000;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&EarlyTxThreshold, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->EarlyTxThreshold = cfgPara->ParameterData.IntegerData<<16;
        if((cfgPara->ParameterData.IntegerData<<16) > 0x380000)
            Adapter->EarlyTxThreshold = 0x380000;

        if(Adapter->EarlyTxThreshold < 0x10000)
            Adapter->EarlyTxThreshold = 0x10000;
    }

    Adapter->ChipOnCardbus = 0;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&ChipOnCardbus, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->ChipOnCardbus = cfgPara->ParameterData.IntegerData;
    } 


    Adapter->TxMaxDMABurst = 0x600;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&TxMaxDMABurst, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->TxMaxDMABurst = (cfgPara->ParameterData.IntegerData<<8);
        if(Adapter->TxMaxDMABurst > 0x700)
            Adapter->TxMaxDMABurst = 0x700;
    }

    Adapter->RxMaxDMABurst = 0x600;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&RxMaxDMABurst, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->RxMaxDMABurst = cfgPara->ParameterData.IntegerData<<8;
        if(Adapter->RxMaxDMABurst > 0x700)
            Adapter->RxMaxDMABurst = 0x700;
    }

    if(Adapter->ChipOnCardbus)
    {
        Adapter->TxMaxDMABurst = 0; 
    } 

    Adapter->EarlyRxThreshold = 0x4000;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&EarlyRxThreshold, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->EarlyRxThreshold = max( 0xE000, cfgPara->ParameterData.IntegerData<<13 );
    }
    

    Adapter->TxInterFrameGap = 0x3000000;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&TxInterFrameGap, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->TxInterFrameGap = min(cfgPara->ParameterData.IntegerData<<24, 0x30000000);
    }

    Adapter->enableLDPS = 0;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&EnableLDPS, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->enableLDPS = cfgPara->ParameterData.IntegerData;
    }

    Adapter->dWakeOnLan = 0;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&WakeOnLan, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->dWakeOnLan = cfgPara->ParameterData.IntegerData;
    }

	Adapter->dMassBrowse = 0;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&MassBrowse, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->dMassBrowse = cfgPara->ParameterData.IntegerData;
    }

    Adapter->RxBufLen = 3;
    NdisReadConfiguration(&Status, &cfgPara, ConfigurationHandle, 
		(PNDIS_STRING)&RxBufLen, NdisParameterInteger); 
    if(Status == NDIS_STATUS_SUCCESS)
    {
        Adapter->RxBufLen = cfgPara->ParameterData.IntegerData;
        if(cfgPara->ParameterData.IntegerData > 3 ) 
            Adapter->RxBufLen = 3;
    }

    NdisCloseConfiguration(ConfigurationHandle);
#if DBG
	DbgPrint("<===ReadRegistry\n");
#endif 
    return Status;
} 

BOOLEAN PatternCheck ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
    PUCHAR p = Adapter->RxPktDMAStart + 0x0C; // remove 2 mac header contents
    USHORT up = (*p<<8) + *(p+1);  // 08 00
#if DBG
	DbgPrint("<===>PatternCheck %04x\n", up);
#endif 
    if(up > 0x5DC || up <0x2E || up == Adapter->PacketxLen - 0x12)             
        return(TRUE);

    return(FALSE);
} 

VOID RTFast_EnableInterrupt ( 
    IN PRTFAST_ADAPTER Adapter 
  ) 
{
#if DBG
	DbgPrint("===>RTFast_EnableInterrupt\n");
#endif 
    Adapter->sysInterruptStatus = 1;
    WritePortUSHORT(IMR, 0xC05F);
#if DBG
	DbgPrint("<===RTFast_EnableInterrupt\n");
#endif 
} 

VOID ResetCheckingTimerProc ( 
    IN PVOID  SystemSpecific1,
    IN PRTFAST_ADAPTER Adapter, 
    IN PVOID  SystemSpecific2,
    IN PVOID  SystemSpecific3
  ) 
{ 
#if DBG
	DbgPrint("===>ResetCheckingTimerProc\n");
#endif 
    Adapter->bResetingNIC  = 0; 
    NdisMResetComplete(Adapter->MiniportHandle, 0, 0);
    RTFast_EnableInterrupt(Adapter);
#if DBG
	DbgPrint("<===ResetCheckingTimerProc\n");
#endif 
} 

BOOLEAN PatternMatch ( 
    IN PUCHAR srcFrameBuf,
    IN PUCHAR dstFrameBuf,
    IN ULONG  PatternSize
  ) 
{ 
    ULONG i;
    ULONG len = PatternSize;
    if(len >= 0x80) 
        len = 0x80;

    if(len <= 0) 
        return(FALSE);

    i = 0;
    while(i < len)
	{
        if(*srcFrameBuf++ != *dstFrameBuf++)
            break;
        i++;
    };

    return(i == len);
} 

UCHAR lookForEmptySlot ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
    UCHAR i = 0;
    while(i < 8)
    {
        if(Adapter->regPattern[i].WUFBufSize == 0)
            return(i);
        i++;
    }
    return 8;
} 


VOID ClearAllWakeupPatternRegisters ( 
    IN PRTFAST_ADAPTER Adapter
    ) 
{ 
    ULONG i = 0;
    ULONG j = 0x84;
    while(j < 0xD4)
    {
        WritePortULONG(j, 0); 
        j += 4;
        i++;
    }
} 

VOID WriteTmpSaveWakeupPatternRegisters ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
    ULONG i = 0;
    ULONG j = 0x84;
    while(j < 0xD4)
    {
        WritePortULONG(j, Adapter->RegWakeupFrameBytes[i]); 
        j += 4;
        i++;
    }
} 

VOID TmpSaveWakeupPatternRegisters ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
    ULONG i = 0;
    ULONG j = 0x84;
    while(j < 0xD4)
    {
        Adapter->RegWakeupFrameBytes[i] = ReadPortULONG(j); 
        j += 4;
        i++;
    }
} 

VOID ClearWakeupPatternRegisters ( 
    IN PRTFAST_ADAPTER Adapter,
    IN ULONG FrameIndex
    ) 
{ 
    WritePortULONG(0x8C + FrameIndex, 0);
    WritePortULONG(0x90 + FrameIndex, 0); 
    WritePortUCHAR(0x84 + FrameIndex, 0); 
    WritePortUCHAR(0xCC + FrameIndex, 0); 
} 

VOID StoreWakeupPatternRegisters ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
    ULONG i = 0;
    while( i < 0x14 ) 
    {
        Adapter->NicWakeupPattern[i] = ReadPortULONG(0x84 + i*4); 
        i++;
    };
    return;
} 

VOID WriteWakeupPatternRegister ( 
    IN PRTFAST_ADAPTER Adapter,
    IN ULONG FrameIndex
    ) 
{ 
    WritePortULONG(FrameIndex*8 + 0x8C, Adapter->regPattern[FrameIndex].Wakeup); 
    WritePortULONG(FrameIndex*8 + 0x90, Adapter->regPattern[FrameIndex].LSBWakeup); 
    WritePortUCHAR(FrameIndex + 0x84, Adapter->regPattern[FrameIndex].CRC);    
    WritePortUCHAR(FrameIndex + 0xCC, Adapter->regPattern[FrameIndex].LSBCRC);    
} 


VOID StorePattern ( 
    IN PRTFAST_ADAPTER Adapter,
    IN ULONG    fIndex,
    IN PUCHAR   FrameBuf,
    IN ULONG    PatternSize
  ) 
{ 
    if(fIndex >= 8)
        return;

    NdisMoveMemory(&Adapter->regPattern[fIndex].WUFPacketBytes, FrameBuf, PatternSize);
    return;
} 

VOID TransformPattern ( 
    IN PRT_WUFPATT WUFPattern,         // ebp+8
    IN PUCHAR pakbuf,                  // ebp+0x0C
    IN UCHAR  makebyte,                // ebp+0x10
    IN PNDIS_PM_PACKET_PATTERN Pktpatt // ebp+0x14
  ) 
{
//   TransformPattern(Adapter->regPattern[fIndex], FrameBuf2Add, (PUCHAR)pattn + sizeof(NDIS_PM_PACKET_PATTERN), pattn);
	return;
}


VOID REMOVE_WAKE_UP_PATTERN( 
    IN PRTFAST_ADAPTER Adapter,
    IN PNDIS_PM_PACKET_PATTERN pattern
  ) 
{ 
    PUCHAR  pPatternBuf;
    ULONG   x;

    pPatternBuf  = (PUCHAR)pattern + pattern->PatternOffset;
    x = 0;
    while(x < 8) 
    {
        if(pattern->PatternSize == Adapter->regPattern[x].WUFBufSize) 
        {
            if(PatternMatch(pPatternBuf, \
                (PUCHAR)Adapter->regPattern[x].WUFPacketBytes, \
                pattern->PatternSize))
            {
                ClearWakeupPatternRegisters(Adapter, x); 
                Adapter->regPattern[x].WUFBufSize = 0;
                Adapter->WUPattCount--; 
            }
        }
        x++;
    };
#if DBG
	DbgPrint("<===>REMOVE_WAKE_UP_PATTERN\n");
#endif 
    return;
} 


VOID REMOVE_ALL_WAKE_UP_PATTERN ( 
    IN PRTFAST_ADAPTER Adapter
    ) 
{ 
    UCHAR x = 0x84; // 0x84;
    while(x < 0xD4) 
    {
       WritePortULONG(x, 0);
        x += 4;
    }

    Adapter->WUPattCount = 0;
    WritePortUCHAR(CONFIG5, (~0x10) & ReadPortUCHAR(CONFIG5)); 
    return;
} 

NDIS_STATUS ADD_WAKE_UP_PATTERN ( 
    IN PRTFAST_ADAPTER Adapter,
    IN PNDIS_PM_PACKET_PATTERN pattn
    ) 
{ 
    
    ULONG   i = 0;          
    ULONG   fIndex;         
    PUCHAR  FrameBuf2Add;
	UCHAR   pattnMask;   
    
    fIndex = lookForEmptySlot(Adapter);
    if(8 == fIndex)
        return STATUS_INSUFFICIENT_RESOURCES;
    
    if(Adapter->WUPattCount == 7) 
        return STATUS_INSUFFICIENT_RESOURCES;
    
    FrameBuf2Add = (PUCHAR)pattn + pattn->PatternOffset;
    while(i < 8)
    {
        if(pattn->PatternSize == Adapter->regPattern[i].WUFBufSize)
        {
            if(PatternMatch(FrameBuf2Add, \
                (PUCHAR)Adapter->regPattern[i].WUFPacketBytes, \
                pattn->PatternSize))
                return NDIS_STATUS_SUCCESS;
        }
        i++;
    }
    
    Adapter->WUPattCount++;
    StorePattern(Adapter, fIndex, FrameBuf2Add, pattn->PatternSize);
    
    ClearConfigBit(Adapter, 0x5A, 8);  
    WritePortUCHAR(CR9346, 0xC0);  
    WritePortUCHAR(CONFIG4, 0xF7 & ReadPortUCHAR(CONFIG4)); 
    WritePortUCHAR(CR9346, 0); 

    pattnMask   = *(PUCHAR)pattn + sizeof(NDIS_PM_PACKET_PATTERN);
    i           = pattn->MaskSize ;  //???
    TransformPattern(&Adapter->regPattern[fIndex], FrameBuf2Add, pattnMask, pattn);
    
    WriteWakeupPatternRegister(Adapter, fIndex);  
    StoreWakeupPatternRegisters(Adapter); 
    return NDIS_STATUS_SUCCESS;
} 


VOID ENABLE_WAKE_UP ( 
    IN PRTFAST_ADAPTER Adapter,
    IN PVOID InformationBuffer
  ) 
{ 
    UCHAR MaskByte;

    MaskByte = *(PUCHAR)InformationBuffer;

    TmpSaveWakeupPatternRegisters(Adapter); 

    ClearAllWakeupPatternRegisters(Adapter);
    ClearConfigBit(Adapter, CONFIG3, 0x20); 
    ClearConfigBit(Adapter, CONFIG5, 0x10); 

    if((MaskByte & 1) == 0)
	{
        SetConfigBit(Adapter, CONFIG3, 0x20); 
    }

    if(MaskByte & 2) 
	{
        WriteTmpSaveWakeupPatternRegisters(Adapter); 
        SetConfigBit(Adapter, CONFIG5, 0x10); 
    }

    if((MaskByte & 4) || Adapter->enableWOL == 1)
        return;

    SetConfigBit(Adapter, CONFIG3, 0x10); 
    return;
} 

NDIS_STATUS DriverAutoLoad ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
    ULONG index = 0;

    WritePortUCHAR(CR9346, 0x40);
    while( index < 20000 ) { //4e20
        if(!(0x40 & ReadPortUCHAR(CR9346)))
            break;
        KeStallExecutionProcessor(0x32);
        index++;
    }
#if DBG
	DbgPrint("<===>DriverAutoLoad, returning %d\n", index);
#endif 
    return (index == 20000) ?NDIS_STATUS_FAILURE : NDIS_STATUS_SUCCESS ;
} 

VOID RTFast_TxDpc ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{ 
    USHORT d = 0;

#if DBG
	DbgPrint("===>RTFast_TxDpc\n");
#endif 
    while( Adapter->CurTxDesc < 4)
    {
        Adapter->RegXmitStatus = (USHORT)ReadPortUSHORT(TSAD); 

		switch (Adapter->HwFinishTxPacket & 3 - 0) {