Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
NT4/private/ntos/ndis/ieepro/sndrcv.c
Microsoft ce47f986d8 First commit
2020-09-30 17:12:29 +02:00

1179 lines
34 KiB
C
Raw Permalink Blame History

#include <ndis.h>
#include "82595.h"
#include "eprohw.h"
#include "eprosw.h"
#include "epro.h"
#include "eprodbg.h"
//////////////////////////////////////////////////////////////////////
// SEND code
//////////////////////////////////////////////////////////////////////
ULONG numberOfResources = 0;
NDIS_STATUS EProSend(IN NDIS_HANDLE miniportAdapterContext,
IN PNDIS_PACKET packet,
IN UINT flags)
/*++
Routine Description:
The MiniportSend handler for the EPro. About 18 million different
things happen here:
1) We need to see if there are free transmit buffer pointer for
this packet.
2) Once we've got a tx buffer pointer, we then see if we have enough
physical memory space for this transmit. If we don't, then
we resources out
3) We need to copy the 82595 frame header, then the packet to the card
4) We need to start the transmit if none are in progress
5) We need to update some structures to keep track of the transmit
Arguments:
miniportAdapterContext - Really a pointer to our EPRO_ADAPTER structure
packet - the packet to send
flags - an optional FLAGS field - not used currently in NDIS
Return Value:
NDIS_STATUS_RESOURCES - no free transmit buffers. Please hang up and then
dial again. If you need help, please dial your operator
NDIS_STATUS_PENDING - The packet is on the card and is being sent.
--*/
{
PEPRO_ADAPTER adapter = (EPRO_ADAPTER *)miniportAdapterContext;
// This is the adapter's current transmit buffer...
PEPRO_TRANSMIT_BUFFER curTBuf = adapter->CurrentTXBuf;
USHORT freeSpace;
UINT totalPacketLength;
USHORT result;
// If we're currently executing an MC_SETUP command, we can't
// handle any transmits. The reason is that the MC_SETUP uses
// a transmit buffer, and we will have problems trying to complete
// transfers if we do both at the same time. There are a few ways
// we could get around this, but they'd make things more complicated,
// and don't gain us much if we go by the assumption that in "normal"
// use we won't get that many MC-setups...
if (adapter->IntPending == EPRO_INT_MC_SET_PENDING) {
return(NDIS_STATUS_RESOURCES);
}
// Check for free buffer. If can't find one, then return
// NDIS_STATUS_RESOURCES.
// is the current buffer free?
if (!curTBuf->fEmpty) {
// nope. can we free it?
if (!EProCheckTransmitCompletion(adapter, curTBuf)) {
numberOfResources++;
return(NDIS_STATUS_RESOURCES);
}
}
// Get the total length of this packet so we can see if we have
// room for it.
NdisQueryPacket(packet, NULL, NULL, NULL, &totalPacketLength);
curTBuf->TXSize = totalPacketLength;
// Add in the 82595's tx memory structure plus 2 bytes padding
// between frames
totalPacketLength+=(I82595_TX_FRM_HDR_SIZE + 2);
// is there a transmit in progress?
if (adapter->TXChainStart == NULL) {
curTBuf->TXBaseAddr = EPRO_TX_LOWER_LIMIT_SHORT;
curTBuf->NextBuf->TXBaseAddr = totalPacketLength;
} else {
// Do we have free space for this packet?
EPRO_ASSERT(adapter->TXChainStart != curTBuf);
EPRO_ASSERT(curTBuf->TXBaseAddr >= EPRO_TX_LOWER_LIMIT_SHORT);
// Although TxBaseAddr == upper limit is NOT LEGAL, we allow it in
// this assert because it will fall through the next if statement
// and be dealt with properly. (freespace will = 0 and then we will wrap)
EPRO_ASSERT(curTBuf->TXBaseAddr <= EPRO_TX_UPPER_LIMIT_SHORT);
// Now we need to know if the current buffer position is above or
// below the space in use.
if (adapter->TXChainStart->TXBaseAddr >= curTBuf->TXBaseAddr) {
// We're BELOW the in-use space
freeSpace = adapter->TXChainStart->TXBaseAddr -
curTBuf->TXBaseAddr;
} else {
freeSpace = EPRO_TX_UPPER_LIMIT_SHORT -
curTBuf->TXBaseAddr;
freeSpace += (adapter->TXChainStart->TXBaseAddr -
EPRO_TX_LOWER_LIMIT_SHORT);
}
if (freeSpace < totalPacketLength) {
return(NDIS_STATUS_RESOURCES);
}
}
// Now, the set the next buffer's address:
curTBuf->NextBuf->TXBaseAddr = curTBuf->TXBaseAddr +
totalPacketLength;
if (curTBuf->NextBuf->TXBaseAddr >= EPRO_TX_UPPER_LIMIT_SHORT)
curTBuf->NextBuf->TXBaseAddr -= EPRO_TX_UPPER_LIMIT_SHORT;
// Okay, when we've gotten to this point, it's because we've determined
// that there is enough space on the card for the packet. So, now we
// set the current transmit buffer to be empty.
curTBuf->fEmpty = FALSE;
// move the current buffer pointer forward
adapter->CurrentTXBuf = curTBuf->NextBuf;
// bank 0
EPRO_ASSERT_BANK_0(adapter);
// set our packet pointer so we can ethindicatereceive later.
curTBuf->TXPacket = packet;
// This is a double-check that the txbuffer structure was freed
// correctly -- this is set in checktransmitcompletion
EPRO_ASSERT(curTBuf->TXSendAddr == 0xffff);
// We make a backup copy of the TXBaseAddr, in case we use up all
// of our buffer pointer strucutres and wrap around and overwrite the
// TXBaseAddr of this buffer....
curTBuf->TXSendAddr = curTBuf->TXBaseAddr;
// Set the address on the card to copy to
EPRO_SET_HOST_ADDR(adapter, curTBuf->TXBaseAddr);
EProCopyPacketToCard(adapter, packet);
// Is there a transmit already going?
if (!adapter->TXChainStart) {
// Nope - queue this one up and let it rip..
{
UINT i;
UCHAR result;
for (i=0;i<I82595_SPIN_TIMEOUT;i++) {
EPRO_RD_PORT_UCHAR(adapter, I82595_STATUS_REG, &result);
if (!(result &I82595_EXEC_STATE)) {
if (result & I82595_EXEC_INT_RCVD) {
EPRO_WR_PORT_UCHAR(adapter, I82595_STATUS_REG,
I82595_EXEC_INT_RCVD);
}
break;
}
}
}
// Set up and start the transmit
EPRO_WR_PORT_USHORT(adapter, I82595_TX_BAR_REG, curTBuf->TXBaseAddr);
EPRO_WR_PORT_UCHAR(adapter, I82595_CMD_REG, I82595_XMT);
adapter->TXChainStart = curTBuf;
} else {
// If chainstart != NULL (ie is pointing to a buffer) and there is no tx
// in progress - we're hosed....
// if (curTBuf->LastBuf->TXSendAddr + 4 >= EPRO_TX_UPPER_LIMIT_SHORT) {
// EPRO_SET_HOST_ADDR(adapter, ((curTBuf->LastBuf->TXSendAddr + 4) -
// EPRO_TX_UPPER_LIMIT_SHORT));
// } else {
// EPRO_SET_HOST_ADDR(adapter, (curTBuf->LastBuf->TXSendAddr + 4));
// }
// EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG,
// curTBuf->TXSendAddr);
// EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG,
// curTBuf->LastBuf->TXSize | 8000);
//
// EPRO_RD_PORT_USHORT(adapter, I82595_MEM_IO_REG, &result);
//
// EPRO_WR_PORT_UCHAR(adapter, I82595_CMD_REG, I82595_XMT_RESUME);
}
// okay, we're PENDING...
return(NDIS_STATUS_PENDING);
}
VOID EProCopyPacketToCard(PEPRO_ADAPTER adapter,
PNDIS_PACKET packet)
/*++
Routine Description:
This routine copies a packet down to the card. We assume the card's IO port
has been set to the correct address at function entry.
Parameters:
adapter - Pointer to our EPRO_ADAPTER structure
packet - pointer to the NDIS_PACKET we are copying down.
Return Values:
none
--*/
{
// frame header....
EPRO_TX_FRAME_HEADER txFrameHeader;
// This is a hack to transfer buffers of odd lengths
BOOLEAN fForward = FALSE;
// this is the
USHORT forwardedShort;
// The physical address of the buffer to copy out of...
PVOID bufferAddr;
// packet information
UINT bufferCount, totalPacketLength, bufferLen, currentOffset;
// This is the current buffer of the packet that is passed in...
PNDIS_BUFFER curBuffer;
// Get the first buffer out of the packet.
NdisQueryPacket(packet, NULL, &bufferCount,
&curBuffer, &totalPacketLength);
// Copy the TX header down to the card.
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG, I82595_XMT_SHORT);
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG, 0);
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG, 0);
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG, totalPacketLength);
/////////////////////////////////////////////////////
// LOOP on all the buffers in the packet...
/////////////////////////////////////////////////////
do {
NdisQueryBuffer(curBuffer, &bufferAddr, &bufferLen);
// skip over zero-length buffers.
if (bufferLen == 0) {
NdisGetNextBuffer(curBuffer, &curBuffer);
continue;
}
// BEGIN fix for odd-length buffers
if (fForward) {
fForward = FALSE;
forwardedShort |= ((*((UCHAR *)bufferAddr)) << 8);
((UCHAR *)bufferAddr)++;
bufferLen--;
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG, forwardedShort);
}
if (bufferLen & 1) {
fForward = TRUE;
forwardedShort =*(UCHAR *)( ((UCHAR *)bufferAddr) + (bufferLen-1) );
}
// END fix for odd-length buffers...
#ifndef EPRO_USE_32_BIT_IO
EPRO_COPY_BUFFER_TO_NIC_USHORT(adapter,
((UNALIGNED USHORT *)bufferAddr),
((ULONG)bufferLen>>1));
#else
// using 32-bit
if (adapter->EProUse32BitIO) {
if (bufferLen & 2) {
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG,
*((UNALIGNED USHORT *)bufferAddr));
(UCHAR *)bufferAddr += 2;
EPRO_COPY_BUFFER_TO_NIC_ULONG(adapter, ((UNALIGNED ULONG *)bufferAddr),
((ULONG)bufferLen >> 2));
} else {
EPRO_COPY_BUFFER_TO_NIC_ULONG(adapter, ((UNALIGNED ULONG *)bufferAddr),
((ULONG)bufferLen >> 2));
}
} else {
// This is an older version of the 82595 - we need to use 16-bit anyway
EPRO_COPY_BUFFER_TO_NIC_USHORT(adapter,
(USHORT *)bufferAddr,
((ULONG)bufferLen>>1));
}
#endif
NdisGetNextBuffer(curBuffer, &curBuffer);
} while (curBuffer);
////////////////////////////////////////////////////////
// END of loop for all buffers in packet
////////////////////////////////////////////////////////
// copy down a trailing byte
if (fForward) {
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG, forwardedShort);
}
}
BOOLEAN EProCheckTransmitCompletion(PEPRO_ADAPTER adapter,
PEPRO_TRANSMIT_BUFFER txBuf)
/*++
Routine Description:
This routine takes the transmit buffer pointed to by txBuf and tries to
free it. This can be called from two places. On an adapter that is very
very busy transmitting, it can get called from our send handler if the send
handler is called and all the transmit buffers on the card are full. This
routine is called directly from the send handler to minimize the latency of
the returning NDIS_STATUS_RESOURCES----free buffer in interrupt handler dpc---
---ndis calls back down in it's send handler. There is the possibility here
that packets will be sent out of order in this, but it doesn't matter, let the
protocols figure that out.
This routine is also called by our handleinterrupt handler where it does the
exact same thing, except in response to a transmit interrupt.
Arguments:
adapter - a pointer to our EPRO_ADAPTER structure
txBuf - this is a pointer to the transmit buffer we are checking
Return Value:
TRUE if the buffer is already free or has been indicated and now is free.
FALSE if the buffer is not finished being transmitted.
--*/
{
UCHAR result;
USHORT status;
// NDIS_STATUS returnStatus = NDIS_STATUS_FAILURE;
if (!txBuf) {
return(FALSE);
}
if (txBuf->fEmpty) {
return(TRUE);
}
// if we got through the first if, then there must be a non-empty
// buffer. Therefore, we have to assume that there is a transmit in
// progress (txchainstart is set to the tx in progress) - if there
// is not one in progress, then something is screwed.
EPRO_ASSERT(adapter->TXChainStart != NULL);
// bank0
EPRO_ASSERT_BANK_0(adapter);
// Check and see if this transmit has completed...
EPRO_SET_HOST_ADDR(adapter, txBuf->TXSendAddr);
// check DN (tx done) flag...
EPRO_RD_PORT_USHORT(adapter, I82595_MEM_IO_REG, &status);
// See if the TX_DONE bit is set...
if (!(status & I82595_TX_DN_BYTE_MASK)) {
return(FALSE);
}
// Check the status of the transmition
EPRO_RD_PORT_USHORT(adapter, I82595_MEM_IO_REG, &status);
if (status & I82595_TX_OK_SHORT_MASK) {
// returnStatus = NDIS_STATUS_SUCCESS;
adapter->FramesXmitOK++;
if ((status & I82595_NO_COLLISIONS_MASK) > 0) {
adapter->FramesXmitOneCollision++;
if ((status & I82595_NO_COLLISIONS_MASK) > 1) {
adapter->FramesXmitManyCollisions++;
}
}
} else {
adapter->FramesXmitErr++;
// D---it, the frame errored out...
// Just re-send it.
EPRO_SET_HOST_ADDR(adapter, adapter->TXChainStart->TXSendAddr);
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG, I82595_XMT);
EPRO_WR_PORT_USHORT(adapter, I82595_MEM_IO_REG, 0);
if (!EProWaitForExeDma(adapter)) {
adapter->fHung = TRUE;
// EPRO_ASSERT(FALSE);
}
EPRO_WR_PORT_USHORT(adapter, I82595_TX_BAR_REG,
adapter->TXChainStart->TXSendAddr);
EPRO_WR_PORT_UCHAR(adapter, I82595_CMD_REG, I82595_XMT);
return(FALSE);
}
// move the chain forward b/c this buffer has been freed....
#if DBG
adapter->TXChainStart->TXSendAddr = 0xffff;
#endif
adapter->TXChainStart = adapter->TXChainStart->NextBuf;
if (adapter->TXChainStart == adapter->CurrentTXBuf) {
// since we just moved the chain FORWARD one, if these
// two pointers are equal it means the buffer is EMPTY, not full...
adapter->TXChainStart = NULL;
} else {
// Make sure the card is idle
// EProWaitForExeDma(adapter);
{
UINT i;
for (i=0;i<I82595_SPIN_TIMEOUT;i++) {
EPRO_RD_PORT_UCHAR(adapter, I82595_STATUS_REG, &result);
if (!(result &I82595_EXEC_STATE)) {
if (result & I82595_EXEC_INT_RCVD) {
EPRO_WR_PORT_UCHAR(adapter, I82595_STATUS_REG,
I82595_EXEC_INT_RCVD);
}
break;
}
}
}
// Get the next TX going....
EPRO_WR_PORT_USHORT(adapter, I82595_TX_BAR_REG,
adapter->TXChainStart->TXSendAddr);
EPRO_WR_PORT_UCHAR(adapter, I82595_CMD_REG, I82595_XMT);
}
// this buffer is empty now.
txBuf->fEmpty = TRUE;
// Yes, here's the deep and dark secret: either we succeed a packet,
// or we re-send it, so whenever packets complete, they ALWAYS
// succeed :)
NdisMSendComplete(adapter->MiniportAdapterHandle,
txBuf->TXPacket, NDIS_STATUS_SUCCESS);
return(TRUE);
}
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// RECEIVE code...
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
UINT EProHandleReceive(PEPRO_ADAPTER adapter)
/*++
Routine Description:
This is the dpc-level code that really handles a receive interrupt.
Arguments:
adapter - pointer to the adapter structure.
Return Value:
the number of packets received
--*/
{
// The 82595s RCV header
EPRO_RCV_HEADER header;
// the Ethernet header to indicate up
EPRO_ETH_HEADER ethHeader;
// temp variable to figure out how much to copy up
USHORT bytesToCopy;
// Our context to pass in NdisMEthIndicateReceive...
EPRO_RCV_CONTEXT context;
// Use this to loop and handle multiple receives in one int...
//
UCHAR tempCopy;
UINT numRcvd = 0;
// bank0
// EPRO_SWITCH_BANK_0(adapter);
//
EPRO_ASSERT_BANK_0(adapter);
if ((adapter->RXCurrentAddress < EPRO_RX_LOWER_LIMIT_SHORT) ||
(adapter->RXCurrentAddress > EPRO_RX_UPPER_LIMIT_SHORT))
{
adapter->fHung = TRUE;
#if DBG
DbgPrint("the RxCurrentAddress is not within acceptable limits: 0x%x\n", adapter->RXCurrentAddress);
// EPRO_ASSERT(FALSE);
#endif
return(0);
}
// Read the header...
EPRO_SET_HOST_ADDR(adapter, adapter->RXCurrentAddress);
EPRO_READ_BUFFER_FROM_NIC_USHORT(
adapter,
(USHORT *)&header,
((ULONG)sizeof(EPRO_RCV_HEADER) >> 1));
// Process one or more received frames...
while ((header.Event == I82595_RX_EOF) && !adapter->fHung)
{
// Was the transmit OK?
if (!header.Status1 & I82595_RX_OK)
{
adapter->FramesRcvErr++;
// Since we configure the 82595 to discard bad frames, we know we've reached the
// latest received frame when we hit a bad one -- since the card will "reclaim"
// the space filled by the bad frame as soon as it gets another one.
break;
}
else
{
numRcvd++;
// Fill in our receive context - to be passed in to TransferData
context.RXFrameSize = (USHORT)((USHORT)header.ByteCountLo) | (((USHORT)header.ByteCountHi) << 8);
// Figure out how many bytes to indicate up. Either the size of the current lookahead
// or the entire frame - whichever is smaller.
bytesToCopy = ((context.RXFrameSize-sizeof(EPRO_ETH_HEADER)) > adapter->RXLookAheadSize) ?
adapter->RXLookAheadSize :
(context.RXFrameSize - sizeof(EPRO_ETH_HEADER));
EPRO_READ_BUFFER_FROM_NIC_USHORT(
adapter,
(USHORT *)(&ethHeader),
sizeof(EPRO_ETH_HEADER) >> 1);
#ifndef EPRO_USE_32_BIT_IO
EPRO_READ_BUFFER_FROM_NIC_USHORT(adapter, &adapter->RXLookAhead, bytesToCopy >> 1);
#else
if (adapter->EProUse32BitIO)
{
if (bytesToCopy & 2)
{
EPRO_RD_PORT_USHORT(
adapter,
I82595_MEM_IO_REG,
(UNALIGNED USHORT *)(&adapter->RXLookAhead));
EPRO_READ_BUFFER_FROM_NIC_ULONG(
adapter,
(UNALIGNED ULONG *)(((UCHAR *)&(adapter->RXLookAhead)) + 2),
bytesToCopy >> 2);
}
else
{
EPRO_READ_BUFFER_FROM_NIC_ULONG(
adapter,
(UNALIGNED ULONG *)(&(adapter->RXLookAhead)),
bytesToCopy >> 2);
}
}
else
{
// This is an old version of the 82595 - we have to use 16-bit IO
EPRO_READ_BUFFER_FROM_NIC_USHORT(
adapter,
(USHORT *)&adapter->RXLookAhead,
bytesToCopy>>1);
}
#endif
if (bytesToCopy & 1)
{
// just read the low-order byte here....
EPRO_RD_PORT_UCHAR(adapter, I82595_MEM_IO_REG, &tempCopy);
adapter->RXLookAhead[bytesToCopy-1] = tempCopy;
}
context.RXCurrentAddress = adapter->RXCurrentAddress;
context.LookAheadSize = bytesToCopy;
// indicate packet
NdisMEthIndicateReceive(adapter->MiniportAdapterHandle,
(NDIS_HANDLE)&context,
(PCHAR)&ethHeader,
sizeof(EPRO_ETH_HEADER),
&adapter->RXLookAhead,
bytesToCopy,
context.RXFrameSize - sizeof(EPRO_ETH_HEADER));
// verify bank0
EPRO_ASSERT_BANK_0(adapter);
}
{
USHORT temp = (USHORT)header.NextFrmLo | (((USHORT)header.NextFrmHi) << 8);
if ((temp < EPRO_RX_LOWER_LIMIT_SHORT) ||
(temp > EPRO_RX_UPPER_LIMIT_SHORT))
{
adapter->fHung = TRUE;
#if DBG
DbgPrint("The receive header has an invalid next frame pointer!\n");
DbgPrint("current rx: %lx, rx: %lx, hi: %x, lo: %x hdr: %lx\n",
adapter->RXCurrentAddress,
temp,
header.NextFrmHi,
header.NextFrmLo,
&header);
// EPRO_ASSERT(FALSE);
#endif
break;
}
}
adapter->RXCurrentAddress = (USHORT)header.NextFrmLo | (((USHORT)header.NextFrmHi) << 8);
// Seek to the next frame
EPRO_SET_HOST_ADDR(adapter, adapter->RXCurrentAddress);
// Read the header...
EPRO_READ_BUFFER_FROM_NIC_USHORT(
adapter,
(USHORT *)(&header),
sizeof(EPRO_RCV_HEADER) >> 1);
}
// now, update the stop reg to = the bottom of the received frame....
if (numRcvd > 0)
{
USHORT value;
value = context.RXCurrentAddress + context.RXFrameSize;
// wrap around...
if (value >= EPRO_RX_UPPER_LIMIT_SHORT)
{
value -= (EPRO_RX_UPPER_LIMIT_SHORT - EPRO_RX_LOWER_LIMIT_SHORT);
}
if (!((value <= EPRO_RX_UPPER_LIMIT_SHORT) &&
(value >= EPRO_RX_LOWER_LIMIT_SHORT)))
{
adapter->fHung = TRUE;
#if DBG
DbgPrint("ca: %lx, fs: %lx, val: %lx",
context.RXCurrentAddress,
context.RXFrameSize,
value);
// EPRO_ASSERT(FALSE);
#endif
}
EPRO_WR_PORT_USHORT(adapter, I82595_RX_STOP_REG, value);
}
adapter->FramesRcvOK += numRcvd;
return(numRcvd);
}
#if 0
// You know. This code PASSES all the stress tests. Passes everything the
// tester can throw out, but still is broken when I try to make it work
// in real life. <sigh>. Look at this later.
NDIS_STATUS EProTransferData(OUT PNDIS_PACKET packet,
OUT PUINT bytesTransferred,
IN NDIS_HANDLE miniportAdapterContext,
IN NDIS_HANDLE miniportReceivedContext,
IN UINT byteOffset,
IN UINT bytesToTransfer)
/*++
Routine Description:
The transferdata handler for the EPro.
Arguments:
packet - The packet to transfer the data into
bytesTransferred - The number of bytes actually copied into packet.
miniportAdapterContext - Reallly a pointer to our EPRO_ADAPTER structure
miniportReceivedContext - This is our EPRO_RCV_CONTEXT, which basically just
has the packet length and pointer to where it lies
in the card's address space.
byteOffset - where in the frame to begin trasferring from
bytesToTransfer - how many bytes to transfer.
Return Value:
NDIS_STATUS_SUCCESS - data transfered OK
NDIS_STATUS_FAILURE - tried to transfer off end of frame
--*/
{
PEPRO_ADAPTER adapter = (PEPRO_ADAPTER)miniportAdapterContext;
// The 82595's on-card RCV memory structure
EPRO_RCV_HEADER header;
// An 802.3 ethernet header.
EPRO_ETH_HEADER ethHeader;
// How many bytes have we copied, how many are left to copy
USHORT byteCount, bytesToCopy;
PEPRO_RCV_CONTEXT pcontext = (PEPRO_RCV_CONTEXT)miniportReceivedContext;
// The current buffer we are copying into.
PNDIS_BUFFER curDestBuf;
// The physical address of the buffer we are currently copying into
PVOID curDestBufAddr;
// The length of that buffer
UINT curDestBufLen;
// Two bytes used when we have to transfer in to odd-length buffers (since
// accesses to the EPro's memory are only by-word.
UCHAR tempCopy[2];
// This is TRUE if we are "forwarding" a single byte from an odd-length transfer
BOOLEAN fForward = FALSE;
// the address to read from on the card
USHORT cardAddress;
UINT bytesWriteThisPacket;
// TODO - copy first lookahead size bytes out of lookahead buffer.
*bytesTransferred = 0;
// switch to bank0 for mem io
EPRO_ASSERT_BANK_0(adapter);
// Make sure they're not seeking past the end of the frame
if (byteOffset > pcontext->RXFrameSize) {
return(NDIS_STATUS_FAILURE);
}
// get the first buffer
NdisQueryPacket(packet, NULL, NULL, &curDestBuf, NULL);
// copy the amount requested, or the entire packet - whichever is smaller
if ((bytesToTransfer + byteOffset) <= pcontext->RXFrameSize) {
bytesToCopy = bytesToTransfer;
} else {
bytesToCopy = (pcontext->RXFrameSize - byteOffset);
}
// first loop -- copy up to the end of the lookahead buffer's worth:
if (byteOffset < adapter->RXLookAheadSize) {
UINT laOffset = byteOffset;
UINT laToCopy = adapter->RXLookAheadSize - laOffset;
if (laToCopy > bytesToCopy) {
laToCopy = bytesToCopy;
}
*bytesTransferred+=laToCopy;
bytesToCopy-=laToCopy;
while (laToCopy > 0) {
NdisQueryBuffer(curDestBuf, &curDestBufAddr, &curDestBufLen);
if (curDestBufLen == 0) {
continue;
}
// We either write the entire buffer size bytes or the number of bytes
// remaining to copy - whichever is smaller.
bytesWriteThisPacket = (laToCopy > curDestBufLen) ?
curDestBufLen : laToCopy;
EPRO_ASSERT(bytesWriteThisPacket <= laToCopy);
NdisMoveMemory(curDestBufAddr, &adapter->RXLookAhead[laOffset],
bytesWriteThisPacket);
laToCopy-=bytesWriteThisPacket;
laOffset+=bytesWriteThisPacket;
}
byteOffset = adapter->RXLookAheadSize;
EPRO_ASSERT(bytesToCopy >= laToCopy);
if (bytesToCopy == 0) {
EProLogStr(" 1BytesTo:");
EProLogLong(bytesToTransfer);
EProLogStr("BytesTransf:");
EProLogLong(*bytesTransferred);
return(NDIS_STATUS_SUCCESS);
}
if (curDestBufLen > bytesWriteThisPacket) {
(UCHAR *)curDestBufAddr += bytesWriteThisPacket;
} else {
curDestBufLen = 0;
while (curDestBufLen == 0) {
NdisGetNextBuffer(curDestBuf, &curDestBuf);
if (!curDestBuf) {
EProLogStr(" 2BytesTo:");
EProLogLong(bytesToTransfer);
EProLogStr("BytesTransf:");
EProLogLong(*bytesTransferred);
return(NDIS_STATUS_SUCCESS);
}
NdisQueryBuffer(curDestBuf, &curDestBufAddr, &curDestBufLen);
}
}
} else {
NdisQueryBuffer(curDestBuf, &curDestBufAddr, &curDestBufLen);
}
// set our memory address on the card...
cardAddress = (pcontext->RXCurrentAddress + sizeof(EPRO_RCV_HEADER) +
sizeof(EPRO_ETH_HEADER) + byteOffset);
// Set the address on the card. Note that you can do sequential reads
// from the IO port which WRAP around the memory boundry, but if you
// manually set the address, you have to wrap manually.
if (cardAddress >= EPRO_RX_UPPER_LIMIT_SHORT) {
cardAddress -= (EPRO_RX_UPPER_LIMIT_SHORT - EPRO_RX_LOWER_LIMIT_SHORT);
}
// Are we starting of reading from an odd address?
if (cardAddress & 1) {
// yes; odd offset -- forward a byte in...
fForward = TRUE;
cardAddress--;
}
// Okay, now seek to the right address on the card
EPRO_SET_HOST_ADDR(adapter, cardAddress);
// Are we forwarding a byte in? If so, fetch it now....
if (fForward == TRUE) {
EPRO_RD_PORT_USHORT(adapter, I82595_MEM_IO_REG, (USHORT *)(&tempCopy));
}
// continue until we either run out of buffers, or out of bytes....
while((bytesToCopy > 0) && (curDestBuf!=NULL)) {
// We either write the entire buffer size bytes or the number of bytes
// remaining to copy - whichever is smaller.
bytesWriteThisPacket = (bytesToCopy > curDestBufLen) ?
curDestBufLen : bytesToCopy;
bytesToCopy-=bytesWriteThisPacket;
// Ooh, we're going to transfer some bytes...
*bytesTransferred+=bytesWriteThisPacket;
// Okay. Did we have to forward a byte in? Copy it to the buffer NOW..
if (fForward == TRUE) {
*(UCHAR *)curDestBufAddr = tempCopy[1];
fForward = FALSE;
((UCHAR *)curDestBufAddr)++;
bytesWriteThisPacket--;
}
// Copy the bulk of the data...
#ifndef EPRO_USE_32_BIT_IO
EPRO_READ_BUFFER_FROM_NIC_USHORT(adapter, curDestBufAddr,
bytesWriteThisPacket>>1);
#else
if (adapter->EProUse32BitIO) {
if (bytesWriteThisPacket & 2) {
EPRO_RD_PORT_USHORT(adapter, I82595_MEM_IO_REG, (USHORT *)curDestBufAddr);
EPRO_READ_BUFFER_FROM_NIC_ULONG(adapter,
(UNALIGNED ULONG *)((UCHAR *)curDestBufAddr +2),
bytesWriteThisPacket >> 2);
} else {
EPRO_READ_BUFFER_FROM_NIC_ULONG(adapter,
(UNALIGNED ULONG *)curDestBufAddr,
bytesWriteThisPacket >> 2);
}
} else {
EPRO_READ_BUFFER_FROM_NIC_USHORT(adapter, curDestBufAddr,
bytesWriteThisPacket>>1);
}
#endif
// Okay, the rshift in the last call will lose the odd byte. If there is one, we need
// to read it and possibly forward the second byte....
if (bytesWriteThisPacket & 1) {
fForward = TRUE;
// Read the LOW order byte.
EPRO_RD_PORT_USHORT(adapter, I82595_MEM_IO_REG, (USHORT *)(&tempCopy));
((UCHAR *)curDestBufAddr)[bytesWriteThisPacket-1] = tempCopy[0];
}
NdisGetNextBuffer(curDestBuf, &curDestBuf);
if (curDestBuf != NULL) {
NdisQueryBuffer(curDestBuf, &curDestBufAddr, &curDestBufLen);
}
}
EProLogStr(" 3BytesTo:");
EProLogLong(bytesToTransfer);
EProLogStr("BytesTransf:");
EProLogLong(*bytesTransferred);
return(NDIS_STATUS_SUCCESS);
}
#else
NDIS_STATUS EProTransferData(OUT PNDIS_PACKET packet,
OUT PUINT bytesTransferred,
IN NDIS_HANDLE miniportAdapterContext,
IN NDIS_HANDLE miniportReceivedContext,
IN UINT byteOffset,
IN UINT bytesToTransfer)
/*++
Routine Description:
The transferdata handler for the EPro.
Arguments:
packet - The packet to transfer the data into
bytesTransferred - The number of bytes actually copied into packet.
miniportAdapterContext - Reallly a pointer to our EPRO_ADAPTER structure
miniportReceivedContext - This is our EPRO_RCV_CONTEXT, which basically just
has the packet length and pointer to where it lies
in the card's address space.
byteOffset - where in the frame to begin trasferring from
bytesToTransfer - how many bytes to transfer.
Return Value:
NDIS_STATUS_SUCCESS - data transfered OK
NDIS_STATUS_FAILURE - tried to transfer off end of frame
--*/
{
PEPRO_ADAPTER adapter = (PEPRO_ADAPTER)miniportAdapterContext;
// The 82595's on-card RCV memory structure
EPRO_RCV_HEADER header;
// An 802.3 ethernet header.
EPRO_ETH_HEADER ethHeader;
// How many bytes have we copied, how many are left to copy
USHORT byteCount, bytesToCopy;
PEPRO_RCV_CONTEXT pcontext = (PEPRO_RCV_CONTEXT)miniportReceivedContext;
// The current buffer we are copying into.
PNDIS_BUFFER curDestBuf;
// The physical address of the buffer we are currently copying into
PVOID curDestBufAddr;
// The length of that buffer
UINT curDestBufLen;
// Two bytes used when we have to transfer in to odd-length buffers (since
// accesses to the EPro's memory are only by-word.
UCHAR tempCopy[2];
// This is TRUE if we are "forwarding" a single byte from an odd-length transfer
BOOLEAN fForward = FALSE;
// the address to read from on the card
USHORT cardAddress;
// TODO - copy first lookahead size bytes out of lookahead buffer.
*bytesTransferred = 0;
// switch to bank0 for mem io
// EPRO_SWITCH_BANK_0(adapter);
EPRO_ASSERT_BANK_0(adapter);
// Make sure they're not asking for too much.
// if (bytesToTransfer + byteOffset > pcontext->RXFrameSize)
// {
// return(NDIS_STATUS_FAILURE);
// }
// Make sure they're not seeking past the end of the frame
if (byteOffset > pcontext->RXFrameSize)
{
return(NDIS_STATUS_FAILURE);
}
// copy the amount requested, or the entire packet - whichever is smaller
if ((bytesToTransfer + byteOffset) <= pcontext->RXFrameSize)
{
bytesToCopy = bytesToTransfer;
}
else
{
bytesToCopy = (pcontext->RXFrameSize - byteOffset);
}
// set our memory address on the card...
cardAddress = (pcontext->RXCurrentAddress +
sizeof(EPRO_RCV_HEADER) +
sizeof(EPRO_ETH_HEADER) +
byteOffset);
if (cardAddress >= EPRO_RX_UPPER_LIMIT_SHORT)
{
// cardAddress = EPRO_RX_LOWER_LIMIT_SHORT + (cardAddress - EPRO_RX_UPPER_LIMIT_SHORT);
// Go algebraic simplification:
cardAddress -= (EPRO_RX_UPPER_LIMIT_SHORT - EPRO_RX_LOWER_LIMIT_SHORT);
}
// Are we starting of reading from an odd address?
if (cardAddress & 1)
{
// yes; odd offset -- forward a byte in...
fForward = TRUE;
cardAddress--;
}
// Okay, now seek to the right address on the card
EPRO_SET_HOST_ADDR(adapter, cardAddress);
// Are we forwarding a byte in? If so, fetch it now....
if (fForward == TRUE)
{
EPRO_RD_PORT_USHORT(adapter, I82595_MEM_IO_REG, (USHORT *)(&tempCopy));
}
// get the first buffer
NdisQueryPacket(packet, NULL, NULL, &curDestBuf, NULL);
// continue until we either run out of buffers, or out of bytes....
while((bytesToCopy > 0) && (curDestBuf!=NULL))
{
UINT bytesWriteThisPacket;
NdisQueryBuffer(curDestBuf, &curDestBufAddr, &curDestBufLen);
// We either write the entire buffer size bytes or the number of bytes
// remaining to copy - whichever is smaller.
bytesWriteThisPacket =
(bytesToCopy > curDestBufLen) ? curDestBufLen : bytesToCopy;
// Ooh, we're going to transfer some bytes...
*bytesTransferred+=bytesWriteThisPacket;
// Okay. Did we have to forward a byte in? Copy it to the buffer NOW..
if (fForward == TRUE)
{
*(UCHAR *)curDestBufAddr = tempCopy[1];
fForward = FALSE;
((UCHAR *)curDestBufAddr)++;
bytesWriteThisPacket--;
}
// Copy the bulk of the data...
#ifndef EPRO_USE_32_BIT_IO
EPRO_READ_BUFFER_FROM_NIC_USHORT(adapter, curDestBufAddr, bytesWriteThisPacket>>1);
#else
if (adapter->EProUse32BitIO)
{
if (bytesWriteThisPacket & 2)
{
EPRO_RD_PORT_USHORT(
adapter,
I82595_MEM_IO_REG,
(UNALIGNED USHORT *)curDestBufAddr);
EPRO_READ_BUFFER_FROM_NIC_ULONG(
adapter,
((UCHAR *)curDestBufAddr +2),
bytesWriteThisPacket >> 2);
}
else
{
EPRO_READ_BUFFER_FROM_NIC_ULONG(
adapter,
curDestBufAddr,
bytesWriteThisPacket >> 2);
}
}
else
{
EPRO_READ_BUFFER_FROM_NIC_USHORT(
adapter,
curDestBufAddr,
bytesWriteThisPacket >> 1);
}
#endif
// Okay, the rshift in the last call will lose the odd byte. If there is one, we need
// to read it and possibly forward the second byte....
if (bytesWriteThisPacket & 1)
{
fForward = TRUE;
// Read the LOW order byte.
EPRO_RD_PORT_USHORT(
adapter,
I82595_MEM_IO_REG,
(USHORT *)(&tempCopy));
((UCHAR *)curDestBufAddr)[bytesWriteThisPacket-1] = tempCopy[0];
}
NdisGetNextBuffer(curDestBuf, &curDestBuf);
bytesToCopy -= curDestBufLen;
}
return(NDIS_STATUS_SUCCESS);
}
#endif
BOOLEAN EProSyncCopyBufferToNicUlong(PVOID context)
{
UCHAR result;
PEPRO_ADAPTER adapter = ((PEPRO_COPYBUF_CONTEXT)context)->Adapter;
// PVOID buffer = ((PEPRO_COPYBUF_CONTEXT)context)->Buffer;
// UINT len = ((PEPRO_COPYBUF_CONTEXT)context)->Len;
EPRO_RD_PORT_UCHAR(adapter, I82595_32IOSEL_REG, &result);
// result |= I82595_32IOSEL;
EPRO_WR_PORT_UCHAR(adapter, I82595_32IOSEL_REG, (result | I82595_32IOSEL));
NdisRawWritePortBufferUlong(adapter->IoPAddr + I82595_32MEM_IO_REG,
((PEPRO_COPYBUF_CONTEXT)context)->Buffer,
((PEPRO_COPYBUF_CONTEXT)context)->Len);
// result &= ~I82595_32IOSEL;
EPRO_WR_PORT_UCHAR(adapter, I82595_32IOSEL_REG, result);
return(TRUE);
}
BOOLEAN EProSyncReadBufferFromNicUlong(PVOID context)
{
UCHAR result;
PEPRO_ADAPTER adapter = ((PEPRO_COPYBUF_CONTEXT)context)->Adapter;
// PVOID buffer = ((PEPRO_COPYBUF_CONTEXT)context)->Buffer;
// UINT len = ((PEPRO_COPYBUF_CONTEXT)context)->Len;
EPRO_RD_PORT_UCHAR(adapter, I82595_32IOSEL_REG, &result);
// result |= I82595_32IOSEL;
EPRO_WR_PORT_UCHAR(adapter, I82595_32IOSEL_REG, (result | I82595_32IOSEL));
NdisRawReadPortBufferUlong(adapter->IoPAddr + I82595_32MEM_IO_REG,
((PEPRO_COPYBUF_CONTEXT)context)->Buffer,
((PEPRO_COPYBUF_CONTEXT)context)->Len);
// result &= ~I82595_32IOSEL;
EPRO_WR_PORT_UCHAR(adapter, I82595_32IOSEL_REG, result);
return(TRUE);
}
Reference in New Issue View Git Blame Copy Permalink