⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 rtfast.c

📁 xp sp2 rtl8139 网卡驱动程序。
💻 C
📖 第 1 页 / 共 5 页
字号:
            case 0:
                d = Adapter->RegXmitStatus & 0x1000;
                break;
            case 1:
                d = Adapter->RegXmitStatus & 0x2000;
                break;
            case 2:
                d = Adapter->RegXmitStatus & 0x4000;
                break;
            case 3:
                d = Adapter->RegXmitStatus & 0x8000;
                break;
        }   

        if( d == 0 )
            break;

        NdisMSendComplete(Adapter->MiniportHandle, Adapter->Packets[Adapter->HwFinishTxPacket], NDIS_STATUS_SUCCESS);

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

        if( NDIS_STATUS_MEDIA_CONNECT == Adapter->connectStatus)
            Adapter->FramesXmitGood += 1;
    };

    RTFast_DoNextSend(Adapter); 

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

NDIS_STATUS RTFast_IndicatePacket ( 
    IN PRTFAST_ADAPTER Adapter 
  ) 
{ 
    UINT length, IndicateLen;
#if DBG
	DbgPrint("===>RTFast_IndicatePacket\n");
#endif 
    if(Adapter->PacketxLen <= 0x5EE) 
    {
        if(Adapter->RxPktDMAStart + Adapter->PacketxLen > Adapter->RxPktDMAStop)
        {
            length  = Adapter->RxPktDMAStart - Adapter->RxPktDMAStop + Adapter->PacketxLen;
			if(length > 0)
				NdisMoveMemory(Adapter->RxPktDMAStop, Adapter->RxDMABufStart, length);

        }

        if(PatternCheck(Adapter))
        {
            IndicateLen = Adapter->MaxLookAhead + NIC_HEADER_SIZE;

            if((Adapter->PacketxLen - 4) <= (Adapter->MaxLookAhead + NIC_HEADER_SIZE))
                IndicateLen = Adapter->PacketxLen - 4;

            IndicateLen -= NIC_HEADER_SIZE;

            NdisMEthIndicateReceive(
                Adapter->MiniportHandle,
                Adapter,
                (PUCHAR)Adapter->RxPktDMAStart,
                NIC_HEADER_SIZE,
                Adapter->RxPktDMAStart + NIC_HEADER_SIZE,
                IndicateLen,
                Adapter->PacketxLen - 0x12);
            Adapter->bRxIntEnabled = 1; 
        }
    }
	
    Adapter->CurChipReadPtr = (Adapter->CurChipReadPtr + Adapter->PacketxLen + 7) & ~3;
    WritePortUSHORT(CAPR, Adapter->CurChipReadPtr);

    Adapter->RxPktDMAStart = Adapter->RxPktDMAStart + Adapter->PacketxLen + 3;
	Adapter->RxPktDMAStart = (PUCHAR)(((UINT)Adapter->RxPktDMAStart) & ~3); 

    if(&Adapter->RxPktDMAStart >= &Adapter->RxPktDMAStop)
    {
        Adapter->RxPktDMAStart = Adapter->RxDMABufStart + (Adapter->RxPktDMAStart - Adapter->RxPktDMAStop);
    }

    Adapter->RxReadPtr = (PUCHAR)&Adapter->RxPktDMAStart;
#if DBG
	DbgPrint("<===RTFast_IndicatePacket\n");
#endif 
    return NDIS_STATUS_SUCCESS;
} 

BOOLEAN SyncCardSetReceiveConfig ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{
    WritePortULONG(RCR, Adapter->RxConfig);
#if DBG
	DbgPrint("<===>SyncCardSetReceiveConfig\n");
#endif 
    return(FALSE);
} 


BOOLEAN SyncCardSetAllMulticast ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{
    WritePortULONG(MAR0, -1);
    WritePortULONG(MAR4, -1);
    return(FALSE);
} 


