1032 lines
27 KiB
C
1032 lines
27 KiB
C
/*
|
|
************************************************************************
|
|
*
|
|
* COMM.c
|
|
*
|
|
* Portions Copyright (C) 1996-2001 National Semiconductor Corp.
|
|
* All rights reserved.
|
|
* Copyright (C) 1996-2001 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
*
|
|
*
|
|
*************************************************************************
|
|
*/
|
|
|
|
#include "nsc.h"
|
|
|
|
#define MEDIA_BUSY_THRESHOLD (16)
|
|
|
|
#define SYNC_SET_COMM_PORT(_intobj,_port,_index,_value) SyncWriteBankReg(_intobj,_port,0,_index,_value);
|
|
|
|
#define SYNC_GET_COMM_PORT(_intobj,_port,_index) SyncReadBankReg(_intobj,_port,0,_index)
|
|
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* SetCOMInterrupts
|
|
*************************************************************************
|
|
*/
|
|
VOID SetCOMInterrupts(IrDevice *thisDev, BOOLEAN enable)
|
|
{
|
|
UCHAR newMask;
|
|
|
|
if (enable){
|
|
if (thisDev->portInfo.SirWritePending){
|
|
if (thisDev->currentSpeed > MAX_SIR_SPEED){
|
|
newMask = thisDev->FirIntMask;
|
|
}
|
|
else {
|
|
newMask = XMIT_MODE_INTS_ENABLE;
|
|
}
|
|
}
|
|
else {
|
|
if (thisDev->currentSpeed > MAX_SIR_SPEED){
|
|
newMask = thisDev->FirIntMask;
|
|
}
|
|
else {
|
|
newMask = RCV_MODE_INTS_ENABLE;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
newMask = ALL_INTS_DISABLE;
|
|
}
|
|
|
|
SetCOMPort(thisDev->portInfo.ioBase, INT_ENABLE_REG_OFFSET, newMask);
|
|
}
|
|
|
|
VOID
|
|
SyncSetInterruptMask(
|
|
IrDevice *thisDev,
|
|
BOOLEAN enable
|
|
)
|
|
|
|
{
|
|
|
|
UCHAR newMask;
|
|
|
|
if (enable){
|
|
if (thisDev->portInfo.SirWritePending){
|
|
if (thisDev->currentSpeed > MAX_SIR_SPEED){
|
|
newMask = thisDev->FirIntMask;
|
|
}
|
|
else {
|
|
newMask = XMIT_MODE_INTS_ENABLE;
|
|
}
|
|
}
|
|
else {
|
|
if (thisDev->currentSpeed > MAX_SIR_SPEED){
|
|
newMask = thisDev->FirIntMask;
|
|
}
|
|
else {
|
|
newMask = RCV_MODE_INTS_ENABLE;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
newMask = ALL_INTS_DISABLE;
|
|
}
|
|
|
|
SYNC_SET_COMM_PORT(&thisDev->interruptObj,thisDev->portInfo.ioBase, INT_ENABLE_REG_OFFSET, newMask);
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* DoOpen
|
|
*************************************************************************
|
|
*
|
|
* Open COMM port
|
|
*
|
|
*/
|
|
BOOLEAN DoOpen(IrDevice *thisDev)
|
|
{
|
|
BOOLEAN result;
|
|
|
|
DBGOUT(("DoOpen(%d)", thisDev->portInfo.ioBase));
|
|
|
|
/*
|
|
* This buffer gets swapped with the rcvBuffer data pointer
|
|
* and must be the same size.
|
|
*/
|
|
thisDev->portInfo.readBuf = LIST_ENTRY_TO_RCV_BUF(MyMemAlloc(RCV_BUFFER_SIZE, TRUE)); // Was FALSE -SWA
|
|
if (!thisDev->portInfo.readBuf){
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*
|
|
* The write buffer is also used as a DMA buffer.
|
|
*/
|
|
thisDev->portInfo.writeBuf = MyMemAlloc(MAX_IRDA_DATA_SIZE * 8, TRUE);
|
|
if (!thisDev->portInfo.writeBuf){
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Initialize send/receive FSMs before OpenCOM(), which enables rcv interrupts.
|
|
*/
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
thisDev->portInfo.SirWritePending = FALSE;
|
|
//
|
|
// the sir recieve will start automatically
|
|
//
|
|
thisDev->TransmitIsIdle= TRUE;
|
|
|
|
NdisInitializeEvent(&thisDev->ReceiveStopped);
|
|
NdisResetEvent(&thisDev->ReceiveStopped);
|
|
|
|
NdisInitializeEvent(&thisDev->SendStoppedOnHalt);
|
|
NdisResetEvent(&thisDev->SendStoppedOnHalt);
|
|
|
|
result = OpenCOM(thisDev);
|
|
|
|
DBGOUT(("DoOpen %s", (CHAR *)(result ? "succeeded" : "failed")));
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* DoClose
|
|
*************************************************************************
|
|
*
|
|
* Close COMM port
|
|
*
|
|
*/
|
|
VOID DoClose(IrDevice *thisDev)
|
|
{
|
|
DBGOUT(("DoClose(COM%d)", thisDev->portInfo.ioBase));
|
|
|
|
if (thisDev->portInfo.readBuf){
|
|
MyMemFree(RCV_BUF_TO_LIST_ENTRY(thisDev->portInfo.readBuf),
|
|
RCV_BUFFER_SIZE, TRUE); // Was FALSE -SWA
|
|
thisDev->portInfo.readBuf = NULL;
|
|
}
|
|
if (thisDev->portInfo.writeBuf){
|
|
MyMemFree(thisDev->portInfo.writeBuf, MAX_IRDA_DATA_SIZE * 8, TRUE);
|
|
thisDev->portInfo.writeBuf = NULL;
|
|
}
|
|
#if 0
|
|
CloseCOM(thisDev);
|
|
#endif
|
|
}
|
|
|
|
typedef struct _SYNC_SET_SPEED {
|
|
|
|
PUCHAR PortBase;
|
|
UINT BitsPerSecond;
|
|
|
|
} SYNC_SET_SPEED, *PSYNC_SET_SPEED;
|
|
|
|
|
|
VOID
|
|
SyncSetUARTSpeed(
|
|
PVOID Context
|
|
)
|
|
|
|
{
|
|
|
|
PSYNC_SET_SPEED SyncContext=(PSYNC_SET_SPEED)Context;
|
|
|
|
NdisRawWritePortUchar(SyncContext->PortBase+LINE_CONTROL_REG_OFFSET,0x83);
|
|
NdisRawWritePortUchar(SyncContext->PortBase+XFER_REG_OFFSET, (UCHAR)(115200/SyncContext->BitsPerSecond));
|
|
NdisRawWritePortUchar(SyncContext->PortBase+INT_ENABLE_REG_OFFSET, (UCHAR)((115200/SyncContext->BitsPerSecond)>>8));
|
|
NdisRawWritePortUchar(SyncContext->PortBase+LINE_CONTROL_REG_OFFSET, 0x03);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* SetUARTSpeed
|
|
*************************************************************************
|
|
*
|
|
*
|
|
*/
|
|
VOID SetUARTSpeed(IrDevice *thisDev, UINT bitsPerSec)
|
|
{
|
|
|
|
if (bitsPerSec <= MAX_SIR_SPEED){
|
|
|
|
/*
|
|
* Set speed in the standard UART divisor latch
|
|
*
|
|
* 1. Set up to access the divisor latch.
|
|
*
|
|
* 2. In divisor-latch mode:
|
|
* the transfer register doubles as the low divisor latch
|
|
* the int-enable register doubles as the hi divisor latch
|
|
*
|
|
* Set the divisor for the given speed.
|
|
* The divisor divides the maximum Slow IR speed of 115200 bits/sec.
|
|
*
|
|
* 3. Take the transfer register out of divisor-latch mode.
|
|
*
|
|
*/
|
|
|
|
SYNC_SET_SPEED SyncContext;
|
|
|
|
if (!bitsPerSec){
|
|
bitsPerSec = 9600;
|
|
}
|
|
|
|
|
|
SyncContext.PortBase=thisDev->portInfo.ioBase;
|
|
SyncContext.BitsPerSecond=bitsPerSec;
|
|
|
|
//
|
|
// since we are changeing the port bank, sync with the interrupt
|
|
//
|
|
NdisMSynchronizeWithInterrupt(
|
|
&thisDev->interruptObj,
|
|
SyncSetUARTSpeed,
|
|
&SyncContext
|
|
);
|
|
|
|
|
|
NdisStallExecution(5000);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* SetSpeed
|
|
*************************************************************************
|
|
*
|
|
*
|
|
*/
|
|
BOOLEAN SetSpeed(IrDevice *thisDev)
|
|
{
|
|
UINT bitsPerSec = thisDev->linkSpeedInfo->bitsPerSec;
|
|
BOOLEAN dongleSet, result = TRUE;
|
|
|
|
// DbgPrint("nsc: setspeed %d\n",bitsPerSec);
|
|
DBGOUT((" **** SetSpeed(%xh, %d bps) ***************************", thisDev->portInfo.ioBase, bitsPerSec));
|
|
|
|
|
|
/*
|
|
* Disable interrupts while changing speed.
|
|
* (This is especially important for the ADAPTEC dongle;
|
|
* we may get interrupted while setting command mode
|
|
* between writing 0xff and reading 0xc3).
|
|
*/
|
|
SyncSetInterruptMask(thisDev, FALSE);
|
|
|
|
/*
|
|
* First, set the UART's speed to 9600 baud.
|
|
* Some of the dongles need to receive their command sequences at this speed.
|
|
*/
|
|
SetUARTSpeed(thisDev, 9600);
|
|
|
|
dongleSet = NSC_DEMO_SetSpeed(thisDev, thisDev->portInfo.ioBase, bitsPerSec, thisDev->portInfo.dongleContext);
|
|
//
|
|
// debug info.
|
|
//
|
|
thisDev->portInfo.PacketsReceived_DEBUG = 0;
|
|
if (!dongleSet){
|
|
DBGERR(("Dongle set-speed failed"));
|
|
result = FALSE;
|
|
}
|
|
|
|
/*
|
|
* Now set the speed for the COM port
|
|
*/
|
|
SetUARTSpeed(thisDev, bitsPerSec);
|
|
|
|
thisDev->currentSpeed = bitsPerSec;
|
|
|
|
DebugSpeed=bitsPerSec;
|
|
|
|
SyncSetInterruptMask(thisDev, TRUE);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* StepSendFSM
|
|
*************************************************************************
|
|
*
|
|
*
|
|
* Step the send fsm to send a few more bytes of an IR frame.
|
|
* Return TRUE only after an entire frame has been sent.
|
|
*
|
|
*/
|
|
BOOLEAN StepSendFSM(IrDevice *thisDev)
|
|
{
|
|
UINT i, bytesAtATime, startPos = thisDev->portInfo.writeBufPos;
|
|
UCHAR lineStatReg;
|
|
BOOLEAN result;
|
|
UINT maxLoops;
|
|
|
|
/*
|
|
* Ordinarily, we want to fill the send FIFO once per interrupt.
|
|
* However, at high speeds the interrupt latency is too slow and
|
|
* we need to poll inside the ISR to send the whole packet during
|
|
* the first interrupt.
|
|
*/
|
|
if (thisDev->currentSpeed > 115200){
|
|
maxLoops = REG_TIMEOUT_LOOPS;
|
|
}
|
|
else {
|
|
maxLoops = REG_POLL_LOOPS;
|
|
}
|
|
|
|
|
|
/*
|
|
* Write databytes as long as we have them and the UART's FIFO hasn't filled up.
|
|
*/
|
|
while (thisDev->portInfo.writeBufPos < thisDev->portInfo.writeBufLen){
|
|
|
|
/*
|
|
* If this COM port has a FIFO, we'll send up to the FIFO size (16 bytes).
|
|
* Otherwise, we can only send one byte at a time.
|
|
*/
|
|
if (thisDev->portInfo.haveFIFO){
|
|
bytesAtATime = MIN(FIFO_SIZE, (thisDev->portInfo.writeBufLen - thisDev->portInfo.writeBufPos));
|
|
}
|
|
else {
|
|
bytesAtATime = 1;
|
|
}
|
|
|
|
|
|
/*
|
|
* Wait for ready-to-send.
|
|
*/
|
|
i = 0;
|
|
do {
|
|
lineStatReg = GetCOMPort(thisDev->portInfo.ioBase, LINE_STAT_REG_OFFSET);
|
|
} while (!(lineStatReg & LINESTAT_XMIT_HOLDING_REG_EMPTY) && (++i < maxLoops));
|
|
if (!(lineStatReg & LINESTAT_XMIT_HOLDING_REG_EMPTY)){
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Send the next byte or FIFO-volume of bytes.
|
|
*/
|
|
for (i = 0; i < bytesAtATime; i++){
|
|
SetCOMPort( thisDev->portInfo.ioBase,
|
|
XFER_REG_OFFSET,
|
|
thisDev->portInfo.writeBuf[thisDev->portInfo.writeBufPos++]);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* The return value will indicate whether we've sent the entire frame.
|
|
*/
|
|
if (thisDev->portInfo.writeBufPos >= thisDev->portInfo.writeBufLen){
|
|
|
|
if (thisDev->setSpeedAfterCurrentSendPacket){
|
|
/*
|
|
* We'll be changing speeds after this packet,
|
|
* so poll until the packet bytes have been completely sent out the FIFO.
|
|
* After the 16550 says that it is empty, there may still be one remaining
|
|
* byte in the FIFO, so flush it out by sending one more BOF.
|
|
*/
|
|
i = 0;
|
|
do {
|
|
lineStatReg = GetCOMPort(thisDev->portInfo.ioBase, LINE_STAT_REG_OFFSET);
|
|
} while (!(lineStatReg & 0x20) && (++i < REG_TIMEOUT_LOOPS));
|
|
|
|
SetCOMPort(thisDev->portInfo.ioBase, XFER_REG_OFFSET, (UCHAR)SLOW_IR_EXTRA_BOF);
|
|
i = 0;
|
|
do {
|
|
lineStatReg = GetCOMPort(thisDev->portInfo.ioBase, LINE_STAT_REG_OFFSET);
|
|
} while (!(lineStatReg & 0x20) && (++i < REG_TIMEOUT_LOOPS));
|
|
}
|
|
|
|
result = TRUE;
|
|
}
|
|
else {
|
|
result = FALSE;
|
|
}
|
|
|
|
DBGOUT(("StepSendFSM wrote %d bytes (%s):", (UINT)(thisDev->portInfo.writeBufPos-startPos), (PUCHAR)(result ? "DONE" : "not done")));
|
|
// DBGPRINTBUF(thisDev->portInfo.writeBuf+startPos, thisDev->portInfo.writeBufPos-startPos);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* StepReceiveFSM
|
|
*************************************************************************
|
|
*
|
|
*
|
|
* Step the receive fsm to read in a piece of an IR frame;
|
|
* strip the BOFs and EOF, and eliminate escape sequences.
|
|
* Return TRUE only after an entire frame has been read in.
|
|
*
|
|
*/
|
|
BOOLEAN StepReceiveFSM(IrDevice *thisDev)
|
|
{
|
|
UINT rawBufPos, rawBytesRead;
|
|
BOOLEAN result;
|
|
UCHAR thisch;
|
|
PLIST_ENTRY pListEntry;
|
|
|
|
DBGOUT(("StepReceiveFSM(%xh)", thisDev->portInfo.ioBase));
|
|
|
|
/*
|
|
* Read in and process groups of incoming bytes from the FIFO.
|
|
* NOTE: We have to loop once more after getting MAX_RCV_DATA_SIZE
|
|
* bytes so that we can see the 'EOF'; hence <= and not <.
|
|
*/
|
|
while ((thisDev->portInfo.rcvState != STATE_SAW_EOF) && (thisDev->portInfo.readBufPos <= MAX_RCV_DATA_SIZE)){
|
|
|
|
if (thisDev->portInfo.rcvState == STATE_CLEANUP){
|
|
/*
|
|
* We returned a complete packet last time, but we had read some
|
|
* extra bytes, which we stored into the rawBuf after returning
|
|
* the previous complete buffer to the user.
|
|
* So instead of calling DoRcvDirect in this first execution of this loop,
|
|
* we just use these previously-read bytes.
|
|
* (This is typically only 1 or 2 bytes).
|
|
*/
|
|
rawBytesRead = thisDev->portInfo.readBufPos;
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
thisDev->portInfo.readBufPos = 0;
|
|
}
|
|
else {
|
|
rawBytesRead = DoRcvDirect(thisDev->portInfo.ioBase, thisDev->portInfo.rawBuf, FIFO_SIZE);
|
|
if (rawBytesRead == (UINT)-1){
|
|
/*
|
|
* Receive error occurred. Go back to INIT state.
|
|
*/
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
thisDev->portInfo.readBufPos = 0;
|
|
continue;
|
|
}
|
|
else if (rawBytesRead == 0){
|
|
/*
|
|
* No more receive bytes. Break out.
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Let the receive state machine process this group of characters
|
|
* we got from the FIFO.
|
|
*
|
|
* NOTE: We have to loop once more after getting MAX_RCV_DATA_SIZE
|
|
* bytes so that we can see the 'EOF'; hence <= and not <.
|
|
*/
|
|
for (rawBufPos = 0;
|
|
((thisDev->portInfo.rcvState != STATE_SAW_EOF) &&
|
|
(rawBufPos < rawBytesRead) &&
|
|
(thisDev->portInfo.readBufPos <= MAX_RCV_DATA_SIZE));
|
|
rawBufPos++){
|
|
|
|
thisch = thisDev->portInfo.rawBuf[rawBufPos];
|
|
|
|
switch (thisDev->portInfo.rcvState){
|
|
|
|
case STATE_INIT:
|
|
switch (thisch){
|
|
case SLOW_IR_BOF:
|
|
thisDev->portInfo.rcvState = STATE_GOT_BOF;
|
|
break;
|
|
case SLOW_IR_EOF:
|
|
case SLOW_IR_ESC:
|
|
default:
|
|
/*
|
|
* This is meaningless garbage. Scan past it.
|
|
*/
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case STATE_GOT_BOF:
|
|
switch (thisch){
|
|
case SLOW_IR_BOF:
|
|
break;
|
|
case SLOW_IR_EOF:
|
|
/*
|
|
* Garbage
|
|
*/
|
|
DBGERR(("EOF in absorbing-BOFs state in DoRcv"));
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
break;
|
|
case SLOW_IR_ESC:
|
|
/*
|
|
* Start of data.
|
|
* Our first data byte happens to be an ESC sequence.
|
|
*/
|
|
thisDev->portInfo.readBufPos = 0;
|
|
thisDev->portInfo.rcvState = STATE_ESC_SEQUENCE;
|
|
break;
|
|
default:
|
|
thisDev->portInfo.readBuf[0] = thisch;
|
|
thisDev->portInfo.readBufPos = 1;
|
|
thisDev->portInfo.rcvState = STATE_ACCEPTING;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case STATE_ACCEPTING:
|
|
switch (thisch){
|
|
case SLOW_IR_BOF:
|
|
/*
|
|
* Meaningless garbage
|
|
*/
|
|
DBGOUT(("WARNING: BOF during accepting state in DoRcv"));
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
thisDev->portInfo.readBufPos = 0;
|
|
break;
|
|
case SLOW_IR_EOF:
|
|
if (thisDev->portInfo.readBufPos <
|
|
IR_ADDR_SIZE+IR_CONTROL_SIZE+SLOW_IR_FCS_SIZE){
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
thisDev->portInfo.readBufPos = 0;
|
|
}
|
|
else {
|
|
thisDev->portInfo.rcvState = STATE_SAW_EOF;
|
|
}
|
|
break;
|
|
case SLOW_IR_ESC:
|
|
thisDev->portInfo.rcvState = STATE_ESC_SEQUENCE;
|
|
break;
|
|
default:
|
|
thisDev->portInfo.readBuf[thisDev->portInfo.readBufPos++] = thisch;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case STATE_ESC_SEQUENCE:
|
|
switch (thisch){
|
|
case SLOW_IR_EOF:
|
|
case SLOW_IR_BOF:
|
|
case SLOW_IR_ESC:
|
|
/*
|
|
* ESC + {EOF|BOF|ESC} is an abort sequence
|
|
*/
|
|
DBGERR(("DoRcv - abort sequence; ABORTING IR PACKET: (got following packet + ESC,%xh)", (UINT)thisch));
|
|
DBGPRINTBUF(thisDev->portInfo.readBuf, thisDev->portInfo.readBufPos);
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
thisDev->portInfo.readBufPos = 0;
|
|
break;
|
|
|
|
case SLOW_IR_EOF^SLOW_IR_ESC_COMP:
|
|
case SLOW_IR_BOF^SLOW_IR_ESC_COMP:
|
|
case SLOW_IR_ESC^SLOW_IR_ESC_COMP:
|
|
thisDev->portInfo.readBuf[thisDev->portInfo.readBufPos++] = thisch ^ SLOW_IR_ESC_COMP;
|
|
thisDev->portInfo.rcvState = STATE_ACCEPTING;
|
|
break;
|
|
|
|
default:
|
|
DBGERR(("Unnecessary escape sequence: (got following packet + ESC,%xh", (UINT)thisch));
|
|
DBGPRINTBUF(thisDev->portInfo.readBuf, thisDev->portInfo.readBufPos);
|
|
|
|
thisDev->portInfo.readBuf[thisDev->portInfo.readBufPos++] = thisch ^ SLOW_IR_ESC_COMP;
|
|
thisDev->portInfo.rcvState = STATE_ACCEPTING;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case STATE_SAW_EOF:
|
|
default:
|
|
DBGERR(("Illegal state in DoRcv"));
|
|
thisDev->portInfo.readBufPos = 0;
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Set result and do any post-cleanup.
|
|
*/
|
|
switch (thisDev->portInfo.rcvState){
|
|
|
|
case STATE_SAW_EOF:
|
|
/*
|
|
* We've read in the entire packet.
|
|
* Queue it and return TRUE.
|
|
*/
|
|
DBGOUT((" *** DoRcv returning with COMPLETE packet, read %d bytes ***", thisDev->portInfo.readBufPos));
|
|
|
|
if (!IsListEmpty(&thisDev->rcvBufBuf))
|
|
{
|
|
QueueReceivePacket(thisDev, thisDev->portInfo.readBuf, thisDev->portInfo.readBufPos, FALSE);
|
|
|
|
// The protocol has our buffer. Get a new one.
|
|
#if 1
|
|
pListEntry = RemoveHeadList(&thisDev->rcvBufBuf);
|
|
thisDev->portInfo.readBuf = LIST_ENTRY_TO_RCV_BUF(pListEntry);
|
|
#else
|
|
thisDev->portInfo.readBuf = (PVOID)RemoveHeadList(&thisDev->rcvBufBuf);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
// No new buffers were available. We just discard this packet.
|
|
DBGERR(("No rcvBufBuf available, discarding packet\n"));
|
|
}
|
|
|
|
result = TRUE;
|
|
|
|
if (rawBufPos < rawBytesRead){
|
|
/*
|
|
* This is ugly.
|
|
* We have some more unprocessed bytes in the raw buffer.
|
|
* Move these to the beginning of the raw buffer
|
|
* go to the CLEANUP state, which indicates that these
|
|
* bytes be used up during the next call.
|
|
* (This is typically only 1 or 2 bytes).
|
|
* Note: We can't just leave these in the raw buffer because
|
|
* we might be supporting connections to multiple COM ports.
|
|
*/
|
|
memcpy(thisDev->portInfo.rawBuf, &thisDev->portInfo.rawBuf[rawBufPos], rawBytesRead-rawBufPos);
|
|
thisDev->portInfo.readBufPos = rawBytesRead-rawBufPos;
|
|
thisDev->portInfo.rcvState = STATE_CLEANUP;
|
|
}
|
|
else {
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (thisDev->portInfo.readBufPos > MAX_RCV_DATA_SIZE){
|
|
DBGERR(("Overrun in DoRcv : read %d=%xh bytes:", thisDev->portInfo.readBufPos, thisDev->portInfo.readBufPos));
|
|
DBGPRINTBUF(thisDev->portInfo.readBuf, thisDev->portInfo.readBufPos);
|
|
thisDev->portInfo.readBufPos = 0;
|
|
thisDev->portInfo.rcvState = STATE_INIT;
|
|
}
|
|
else {
|
|
DBGOUT(("DoRcv returning with partial packet, read %d bytes", thisDev->portInfo.readBufPos));
|
|
}
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* COM_ISR
|
|
*************************************************************************
|
|
*
|
|
*
|
|
*/
|
|
VOID COM_ISR(IrDevice *thisDev, BOOLEAN *claimingInterrupt, BOOLEAN *requireDeferredCallback)
|
|
{
|
|
|
|
LONG NewCount;
|
|
/*
|
|
* Get the interrupt status register value.
|
|
*/
|
|
UCHAR intId = GetCOMPort(thisDev->portInfo.ioBase, INT_ID_AND_FIFO_CNTRL_REG_OFFSET);
|
|
|
|
|
|
|
|
if (intId & INTID_INTERRUPT_NOT_PENDING){
|
|
/*
|
|
* This is NOT our interrupt.
|
|
* Set carry bit to pass the interrupt to the next driver in the chain.
|
|
*/
|
|
*claimingInterrupt = *requireDeferredCallback = FALSE;
|
|
}
|
|
else {
|
|
/*
|
|
* This is our interrupt
|
|
*/
|
|
|
|
/*
|
|
* In some odd situations, we can get interrupt bits that don't
|
|
* get cleared; we don't want to loop forever in this case, so keep a counter.
|
|
*/
|
|
UINT loops = 0;
|
|
|
|
*claimingInterrupt = TRUE;
|
|
*requireDeferredCallback = FALSE;
|
|
|
|
while (!(intId & INTID_INTERRUPT_NOT_PENDING) && (loops++ < 0x10)){
|
|
|
|
switch (intId & INTID_INTIDMASK){
|
|
|
|
case INTID_MODEMSTAT_INT:
|
|
DBGOUT(("COM INTERRUPT: modem status int"));
|
|
GetCOMPort(thisDev->portInfo.ioBase, MODEM_STAT_REG_OFFSET);
|
|
break;
|
|
|
|
case INTID_XMITREG_INT:
|
|
DBGOUT(("COM INTERRUPT: xmit reg empty"));
|
|
|
|
if (thisDev->portInfo.SirWritePending){
|
|
|
|
/*
|
|
* Try to send a few more bytes
|
|
*/
|
|
if (StepSendFSM(thisDev)){
|
|
|
|
/*
|
|
* There are no more bytes to send;
|
|
* reset interrupts for receive mode.
|
|
*/
|
|
thisDev->portInfo.SirWritePending = FALSE;
|
|
InterlockedExchange(&thisDev->portInfo.IsrDoneWithPacket,1);
|
|
|
|
//
|
|
// this will unmask the receive interrupt
|
|
//
|
|
SetCOMInterrupts(thisDev, TRUE);
|
|
|
|
/*
|
|
* Request a DPC so that we can try
|
|
* to send other pending write packets.
|
|
*/
|
|
*requireDeferredCallback = TRUE;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case INTID_RCVDATAREADY_INT:
|
|
DBGOUT(("COM INTERRUPT: rcv data available!"));
|
|
|
|
thisDev->nowReceiving = TRUE;
|
|
|
|
NewCount=NdisInterlockedIncrement(&thisDev->RxInterrupts);
|
|
|
|
if (!thisDev->mediaBusy && (NewCount > MEDIA_BUSY_THRESHOLD)){
|
|
|
|
thisDev->mediaBusy = TRUE;
|
|
thisDev->haveIndicatedMediaBusy = FALSE;
|
|
*requireDeferredCallback = TRUE;
|
|
}
|
|
|
|
if (StepReceiveFSM(thisDev)){
|
|
/*
|
|
* The receive engine has accumulated an entire frame.
|
|
* Request a deferred callback so we can deliver the frame
|
|
* when not in interrupt context.
|
|
*/
|
|
*requireDeferredCallback = TRUE;
|
|
thisDev->nowReceiving = FALSE;
|
|
}
|
|
|
|
break;
|
|
|
|
case INTID_RCVLINESTAT_INT:
|
|
DBGOUT(("COM INTERRUPT: rcv line stat int!"));
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* After we service each interrupt condition, we read the line status register.
|
|
* This clears the current interrupt, and a new interrupt may then appear in
|
|
* the interrupt-id register.
|
|
*/
|
|
GetCOMPort(thisDev->portInfo.ioBase, LINE_STAT_REG_OFFSET);
|
|
intId = GetCOMPort(thisDev->portInfo.ioBase, INT_ID_AND_FIFO_CNTRL_REG_OFFSET);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
*************************************************************************
|
|
* OpenCOM
|
|
*************************************************************************
|
|
*
|
|
* Initialize UART registers
|
|
*
|
|
*/
|
|
BOOLEAN OpenCOM(IrDevice *thisDev)
|
|
{
|
|
BOOLEAN dongleInit;
|
|
UCHAR intIdReg;
|
|
|
|
DBGOUT(("-> OpenCOM"));
|
|
|
|
//
|
|
// Make sure bank zero is selected
|
|
//
|
|
NdisRawWritePortUchar(thisDev->portInfo.ioBase+LCR_BSR_OFFSET, 03);
|
|
|
|
/*
|
|
* Disable all COM interrupts while setting up.
|
|
*/
|
|
SyncSetInterruptMask(thisDev, FALSE);
|
|
|
|
/*
|
|
* Set request-to-send and clear data-terminal-ready.
|
|
* Note: ** Bit 3 must be set to enable interrupts.
|
|
*/
|
|
SYNC_SET_COMM_PORT(&thisDev->interruptObj,thisDev->portInfo.ioBase, MODEM_CONTROL_REG_OFFSET, 0x0A);
|
|
|
|
/*
|
|
* Set dongle- or part-specific info to default
|
|
*/
|
|
thisDev->portInfo.hwCaps.supportedSpeedsMask = ALL_SLOW_IRDA_SPEEDS;
|
|
thisDev->portInfo.hwCaps.turnAroundTime_usec = DEFAULT_TURNAROUND_usec;
|
|
thisDev->portInfo.hwCaps.extraBOFsRequired = 0;
|
|
|
|
/*
|
|
* Set the COM port speed to the default 9600 baud.
|
|
* Some dongles can only receive cmd sequences at this speed.
|
|
*/
|
|
SetUARTSpeed(thisDev, 9600);
|
|
|
|
dongleInit = NSC_DEMO_Init( thisDev );
|
|
|
|
/*
|
|
* Set request-to-send and clear data-terminal-ready.
|
|
* Note: ** Bit 3 must be set to enable interrupts.
|
|
*/
|
|
SYNC_SET_COMM_PORT(&thisDev->interruptObj,thisDev->portInfo.ioBase, MODEM_CONTROL_REG_OFFSET, 0x0A);
|
|
|
|
if (!dongleInit){
|
|
DBGERR(("Dongle-specific init failed in OpenCOM"));
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Set speed to default for the entire part.
|
|
* (This is redundant in most, but not all, cases.)
|
|
*/
|
|
thisDev->linkSpeedInfo = &supportedBaudRateTable[BAUDRATE_9600];;
|
|
SetSpeed(thisDev);
|
|
|
|
/*
|
|
* Clear the FIFO control register
|
|
*/
|
|
SYNC_SET_COMM_PORT(&thisDev->interruptObj,thisDev->portInfo.ioBase, INT_ID_AND_FIFO_CNTRL_REG_OFFSET, 0x00);
|
|
|
|
/*
|
|
* Set up the FIFO control register to use both read and write FIFOs (if 16650),
|
|
* and with a receive FIFO trigger level of 1 byte.
|
|
*/
|
|
SYNC_SET_COMM_PORT(&thisDev->interruptObj,thisDev->portInfo.ioBase, INT_ID_AND_FIFO_CNTRL_REG_OFFSET, 0x07);
|
|
|
|
/*
|
|
* Check whether we're running on a 16550,which has a 16-byte write FIFO.
|
|
* In this case, we'll be able to blast up to 16 bytes at a time.
|
|
*/
|
|
intIdReg = SYNC_GET_COMM_PORT(&thisDev->interruptObj,thisDev->portInfo.ioBase, INT_ID_AND_FIFO_CNTRL_REG_OFFSET);
|
|
thisDev->portInfo.haveFIFO = (BOOLEAN)((intIdReg & 0xC0) == 0xC0);
|
|
|
|
/*
|
|
* Start out in receive mode.
|
|
* We always want to be in receive mode unless we're transmitting a frame.
|
|
*/
|
|
SyncSetInterruptMask(thisDev, TRUE);
|
|
|
|
DBGOUT(("OpenCOM succeeded"));
|
|
return TRUE;
|
|
}
|
|
#if 1
|
|
/*
|
|
*************************************************************************
|
|
* CloseCOM
|
|
*************************************************************************
|
|
*
|
|
*/
|
|
VOID CloseCOM(IrDevice *thisDev)
|
|
{
|
|
/*
|
|
* Do special deinit for dongles.
|
|
* Some dongles can only rcv cmd sequences at 9600, so set this speed first.
|
|
*/
|
|
thisDev->linkSpeedInfo = &supportedBaudRateTable[BAUDRATE_9600];;
|
|
SetSpeed(thisDev);
|
|
NSC_DEMO_Deinit(thisDev->portInfo.ioBase, thisDev->portInfo.dongleContext);
|
|
|
|
SyncSetInterruptMask(thisDev, FALSE);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
*************************************************************************
|
|
* DoRcvDirect
|
|
*************************************************************************
|
|
*
|
|
* Read up to maxBytes bytes from the UART's receive FIFO.
|
|
* Return the number of bytes read or (UINT)-1 if an error occurred.
|
|
*
|
|
*/
|
|
UINT DoRcvDirect(PUCHAR ioBase, UCHAR *data, UINT maxBytes)
|
|
{
|
|
USHORT bytesRead;
|
|
UCHAR lineStatReg;
|
|
UINT i;
|
|
BOOLEAN goodChar;
|
|
|
|
for (bytesRead = 0; bytesRead < maxBytes; bytesRead++){
|
|
|
|
/*
|
|
* Wait for data-ready
|
|
*/
|
|
i = 0;
|
|
do {
|
|
lineStatReg = GetCOMPort(ioBase, LINE_STAT_REG_OFFSET);
|
|
|
|
/*
|
|
* The UART reports framing and break errors as the effected
|
|
* characters appear on the stack. We drop these characters,
|
|
* which will probably result in a bad frame checksum.
|
|
*/
|
|
if (lineStatReg & (LINESTAT_BREAK | LINESTAT_FRAMINGERROR)){
|
|
|
|
UCHAR badch = GetCOMPort(ioBase, XFER_REG_OFFSET);
|
|
DBGERR(("Bad rcv %02xh, LSR=%02xh", (UINT)badch, (UINT)lineStatReg));
|
|
return (UINT)-1;
|
|
}
|
|
else if (lineStatReg & LINESTAT_DATAREADY){
|
|
|
|
if (lineStatReg & LINESTAT_OVERRUNERROR) {
|
|
DBGERR(("Overrun"));
|
|
}
|
|
|
|
goodChar = TRUE;
|
|
}
|
|
else {
|
|
/*
|
|
* No input char ready
|
|
*/
|
|
goodChar = FALSE;
|
|
}
|
|
|
|
} while (!goodChar && (++i < REG_POLL_LOOPS));
|
|
if (!goodChar){
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Read in the next data byte
|
|
*/
|
|
data[bytesRead] = GetCOMPort(ioBase, XFER_REG_OFFSET);
|
|
}
|
|
|
|
return bytesRead;
|
|
}
|
|
|
|
/*
|
|
*************************************************************************
|
|
* GetCOMPort
|
|
*************************************************************************
|
|
*/
|
|
UCHAR GetCOMPort(PUCHAR comBase, comPortRegOffset portOffset)
|
|
{
|
|
UCHAR val;
|
|
#if DBG
|
|
{
|
|
UCHAR TempVal;
|
|
//
|
|
// This code assumes that bank 0 is current, we will make sure of that
|
|
//
|
|
NdisRawReadPortUchar(comBase+LCR_BSR_OFFSET, &TempVal);
|
|
|
|
ASSERT((TempVal & BKSE) == 0);
|
|
}
|
|
#endif
|
|
|
|
NdisRawReadPortUchar(comBase+portOffset, &val);
|
|
return val;
|
|
}
|
|
|
|
/*
|
|
*************************************************************************
|
|
* SetCOMPort
|
|
*************************************************************************
|
|
*/
|
|
VOID SetCOMPort(PUCHAR comBase, comPortRegOffset portOffset, UCHAR val)
|
|
{
|
|
|
|
#if DBG
|
|
UCHAR TempVal;
|
|
|
|
|
|
//
|
|
// This code assumes that bank 0 is current, we will make sure of that
|
|
//
|
|
NdisRawReadPortUchar(comBase+LCR_BSR_OFFSET, &TempVal);
|
|
|
|
ASSERT((TempVal & BKSE) == 0);
|
|
#endif
|
|
|
|
NdisRawWritePortUchar(comBase+portOffset, val);
|
|
}
|