void NIC_DRIVER_OBJECT::DriverReceiveIndication(
int nCurr,
PVOID pVoid,
int nLength)
{
NdisMEthIndicateReceive(
m_NdisHandle,
(PNDIS_HANDLE)nCurr,
(char*)pVoid,
ETH_HEADER_SIZE,
((char*)pVoid + ETH_HEADER_SIZE),
nLength - ETH_HEADER_SIZE,
nLength - ETH_HEADER_SIZE);
NdisMEthIndicateReceiveComplete(m_NdisHandle);
return;
}
// Process the received packet
void NeoWrite(void *buf)
{
UINT num, i, size;
void *packet_buf;
// Validate arguments
if (buf == NULL)
{
return;
}
// Number of packets
num = NEO_NUM_PACKET(buf);
if (num > NEO_MAX_PACKET_EXCHANGE)
{
// Number of packets is too many
return;
}
if (num == 0)
{
// No packet
return;
}
if (ctx->Halting != FALSE)
{
// Halting
return;
}
if (ctx->Opened == FALSE)
{
// Not connected
return;
}
for (i = 0;i < num;i++)
{
PACKET_BUFFER *p = ctx->PacketBuffer[i];
size = NEO_SIZE_OF_PACKET(buf, i);
if (size > NEO_MAX_PACKET_SIZE)
{
size = NEO_MAX_PACKET_SIZE;
}
if (size < NEO_PACKET_HEADER_SIZE)
{
size = NEO_PACKET_HEADER_SIZE;
}
packet_buf = NEO_ADDR_OF_PACKET(buf, i);
// Buffer copy
NeoCopy(p->Buf, packet_buf, size);
if (g_is_win8 == false)
{
// Adjust the buffer size
NdisAdjustBufferLength(p->NdisBuffer, size);
// Set the packet information
NDIS_SET_PACKET_STATUS(p->NdisPacket, NDIS_STATUS_RESOURCES);
NDIS_SET_PACKET_HEADER_SIZE(p->NdisPacket, NEO_PACKET_HEADER_SIZE);
}
else
{
NdisMEthIndicateReceive(ctx->NdisMiniport, ctx,
p->Buf, NEO_PACKET_HEADER_SIZE,
((UCHAR *)p->Buf) + NEO_PACKET_HEADER_SIZE, size - NEO_PACKET_HEADER_SIZE,
size - NEO_PACKET_HEADER_SIZE);
NdisMEthIndicateReceiveComplete(ctx->NdisMiniport);
}
}
// Notify that packets have received
ctx->Status.NumPacketRecv += num;
if (g_is_win8 == false)
{
NdisMIndicateReceivePacket(ctx->NdisMiniport, ctx->PacketBufferArray, num);
}
}
INDICATE_STATUS
R6040IndicatePacket(
IN PR6040_ADAPTER Adapter,
IN INT Len
)
/*++
Routine Description:
Indicates the first packet on the card to the protocols.
NOTE: For MP, non-x86 architectures, this assumes that the packet has been
read from the card and into Adapter->PacketHeader and Adapter->Lookahead.
NOTE: For UP x86 systems this assumes that the packet header has been
read into Adapter->PacketHeader and the minimal lookahead stored in
Adapter->Lookahead
Arguments:
Adapter - pointer to the adapter block.
Return Value:
CARD_BAD if the card should be reset;
INDICATE_OK otherwise.
--*/
{
// Length of the packet
UINT PacketLen = Len;
// Length of the lookahead buffer
UINT IndicateLen;
if (PacketLen > 1514) {
RETAILMSG(R6040DBG,
(TEXT("R6040:IndicatePacket Third CARD_BAD check failed\r\n")));
return(SKIPPED);
}
// Lookahead amount to indicate
IndicateLen = (PacketLen > (Adapter->MaxLookAhead + R6040_HEADER_SIZE )) ?
(Adapter->MaxLookAhead + R6040_HEADER_SIZE ) :
PacketLen;
// Indicate packet
Adapter->PacketLen = PacketLen;
if (IndicateLen < R6040_HEADER_SIZE)
{
// Runt Packet
NdisDprReleaseSpinLock(&Adapter->RcvLock);
NdisMEthIndicateReceive(
Adapter->MiniportAdapterHandle,
(NDIS_HANDLE)Adapter,
(PCHAR)(Adapter->PacketHeaderLoc),
IndicateLen,
NULL,
0,
0
);
NdisDprAcquireSpinLock(&Adapter->RcvLock);
} else {
NdisDprReleaseSpinLock(&Adapter->RcvLock);
NdisMEthIndicateReceive(
Adapter->MiniportAdapterHandle,
(NDIS_HANDLE)Adapter,
(PCHAR)(Adapter->PacketHeaderLoc),
R6040_HEADER_SIZE,
(PCHAR)(Adapter->PacketHeaderLoc) + R6040_HEADER_SIZE,
IndicateLen - R6040_HEADER_SIZE,
PacketLen - R6040_HEADER_SIZE
);
NdisDprAcquireSpinLock(&Adapter->RcvLock);
}
Adapter->IndicateReceiveDone = TRUE;
return INDICATE_OK;
}
NDIS_STATUS
PtReceive(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookAheadBufferSize,
IN UINT PacketSize
)
/*++
Routine Description:
Handle receive data indicated up by the miniport below. We pass
it along to the protocol above us.
If the miniport below indicates packets, NDIS would more
likely call us at our ReceivePacket handler. However we
might be called here in certain situations even though
the miniport below has indicated a receive packet, e.g.
if the miniport had set packet status to NDIS_STATUS_RESOURCES.
Arguments:
<see DDK ref page for ProtocolReceive>
Return Value:
NDIS_STATUS_SUCCESS if we processed the receive successfully,
NDIS_STATUS_XXX error code if we discarded it.
--*/
{
PADAPT pAdapt =(PADAPT)ProtocolBindingContext;
PNDIS_PACKET MyPacket, Packet;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
if (!pAdapt->MiniportHandle)
{
Status = NDIS_STATUS_FAILURE;
}
else do
{
//
// Get at the packet, if any, indicated up by the miniport below.
//
Packet = NdisGetReceivedPacket(pAdapt->BindingHandle, MacReceiveContext);
if (Packet != NULL)
{
//------------------------------WestChamber---------------------------------
BOOLEAN result=WestChamberReceiverMain(Packet,pAdapt);
if(result==FALSE) {
//Simply drop the packet.
return NDIS_STATUS_NOT_ACCEPTED;
}
//------------------------------WestChamber---------------------------------
//
// The miniport below did indicate up a packet. Use information
// from that packet to construct a new packet to indicate up.
//
#ifdef NDIS51
//
// NDIS 5.1 NOTE: Do not reuse the original packet in indicating
// up a receive, even if there is sufficient packet stack space.
// If we had to do so, we would have had to overwrite the
// status field in the original packet to NDIS_STATUS_RESOURCES,
// and it is not allowed for protocols to overwrite this field
// in received packets.
//
#endif // NDIS51
//
// Get a packet off the pool and indicate that up
//
NdisDprAllocatePacket(&Status,
&MyPacket,
pAdapt->RecvPacketPoolHandle);
if (Status == NDIS_STATUS_SUCCESS)
{
//
// Make our packet point to data from the original
// packet. NOTE: this works only because we are
// indicating a receive directly from the context of
// our receive indication. If we need to queue this
// packet and indicate it from another thread context,
// we will also have to allocate a new buffer and copy
// over the packet contents, OOB data and per-packet
// information. This is because the packet data
// is available only for the duration of this
// receive indication call.
//
MyPacket->Private.Head = Packet->Private.Head;
MyPacket->Private.Tail = Packet->Private.Tail;
//
// Get the original packet (it could be the same packet as the
// one received or a different one based on the number of layered
// miniports below) and set it on the indicated packet so the OOB
// data is visible correctly at protocols above.
//
NDIS_SET_ORIGINAL_PACKET(MyPacket, NDIS_GET_ORIGINAL_PACKET(Packet));
NDIS_SET_PACKET_HEADER_SIZE(MyPacket, HeaderBufferSize);
//
// Copy packet flags.
//
NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
//
// Force protocols above to make a copy if they want to hang
// on to data in this packet. This is because we are in our
// Receive handler (not ReceivePacket) and we can't return a
// ref count from here.
//
NDIS_SET_PACKET_STATUS(MyPacket, NDIS_STATUS_RESOURCES);
//
// By setting NDIS_STATUS_RESOURCES, we also know that we can reclaim
// this packet as soon as the call to NdisMIndicateReceivePacket
// returns.
//
NdisMIndicateReceivePacket(pAdapt->MiniportHandle, &MyPacket, 1);
//
// Reclaim the indicated packet. Since we had set its status
// to NDIS_STATUS_RESOURCES, we are guaranteed that protocols
// above are done with it.
//
NdisDprFreePacket(MyPacket);
break;
}
}
else
{
//
// The miniport below us uses the old-style (not packet)
// receive indication. Fall through.
//
}
//
// Fall through if the miniport below us has either not
// indicated a packet or we could not allocate one
//
pAdapt->IndicateRcvComplete = TRUE;
switch (pAdapt->Medium)
{
case NdisMedium802_3:
case NdisMediumWan:
NdisMEthIndicateReceive(pAdapt->MiniportHandle,
MacReceiveContext,
HeaderBuffer,
HeaderBufferSize,
LookAheadBuffer,
LookAheadBufferSize,
PacketSize);
break;
case NdisMedium802_5:
NdisMTrIndicateReceive(pAdapt->MiniportHandle,
MacReceiveContext,
HeaderBuffer,
HeaderBufferSize,
LookAheadBuffer,
LookAheadBufferSize,
PacketSize);
break;
case NdisMediumFddi:
/*
NdisMFddiIndicateReceive(pAdapt->MiniportHandle,
MacReceiveContext,
HeaderBuffer,
HeaderBufferSize,
LookAheadBuffer,
LookAheadBufferSize,
PacketSize);
*/
break;
default:
ASSERT(FALSE);
break;
}
} while(FALSE);
return Status;
}
VOID
NTAPI
MiniportHandleInterrupt (
IN NDIS_HANDLE MiniportAdapterContext
)
{
PRTL_ADAPTER adapter = (PRTL_ADAPTER)MiniportAdapterContext;
ULONG txStatus;
UCHAR command;
PPACKET_HEADER nicHeader;
PETH_HEADER ethHeader;
NdisDprAcquireSpinLock(&adapter->Lock);
NDIS_DbgPrint(MAX_TRACE, ("Interrupts pending: 0x%x\n", adapter->InterruptPending));
//
// Handle a link change
//
if (adapter->LinkChange)
{
NdisDprReleaseSpinLock(&adapter->Lock);
NdisMIndicateStatus(adapter->MiniportAdapterHandle,
adapter->MediaState == NdisMediaStateConnected ?
NDIS_STATUS_MEDIA_CONNECT : NDIS_STATUS_MEDIA_DISCONNECT,
NULL,
0);
NdisMIndicateStatusComplete(adapter->MiniportAdapterHandle);
NdisDprAcquireSpinLock(&adapter->Lock);
adapter->LinkChange = FALSE;
}
//
// Handle a TX interrupt
//
if (adapter->InterruptPending & (R_I_TXOK | R_I_TXERR))
{
while (adapter->TxFull || adapter->DirtyTxDesc != adapter->CurrentTxDesc)
{
NdisRawReadPortUlong(adapter->IoBase + R_TXSTS0 +
(adapter->DirtyTxDesc * sizeof(ULONG)), &txStatus);
if (!(txStatus & (R_TXS_STATOK | R_TXS_UNDERRUN | R_TXS_ABORTED)))
{
//
// Not sent yet
//
break;
}
NDIS_DbgPrint(MAX_TRACE, ("Transmission for desc %d complete: 0x%x\n",
adapter->DirtyTxDesc, txStatus));
if (txStatus & R_TXS_STATOK)
{
adapter->TransmitOk++;
}
else
{
adapter->TransmitError++;
}
adapter->DirtyTxDesc++;
adapter->DirtyTxDesc %= TX_DESC_COUNT;
adapter->InterruptPending &= ~(R_I_TXOK | R_I_TXERR);
adapter->TxFull = FALSE;
}
}
//
// Handle a good RX interrupt
//
if (adapter->InterruptPending & (R_I_RXOK | R_I_RXERR))
{
for (;;)
{
NdisRawReadPortUchar(adapter->IoBase + R_CMD, &command);
if (command & R_CMD_RXEMPTY)
{
//
// The buffer is empty
//
adapter->InterruptPending &= ~(R_I_RXOK | R_I_RXERR);
break;
}
adapter->ReceiveOffset %= RECEIVE_BUFFER_SIZE;
NDIS_DbgPrint(MAX_TRACE, ("Looking for a packet at offset 0x%x\n",
adapter->ReceiveOffset));
nicHeader = (PPACKET_HEADER)(adapter->ReceiveBuffer + adapter->ReceiveOffset);
if (!(nicHeader->Status & RSR_ROK))
{
//
// Receive failed
//
NDIS_DbgPrint(MIN_TRACE, ("Receive failed: 0x%x\n", nicHeader->Status));
if (nicHeader->Status & RSR_FAE)
{
adapter->ReceiveAlignmentError++;
}
else if (nicHeader->Status & RSR_CRC)
{
adapter->ReceiveCrcError++;
}
adapter->ReceiveError++;
goto NextPacket;
}
NDIS_DbgPrint(MAX_TRACE, ("Indicating %d byte packet to NDIS\n",
nicHeader->PacketLength - RECV_CRC_LENGTH));
ethHeader = (PETH_HEADER)(nicHeader + 1);
NdisMEthIndicateReceive(adapter->MiniportAdapterHandle,
NULL,
(PVOID)(ethHeader),
sizeof(ETH_HEADER),
(PVOID)(ethHeader + 1),
nicHeader->PacketLength - sizeof(ETH_HEADER) - RECV_CRC_LENGTH,
nicHeader->PacketLength - sizeof(ETH_HEADER) - RECV_CRC_LENGTH);
adapter->ReceiveOk++;
NextPacket:
adapter->ReceiveOffset += nicHeader->PacketLength + sizeof(PACKET_HEADER);
adapter->ReceiveOffset = (adapter->ReceiveOffset + 3) & ~3;
NdisRawWritePortUshort(adapter->IoBase + R_CAPR, adapter->ReceiveOffset - 0x10);
if (adapter->InterruptPending & (R_I_RXOVRFLW | R_I_FIFOOVR))
{
//
// We can only clear these interrupts once CAPR has been reset
//
NdisRawWritePortUshort(adapter->IoBase + R_IS, R_I_RXOVRFLW | R_I_FIFOOVR);
adapter->InterruptPending &= ~(R_I_RXOVRFLW | R_I_FIFOOVR);
}
}
NdisMEthIndicateReceiveComplete(adapter->MiniportAdapterHandle);
}
NdisDprReleaseSpinLock(&adapter->Lock);
}