BOOLEAN SyncCardCopyMulticastRegs ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{
	ULONG x;

	x = Adapter->MulticastRegs[0];
	x += Adapter->MulticastRegs[1]<<8;
	x += Adapter->MulticastRegs[2]<<16;
	x += Adapter->MulticastRegs[3]<<24;
    WritePortULONG(MAR0, x);

	x += Adapter->MulticastRegs[4];
	x += Adapter->MulticastRegs[5]<<8;
	x += Adapter->MulticastRegs[6]<<16;
	x += Adapter->MulticastRegs[7]<<24;
    WritePortULONG(MAR4, x);
    return(FALSE);
} 

//???
ULONG CardComputeCrc ( 
    IN PUCHAR Buffer,
    IN UINT Length
  )                                                                 
{                                                                     
    ULONG   Crc, Carry;
    UINT    i, j;
    UCHAR   CurByte;

    Crc = 0xFFFFFFFF;
    for (i = 0; i < Length; i++) 
	{
        CurByte = Buffer[i];
        for (j = 0; j < 8; j++) 
		{
            Carry = ((Crc & 0x80000000) ? 1 : 0) ^ (CurByte & 0x01);
            Crc <<= 1;
            CurByte >>= 1;
            if (Carry) 
                Crc = (Crc ^ 0x04c11db6) | Carry;
		}
	}

    return (Crc & 0xFF000000);                                                 
}                                             

//???
VOID CardGetMulticastBit ( 
    IN  PUCHAR Address,
    OUT UCHAR * byte,
    OUT UCHAR * bit
  )                                                                 
{                                                                     
    ULONG Crc;
    UINT BitNumber;

    Crc = CardComputeCrc(Address, MAC_LENGTH);

    BitNumber = (UINT)((Crc >> 0x1A) & 0x3F);

    *byte = (UCHAR)(BitNumber / 8);
    *bit  = (UCHAR)((UCHAR)1 << (BitNumber & 7));
}        

