/*----------------------------------------------------------------------------*/
WLAN_STATUS
kalProcessRxPacket(IN P_GLUE_INFO_T prGlueInfo,
IN PVOID pvPacket,
IN PUINT_8 pucPacketStart,
IN UINT_32 u4PacketLen, IN BOOL fgIsRetain, IN ENUM_CSUM_RESULT_T aerCSUM[]
)
{
PNDIS_PACKET prNdisPacket;
PNDIS_BUFFER prNdisBuf;
NDIS_STATUS rStatus;
ASSERT(prGlueInfo);
ASSERT(pvPacket);
ASSERT(pucPacketStart);
prNdisPacket = (PNDIS_PACKET) pvPacket;
NdisAllocateBuffer(&rStatus,
&prNdisBuf,
prGlueInfo->hBufPool, (PVOID) pucPacketStart, (UINT_32) u4PacketLen);
if (rStatus != NDIS_STATUS_SUCCESS) {
ASSERT(0);
return WLAN_STATUS_FAILURE;
}
NdisChainBufferAtBack(prNdisPacket, prNdisBuf);
if (fgIsRetain) {
/* We don't have enough receive buffers, so set the status
on the packet to NDIS_STATUS_RESOURCES to force the
protocol driver(s) to copy this packet and return this
buffer immediately after returning from the
NdisMIndicateReceivePacket function. */
NDIS_SET_PACKET_STATUS(prNdisPacket, NDIS_STATUS_RESOURCES);
} else {
/* We have enough receive buffers, so set the status on the
packet to NDIS_STATUS_SUCCESS. */
NDIS_SET_PACKET_STATUS(prNdisPacket, NDIS_STATUS_SUCCESS);
}
#if CFG_TCP_IP_CHKSUM_OFFLOAD
kalUpdateRxCSUMOffloadParam(pvPacket, aerCSUM);
#endif
return WLAN_STATUS_SUCCESS;
}
NTSTATUS
MPIndicatePacket(PHWT_ADAPTER Adapter, PVOID Input, ULONG InputSize, PDEV_RET Output, ULONG OutputSize, PIRP Irp) {
PVOID data = NULL;
NDIS_STATUS ndis_status = NDIS_STATUS_FAILURE;
PNDIS_BUFFER ndis_buffer = NULL;
PNDIS_PACKET ndis_packet = NULL;
do {
data = ExAllocatePoolWithTag(NonPagedPool, InputSize, 'tkpi');
RtlCopyMemory(data, Input, InputSize);
NdisAllocateBuffer(&ndis_status,
&ndis_buffer,
Adapter->AllocateBufferPool,
data,
InputSize);
if (ndis_status != NDIS_STATUS_SUCCESS)
break;
NdisAllocatePacket(&ndis_status,
&ndis_packet,
Adapter->AllocatePacketPool);
if (ndis_status != NDIS_STATUS_SUCCESS)
break;
NdisReinitializePacket(ndis_packet);
*(PVOID*)ndis_packet->MiniportReserved = data;
NdisChainBufferAtBack(ndis_packet, ndis_buffer);
NDIS_SET_PACKET_HEADER_SIZE(ndis_packet, sizeof(ETHERNET_HEADER));
NDIS_SET_PACKET_STATUS(ndis_packet, NDIS_STATUS_SUCCESS);
NdisMIndicateReceivePacket(Adapter->AdapterHandle, &ndis_packet, 1);
Output->hResult = S_OK;
ndis_status = NDIS_STATUS_SUCCESS;
} while(FALSE);
if (ndis_status != NDIS_STATUS_SUCCESS &&
ndis_status != STATUS_PENDING) {
if (ndis_packet)
NdisFreePacket(ndis_packet);
if (ndis_buffer)
NdisFreeBuffer(ndis_buffer);
if (data)
ExFreePoolWithTag(data, 'tkpi');
}
return ndis_status;
}
BOOLEAN
ArcConvertToNdisPacket(
IN PARC_FILTER Filter,
IN PARC_PACKET Packet,
IN BOOLEAN ConvertWholePacket
)
/*++
Routine description:
This routine builds a corresponding NDIS_PACKET in TmpNdisPacket,
that corresponds to the arcnet packet. The flag ConvertWholePacket
is used to convert only part of the arcnet packet, or the whole
stream. If the flag is FALSE, then only the buffers that have
free space (starting with buffer LastBuffer on up) are converted.
NOTE: It assumes TmpNdisPacket is an initialized ndis_packet structure.
Arguments:
Filter - Filter to allocate from.
Packet - The packet to convert.
ConvertWholePacket - Convert the whole stream, or only part?
Return values:
TRUE - If successful, else FALSE
--*/
{
PNDIS_BUFFER NdisBuffer;
PARC_BUFFER_LIST Buffer;
NDIS_STATUS NdisStatus;
Buffer = Packet->FirstBuffer;
while (Buffer != NULL) {
NdisAllocateBuffer(
&NdisStatus,
&NdisBuffer,
Filter->ReceiveBufferPool,
Buffer->Buffer,
Buffer->Size - Buffer->BytesLeft
);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
return(FALSE);
}
NdisChainBufferAtBack(
&(Packet->TmpNdisPacket),
NdisBuffer
);
Buffer = Buffer->Next;
}
return(TRUE);
}
NDIS_STATUS NICAllocAdapter(
PMP_ADAPTER *pAdapter)
{
PMP_ADAPTER Adapter = NULL;
PNDIS_PACKET Packet;
PNDIS_BUFFER Buffer;
PUCHAR pTCBMem;
PTCB pTCB;
NDIS_STATUS Status;
LONG index;
DEBUGP(MP_TRACE, ("--> NICAllocAdapter\n"));
PAGED_CODE();
*pAdapter = NULL;
do
{
//
// Allocate memory for adapter context
//
Status = NdisAllocateMemoryWithTag(
&Adapter,
sizeof(MP_ADAPTER),
NIC_TAG);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("Failed to allocate memory for adapter context\n"));
break;
}
//
// Zero the memory block
//
NdisZeroMemory(Adapter, sizeof(MP_ADAPTER));
NdisInitializeListHead(&Adapter->List);
//
// Initialize Send & Recv listheads and corresponding
// spinlocks.
//
//NdisInitializeListHead(&Adapter->RecvWaitList);
//NdisInitializeListHead(&Adapter->SendWaitList);
//NdisInitializeListHead(&Adapter->SendFreeList);
NdisAllocateSpinLock(&Adapter->SendLock);
//NdisInitializeListHead(&Adapter->RecvFreeList);
NdisAllocateSpinLock(&Adapter->RecvLock);
//allocate a packet pool
NdisAllocatePacketPool(
&Status,
&Adapter->LdnRecvPacketPoolHandle,
1,
PROTOCOL_RESERVED_SIZE_IN_PACKET);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocatePacketPool failed\n"));
break;
}
//allocate a single packet in the pool
NdisAllocatePacket(
&Status,
&Adapter->LdnRecvPacket,
Adapter->LdnRecvPacketPoolHandle);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocatePacket failed\n"));
break;
}
//allocate a buffer pool
NdisAllocateBufferPool(
&Status,
&Adapter->LdnRecvBufferPoolHandle,
1);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocateBufferPool for recv buffer failed\n"));
break;
}
//allocate a single buffer in the buffer pool
NdisAllocateBuffer(
&Status,
&Adapter->LdnRecvPacketBuffer,
Adapter->LdnRecvBufferPoolHandle,
(PVOID)&Adapter->LdnRecvPacketBufferData[0],
NIC_BUFFER_SIZE);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocateBuffer failed\n"));
break;
}
//chain the buffer to the packet
NdisChainBufferAtBack(Adapter->LdnRecvPacket,
Adapter->LdnRecvPacketBuffer);
NDIS_SET_PACKET_STATUS(Adapter->LdnRecvPacket, NDIS_STATUS_RESOURCES);
NDIS_SET_PACKET_HEADER_SIZE(Adapter->LdnRecvPacket, ETH_HEADER_SIZE);
/*//
// Allocate lookside list for Receive Control blocks.
//
NdisInitializeNPagedLookasideList(
&Adapter->RecvLookaside,
NULL, // No Allocate function
NULL, // No Free function
0, // Reserved for system use
sizeof(RCB),
NIC_TAG,
0); // Reserved for system use
MP_SET_FLAG(Adapter, fMP_ADAPTER_RECV_LOOKASIDE);
//
// Allocate packet pool for receive indications
//
NdisAllocatePacketPool(
&Status,
&Adapter->RecvPacketPoolHandle,
NIC_MAX_BUSY_RECVS,
PROTOCOL_RESERVED_SIZE_IN_PACKET);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocatePacketPool failed\n"));
break;
}
//
// Initialize receive packets
//
for(index=0; index < NIC_MAX_BUSY_RECVS; index++)
{
//
// Allocate a packet descriptor for receive packets
// from a preallocated pool.
//
NdisAllocatePacket(
&Status,
&Packet,
Adapter->RecvPacketPoolHandle);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocatePacket failed\n"));
break;
}
NDIS_SET_PACKET_HEADER_SIZE(Packet, ETH_HEADER_SIZE);
//
// Insert it into the list of free receive packets.
//
NdisInterlockedInsertTailList(
&Adapter->RecvFreeList,
(PLIST_ENTRY)&Packet->MiniportReserved[0],
&Adapter->RecvLock);
}
//
// Allocate a huge block of memory for all TCB's
//
Status = NdisAllocateMemoryWithTag(
&pTCBMem,
sizeof(TCB) * NIC_MAX_BUSY_SENDS,
NIC_TAG);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("Failed to allocate memory for TCB's\n"));
break;
}
NdisZeroMemory(pTCBMem, sizeof(TCB) * NIC_MAX_BUSY_SENDS);
Adapter->TCBMem = pTCBMem;
//
// Allocate a buffer pool for send buffers.
//
NdisAllocateBufferPool(
&Status,
&Adapter->SendBufferPoolHandle,
NIC_MAX_BUSY_SENDS);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocateBufferPool for send buffer failed\n"));
break;
}
//
// Divide the TCBMem blob into TCBs and create a buffer
// descriptor for the Data portion of the TCBs.
//
for(index=0; index < NIC_MAX_BUSY_SENDS; index++)
{
pTCB = (PTCB) pTCBMem;
//
// Create a buffer descriptor for the Data portion of the TCBs.
// Buffer descriptors are nothing but MDLs on NT systems.
//
NdisAllocateBuffer(
&Status,
&Buffer,
Adapter->SendBufferPoolHandle,
(PVOID)&pTCB->Data[0],
NIC_BUFFER_SIZE);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocateBuffer failed\n"));
break;
}
//
// Initialize the TCB structure.
//
pTCB->Buffer = Buffer;
pTCB->pData = (PUCHAR) &pTCB->Data[0];
pTCB->Adapter = Adapter;
NdisInterlockedInsertTailList(
&Adapter->SendFreeList,
&pTCB->List,
&Adapter->SendLock);
pTCBMem = pTCBMem + sizeof(TCB);
}*/
} while(FALSE);
*pAdapter = Adapter;
//
// In the failure case, the caller of this routine will end up
// calling NICFreeAdapter to free all the successfully allocated
// resources.
//
DEBUGP(MP_TRACE, ("<-- NICAllocAdapter\n"));
return(Status);
}
void
CAR6KMini::ReceiveWMIDataPacket(
HTC_EVENT_INFO *evInfo)
//
// This function processes data from an HTC_BUFFER_RECEIVED indication
// not on the WMI_CONTROL_MBOX endpoint.
//
{
ndis_mini_buf_t *pb = (ndis_mini_buf_t *)evInfo->cookie;
NDIS_STATUS Status;
NDIS_PACKET *pPacket;
NDIS_BUFFER *pBuffer;
PBYTE pData;
ULONG cbData;
BOOL doDix = FALSE;
USHORT etherType;
SNAP_HEADER *pSnapHdr;
MAC_ADDRESS *pDestAddr,*tempAddr;
BOOL mcForUs = FALSE;
NDIS_DEBUG_PRINTF(ATH_LOG_TRC | ATH_LOG_RECV, "AR6K: +ReceiveWMIDataPacket");
if (evInfo->status != A_OK) {
NDIS_DEBUG_PRINTF(ATH_LOG_ERR, "AR6K: ERROR - ReceiveWMIPacket Error in receiving : status = %x\n", evInfo->status);
if (A_OK != HTCBufferReceive(m_pHTCTarget, ENDPOINT2, a_netbuf_to_data(pb), AR6000_BUFFER_SIZE, pb)) {
a_netbuf_free(pb);
}
goto done;
}
// evInfo->actualLength is the length of the pb->data including
// 2 bytes: WMI_DATA_HEADER [optional - only if HTC header is 46 00]
// 14 bytes: 802.3 MAC header
// 8 bytes: SNAP header (with EthType as last 2 bytes)
// N bytes: payload (e.g. IP packet)
pData = evInfo->buffer;
cbData = evInfo->actualLength;
// Remove the WMI_DATA_HDR.
if (cbData < sizeof(WMI_DATA_HDR))
{
NDIS_DEBUG_PRINTF(ATH_LOG_ERR, "AR6K: ERROR - ReceiveWMIPacket missing WMI header (%u bytes)\n", evInfo->actualLength);
if ( A_OK != HTCBufferReceive(m_pHTCTarget, ENDPOINT2, a_netbuf_to_data(pb), AR6000_BUFFER_SIZE, pb)) {
a_netbuf_free(pb);
}
goto done;
}
pData += sizeof(WMI_DATA_HDR);
cbData -= sizeof(WMI_DATA_HDR);
if (cbData < sizeof(ETHERNET_MAC_HEADER) + sizeof(SNAP_HEADER))
{
NDIS_DEBUG_PRINTF(ATH_LOG_ERR, "AR6K: ERROR - ReceiveWMIPacket missing MAC + SNAP (%u bytes)\n", cbData);
if ( A_OK != HTCBufferReceive(m_pHTCTarget, ENDPOINT2, a_netbuf_to_data(pb), AR6000_BUFFER_SIZE, pb)) {
a_netbuf_free(pb);
}
goto done;
}
#ifdef WMM
Lock();
wmi_implicit_create_pstream((wmi_t *)m_pWMI, pb, DNLINK_TRAFFIC,1);
Unlock();
#endif //WMM
pDestAddr=(MAC_ADDRESS *)pData;
/* Apply NDIS receive filter */
if (isGrp(pDestAddr)) {
if (isBcast(pDestAddr)) {
if (!(m_CurrentPacketFilter & NDIS_PACKET_TYPE_BROADCAST)) {
if ( A_OK != HTCBufferReceive(m_pHTCTarget, ENDPOINT2, a_netbuf_to_data(pb), AR6000_BUFFER_SIZE, pb)) {
a_netbuf_free(pb);
}
goto done;
}
} else {
isMcForUs(pDestAddr,&mcForUs);
if (!(m_CurrentPacketFilter & (NDIS_PACKET_TYPE_MULTICAST |
NDIS_PACKET_TYPE_ALL_MULTICAST)) || !(mcForUs))
{
if ( A_OK != HTCBufferReceive(m_pHTCTarget, ENDPOINT2, a_netbuf_to_data(pb), AR6000_BUFFER_SIZE, pb)) {
a_netbuf_free(pb);
}
goto done;
}
}
} else {
tempAddr=(MAC_ADDRESS *) m_PermanentAddress;
if ((A_MACADDR_COMP(pDestAddr,tempAddr) != 0) &&
!(m_CurrentPacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS))
{
if ( A_OK != HTCBufferReceive(m_pHTCTarget, ENDPOINT2, a_netbuf_to_data(pb), AR6000_BUFFER_SIZE, pb)) {
a_netbuf_free(pb);
}
goto done;
}
}
// Allocate an NDIS_PACKET from our packet pool.
NdisAllocatePacket(&Status, &pPacket, m_RxPacketPool);
if (NDIS_STATUS_SUCCESS != Status)
{
NDIS_DEBUG_PRINTF(ATH_LOG_ERR, "AR6K: ERROR - NdisAllocatePacket failed\n");
if ( A_OK != HTCBufferReceive(m_pHTCTarget, ENDPOINT2, a_netbuf_to_data(pb), AR6000_BUFFER_SIZE, pb)) {
a_netbuf_free(pb);
}
goto done;
}
// Check for ethernetType in SNAP header for NOVELL_IPX, APPLE_TALK_ARP etc
// remove 802.3 length and SNAP header if it is not of these types
pSnapHdr=(SNAP_HEADER *)(pData+sizeof(ETHERNET_MAC_HEADER));
etherType=A_BE2CPU16(pSnapHdr->Type);
doDix=((A_MEMCMP(pSnapHdr,&bridgeTunnel, sizeof(CAP_CONST))) == 0);
if((!doDix) && ((A_MEMCMP(pSnapHdr,&vrfc1042, sizeof(CAP_CONST))) == 0))
{
doDix = ((etherType != APPLE_TALK_ARP) && (etherType != NOVELL_IPX));
}
// Get rid of the 802.3 length and SNAP header by copying
// the 802.3 DestMACAddr and SrcMACAddr forward so they
// immediately precede the EthType at the end of the SNAP header.
// That gives us a DIX packet.
if (doDix) {
memmove(pData + sizeof(SNAP_HEADER), pData, ETHERNET_MAC_ADDRESS_LENGTH * 2);
pData += sizeof(SNAP_HEADER);
cbData -= sizeof(SNAP_HEADER);
}
// Setup the fields of NDIS_BUFFER to point to our data.
pBuffer = &pb->NdisBuffer;
NdisInitializeBuffer(pBuffer, pData, cbData);
// Chain the NDIS_BUFFER to the start of the NDIS_PACKET
NdisChainBufferAtBack(pPacket, pBuffer);
NDIS_SET_PACKET_HEADER_SIZE(pPacket, sizeof(ETHERNET_MAC_HEADER));
NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_SUCCESS);
#ifdef NDIS_BUS_DRIVER
NDIS_PACKET *PacketArray[1];
PacketArray[0]=pPacket;
NdisMIndicateReceivePacket(m_MiniportAdapterHandle, PacketArray, 1);
#else
// Perform the indicate on the timer thread because tying up the
// SDIO receive indication thread can result in a deadlock.
PLIST_ENTRY pEntry = (PLIST_ENTRY)(pPacket->MiniportReserved);
Lock();
InsertTailList(&m_RxPendingPacketList, pEntry);
NdisSetEvent(&m_RxPendingEvent);
Unlock();
#endif
done:
NDIS_DEBUG_PRINTF(ATH_LOG_TRC | ATH_LOG_RECV, "AR6K: -ReceiveWMIDataPacket");
}
NDIS_STATUS
NdisuioReceive(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID pHeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID pLookaheadBuffer,
IN UINT LookaheadBufferSize,
IN UINT PacketSize
)
/*++
Routine Description:
Our protocol receive handler called by NDIS, typically if we have
a miniport below that doesn't indicate packets.
We make a local packet/buffer copy of this data, queue it up, and
kick off the read service routine.
Arguments:
ProtocolBindingContext - pointer to open context
MacReceiveContext - for use in NdisTransferData
pHeaderBuffer - pointer to data header
HeaderBufferSize - size of the above
pLookaheadBuffer - pointer to buffer containing lookahead data
LookaheadBufferSize - size of the above
PacketSize - size of the entire packet, minus header size.
Return Value:
NDIS_STATUS_NOT_ACCEPTED - if this packet is uninteresting
NDIS_STATUS_SUCCESS - if we processed this successfully
--*/
{
PNDISUIO_OPEN_CONTEXT pOpenContext;
NDIS_STATUS Status;
PNDISUIO_ETH_HEADER pEthHeader;
PNDIS_PACKET pRcvPacket;
PUCHAR pRcvData;
UINT BytesTransferred;
PNDIS_BUFFER pOriginalNdisBuffer, pPartialNdisBuffer;
PIRP pIrp;
PLIST_ENTRY pIrpEntry;
ULONG BytesRemaining; // at pDst
PPACKET_GROUP pGroup;
//ULONG pDst;
pOpenContext = (PNDISUIO_OPEN_CONTEXT)ProtocolBindingContext;
NUIO_STRUCT_ASSERT(pOpenContext, oc);
pRcvPacket = NULL;
pRcvData = NULL;
Status = NDIS_STATUS_SUCCESS;
DEBUGP(DL_LOUD, ("Receive: Open %p, LookaheadBufferSize %d, PacketSize %d\n",
pOpenContext, LookaheadBufferSize, PacketSize));
NdisInterlockedAddLargeStatistic((PLARGE_INTEGER)&pOpenContext->ReceivedPackets, 1);
do
{
if (HeaderBufferSize != sizeof(NDISUIO_ETH_HEADER))
{
Status = NDIS_STATUS_NOT_ACCEPTED;
break;
}
pEthHeader = (PNDISUIO_ETH_HEADER)pHeaderBuffer;
NUIO_ACQUIRE_LOCK(&pOpenContext->Lock);
//
// Someone is reading, and this is the first packet.
//
if (!NUIO_IS_LIST_EMPTY(&pOpenContext->PendedReads) &&
NUIO_IS_LIST_EMPTY(&pOpenContext->RecvPktQueue))
{
//
// Get the first pended Read IRP
//
pIrpEntry = pOpenContext->PendedReads.Flink;
pIrp = CONTAINING_RECORD(pIrpEntry, IRP, Tail.Overlay.ListEntry);
//
// We don't have to worry about the situation where the IRP is cancelled
// after we remove it from the queue and before we reset the cancel
// routine because the cancel routine has been coded to cancel an IRP
// only if it's in the queue.
//
IoSetCancelRoutine(pIrp, NULL);
NUIO_REMOVE_ENTRY_LIST(pIrpEntry);
pOpenContext->PendedReadCount--;
NUIO_RELEASE_LOCK(&pOpenContext->Lock);
NUIO_DEREF_OPEN(pOpenContext); // Service: dequeue rcv packet
//
// Copy as much data as possible from the receive packet to
// the IRP MDL.
//
#ifndef WIN9X
pGroup = MmGetSystemAddressForMdlSafe(pIrp->MdlAddress, NormalPagePriority);
//NUIO_ASSERT(pDst != NULL); // since it was already mapped
#else
pGroup = MmGetSystemAddressForMdl(pIrp->MdlAddress); // Win9x
#endif
BytesRemaining = MmGetMdlByteCount(pIrp->MdlAddress);
BytesRemaining -= sizeof(PACKET_GROUP);
//
// copy the ethernet header into the actual readbuffer
//
NdisMoveMappedMemory(pGroup->Data, pHeaderBuffer, HeaderBufferSize);
if (PacketSize == LookaheadBufferSize)
{
BytesTransferred = MIN(LookaheadBufferSize, BytesRemaining);
NdisCopyLookaheadData(pGroup->Data + HeaderBufferSize,
pLookaheadBuffer,
BytesTransferred,
pOpenContext->MacOptions);
pGroup->Length = BytesTransferred + HeaderBufferSize;
pIrp->IoStatus.Information = pGroup->Length + sizeof(PACKET_GROUP);
pIrp->IoStatus.Status = STATUS_SUCCESS;
DEBUGP(DL_LOUD, ("Receive: %d bytes\n", pIrp->IoStatus.Information));
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
else
{
BytesTransferred = 0;
NdisAllocatePacket(
&Status,
&pRcvPacket,
pOpenContext->RecvBufferPool
);
if (Status != NDIS_STATUS_SUCCESS)
goto ERROR;
//
// Allocate an MDL to map the portion of the buffer following the
// header
//
pPartialNdisBuffer = IoAllocateMdl(pGroup->Data, BytesRemaining, FALSE, FALSE, NULL);
if (pPartialNdisBuffer == NULL)
{
NdisFreePacket(pRcvPacket);
Status = NDIS_STATUS_RESOURCES;
goto ERROR;
}
//
// Build the mdl to point to the the portion of the buffer following
// the header
//
IoBuildPartialMdl(
pIrp->MdlAddress,
pPartialNdisBuffer,
pGroup->Data + HeaderBufferSize,
0);
//
// Clear the next link in the new MDL
//
pPartialNdisBuffer->Next = NULL;
//
// Get a pointer to the packet itself.
//
NUIO_IRP_FROM_RCV_PKT(pRcvPacket) = pIrp;
NUIO_RCV_PKT_TO_ORIGINAL_BUFFER(pRcvPacket) = pPartialNdisBuffer;
//
// Attach our partial MDL to the packet
//
NdisChainBufferAtFront(pRcvPacket, pPartialNdisBuffer);
//
// Call the Mac to transfer the packet
//
NdisTransferData(
&Status,
pOpenContext->BindingHandle,
MacReceiveContext,
0, // ByteOffset
PacketSize,
pRcvPacket,
&BytesTransferred);
ERROR:
//
// If it didn't pend, call the completeion routine now
//
if (Status != NDIS_STATUS_PENDING)
{
NdisuioTransferDataComplete(
(NDIS_HANDLE)pOpenContext,
pRcvPacket,
Status,
BytesTransferred);
}
}
break;
}
NUIO_RELEASE_LOCK(&pOpenContext->Lock);
//
// Allocate resources for queueing this up.
//
pRcvPacket = ndisuioAllocateReceivePacket(
pOpenContext,
PacketSize + HeaderBufferSize,
&pRcvData
);
if (pRcvPacket == NULL)
{
Status = NDIS_STATUS_NOT_ACCEPTED;
break;
}
NdisMoveMappedMemory(pRcvData, pHeaderBuffer, HeaderBufferSize);
//
// Check if the entire packet is within the lookahead.
//
if (PacketSize == LookaheadBufferSize)
{
NdisCopyLookaheadData(pRcvData + HeaderBufferSize,
pLookaheadBuffer,
LookaheadBufferSize,
pOpenContext->MacOptions);
//
// Queue this up for receive processing, and
// try to complete some read IRPs.
//
ndisuioQueueReceivePacket(pOpenContext, pRcvPacket);
}
else
{
//
// Allocate an NDIS buffer to map the receive area
// at an offset "HeaderBufferSize" from the current
// start. This is so that NdisTransferData can copy
// in at the right point in the destination buffer.
//
NdisAllocateBuffer(
&Status,
&pPartialNdisBuffer,
pOpenContext->RecvBufferPool,
pRcvData + HeaderBufferSize,
PacketSize);
if (Status == NDIS_STATUS_SUCCESS)
{
//
// Unlink and save away the original NDIS Buffer
// that maps the full receive buffer.
//
NdisUnchainBufferAtFront(pRcvPacket, &pOriginalNdisBuffer);
NUIO_RCV_PKT_TO_ORIGINAL_BUFFER(pRcvPacket) = pOriginalNdisBuffer;
NUIO_IRP_FROM_RCV_PKT(pRcvPacket) = NULL;
//
// Link in the partial buffer for NdisTransferData to
// operate on.
//
NdisChainBufferAtBack(pRcvPacket, pPartialNdisBuffer);
DEBUGP(DL_LOUD, ("Receive: setting up for TransferData:"
" Pkt %p, OriginalBuf %p, PartialBuf %p\n",
pRcvPacket, pOriginalNdisBuffer, pPartialNdisBuffer));
NdisTransferData(
&Status,
pOpenContext->BindingHandle,
MacReceiveContext,
0, // ByteOffset
PacketSize,
pRcvPacket,
&BytesTransferred);
}
else
{
//
// Failure handled below in TransferDataComplete.
//
BytesTransferred = 0;
}
if (Status != NDIS_STATUS_PENDING)
{
NdisuioTransferDataComplete(
(NDIS_HANDLE)pOpenContext,
pRcvPacket,
Status,
BytesTransferred);
}
}
} while (FALSE);
if (Status != NDIS_STATUS_SUCCESS && Status != NDIS_STATUS_PENDING)
NdisInterlockedAddLargeStatistic((PLARGE_INTEGER)&pOpenContext->DroppedPackets, 1);
return Status;
}
VOID
NdisuioTransferDataComplete(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET pNdisPacket,
IN NDIS_STATUS TransferStatus,
IN UINT BytesTransferred
)
/*++
Routine Description:
NDIS entry point called to signal completion of a call to
NdisTransferData that had pended.
Arguments:
ProtocolBindingContext - pointer to open context
pNdisPacket - our receive packet into which data is transferred
TransferStatus - status of the transfer
BytesTransferred - bytes copied into the packet.
Return Value:
None
--*/
{
PNDISUIO_OPEN_CONTEXT pOpenContext;
PNDIS_BUFFER pOriginalBuffer, pPartialBuffer;
PIRP pIrp;
PPACKET_GROUP pGroup;
//ULONG pDst;
pOpenContext = (PNDISUIO_OPEN_CONTEXT)ProtocolBindingContext;
NUIO_STRUCT_ASSERT(pOpenContext, oc);
pIrp = NUIO_IRP_FROM_RCV_PKT(pNdisPacket);
if (pIrp)
{
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(pIrp);
pOriginalBuffer = NUIO_RCV_PKT_TO_ORIGINAL_BUFFER(pNdisPacket);
//
// Free the partial MDL that we allocated
//
if (pOriginalBuffer)
IoFreeMdl(pOriginalBuffer);
//
// Put the packet on the free queue
//
NdisFreePacket(pNdisPacket);
#ifndef WIN9X
pGroup = MmGetSystemAddressForMdlSafe(pIrp->MdlAddress, NormalPagePriority);
//NUIO_ASSERT(pDst != NULL); // since it was already mapped
#else
pGroup = MmGetSystemAddressForMdl(pIrp->MdlAddress); // Win9x
#endif
pGroup->Length = BytesTransferred + sizeof(NDISUIO_ETH_HEADER);
if (TransferStatus == NDIS_STATUS_SUCCESS)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = pGroup->Length + sizeof(PACKET_GROUP);
}
else
{
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
pIrp->IoStatus.Information = 0;
}
DEBUGP(DL_LOUD, ("TransferComp: Pkt %p, OrigBuf %p, BytesTransferred %d\n",
pNdisPacket, pOriginalBuffer, BytesTransferred));
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
else
{
//
// Check if an NDIS_BUFFER was created to map part of the receive buffer;
// if so, free it and link back the original NDIS_BUFFER that maps
// the full receive buffer to the packet.
//
pOriginalBuffer = NUIO_RCV_PKT_TO_ORIGINAL_BUFFER(pNdisPacket);
if (pOriginalBuffer != NULL)
{
//
// We had stashed off the NDIS_BUFFER for the full receive
// buffer in the packet reserved area. Unlink the partial
// buffer and link in the full buffer.
//
NdisUnchainBufferAtFront(pNdisPacket, &pPartialBuffer);
NdisChainBufferAtBack(pNdisPacket, pOriginalBuffer);
DEBUGP(DL_LOUD, ("TransferComp: Pkt %p, OrigBuf %p, PartialBuf %p\n",
pNdisPacket, pOriginalBuffer, pPartialBuffer));
//
// Free up the partial buffer.
//
NdisFreeBuffer(pPartialBuffer);
}
}
if (TransferStatus == NDIS_STATUS_SUCCESS)
{
//
// Queue this up for receive processing, and
// try to complete some read IRPs.
//
ndisuioQueueReceivePacket(pOpenContext, pNdisPacket);
}
else
{
ndisuioFreeReceivePacket(pOpenContext, pNdisPacket);
NdisInterlockedAddLargeStatistic((PLARGE_INTEGER)&pOpenContext->DroppedPackets, 1);
}
}
VOID
NICIndicateReceivedPacket(
IN PRCB pRCB,
IN ULONG dataoffset,
IN ULONG BytesToIndicate,
IN ULONG PacketNum
)
/*++
Routine Description:
Initialize the packet to describe the received data and
indicate to NDIS.
Arguments:
pRCB - pointer to the RCB block
BytesToIndicate - number of bytes to indicate
Return value:
VOID
--*/
{
ULONG PacketLength;
PNDIS_BUFFER CurrentBuffer = NULL;
PETH_HEADER pEthHeader = NULL;
PMP_ADAPTER Adapter = pRCB->Adapter;
KIRQL oldIrql;
PVOID VirtualAddress=NULL;
ASSERT( PacketNum < RCB_BUFFERARRAY_SIZE);
ASSERT((dataoffset+BytesToIndicate) < pRCB->ulBufferSize);
//NdisAdjustBufferLength(pRCB->Buffer, BytesToIndicate);
//MmInitializeMdl(pRCB->BufferArray[PacketNum],pRCB->pDataForNTB+dataoffset,BytesToIndicate);
VirtualAddress=MmGetMdlVirtualAddress(pRCB->BufferArray[PacketNum]);
ASSERT(VirtualAddress!=NULL);
NdisMoveMemory(VirtualAddress,pRCB->pDataForNTB+dataoffset,BytesToIndicate);
NdisAdjustBufferLength(pRCB->BufferArray[PacketNum], BytesToIndicate);
//NdisMoveMemory(pRCB->pDataForNet+NIC_BUFFER_SIZE*PacketNum,pRCB->pDataForNTB+dataoffset,BytesToIndicate);
//
// Prepare the recv packet
//
NdisReinitializePacket(pRCB->PacketArray[PacketNum]);
*((PRCB *)pRCB->PacketArray[PacketNum]->MiniportReserved) = pRCB;
//
// Chain the TCB buffers to the packet
//
NdisChainBufferAtBack(pRCB->PacketArray[PacketNum], pRCB->BufferArray[PacketNum]);
NdisQueryPacket(pRCB->PacketArray[PacketNum], NULL, NULL, &CurrentBuffer, (PUINT) &PacketLength);
ASSERT(CurrentBuffer == pRCB->BufferArray[PacketNum]);
pEthHeader = (PETH_HEADER)(pRCB->pDataForNTB+dataoffset);
if(PacketLength >= sizeof(ETH_HEADER) &&
Adapter->PacketFilter &&
NICIsPacketAcceptable(Adapter, pEthHeader->DstAddr)){
DEBUGP(MP_LOUD, ("Src Address = %02x-%02x-%02x-%02x-%02x-%02x",
pEthHeader->SrcAddr[0],
pEthHeader->SrcAddr[1],
pEthHeader->SrcAddr[2],
pEthHeader->SrcAddr[3],
pEthHeader->SrcAddr[4],
pEthHeader->SrcAddr[5]));
DEBUGP(MP_LOUD, (" Dest Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
pEthHeader->DstAddr[0],
pEthHeader->DstAddr[1],
pEthHeader->DstAddr[2],
pEthHeader->DstAddr[3],
pEthHeader->DstAddr[4],
pEthHeader->DstAddr[5]));
DEBUGP(MP_LOUD, ("Indicating packet = %p, Packet Length = %d\n",
pRCB->PacketArray[PacketNum], PacketLength));
NdisInterlockedIncrement(&pRCB->Ref);
NDIS_SET_PACKET_STATUS(pRCB->PacketArray[PacketNum], NDIS_STATUS_SUCCESS);
Adapter->nPacketsIndicated++;
//
// NDIS expects the indication to happen at DISPATCH_LEVEL if the
// device is assinged any I/O resources in the IRP_MN_START_DEVICE_IRP.
// Since this sample is flexible enough to be used as a standalone
// virtual miniport talking to another device or part of a WDM stack for
// devices consuming hw resources such as ISA, PCI, PCMCIA. I have to
// do the following check. You should avoid raising the IRQL, if you
// know for sure that your device wouldn't have any I/O resources. This
// would be the case if your driver is talking to USB, 1394, etc.
//
if(Adapter->IsHardwareDevice){
KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
NdisMIndicateReceivePacket(Adapter->AdapterHandle,
&pRCB->PacketArray[PacketNum],
1);
KeLowerIrql(oldIrql);
}else{
NdisMIndicateReceivePacket(Adapter->AdapterHandle,
&pRCB->PacketArray[PacketNum],
1);
}
}else {
DEBUGP(MP_VERY_LOUD,
("Invalid packet or filter is not set packet = %p,Packet Length = %d\n",
pRCB->PacketArray, PacketLength));
}
}
