/*
* IDD_PROC.C - do real tx/rx processing
*/
#include <ndis.h>
#include <ndiswan.h>
#include <mytypes.h>
#include <mydefs.h>
#include <disp.h>
#include <util.h>
#include <opcodes.h>
#include <adapter.h>
#include <idd.h>
#include <mtl.h>
#include <cm.h>
#include <res.h>
#if DBG
#define AddBufferToList(_idd, _Part, _Buffer) \
{ \
BUFFER_MANAGER *IdpBufferStuff = &(_idd)->BufferStuff[_Part]; \
ULONG *PutBuffer = &IdpBufferStuff->Buffer[IdpBufferStuff->Put % 32]; \
ASSERT(!*PutBuffer); \
*PutBuffer = _Buffer; \
IdpBufferStuff->Put++; \
IdpBufferStuff->Count++; \
ASSERT(IdpBufferStuff->Count < 32); \
}
#define RemoveBufferFromList(_idd, _Part) \
{ \
BUFFER_MANAGER *IdpBufferStuff = &(_idd)->BufferStuff[_Part]; \
ULONG *GetBuffer = &IdpBufferStuff->Buffer[IdpBufferStuff->Get % 32]; \
ASSERT(*GetBuffer); \
*GetBuffer = 0; \
IdpBufferStuff->Get++; \
ASSERT(IdpBufferStuff->Count > 0); \
IdpBufferStuff->Count--; \
}
#endif
/* poll (process) trasmitter side */
ULONG
IdpPollTx(IDD *idd)
{
INT n, has_msg;
ULONG EventNum = 0;
IDD_SMSG smsg;
USHORT buf_len = 0, TxFlags = 0, TempUshort;
UCHAR status;
ULONG msg_bufptr, TempUlong;
D_LOG(D_NEVER, ("IdpPollTx: entry, idd: 0x%lx\n", idd));
/* must get semaphore */
if ( !sema_get(&idd->proc_sema) )
return(IDD_E_SUCC);
/* lock idd */
NdisAcquireSpinLock(&idd->lock);
if (!GetResourceSem (idd->res_mem))
{
NdisReleaseSpinLock(&idd->lock);
sema_free(&idd->proc_sema);
return(IDD_E_SUCC);
}
IdpCPage(idd, 0);
/* loop on all tx ports */
for ( n = 0 ; n < IDD_TX_PORTS ; n++ )
{
USHORT part = idd->tx_partq[n];
/* skip non existent ports */
if ( !idd->tx_port[n] )
continue;
/* check if port is blocked on a buffer */
if ( !idd->tx_buf[part] )
{
/* try to get a buffer for this partition */
IdpCPage(idd, 0);
TempUlong = (ULONG)(part + 4);
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->msg_param, (PVOID)&TempUlong, sizeof (ULONG));
status = idd->Execute(idd, IDP_L_GET_WBUF);
if ( status != IDP_S_OK)
{
D_LOG( DIGIERRORS, ( "Please contact Kendal Gabel or Rik Logan #1: status=0x%x\n",
((ULONG)status & 0x000000FF)) );
continue;
}
/* if here, buffer allocated, register it */
NdisMoveFromMappedMemory( (PVOID)&idd->tx_buf[part], (PVOID)&idd->IdpCmd->msg_bufptr, sizeof (ULONG));
#if DBG
AddBufferToList(idd, part, idd->tx_buf[part]);
#endif
}
/* check if a message is waiting to be sent on a port */
NdisAcquireSpinLock(&idd->sendq[n].lock);
if ( has_msg = idd->sendq[n].num )
{
/* extract message off queue */
smsg = idd->sendq[n].tbl[idd->sendq[n].get];
if ( ++idd->sendq[n].get >= idd->sendq[n].max )
idd->sendq[n].get = 0;
idd->sendq[n].num--;
}
NdisReleaseSpinLock(&idd->sendq[n].lock);
/* if no message, escape here */
if ( !has_msg )
continue;
/* debug print message */
D_LOG(DIGIIDD, ("poll_tx: smsg: opcode: 0x%x, buflen: 0x%x, bufptr: 0x%lx\n", \
smsg.msg.opcode, smsg.msg.buflen, smsg.msg.bufptr));
D_LOG(DIGIIDD, ("poll_tx: bufid: 0x%x, param: 0x%x, handler: 0x%lx, arg: 0x%lx\n", \
smsg.msg.bufid, smsg.msg.param, smsg.handler, smsg.handler_arg));
//
// save xmitflags clearing out dkf fragment indicator
// they are in most significant nible
// Bits - xxxx
// ||||__ fragment indicator
// |||___ tx flush flag
// ||____ !tx end flag
// |_____ !tx begin flag
//
TxFlags = smsg.msg.buflen & TX_FLAG_MASK;
#if DBG
switch (idd->BufferStuff[part].TxState)
{
case TX_BEGIN:
case TX_END:
if (TxFlags & H_TX_N_BEG)
{
DbgPrint("Missed a begining buffer! idd: 0x%x, part: %d\n", idd, part);
DbgPrint("TxFlags: 0x%x, State: 0x%x\n", TxFlags, idd->BufferStuff[part].TxState);
DbgBreakPoint();
}
else if (TxFlags & H_TX_N_END)
{
idd->BufferStuff[part].TxState = TX_MIDDLE;
idd->BufferStuff[part].FragsSinceBegin = 0;
}
break;
case TX_MIDDLE:
if (TxFlags & H_TX_N_BEG)
break;
else
{
DbgPrint("Missed an ending buffer! idd: 0x%x, part: %d\n", idd, part);
DbgPrint("TxFlags: 0x%x, State: 0x%x\n", TxFlags, idd->BufferStuff[part].TxState);
DbgBreakPoint();
}
break;
default:
DbgPrint("Unknown State! idd: 0x%x, part: %d\n", idd, part);
DbgPrint("TxFlags: 0x%x, State: 0x%x\n", TxFlags, idd->BufferStuff[part].TxState);
DbgBreakPoint();
idd->BufferStuff[part].TxState = TX_BEGIN;
idd->BufferStuff[part].FragsSinceBegin = 0;
break;
}
idd->BufferStuff[part].FragsSinceBegin++;
if (!(TxFlags & H_RX_N_END))
idd->BufferStuff[part].TxState = TX_END;
#endif
/* check for buffer, if has one, copyin */
IdpCPage(idd, 0);
if( idd->tx_buf[part] == 0 )
DbgPrint( "Giving a 0 buffer back in IDP_L_WRITE call!\n" );
NdisMoveToMappedMemory( (PVOID)&idd->IdpCmd->msg_bufptr,
(PVOID)&idd->tx_buf[part],
sizeof (ULONG) );
#if DBG
RemoveBufferFromList(idd, part);
#endif
if ( smsg.msg.bufptr )
buf_len = IdpCopyin(idd, (char*)idd->tx_buf[part],
smsg.msg.bufptr, smsg.msg.buflen);
else
buf_len = 0;
IdpCPage(idd, 0);
TempUshort = (USHORT)(buf_len | TxFlags);
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->msg_buflen, (PVOID)&TempUshort, sizeof(USHORT));
/* copy rest of command area */
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->msg_opcode, (PVOID)&smsg.msg.opcode, sizeof(USHORT));
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->msg_bufid, (PVOID)&smsg.msg.bufid, sizeof (ULONG));
TempUlong = (ULONG)(part + 4);
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->msg_param, (PVOID)&TempUlong, sizeof (ULONG));
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->port_id, (PVOID)&idd->tx_port[n], sizeof(USHORT));
/* execute the command, mark an event */
status = idd->Execute(idd, IDP_L_WRITE);
EventNum++;
/* if came back with no buffer, mark it - else store buffer */
if ( status != IDP_S_OK )
{
idd->tx_buf[part] = 0;
D_LOG(D_RARE, ("poll_tx: no buffer!, part: %d\n", part));
D_LOG( DIGIERRORS, ( "Please contact Kendal Gabel or Rik Logan #2: status=0x%x\n",
((ULONG)status & 0x000000FF)) );
}
else
{
NdisMoveFromMappedMemory((PVOID)&msg_bufptr, (PVOID)&idd->IdpCmd->msg_bufptr, sizeof (ULONG));
if ( msg_bufptr )
{
idd->tx_buf[part] = msg_bufptr;
#if DBG
AddBufferToList(idd, part, idd->tx_buf[part]);
#endif
D_LOG(D_RARE, ("poll_tx: new buffer, part: %d, buf: 0x%lx\n", \
part, idd->tx_buf[part]));
}
else
{
idd->tx_buf[part] = 0;
DbgPrint( "Adapter did not return buffer in IDP_L_WRITE\n" );
}
}
/* call user's handler */
if ( smsg.handler ) {
(*smsg.handler)(smsg.handler_arg, n, &smsg);
}
}
/* unset page, free memory window */
IdpCPage(idd, IDD_PAGE_NONE);
FreeResourceSem (idd->res_mem);
NdisReleaseSpinLock(&idd->lock);
sema_free(&idd->proc_sema);
return(EventNum);
}
/* poll (process) trasmitter side */
ULONG
AdpPollTx(IDD *idd)
{
USHORT buf_len = 0, TxFlags = 0;
UCHAR status;
ULONG n, part, has_msg, EventNum = 0;
IDD_SMSG smsg;
D_LOG(D_NEVER, ("AdpPollTx: entry, idd: 0x%lx\n", idd));
/* must get semaphore */
if ( !sema_get(&idd->proc_sema) )
return(IDD_E_SUCC);
/* lock idd */
NdisAcquireSpinLock(&idd->lock);
//
// Lock access to the I/O ports in case this is a multi-BRI adapter
// e.g. DataFire4
//
if (!GetResourceSem (idd->res_io))
{
NdisReleaseSpinLock(&idd->lock);
sema_free(&idd->proc_sema);
return(IDD_E_SUCC);
}
//
// for all tx ports
//
for (n = 0; n < IDD_TX_PORTS; n++)
{
//
// skip non existent ports
//
if (!idd->tx_port[n])
continue;
//
// clear command structure
//
NdisZeroMemory(&idd->AdpCmd, sizeof(ADP_CMD));
//
// see if port is blocked needing a buffer
//
if ( !idd->tx_buf[part = idd->tx_partq[n]] )
{
//
// fill port id and status bit
//
idd->AdpCmd.msg_param = (UCHAR)part + 4;
//
// execute command
//
status = idd->Execute(idd, ADP_L_GET_WBUF);
//
// if no buffer then go to next port
//
if (status != ADP_S_OK)
{
D_LOG( DIGIERRORS, ( "Please contact Kendal Gabel or Rik Logan #1: status=0x%x\n",
((ULONG)status & 0x000000FF)) );
continue;
}
//
// if here, buffer was allocate, register it
//
idd->tx_buf[part] = (ULONG)idd->AdpCmd.msg_bufptr;
}
//
// see if there is a message waiting to be sent
//
NdisAcquireSpinLock(&idd->sendq[n].lock);
if ( has_msg = idd->sendq[n].num )
{
/* extract message off queue */
smsg = idd->sendq[n].tbl[idd->sendq[n].get];
if ( ++idd->sendq[n].get >= idd->sendq[n].max )
idd->sendq[n].get = 0;
idd->sendq[n].num--;
}
NdisReleaseSpinLock(&idd->sendq[n].lock);
//
// if no message go to next port
//
if (!has_msg)
continue;
/* debug print message */
D_LOG(DIGIIDD, ("AdpPollTx: smsg: opcode: 0x%x, buflen: 0x%x, bufptr: 0x%lx\n", \
smsg.msg.opcode, smsg.msg.buflen, smsg.msg.bufptr));
D_LOG(DIGIIDD, ("AdpPollTx: bufid: 0x%x, param: 0x%x, handler: 0x%lx, arg: 0x%lx\n", \
smsg.msg.bufid, smsg.msg.param, smsg.handler, smsg.handler_arg));
//
// save xmitflags clearing out dkf fragment indicator
// they are in most significant nible
// Bits - xxxx
// ||||__ fragment indicator
// |||___ tx flush flag
// ||____ !tx end flag
// |_____ !tx begin flag
//
TxFlags = smsg.msg.buflen & TX_FLAG_MASK;
//
// see if there is a buffer to be copied
//
(ULONG)idd->AdpCmd.msg_bufptr = idd->tx_buf[part];
if ( smsg.msg.bufptr )
buf_len = AdpCopyin(idd, smsg.msg.bufptr, smsg.msg.buflen);
else
buf_len = 0;
idd->AdpCmd.msg_buflen = buf_len | TxFlags;
idd->AdpCmd.msg_opcode = smsg.msg.opcode;
idd->AdpCmd.msg_bufid = smsg.msg.bufid;
idd->AdpCmd.msg_param = (ULONG)(part + 4);
idd->AdpCmd.port_id = idd->tx_port[n];
status = idd->Execute(idd, ADP_L_WRITE);
EventNum++;
if (status != ADP_S_OK)
{
idd->tx_buf[part] = 0;
D_LOG(D_RARE, ("poll_tx: no buffer!, part: %d\n", part));
D_LOG( DIGIERRORS, ( "Please contact Kendal Gabel or Rik Logan #2: status=0x%x\n",
((ULONG)status & 0x000000FF)) );
}
else
{
if (idd->AdpCmd.msg_bufptr)
{
idd->tx_buf[part] = (ULONG)idd->AdpCmd.msg_bufptr;
D_LOG(D_RARE, ("poll_tx: new buffer, part: %d, buf: 0x%lx\n", \
part, idd->tx_buf[part]));
}
}
/* call user's handler */
if ( smsg.handler )
(*smsg.handler)(smsg.handler_arg, n, &smsg);
}
FreeResourceSem (idd->res_io);
NdisReleaseSpinLock(&idd->lock);
sema_free(&idd->proc_sema);
return(EventNum);
} // end AdpPollTx
/* poll (process) reciever ports */
ULONG
IdpPollRx(IDD *idd)
{
INT n, m;
USHORT stat, ofs;
IDD_XMSG msg;
UCHAR status, Page;
ULONG TempUlong, EventNum = 0;
/* must get semaphore */
if ( !sema_get(&idd->proc_sema) )
return(IDD_E_SUCC);
/* lock idd */
NdisAcquireSpinLock(&idd->lock);
if (!GetResourceSem (idd->res_mem))
{
NdisReleaseSpinLock(&idd->lock);
sema_free(&idd->proc_sema);
return(IDD_E_SUCC);
}
/* get status port */
IdpCPage(idd, 0);
NdisMoveFromMappedMemory((PVOID)&stat, (PVOID)idd->IdpStat, sizeof(USHORT));
D_LOG(D_NEVER, ("poll_rx: stat: 0x%x (@0x%lx)\n", stat, idd->IdpStat));
/* make one pass on all rx ports which have a status bit on */
for ( n = 0 ; n < IDD_RX_PORTS ; n++, stat >>= 1 )
if ( stat & 1 )
{
//
// skip non existent ports
//
if (!idd->rx_port[n])
continue;
/* install returned read buffer */
IdpCPage(idd, 0);
TempUlong = MAKELONG(HIWORD(idd->rx_buf), 0);
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->msg_bufid, (PVOID)&TempUlong, sizeof (ULONG));
idd->rx_buf = 0;
/* install port & execute a read */
D_LOG(DIGIIDD, ("poll_rx: index: %d, ReadPort 0x%x\n", n, idd->rx_port[n]));
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->port_id, (PVOID)&idd->rx_port[n], sizeof(USHORT));
status = idd->Execute(idd, IDP_L_READ);
if ( status != IDP_S_OK )
{
continue;
}
EventNum++;
/* copy message out */
NdisMoveFromMappedMemory((PVOID)&msg.opcode, (PVOID)&idd->IdpCmd->msg_opcode, sizeof(USHORT));
NdisMoveFromMappedMemory((PVOID)&msg.buflen, (PVOID)&idd->IdpCmd->msg_buflen, sizeof(USHORT));
// save receive fragment flags
// they are in most significant nible
// Bits - xxxx
// ||||__ reserved
// |||___ reserved
// ||____ !rx end flag
// |_____ !rx begin flag
//
msg.FragmentFlags = msg.buflen & RX_FLAG_MASK;
//
// get real buffer length
//
msg.buflen &= H_RX_LEN_MASK;
NdisMoveFromMappedMemory((PVOID)&msg.bufptr, (PVOID)&idd->IdpCmd->msg_bufptr, sizeof (ULONG));
NdisMoveFromMappedMemory((PVOID)&msg.bufid, (PVOID)&idd->IdpCmd->msg_bufid, sizeof (ULONG));
NdisMoveFromMappedMemory((PVOID)&msg.param, (PVOID)&idd->IdpCmd->msg_param, sizeof (ULONG));
/* save rx buffer */
idd->rx_buf = (ULONG)msg.bufptr;
D_LOG(DIGIIDD, ("poll_rx: 0x%x 0x%x %lx %lx %lx\n", \
msg.opcode, \
msg.buflen, \
msg.bufptr, \
msg.bufid, \
msg.param));
if ( msg.bufptr)
{
ofs = LOWORD(msg.bufptr);
Page = (UCHAR)(ofs >> 14) & 3;
#if DBG
if (Page > 1 )
{
DbgPrint("Page changed to %d on idd 0x%lx!\n", Page, idd);
DbgBreakPoint();
}
#endif
msg.bufptr = idd->vhw.vmem + (ofs & 0x3FFF);
IdpCPage(idd, Page);
}
/* loop on rx handler, call user to copyout buffer */
for ( m = 0 ; m < idd->recit[n].num ; m++ )
(*idd->recit[n].tbl[m].handler)(idd->recit[n].tbl[m].handler_arg,
n,
idd->recit[n].RxFrameType,
&msg);
}
/* unset page, free memory window */
IdpCPage(idd, IDD_PAGE_NONE);
FreeResourceSem (idd->res_mem);
NdisReleaseSpinLock(&idd->lock);
sema_free(&idd->proc_sema);
return(EventNum);
}
/* poll (process) receiver side */
ULONG
AdpPollRx(IDD *idd)
{
INT n, m;
UCHAR status;
ULONG EventNum = 0;
USHORT stat = 0;
IDD_XMSG msg;
/* must get semaphore */
if ( !sema_get(&idd->proc_sema) )
return(IDD_E_SUCC);
/* lock idd */
NdisAcquireSpinLock(&idd->lock);
if (!GetResourceSem (idd->res_io))
{
NdisReleaseSpinLock(&idd->lock);
sema_free(&idd->proc_sema);
return(IDD_E_SUCC);
}
stat = AdpReadReceiveStatus(idd);
for( n = 0; stat && (n < IDD_RX_PORTS); n++, stat >>= 1 )
if (stat & 1)
{
//
// clear command structure
//
NdisZeroMemory(&idd->AdpCmd, sizeof(ADP_CMD));
D_LOG(DIGIIDD, ("poll_rx: index: %d, ReadPort 0x%x\n", n, idd->rx_port[n]));
//
// return read buffer
//
idd->AdpCmd.msg_bufid = MAKELONG(HIWORD(idd->rx_buf), 0);
idd->rx_buf = 0;
idd->AdpCmd.port_id = idd->rx_port[n];
status = idd->Execute(idd, ADP_L_READ);
if (status != ADP_S_OK)
continue;
EventNum++;
msg.opcode = idd->AdpCmd.msg_opcode;
msg.buflen = idd->AdpCmd.msg_buflen;
// save receive fragment flags
// they are in most significant nible
// Bits - xxxx
// ||||__ reserved
// |||___ reserved
// ||____ !rx end flag
// |_____ !rx begin flag
//
msg.FragmentFlags = msg.buflen & RX_FLAG_MASK;
//
// get real buffer length
//
msg.buflen &= H_RX_LEN_MASK;
msg.bufptr = (UCHAR*)LOWORD(idd->AdpCmd.msg_bufptr);
idd->rx_buf = (ULONG)idd->AdpCmd.msg_bufptr;
msg.bufid = idd->AdpCmd.msg_bufid;
msg.param = idd->AdpCmd.msg_param;
D_LOG(DIGIIDD, ("AdpPollRx: Opcode: 0x%x, BufLen: 0x%x, BufPtr: 0x%x\n", \
msg.opcode, \
msg.buflen, \
msg.bufptr));
D_LOG(DIGIIDD, ("AdpPollRx: FragmentFlags: 0x%x, BufId: 0x%x, Param: 0x%x\n", \
msg.FragmentFlags,\
msg.bufid, \
msg.param));
/* loop on rx handler, call user to copyout buffer */
for ( m = 0 ; m < idd->recit[n].num ; m++ )
(*idd->recit[n].tbl[m].handler)(idd->recit[n].tbl[m].handler_arg,
n,
idd->recit[n].RxFrameType,
&msg);
}
FreeResourceSem( idd->res_io );
NdisReleaseSpinLock(&idd->lock);
sema_free(&idd->proc_sema);
return(EventNum);
} // end AdpPollRx
/* execute an idp command. assumes cpage=0 */
UCHAR
IdpExec(IDD *idd, UCHAR opcode)
{
UCHAR status = IDP_S_PEND;
ULONG TempWaitCounter;
#if DBG
USHORT IdpCounter1 = 0;
ULONG IdpCounter2 = 0;
#endif
D_LOG(D_ENTRY, ("IdpExec: entry, idd: 0x%lx, opcode=%d\n", idd, opcode));
/* install opcode, get command started */
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->opcode, (PVOID)&opcode, sizeof(UCHAR));
NdisMoveToMappedMemory((PVOID)&idd->IdpCmd->status, (PVOID)&status, sizeof(UCHAR));
status = IDP_S_EXEC;
#if DBG
NdisMoveFromMappedMemory((PVOID)&IdpCounter1, (PVOID)(idd->vhw.vmem + 0x804), sizeof(USHORT));
NdisMoveFromMappedMemory((PVOID)&IdpCounter2, (PVOID)(idd->vhw.vmem + 0x808), sizeof(ULONG));
#endif
idd->WaitCounter = 0;
while ( idd->state != IDD_S_SHUTDOWN )
{
NdisMoveFromMappedMemory((PVOID)&TempWaitCounter, (PVOID)(idd->vhw.vmem + 0x80C), sizeof(ULONG));
NdisMoveFromMappedMemory((PVOID)&status, (PVOID)&idd->IdpCmd->status, sizeof(UCHAR));
if ( IDP_S_DONE(status) )
break;
//
// wait for 1ms
// the ddk says that this function uses milliseconds but it
// actually takes microseconds
//
NdisStallExecution(1000L);
idd->WaitCounter++;
NdisMoveToMappedMemory((PVOID)(idd->vhw.vmem + 0x80C), (PVOID)&idd->WaitCounter, sizeof(ULONG));
//
// this should wait for about one second
//
if (idd->WaitCounter > 1000)
{
idd->state = IDD_S_SHUTDOWN;
#if DBG
DbgPrint("Shutdown! idd: 0x%lx, Status: 0x%x\n", idd, status);
DbgPrint("Original: IdpCounter1: 0x%x, IdpCounter2: 0x%x\n", IdpCounter1, IdpCounter2);
NdisMoveFromMappedMemory((PVOID)&IdpCounter1, (PVOID)(idd->vhw.vmem + 0x804), sizeof(USHORT));
NdisMoveFromMappedMemory((PVOID)&IdpCounter2, (PVOID)(idd->vhw.vmem + 0x808), sizeof(ULONG));
DbgPrint("Current: IdpCounter1: 0x%x, IdpCounter2: 0x%x\n", IdpCounter1, IdpCounter2);
NdisMoveFromMappedMemory((PVOID)&status, (PVOID)&idd->IdpCmd->status, sizeof(UCHAR));
DbgPrint("CurrentStatus: 0x%x\n",status);
DbgBreakPoint();
#endif
break;
}
else
status = IDP_S_EXEC;
}
D_LOG(D_EXIT, ("IdpExec: exit, IdpCmd->status: 0x%x\n", status));
#if DBG
if (status && (status != IDP_S_NOBUF)
&& (status != IDP_S_NOMSG))
{
USHORT MsgOpcode;
USHORT MsgBuflen;
UCHAR *MsgBufPtr;
ULONG MsgBufId;
ULONG MsgParam;
DbgPrint("Idd 0x%lx error executing opcode: 0x%x, status: 0x%x\n", idd, opcode, status);
NdisMoveFromMappedMemory((PVOID)&MsgOpcode, (PVOID)&idd->IdpCmd->msg_opcode, sizeof(USHORT));
NdisMoveFromMappedMemory((PVOID)&MsgBuflen, (PVOID)&idd->IdpCmd->msg_buflen, sizeof(USHORT));
NdisMoveFromMappedMemory( (PVOID)&MsgBufPtr, (PVOID)&idd->IdpCmd->msg_bufptr, sizeof (ULONG));
NdisMoveFromMappedMemory((PVOID)&MsgBufId, (PVOID)&idd->IdpCmd->msg_bufid, sizeof (ULONG));
NdisMoveFromMappedMemory((PVOID)&MsgParam, (PVOID)&idd->IdpCmd->msg_param, sizeof (ULONG));
DbgPrint("IdpExec: MsgOpcode: 0x%x, MsgBufLen: 0x%x, MsgBufPtr: 0x%x\n", MsgOpcode, MsgBuflen, MsgBufPtr);
DbgPrint("IdpExec: MsgBufId: 0x%x, MsgParam: 0x%x\n", MsgBufId, MsgParam);
}
#endif
if (idd->WaitCounter > idd->MaxWaitCounter)
idd->MaxWaitCounter = idd->WaitCounter;
return(status);
}
/* execute an Adp command. assumes cpage=0 */
UCHAR
AdpExec(IDD *idd, UCHAR opcode)
{
UCHAR status = ADP_S_PEND;
ULONG TempWaitCounter;
//
// set opcode
//
idd->AdpCmd.opcode = opcode;
D_LOG(D_ENTRY, ("AdpExec: entry, idd: 0x%lx, opcode: %d\n", idd, opcode));
D_LOG(D_ENTRY, ("status: 0x%x, port_id: 0x%x", idd->AdpCmd.status, idd->AdpCmd.port_id));
D_LOG(D_ENTRY, ("msg_opcode: 0x%x, msg_buflen: 0x%x\n", idd->AdpCmd.msg_opcode, idd->AdpCmd.msg_buflen));
D_LOG(D_ENTRY, ("msg_bufptr: 0x%x, msg_bufid: 0x%x\n", idd->AdpCmd.msg_bufptr, idd->AdpCmd.msg_bufid));
D_LOG(D_ENTRY, ("msg_param: 0x%x\n", idd->AdpCmd.msg_param));
//
// copy in command buffer
//
AdpPutBuffer(idd, ADP_CMD_WINDOW, (PUCHAR)&idd->AdpCmd, sizeof(ADP_CMD));
//
// start operation
//
AdpWriteCommandStatus(idd, ADP_S_PEND);
idd->WaitCounter = 0;
while ( idd->state != IDD_S_SHUTDOWN )
{
TempWaitCounter = AdpGetULong(idd, 0x50C);
status = AdpReadCommandStatus(idd);
if ( ADP_S_DONE(status) )
break;
//
// wait for 1ms
// the ddk says that this function uses milliseconds but it
// actually takes microseconds
//
NdisStallExecution(1000L);
idd->WaitCounter++;
AdpPutULong(idd, 0x50C, idd->WaitCounter);
//
// this should wait for about one second
//
if (idd->WaitCounter > 1000)
{
idd->state = IDD_S_SHUTDOWN;
idd->AbortReason = AdpGetUShort(idd, ADP_STS_WINDOW + 12);
}
}
AdpGetBuffer(idd, (PUCHAR)&idd->AdpCmd, ADP_CMD_WINDOW, sizeof(ADP_CMD));
if (idd->WaitCounter > idd->MaxWaitCounter)
idd->MaxWaitCounter = idd->WaitCounter;
D_LOG(D_EXIT, ("AdpExec: exit, AdpCmd.status: 0x%x\n", status));
return(status);
} // end AdpExec
/* map current idp page in */
VOID
IdpCPage(IDD *idd, UCHAR page)
{
D_LOG(D_RARE, ("IdpCPage: entry, idd: 0x%lx, page: 0x%x\n", idd, page));
/* if page is IDD_PAGE_NONE, idd is releasing ownership of the page */
if ( page == IDD_PAGE_NONE )
{
idd->SetPage(idd, IDD_PAGE_NONE);
res_unown(idd->res_mem, idd);
}
else
{
page &= 3;
/* real mapping required, lock memory resource */
res_own(idd->res_mem, idd);
idd->SetPage(idd, page);
}
}
/* map current Adp page in */
VOID
AdpCPage(IDD *idd, UCHAR page)
{
}
/* copy data from user buffer to idp */
USHORT
IdpCopyin(IDD *idd, UCHAR *dst, UCHAR *src, USHORT src_len)
{
USHORT ofs, copylen;
UCHAR Page;
UINT tot_len, frag_num;
IDD_FRAG *frag;
D_LOG(D_RARE, ("Idpcopyin: entry, idd: 0x%lx, dst: 0x%lx, src: 0x%lx, src_len: 0x%x\n", \
idd, dst, src, src_len));
/* convert destination pointer to address & map in */
ofs = LOWORD((long)dst);
Page = (UCHAR)(ofs >> 14) & 3;
#if DBG
if (Page > 1 )
DbgPrint("Page changed to %d on idd 0x%lx!\n", Page, idd);
#endif
dst = idd->vhw.vmem + (ofs & 0x3FFF);
IdpCPage(idd, Page);
//
// mask out various flags to get length to copy
//
copylen = src_len & H_TX_LEN_MASK;
/* check for a simple copy, real easy - doit here */
if ( !(src_len & TX_FRAG_INDICATOR) )
{
NdisMoveToMappedMemory (dst, src, copylen);
return(copylen);
}
/* if here, its a fragment descriptor */
tot_len = 0;
frag_num = (copylen) / sizeof(IDD_FRAG);
frag = (IDD_FRAG*)src;
/* copy fragments */
for ( ; frag_num ; frag_num--, frag++ )
{
NdisMoveToMappedMemory (dst, frag->ptr, frag->len);
dst += frag->len;
tot_len += frag->len;
}
/* read total length */
return(tot_len);
}
/* copy data from user buffer to idp */
USHORT
AdpCopyin(IDD *idd, UCHAR *src, USHORT src_len)
{
USHORT Destination, CopyLength;
UINT tot_len, frag_num;
IDD_FRAG *frag;
D_LOG(D_RARE, ("Adpcopyin: entry, idd: 0x%lx, src: 0x%lx, src_len: 0x%x\n", \
idd, src, src_len));
/* convert destination pointer to address & map in */
Destination = LOWORD(idd->AdpCmd.msg_bufptr);
//
// mask out various flags to get length to copy
//
CopyLength = src_len & H_TX_LEN_MASK;
/* check for a simple copy, real easy - doit here */
if ( !(src_len & TX_FRAG_INDICATOR) )
{
AdpPutBuffer(idd, Destination, src, CopyLength);
return(CopyLength);
}
/* if here, its a fragment descriptor */
tot_len = 0;
frag_num = (CopyLength) / sizeof(IDD_FRAG);
frag = (IDD_FRAG*)src;
/* copy fragments */
for ( ; frag_num ; frag_num--, frag++ )
{
AdpPutBuffer(idd, Destination, frag->ptr, frag->len);
Destination += frag->len;
tot_len += frag->len;
}
/* read total length */
return(tot_len);
} // end AdpCopyin
VOID
IddGetDataFromAdapter(
VOID *idd_1,
PUCHAR Destination,
PUCHAR Source,
USHORT Length
)
{
IDD *idd = (IDD*)idd_1;
if( (idd->btype != IDD_BT_DATAFIREU) &&
(idd->btype != IDD_BT_DATAFIREST) &&
(idd->btype != IDD_BT_DATAFIRE4ST) )
{
NdisMoveFromMappedMemory(Destination, Source, Length);
}
else
{
AdpGetBuffer(idd, Destination, (ULONG)Source, Length);
}
}