VOID CardFillMulticastRegs ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{
	LONG i;
	ULONG j;
	UCHAR xbyte, xbit;
	j = Adapter->eMacOptions;
	if(j <= 0)
		return;

	i = 6*j ;
	 while( i >= 0)
	 {
		i -= 6;
		CardGetMulticastBit(&Adapter->MCList[i], &xbyte, &xbit);
		Adapter->MulticastRegs[xbyte] |= xbit;
	};

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

NDIS_STATUS DispatchSetMulticastAddressList ( 
    IN PRTFAST_ADAPTER Adapter
  ) 
{
    CardFillMulticastRegs(Adapter);

    NdisMSynchronizeWithInterrupt(
        (PNDIS_MINIPORT_INTERRUPT)&Adapter->Interrupt,
        (PVOID)SyncCardCopyMulticastRegs,
        Adapter);
#if DBG
	DbgPrint("<===>DispatchSetMulticastAddressList\n");
#endif  
    return NDIS_STATUS_SUCCESS;
} 

NDIS_STATUS DispatchSetPacketFilter ( 
    IN PRTFAST_ADAPTER Adapter 
  ) 
{ 
    if(Adapter->PacketFilter & (NDIS_PACKET_TYPE_PROMISCUOUS | NDIS_PACKET_TYPE_ALL_MULTICAST)) 
        NdisMSynchronizeWithInterrupt((PNDIS_MINIPORT_INTERRUPT)&Adapter->Interrupt, &SyncCardSetAllMulticast, Adapter);
    else 
        DispatchSetMulticastAddressList(Adapter);

    if( Adapter->PacketFilter & (NDIS_PACKET_TYPE_PROMISCUOUS | 
        NDIS_PACKET_TYPE_MULTICAST | NDIS_PACKET_TYPE_ALL_MULTICAST) )
        Adapter->RxConfig |= 4;
    else 
        Adapter->RxConfig &= ~4;

    if( Adapter->PacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS  )
        Adapter->RxConfig |= 0x11;
    else
        Adapter->RxConfig &= ~0x11;


    if( Adapter->PacketFilter & (NDIS_PACKET_TYPE_PROMISCUOUS | NDIS_PACKET_TYPE_BROADCAST) )
        Adapter->RxConfig |= 8;
    else
        Adapter->RxConfig &= ~8;

     if( Adapter->PacketFilter & (NDIS_PACKET_TYPE_PROMISCUOUS | NDIS_PACKET_TYPE_DIRECTED) )
        Adapter->RxConfig |= 2;
    else 
        Adapter->RxConfig &= ~2;


    NdisMSynchronizeWithInterrupt((PNDIS_MINIPORT_INTERRUPT)&Adapter->Interrupt, 
			&SyncCardSetReceiveConfig, Adapter);

#if DBG
	DbgPrint("<===>DispatchSetPacketFilter\n");
#endif  
	return NDIS_STATUS_SUCCESS;
} 

NDIS_STATUS SetupPCIConfiguration ( 
    IN PRTFAST_ADAPTER Adapter 
  ) 
{ 
    ULONG length;
    UCHAR               buffer = 0x00;
    //PPCI_COMMON_CONFIG  pPciConfig = (PPCI_COMMON_CONFIG)buffer;
#if DBG
	DbgPrint("===>SetupPCIConfiguration\n");
#endif 
    length = NdisReadPciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 
        FIELD_OFFSET(PCI_COMMON_CONFIG, Command), (PVOID)&buffer, 1);
    if(length == 0)
	{

#if DBG
		DbgPrint("<===SetupPCIConfiguration  0 %08x\n",length);
#endif 
        return NDIS_STATUS_FAILURE;
	}

    Adapter->Sloth = (UCHAR)(buffer & 4); 
    buffer = ((buffer & ~2) | 5);
    length = NdisWritePciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 
        FIELD_OFFSET(PCI_COMMON_CONFIG, Command), (PVOID)&buffer, 1);
    if(length == 0)
	{

#if DBG
		DbgPrint("<===SetupPCIConfiguration 1 %08x\n", length);
#endif 
        return NDIS_STATUS_FAILURE;
	}

    length = NdisReadPciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum,
        0x50, (PVOID)&buffer, 1);
    if(length == 0)
	{

#if DBG
		DbgPrint("<===SetupPCIConfiguration 2 %08x\n", length);
#endif 
        return NDIS_STATUS_FAILURE;
	}

    if(buffer == 1) 
    {
        buffer = 0; 
        length = NdisWritePciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 
            0x54, (PVOID)&buffer, 1);
        if(length == 0)
		{

	#if DBG
			DbgPrint("<===SetupPCIConfiguration 3 %08x\n", length);
	#endif 
			return NDIS_STATUS_FAILURE;
		}

        length = NdisReadPciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 
            0x55, (PVOID)&buffer, 1);
        if(length == 0)
		{

	#if DBG
			DbgPrint("<===SetupPCIConfiguration 4 %08x\n", length);
	#endif 
			return NDIS_STATUS_FAILURE;
		}

        buffer |= 0x80;
        length = NdisWritePciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 
            0x55, (PVOID)&buffer, 1);
        if(length == 0)
		{

	#if DBG
			DbgPrint("<===SetupPCIConfiguration 5 %08x\n", length);
	#endif 
			return NDIS_STATUS_FAILURE;
		}
    }

    length = NdisReadPciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum, 
        0x55, (PVOID)&buffer, 1);
    if(length == 0)
	{

#if DBG
		DbgPrint("<===SetupPCIConfiguration 6 %08x\n", length);
#endif 
		return NDIS_STATUS_FAILURE;
	}

    if(Adapter->bPME != 1)
        buffer |= 0x81;

    if(Adapter->bPME != 2)
        buffer &= ~1;

    length = NdisWritePciSlotInformation(Adapter->MiniportHandle, Adapter->slotnum,
        0x55, (PVOID)&buffer,1);
#if DBG
	DbgPrint("<===SetupPCIConfiguration\n");
#endif 
	return (length == 0) ? NDIS_STATUS_FAILURE : NDIS_STATUS_SUCCESS; //??? observation needed.
} 

NDIS_STATUS RTFast_Send ( 
    IN  PRTFAST_ADAPTER Adapter,
    IN  PNDIS_PACKET  Packet,
    IN  UINT  flags
  ) 
{ 
    NdisDprAcquireSpinLock(&Adapter->SpinLock); // PNDIS_SPIN_LOCK  SpinLock 
    Enque(Adapter, Packet); 
    NdisDprReleaseSpinLock(&Adapter->SpinLock); // PNDIS_SPIN_LOCK  SpinLock
    RTFast_DoNextSend(Adapter); 
#if DBG
	DbgPrint("<===>RTFast_Send\n");
#endif 
    return NDIS_STATUS_PENDING;
} 

VOID RTFast_Sends ( 
    IN  PRTFAST_ADAPTER Adapter,
    IN  PPNDIS_PACKET   PacketArray,
    IN  UINT            NumberOfPackets
  ) 
{ 
	ULONG i = 0;
	if(NumberOfPackets <= 0)
		return;

	while(i < NumberOfPackets)
	{
		if(Adapter->bInterruptDisabled != 0)
		{
			#if DBG
				DbgPrint("===>RTFast_Sends NDIS_STATUS_FAILURE\n");
			#endif 
			NDIS_SET_PACKET_STATUS(PacketArray[i], NDIS_STATUS_FAILURE);
			return;
		}

		if(Adapter->bResetingNIC != 0 || Adapter->NumXmitInQueue > 0x20)
		{
			NDIS_SET_PACKET_STATUS(PacketArray[i], NDIS_STATUS_RESOURCES);
		} else  {
			RTFast_Send(Adapter, PacketArray[i], 1);
			NDIS_SET_PACKET_STATUS(PacketArray[i], NDIS_STATUS_PENDING);
		}
		i++;
	} ;

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

VOID CardStop( 
    IN PRTFAST_ADAPTER Adapter
  )                                                                 
{
    WritePortUCHAR(CONFIG5, ~0x10 & ReadPortUCHAR(CONFIG5) );
    WritePortUCHAR(CR, 0);
#if DBG
	DbgPrint("<===>CardStop\n");
#endif 
}                                                                     

BOOLEAN RTFast_CheckForHang ( 
    IN PRTFAST_ADAPTER Adapter 
  ) 
{ 
	UCHAR x;
    if(Adapter->bInterruptDisabled)
	{
        CleanupSendedPackets(Adapter);
        if(0xFFFF == (0xFFFF & ReadPortUSHORT(ISR))) 
		{
#if DBG
			DbgPrint("<===RTFast_CheckForHang: ISR==0XFFFF\n");
#endif 
            return(FALSE);
		}
        Adapter->bInterruptDisabled = 0;
#if DBG
		DbgPrint("<===RTFast_CheckForHang: bInterruptDisabled\n");
#endif 
        return(FALSE);
    }

    if(Adapter->bInReseting) 
	{
#if DBG
		DbgPrint("<===RTFast_CheckForHang: bInReseting\n");
#endif 
        return(FALSE);
	}

	x = ReadPortUCHAR(MSR);
    if(4 & x) // link changed
	{
        if(NDIS_STATUS_MEDIA_DISCONNECT != Adapter->connectStatus) 
		{
            Adapter->connectStatus = NDIS_STATUS_MEDIA_DISCONNECT;
            NdisMIndicateStatus(Adapter->MiniportHandle, NDIS_STATUS_MEDIA_DISCONNECT, 0, 0);
            //NdisMIndicateStatusComplete(Adapter->MiniportHandle); //???

			SetLDPS(Adapter, (Adapter->enableLDPS == 0)? 4 : 0); 
        }
		RTFast_DoNextSend(Adapter);
    } else {
		if(NDIS_STATUS_MEDIA_CONNECT != Adapter->connectStatus) 
		{
			Adapter->connectStatus = NDIS_STATUS_MEDIA_CONNECT;
			NdisMIndicateStatus(Adapter->MiniportHandle, NDIS_STATUS_MEDIA_CONNECT, 0, 0);
			//NdisMIndicateStatusComplete(Adapter->MiniportHandle); //???
		}
	}

    if(0x20 & ReadPortUSHORT(ISR))  //PUN | LinkChg
	{ 
        Adapter->RegConnectStatus = ReadPortUSHORT(CSCR); 
        WritePortUSHORT(ISR, 0x20); 
        ProcessLinkChange(Adapter); 
    }
#if 0
		DbgPrint("<===RTFast_CheckForHang MSR: %02x\n", x);
#endif 
    return(FALSE);
}


NDIS_STATUS RTFast_Reset ( 
    OUT PBOOLEAN AddressingReset,

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -