windows-xp/Source/XPSP1/NT/net/irda/irsir/receive.c

/*****************************************************************************
*
*  Copyright (c) 1996-1999 Microsoft Corporation
*
*       @doc
*       @module   receive.c | IrSIR NDIS Miniport Driver
*       @comm
*
*-----------------------------------------------------------------------------
*
*       Author:   Scott Holden (sholden)
*
*       Date:     10/4/1996 (created)
*
*       Contents:
*
*****************************************************************************/

#include "irsir.h"

VOID
SetSpeedCallback(
    PIR_WORK_ITEM pWorkItem
    );




#if LOGGING
ULONG LogIndex = 0;
LOG   Log[NUM_LOG];
#endif

#ifdef DEBUG_IRSIR

    static ULONG_PTR irpCount;
    static ULONG_PTR bytesReceived;

#endif //DEBUG_IRSIR

//
// Declarations.
//

NTSTATUS SerialIoCompleteRead(
            IN PDEVICE_OBJECT pSerialDevObj,
            IN PIRP           pIrp,
            IN PVOID          Context
            );
NTSTATUS
SerialIoCompleteWait(
            IN PDEVICE_OBJECT pSerialDevObj,
            IN PIRP           pIrp,
            IN PVOID          Context
            );

NTSTATUS ProcessData(
            IN PIR_DEVICE pThisDev,
            IN PUCHAR     rawBuffer,
            IN UINT       rawBytesRead
            );
VOID
DeliverBuffer(
    IN  PIR_DEVICE pThisDev
    );

VOID StartSerialReadCallback(PIR_WORK_ITEM pWorkItem);

#pragma alloc_text(PAGE,SetSpeedCallback)
#pragma alloc_text(PAGE,StartSerialReadCallback)

VOID DBG_PrintBuf(PUCHAR bufptr, UINT buflen)
{
	UINT i, linei;

	#define ISPRINT(ch) (((ch) >= ' ') && ((ch) <= '~'))
	#define PRINTCHAR(ch) (UCHAR)(ISPRINT(ch) ? (ch) : '.')

	DbgPrint("\r\n         %d bytes @%x:", buflen, bufptr);

	/*
	 *  Print whole lines of 8 characters with HEX and ASCII
	 */
	for (i = 0; i+8 <= buflen; i += 8) {
		UCHAR ch0 = bufptr[i+0],
			ch1 = bufptr[i+1], ch2 = bufptr[i+2],
			ch3 = bufptr[i+3], ch4 = bufptr[i+4],
			ch5 = bufptr[i+5], ch6 = bufptr[i+6],
			ch7 = bufptr[i+7];

		DbgPrint("\r\n         %02x %02x %02x %02x %02x %02x %02x %02x"
			"   %c %c %c %c %c %c %c %c",
			ch0, ch1, ch2, ch3, ch4, ch5, ch6, ch7,
			PRINTCHAR(ch0), PRINTCHAR(ch1),
			PRINTCHAR(ch2), PRINTCHAR(ch3),
			PRINTCHAR(ch4), PRINTCHAR(ch5),
			PRINTCHAR(ch6), PRINTCHAR(ch7));
	}

	/*
	 *  Print final incomplete line
	 */
	DbgPrint("\r\n        ");
	for (linei = 0; (linei < 8) && (i < buflen); i++, linei++){
		DbgPrint(" %02x", (UINT)(bufptr[i]));
	}

	DbgPrint("  ");
	i -= linei;
	while (linei++ < 8) DbgPrint("   ");

	for (linei = 0; (linei < 8) && (i < buflen); i++, linei++){
		UCHAR ch = bufptr[i];
		DbgPrint(" %c", PRINTCHAR(ch));
	}

	DbgPrint("\t\t<>\r\n");

}


NTSTATUS StartSerialRead(IN PIR_DEVICE pThisDev)
/*++

Routine Description:

    Allocates an irp and calls the serial driver.

Arguments:

    pThisDev - Current IR device.

Return Value:

    STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver

--*/
{
    NTSTATUS    Status;
    PIRP        pIrp;

    LOG_ENTRY('SR', pThisDev, 0, 0);

#if DBG
    NdisZeroMemory(
                pThisDev->pRcvIrpBuffer,
                SERIAL_RECEIVE_BUFFER_LENGTH
                );
#endif

    //
    // Now that we have processed the irp, we will send another read
    // request to the serial device object.
    //

    pIrp = SerialBuildReadWriteIrp(
                        pThisDev->pSerialDevObj,
                        IRP_MJ_READ,
                        pThisDev->pRcvIrpBuffer,
                        SERIAL_RECEIVE_BUFFER_LENGTH,
                        NULL
                        );

    if (pIrp == NULL)
    {
        DEBUGMSG(DBG_ERR, ("    SerialBuildReadWriteIrp failed.\n"));

        Status = STATUS_INSUFFICIENT_RESOURCES;

        pThisDev->fReceiving = FALSE;

        goto done;
    }

    //
    // Set up the io completion routine for the irp.
    //

    IoSetCompletionRoutine(
                pIrp,                      // irp to use
                SerialIoCompleteRead,      // routine to call when irp is done
                DEV_TO_CONTEXT(pThisDev),  // context to pass routine
                TRUE,                      // call on success
                TRUE,                      // call on error
                TRUE);                     // call on cancel

    //
    // Call IoCallDriver to send the irp to the serial port.
    //

    LOG_ENTRY('2I', pThisDev, pIrp, 0);
    IoCallDriver(
                pThisDev->pSerialDevObj,
                pIrp
                );

    Status=STATUS_PENDING;

done:

    return Status;
}

VOID
StartSerialReadCallback(PIR_WORK_ITEM pWorkItem)
/*++

Routine Description:



Arguments:

Return Value:
    none

--*/
{
    PIR_DEVICE      pThisDev = pWorkItem->pIrDevice;

    FreeWorkItem(pWorkItem);

    (void)StartSerialRead(pThisDev);

    return;
}


/*****************************************************************************
*
*  Function:   InitializeReceive
*
*  Synopsis:   Initialize the receive functionality.
*
*  Arguments:  pThisDevice - pointer to current ir device object
*
*  Returns:    NDIS_STATUS_SUCCESS   - if irp is successfully sent to serial
*                                      device object
*              NDIS_STATUS_RESOURCES - if mem can't be alloc'd
*              NDIS_STATUS_FAILURE   - otherwise
*
*  Algorithm:
*              1) Set the receive timeout to READ_INTERVAL_TIMEOUT_MSEC.
*              2) Initialize our rcvInfo and associate info for our
*                 receive state machine.
*              3) Build an IRP_MJ_READ irp to send to the serial device
*                 object, and set the completion(or timeout) routine
*                 to SerialIoCompleteRead.
*
*  History:    dd-mm-yyyy   Author    Comment
*              10/4/1996    sholden   author
*
*  Notes:
*
*  This routine must be called in IRQL PASSIVE_LEVEL.
*
*****************************************************************************/

NDIS_STATUS
InitializeReceive(
            IN PIR_DEVICE pThisDev
            )
{
    PIRP               pIrp;
    PIO_STACK_LOCATION irpSp;
    NDIS_STATUS        status;
#if IRSIR_EVENT_DRIVEN
    NTSTATUS            NtStatus;
    SERIAL_CHARS        SerialChars;
#endif

    DEBUGMSG(DBG_FUNC, ("+InitializeReceive\n"));

#ifdef DEBUG_IRSIR

    irpCount      = 0;
    bytesReceived = 0;

#endif //DEBUG_IRSIR

    //
    // Set up the receive information for our read completion routine.
    //

    pThisDev->rcvInfo.rcvState   = RCV_STATE_READY;
    pThisDev->rcvInfo.rcvBufPos  = 0;

    if (pThisDev->rcvInfo.pRcvBuffer == NULL)
    {
        pThisDev->rcvInfo.pRcvBuffer =
                (PRCV_BUFFER)MyInterlockedRemoveHeadList(
                                        &(pThisDev->rcvFreeQueue),
                                        &(pThisDev->rcvQueueSpinLock)
                                        );

        ASSERT(pThisDev->rcvInfo.pRcvBuffer != NULL);
    }

#if IRSIR_EVENT_DRIVEN

    NtStatus = (NDIS_STATUS) SerialSetTimeouts(pThisDev->pSerialDevObj,
                                               &SerialTimeoutsActive);

    NtStatus = SerialGetChars(pThisDev->pSerialDevObj, &SerialChars);

    if (NtStatus!=STATUS_SUCCESS)
    {
        DEBUGMSG(DBG_ERROR, ("IRSIR: SerialGetChars failed (0x%x:%d)\n", NtStatus));
    }
    else
    {
        SerialChars.EventChar = SLOW_IR_EOF;

        NtStatus = SerialSetChars(pThisDev->pSerialDevObj, &SerialChars);
    }

    if (NtStatus!=STATUS_SUCCESS)
    {
        DEBUGMSG(DBG_ERROR, ("IRSIR: SerialSetChars failed (0x%x:%d)\n", NtStatus));
    }
    else
    {
        ULONG WaitMask = SERIAL_EV_RXFLAG | SERIAL_EV_RX80FULL;

        NtStatus = SerialSetWaitMask(pThisDev->pSerialDevObj, &WaitMask);
    }

    if (NtStatus!=STATUS_SUCCESS)
    {
        DEBUGMSG(DBG_ERROR, ("IRSIR: SerialSetWaitMask failed (0x%x:%d)\n", NtStatus));
    }
    else
    {
        if (InterlockedExchange(&pThisDev->fWaitPending, 1)==0)
        {
            NtStatus = SerialCallbackOnMask(pThisDev->pSerialDevObj,
                                            SerialIoCompleteWait,
                                            &pThisDev->WaitIosb,
                                            DEV_TO_CONTEXT(pThisDev),
                                            &pThisDev->MaskResult);

            if (NtStatus==STATUS_PENDING)
            {
                NtStatus = STATUS_SUCCESS;
            }
        }
    }

    if (NtStatus!=STATUS_SUCCESS)
    {
        DEBUGMSG(DBG_ERROR, ("IRSIR: SerialCallbackOnMask failed (0x%x:%d)\n", NtStatus));
        ASSERT(0);
    }

    status = NtStatus;
#else

    pThisDev->fReceiving = TRUE;

    (void)SerialSetTimeouts(pThisDev->pSerialDevObj,
                            &SerialTimeoutsIdle);

    status = (NDIS_STATUS)StartSerialRead(pThisDev);

    if ( (status != STATUS_SUCCESS) &&
         (status != STATUS_PENDING) &&
         (status != STATUS_TIMEOUT) )
    {
        DEBUGMSG(DBG_ERR, ("    IoCallDriver failed. Returned 0x%.8x\n", status));
        status = NDIS_STATUS_FAILURE;

        pThisDev->fReceiving = FALSE;

        goto error10;
    }

    //
    // If IoCallDriver returned STATUS_PENDING, we were successful
    // in sending the irp to the serial device object. This
    // routine will return STATUS_SUCCESS.
    //

    if (status == NDIS_STATUS_PENDING)
    {
        status = NDIS_STATUS_SUCCESS;
    }

    //
    // Set us into the receive state.
    //



    goto done;

    error10:

#endif
    done:
        DEBUGMSG(DBG_FUNC, ("-InitializeReceive\n"));

        return status;
}


VOID
SetSpeedCallback(
    PIR_WORK_ITEM pWorkItem
    )
{
    PIR_DEVICE      pThisDev = pWorkItem->pIrDevice;
    NDIS_STATUS     status;
    BOOLEAN         fSwitchSuccessful;
    NDIS_HANDLE     hSwitchToMiniport;

    //
    // Set speed of serial device object by request of
    // IrsirSetInformation(OID_IRDA_LINK_SPEED).
    //

    DEBUGMSG(DBG_STAT, ("    primPassive = PASSIVE_SET_SPEED\n"));

    //
    // The set speed event should not be set until a set
    // speed is required.
    //

    ASSERT(pThisDev->fPendingSetSpeed == TRUE);

    //
    // Ensure that receives and sends have been stopped.
    //

    ASSERT(pThisDev->fReceiving == FALSE);

    PausePacketProcessing(&pThisDev->SendPacketQueue,TRUE);

    //
    // We can perform the set speed now.
    //

    status = SetSpeed(pThisDev);

    if (status != STATUS_SUCCESS)
    {
        DEBUGMSG(DBG_STAT, ("    SetSpeed failed. Returned 0x%.8x\n", status));
    }

    ActivatePacketProcessing(&pThisDev->SendPacketQueue);

    pThisDev->fPendingSetSpeed = FALSE;

    {
        NdisMSetInformationComplete(
                            pThisDev->hNdisAdapter,
                            (NDIS_STATUS)status
                            );
    }


    //
    // NOTE: PassiveLevelThread is only signalled with primPassive
    //       equal to PASSIVE_SET_SPEED from the receive completion
    //       routine. After this thread is signalled, the receive
    //       completion routine is shut down...we need to start
    //       it up again.
    //

    status = InitializeReceive(pThisDev);

    if (status != STATUS_SUCCESS)
    {
        DEBUGMSG(DBG_ERROR, ("    InitializeReceive failed = 0x%.8x\n", status));

    }


    FreeWorkItem(pWorkItem);

    return;
}

/*****************************************************************************
*
*  Function:   SerialIoCompleteRead
*
*  Synopsis:
*
*  Arguments:  pSerialDevObj - pointer to the serial device object which
*                              completed the irp
*              pIrp          - the irp which was completed by the serial device
*                              object
*              Context       - the context given to IoSetCompletionRoutine
*                              before calling IoCallDriver on the irp
*                              The Context is a pointer to the ir device object.
*
*  Returns:    STATUS_MORE_PROCESSING_REQUIRED - allows the completion routine
*              (IofCompleteRequest) to stop working on the irp.
*
*  Algorithm:
*              This is the completion routine for all pending IRP_MJ_READ irps
*              sent to the serial device object.
*
*              If there is a pending halt or reset, we exit the completion
*              routine without sending another irp to the serial device object.
*
*              If there is a pending set speed, this function will wait for
*              any pending sends to complete and then perform the set speed.
*
*              If the IRP_MJ_READ irp returned either STATUS_SUCCESS or
*              STATUS_TIMEOUT, we must process any data (stripping BOFs, ESC
*              sequences, and EOF) into an NDIS_BUFFER and NDIS_PACKET.
*
*              Another irp is then built (we just re-use the incoming irp) and
*              sent to the serial device object with another IRP_MJ_READ
*              request.
*
*  History:    dd-mm-yyyy   Author    Comment
*              10/5/1996    sholden   author
*
*  Notes:
*
*  This routine is called (by the io manager) in IRQL DISPATCH_LEVEL.
*
*****************************************************************************/

NTSTATUS
SerialIoCompleteRead(
            IN PDEVICE_OBJECT pSerialDevObj,
            IN PIRP           pIrp,
            IN PVOID          Context
            )
{
    PIR_DEVICE  pThisDev;
    BOOLEAN     fSwitchSuccessful;
    NDIS_HANDLE hSwitchToMiniport;
    NTSTATUS    status;
    ULONG_PTR    BytesRead;
    BOOLEAN     NewRead = TRUE;

 //   DEBUGMSG(DBG_FUNC, ("+SerialIoCompleteRead\n"));

    //
    // The context given to IoSetCompletionRoutine is simply the the ir
    // device object pointer.
    //

    pThisDev = CONTEXT_TO_DEV(Context);

    //
    // Need to check if there is a pending halt or reset. If there is, we
    // just leave the receive completion. Since we maintain one irp associated
    // with the receive functionality, the irp will be deallocated in
    // the ir device object deinitialization routine.
    //

    if ((pThisDev->fPendingHalt  == TRUE) ||
        (pThisDev->fPendingReset == TRUE))
    {
        //
        // Set the fReceiving boolean so that the halt and reset routines
        // know when it is okay to continue.
        //

        pThisDev->fReceiving = FALSE;

        //
        // Free the irp and associate memory...the rest will be
        // freed in the halt or reset.
        //

        LOG_ENTRY('3i', pThisDev, pIrp, 0);
        IoFreeIrp(pIrp);

        goto done;
    }

    //
    // Next we take care of any pending set speeds.
    //

    //
    // This completion routine is running at IRQL DISPATCH_LEVEL. Therefore,
    // we cannot make a synchronous call to the serial driver. Set an event
    // to notify the PassiveLevelThread to perform the speed change. We will
    // exit this without creating another irp to the serial device object.
    // PassiveLevelThread will call InitializeReceive after the speed has
    // been set.
    //

    if (pThisDev->fPendingSetSpeed == TRUE)
    {
        pThisDev->fReceiving = FALSE;

        if (ScheduleWorkItem(PASSIVE_SET_SPEED, pThisDev,
                    SetSpeedCallback, NULL, 0) != NDIS_STATUS_SUCCESS)
        {
            status = NDIS_STATUS_SUCCESS;
        }
        else
        {
            status = NDIS_STATUS_PENDING;
        }

        LOG_ENTRY('4i', pThisDev, pIrp, 0);
        IoFreeIrp(pIrp);

        goto done;
    }

    //
    // We have a number of cases:
    //      1) The serial read timed out and we received no data.
    //      2) The serial read timed out and we received some data.
    //      3) The serial read was successful and fully filled our irp buffer.
    //      4) The irp was cancelled.
    //      5) Some other failure from the serial device object.
    //


    status = pIrp->IoStatus.Status;
    BytesRead = pIrp->IoStatus.Information;
    LOG_ENTRY('CR', pThisDev, BytesRead, 0);

    switch (status)
    {
        case STATUS_SUCCESS:
        case STATUS_TIMEOUT:

            if (BytesRead > 0)
            {
            #ifdef DEBUG_IRSIR

                //
                // Count number of irps received with data. Count will be
                // reset when delivering a buffer to the protocol.
                //

                irpCount++;
                bytesReceived += pIrp->IoStatus.Information;

            #endif //DEBUG_IRSIR

                //
                // Indicate that the next send should implement
                // the min turnaround delay.
                //

                pThisDev->fRequireMinTurnAround = TRUE;

                ProcessData(
                            pThisDev,
                            pThisDev->pRcvIrpBuffer,
                            (UINT) pIrp->IoStatus.Information
                            );
            }

            break; // STATUS_SUCCESS || STATUS_TIMEOUT

        case STATUS_DELETE_PENDING:
            NewRead = FALSE;
            pThisDev->fReceiving = FALSE;
            break;

        case STATUS_CANCELLED:
            //
            // If our irp was cancelled, we just ignore and continue as if
            // we processed data.
            //

            break;

        case STATUS_PENDING:
        case STATUS_UNSUCCESSFUL:
        case STATUS_INSUFFICIENT_RESOURCES:
        default:

            ASSERT(FALSE);

            break;
    }

    //
    // Free the irp and reinit the buffer and status block.
    //

    LOG_ENTRY('5i', pThisDev, pIrp, 0);
    IoFreeIrp(pIrp);

    if (NewRead)
    {
        pThisDev->NumReads++;

        if (InterlockedIncrement(&pThisDev->ReadRecurseLevel)>1)
        {
            if (ScheduleWorkItem(0, pThisDev, StartSerialReadCallback, 0, 0)!=NDIS_STATUS_SUCCESS)
            {
                DEBUGMSG(DBG_ERR, ("IRSIR:SerialIoCompleteRead: Timed out and couldn't reschedule read.\n"
                                   "      We're going down.\n"));
                pThisDev->fReceiving = FALSE;
            }
        }
        else
        {
            StartSerialRead(pThisDev);
        }

        InterlockedDecrement(&pThisDev->ReadRecurseLevel);
    }

done:
//        DEBUGMSG(DBG_FUNC, ("-SerialIoCompleteRead\n"));

        //
        // We return STATUS_MORE_PROCESSING_REQUIRED so that the completion
        // routine (IofCompleteRequest) will stop working on the irp.
        //

        status = STATUS_MORE_PROCESSING_REQUIRED;

        return status;
}

/*****************************************************************************
*
*  Function:   ProcessData
*
*  Synopsis:   State machine to process the input data by stripping BOFs, EOFs
*              and ESC sequences in the data.
*
*  Arguments:  pThisDev     - a pointer to the current ir device object
*              rawBuffer    - a pointer to the input data to process
*              rawBytesRead - the number of bytes in rawBuffer
*
*  Returns:    STATUS_SUCCESS
*
*  Algorithm:
*
*      The state machine for receiving characters is as follows:
*
*      -------------------------------------------------------------------
*      | Event/State    || READY     | BOF       | IN_ESC    | RX        |
*      -------------------------------------------------------------------
*      -------------------------------------------------------------------
*      |                ||           |           |           |           |
*      | char = BOF     || state =   |           | reset     | reset     |
*      |                ||   BOF     |           | state =   | state =   |
*      |                ||           |           |   BOF     |   BOF     |
*      -------------------------------------------------------------------
*      |                ||           |           | error     |           |
*      | char = ESC     ||           | state =   | reset     | state =   |
*      |                ||           |   IN_ESC  | state =   |   IN_ESC  |
*      |                ||           |           |   READY   |           |
*      -------------------------------------------------------------------
*      |                ||           |           |           | if valid  |
*      | char = EOF     ||           |  state =  | error     |   FCS {   |
*      |                ||           |    READY  | reset     | indicate  |
*      |                ||           |           | state =   |   data    |
*      |                ||           |           |   READY   | state =   |
*      |                ||           |           |           |   READY } |
*      -------------------------------------------------------------------
*      |                ||           |           | complement|           |
*      | char =         ||           |  state =  | bit 6 of  | data[] =  |
*      |                ||           |    RX     | char      |   char    |
*      |                ||           |           | data[] =  |           |
*      |                ||           |  data[] = |   char    |           |
*      |                ||           |    char   | state =   |           |
*      |                ||           |           |   RX      |           |
*      -------------------------------------------------------------------
*
*  History:    dd-mm-yyyy   Author    Comment
*              10/7/1996    sholden   author
*
*  Notes:
*
*
*****************************************************************************/

NTSTATUS
ProcessData(
            IN PIR_DEVICE pThisDev,
            IN PUCHAR     rawBuffer,
            IN UINT       rawBytesRead
            )
{
    UINT     rawBufPos;
    UCHAR    currentChar;
    PUCHAR   pReadBuffer;
    NTSTATUS status;

#if DBG

    int      i = 0;

#endif //DBG

    DEBUGMSG(DBG_FUNC, ("+ProcessData\n"));
    DBGTIME("+ProcessData");
    DEBUGMSG(DBG_OUT, ("    Address: 0x%.8x, Length: %d\n", rawBuffer, rawBytesRead));

    LOG_ENTRY('DP', pThisDev, rawBuffer, rawBytesRead);
    status = STATUS_SUCCESS;

    pReadBuffer  = pThisDev->rcvInfo.pRcvBuffer->dataBuf;

    //
    // While there is data in the buffer which we have not processed.
    //

    //
    // NOTE: We have to loop once more after getting MAX_RCV_DATA_SIZE bytes
    //       so that we can see the 'EOF'; hence the <= and not <.
    //       Also, to ensure that we don't overrun the buffer,
    //       RCV_BUFFER_SIZE = MAX_RCV_DATA_SIZE + 4;
    //

    for (
        rawBufPos = 0;
        (rawBufPos < rawBytesRead) && (pThisDev->rcvInfo.rcvBufPos <= MAX_RCV_DATA_SIZE);
        rawBufPos++
        )
    {
    #if DBG

        i++;

        if (i > 10000)
        {
            ASSERT(0);
        }

    #endif //DBG

        currentChar = rawBuffer[rawBufPos];

        switch (pThisDev->rcvInfo.rcvState)
        {
            case RCV_STATE_READY:

                switch (currentChar)
                {
                    case SLOW_IR_BOF:

                        pThisDev->rcvInfo.rcvState = RCV_STATE_BOF;

                        break;

                    case SLOW_IR_EOF:
                    case SLOW_IR_ESC:
                    default:

                        //
                        // Ignore this data.
                        //

                        break;
                }

                break; // RCV_STATE_READY

            case RCV_STATE_BOF:

                switch (currentChar)
                {
                    case SLOW_IR_EOF:

                        pThisDev->rcvInfo.rcvState = RCV_STATE_READY;
                        pThisDev->rcvInfo.rcvBufPos = 0;

                        break;

                    case SLOW_IR_ESC:

                        pThisDev->rcvInfo.rcvState  = RCV_STATE_IN_ESC;
                        pThisDev->rcvInfo.rcvBufPos = 0;

                        break;

                    case SLOW_IR_BOF:

                        //
                        // state = RCV_STATE_BOF
                        //

                        break;

                    default:

                        //
                        // We have data, copy the character into the buffer and
                        // change our state to RCV_STATE_RX.
                        //

                        pReadBuffer[0] = currentChar;

                        pThisDev->rcvInfo.rcvState  = RCV_STATE_RX;
                        pThisDev->rcvInfo.rcvBufPos = 1;

                        break;
                }

                break; // RCV_STATE_BOF

            case RCV_STATE_IN_ESC:

                switch (currentChar)
                {
                    //
                    // ESC + (ESC||EOF||BOF) is an abort sequence.
                    //
                    // If ESC + (ESC||EOF) then state = READY.
                    // If ESC + BOF        then state = BOF.
                    //

                    case SLOW_IR_ESC:
                    case SLOW_IR_EOF:

                        pThisDev->rcvInfo.rcvState  = RCV_STATE_READY;
                        pThisDev->rcvInfo.rcvBufPos = 0;

                        break;

                    case SLOW_IR_BOF:

                        pThisDev->rcvInfo.rcvState  = RCV_STATE_BOF;
                        pThisDev->rcvInfo.rcvBufPos = 0;

                        break;

                    case SLOW_IR_BOF^SLOW_IR_ESC_COMP:
                    case SLOW_IR_ESC^SLOW_IR_ESC_COMP:
                    case SLOW_IR_EOF^SLOW_IR_ESC_COMP:

                        //
                        // Escape sequence for BOF, ESC or EOF chars.
                        //

                        //
                        // Fall through, do same as unnecessary escape
                        // sequence.
                        //

                    default:

                        //
                        // Unnecessary escape sequence, copy the data in to the buffer
                        // we must complement bit 6 of the data.
                        //

                        pReadBuffer[pThisDev->rcvInfo.rcvBufPos++] =
                                    currentChar ^ SLOW_IR_ESC_COMP;
                        pThisDev->rcvInfo.rcvState = RCV_STATE_RX;

                        break;
                }

                break; // RCV_STATE_IN_ESC

            case RCV_STATE_RX:

                switch (currentChar)
                {
                    case SLOW_IR_BOF:

                        //
                        // Reset.
                        //

                        pThisDev->rcvInfo.rcvState  = RCV_STATE_BOF;
                        pThisDev->rcvInfo.rcvBufPos = 0;

                        break;

                    case SLOW_IR_ESC:

                        pThisDev->rcvInfo.rcvState = RCV_STATE_IN_ESC;

                        break;

                    case SLOW_IR_EOF:

                        if (pThisDev->rcvInfo.rcvBufPos <
                            (SLOW_IR_ADDR_SIZE + SLOW_IR_CONTROL_SIZE +
                             SLOW_IR_FCS_SIZE)
                            )
                        {
                            //
                            // Reset. Not enough data.
                            //
                            pThisDev->rcvInfo.rcvState  = RCV_STATE_READY;
                            pThisDev->rcvInfo.rcvBufPos = 0;

                            break;
                        }

                        //
                        // Need to set the length to the proper amount.
                        // (It isn't rcvBufPos + 1 since it was incremented
                        // the next free location...which we are not using.)
                        //

                        pThisDev->rcvInfo.pRcvBuffer->dataLen =
                                    pThisDev->rcvInfo.rcvBufPos;


                        DEBUGMSG(DBG_OUT, ("    RcvBuffer = 0x%.8x, Length = %d\n",
                                        pReadBuffer,
                                        pThisDev->rcvInfo.rcvBufPos
                                        ));

                        //
                        // DeliverBuffer attempts to deliver the current
                        // frame in pThisDev->rcvInfo. If the ownership
                        // of the packet is retained by the protocol, the
                        // DeliverBuffer routine gives us a new receive
                        // buffer.
                        //

                        DeliverBuffer(
                            pThisDev
                            );

                        //
                        // Since DeliverBuffer could have given us a new
                        // buffer, we must update our pReadBuffer pointer.
                        //

                        pReadBuffer  = pThisDev->rcvInfo.pRcvBuffer->dataBuf;

                        pThisDev->rcvInfo.rcvState  = RCV_STATE_READY;
                        pThisDev->rcvInfo.rcvBufPos = 0;

                        break;

                    default:

                        //
                        // The current character is data in the frame.
                        //

                        pReadBuffer[pThisDev->rcvInfo.rcvBufPos++] =
                                    currentChar;

                        break;
                }

                break; // RCV_STATE_RX

            default:
                DEBUGMSG(DBG_ERR, ("    Illegal state\n"));

                //
                // Reset.
                //

                pThisDev->rcvInfo.rcvState  = RCV_STATE_READY;
                pThisDev->rcvInfo.rcvBufPos = 0;

                break;
        }
    }

    //
    // There are two ways to break the for loop:
    // 1) out of data - this is fine
    // 2) overrun, the frame is larger than our buffer size
    //

    if (pThisDev->rcvInfo.rcvBufPos > MAX_RCV_DATA_SIZE)
    {
        DEBUGMSG(DBG_WARN, ("    Overrun in ProcessData!!!\n"));

        //
        // Reset the buffer for our next read.
        //

        pThisDev->rcvInfo.rcvState  = RCV_STATE_READY;
        pThisDev->rcvInfo.rcvBufPos = 0;
        pThisDev->packetsReceivedOverflow++;
    }

    DEBUGMSG(DBG_FUNC, ("-ProcessData\n"));

    return status;
}

VOID
ProcessReturnPacket(
    PIR_DEVICE pThisDev,
    PRCV_BUFFER pRcvBuffer
    )
{
    PNDIS_BUFFER pBuffer;

    NdisQueryPacket(
                pRcvBuffer->packet,
                NULL,     // physical buffer count, don't care
                NULL,     // buffer count, don't care, we know it is 1
                &pBuffer, // get a pointer to our buffer
                NULL      // total packet lenght, don't care
                );

    //
    // We adjusted the buffer length of the NDIS_BUFFER to the size
    // of the data before we gave ownership to the protocol. Now we
    // should reset the buffer length to the full size of the data
    // buffer.
    //
    NdisAdjustBufferLength(
                pBuffer,
                RCV_BUFFER_SIZE
                );
#if DBG
    NdisZeroMemory(
                pRcvBuffer->dataBuf,
                RCV_BUFFER_SIZE
                );
#endif

    pRcvBuffer->dataLen = 0;

    InterlockedDecrement(&pThisDev->packetsHeldByProtocol);

    //
    // Add the buffer to the free queue.
    //
    MyInterlockedInsertTailList(
        &(pThisDev->rcvFreeQueue),
        &pRcvBuffer->linkage,
        &(pThisDev->rcvQueueSpinLock)
        );


}

/*****************************************************************************
*
*  Function:   DeliverBuffer
*
*  Synopsis:   Delivers the buffer to the protocol via
*              NdisMIndicateReceivePacket.
*
*  Arguments:  pThisDev - pointer to the current ir device object
*
*  Returns:    STATUS_SUCCESS      - on success
*              STATUS_UNSUCCESSFUL - if packet can't be delivered to protocol
*
*  Algorithm:
*
*  History:    dd-mm-yyyy   Author    Comment
*              10/7/1996    sholden   author
*
*  Notes:
*
*
*****************************************************************************/

VOID
DeliverBuffer(
            IN  PIR_DEVICE pThisDev
            )
{
    SLOW_IR_FCS_TYPE   fcs;
    PNDIS_BUFFER       pBuffer;
    BOOLEAN            fProcessPacketNow;
    NDIS_HANDLE        hSwitchToMiniport;
    NTSTATUS           status;
    PRCV_BUFFER        pThisBuffer, pNextBuffer;

    DEBUGMSG(DBG_FUNC, ("+DeliverBuffer\n"));

    LOG_ENTRY('BD', pThisDev,
              pThisDev->rcvInfo.pRcvBuffer->dataBuf,
              pThisDev->rcvInfo.pRcvBuffer->dataLen);
#if 0
    LOG_ENTRY('DD',
              ((PULONG)pThisDev->rcvInfo.pRcvBuffer->dataBuf)[0],
              ((PULONG)pThisDev->rcvInfo.pRcvBuffer->dataBuf)[1],
              ((PULONG)pThisDev->rcvInfo.pRcvBuffer->dataBuf)[2]);
#endif

#ifdef DEBUG_IRSIR

    //
    // This is the count of how many irps with data to get this frame.
    //

    DEBUGMSG(DBG_STAT, ("****IrpCount = %d, Bytes = %d, Frame Length = %d\n",
             irpCount, bytesReceived, pThisDev->rcvInfo.pRcvBuffer->dataLen));
    irpCount      = 0;
    bytesReceived = 0;

#endif //DEBUG_IRSIR

    pNextBuffer = (PRCV_BUFFER)MyInterlockedRemoveHeadList(
                                    &(pThisDev->rcvFreeQueue),
                                    &(pThisDev->rcvQueueSpinLock)
                                    );
    //
    // Compute the FCS.
    //

    fcs = ComputeFCS(
                pThisDev->rcvInfo.pRcvBuffer->dataBuf,
                pThisDev->rcvInfo.pRcvBuffer->dataLen
                );

    if (fcs != GOOD_FCS || !pNextBuffer)
    {
        //
        // Bad frame, just drop it and increment our dropped packets
        // count.
        //

        pThisDev->packetsReceivedDropped++;

#if DBG
        if (fcs != GOOD_FCS)
        {
            LOG_ENTRY('CF', pThisDev, 0, 0);
            DEBUGMSG(DBG_STAT|DBG_WARN, ("    FCS ERR Len(%d)\n", pThisDev->rcvInfo.pRcvBuffer->dataLen));
        }
        if (!pNextBuffer)
        {
            LOG_ENTRY('BI', pThisDev, 0, 0);
            DEBUGMSG(DBG_STAT|DBG_WARN, ("    Dropped packet due to insufficient buffers\n"));
        }
#endif

#if 0
        DBG_PrintBuf(pThisDev->rcvInfo.pRcvBuffer->dataBuf,
                     pThisDev->rcvInfo.pRcvBuffer->dataLen);
#endif

        status = STATUS_UNSUCCESSFUL;

        NdisZeroMemory(
                    pThisDev->rcvInfo.pRcvBuffer->dataBuf,
                    RCV_BUFFER_SIZE
                    );

        pThisDev->rcvInfo.pRcvBuffer->dataLen = 0;

        if (pNextBuffer)
        {
            MyInterlockedInsertHeadList(
                        &(pThisDev->rcvFreeQueue),
                        &pNextBuffer->linkage,
                        &(pThisDev->rcvQueueSpinLock)
                        );
        }

        goto done;
    }

    LOG_ENTRY('HF', pThisDev, 0, 0);
    //
    // Remove fcs from the end of the packet.
    //

    pThisDev->rcvInfo.pRcvBuffer->dataLen -= SLOW_IR_FCS_SIZE;

    //
    // Fix up some other packet fields.
    //

    NDIS_SET_PACKET_HEADER_SIZE(
                pThisDev->rcvInfo.pRcvBuffer->packet,
                SLOW_IR_ADDR_SIZE + SLOW_IR_CONTROL_SIZE
                );

    //
    // We need to call NdisQueryPacket to get a pointer to the
    // NDIS_BUFFER so that we can adjust the buffer length
    // to the actual size of the data and not the size
    // of the buffer.
    //
    // NdisQueryPacket will return other information, but since
    // we built the packet ourselves, we already know that info.
    //

    NdisQueryPacket(
                pThisDev->rcvInfo.pRcvBuffer->packet,
                NULL,     // physical buffer count, don't care
                NULL,     // buffer count, don't care, we know it is 1
                &pBuffer, // get a pointer to our buffer
                NULL      // total packet lenght, don't care
                );

    NdisAdjustBufferLength(
                pBuffer,
                pThisDev->rcvInfo.pRcvBuffer->dataLen
                );

    //
    // Set to use the new buffer before we indicate the packet.
    //
    pThisBuffer = pThisDev->rcvInfo.pRcvBuffer;
    pThisDev->rcvInfo.pRcvBuffer = pNextBuffer;

    ASSERT(pThisDev->rcvInfo.pRcvBuffer != NULL);

    //
    // Indicate the packet to NDIS.
    //
    InterlockedIncrement(&pThisDev->packetsHeldByProtocol);

    NdisMIndicateReceivePacket(
                pThisDev->hNdisAdapter,
                &pThisBuffer->packet,
                1
                );


done:

    DEBUGMSG(DBG_FUNC, ("-DeliverBuffer\n"));

    return;
}

/*****************************************************************************
*
*  Function:   IrsirReturnPacket
*
*  Synopsis:   The protocol returns ownership of a receive packet to
*              the ir device object.
*
*  Arguments:  Context         - a pointer to the current ir device obect.
*              pReturnedPacket - a pointer the packet which the protocol
*                                is returning ownership.
*
*  Returns:    None.
*
*  Algorithm:
*              1) Take the receive buffer off of the pending queue.
*              2) Put the receive buffer back on the free queue.
*
*  History:    dd-mm-yyyy   Author    Comment
*              10/8/1996    sholden   author
*
*  Notes:
*
*
*****************************************************************************/

VOID
IrsirReturnPacket(
            IN NDIS_HANDLE  Context,
            IN PNDIS_PACKET pReturnedPacket
            )
{
    PIR_DEVICE   pThisDev;
    PNDIS_BUFFER pBuffer;
    PRCV_BUFFER  pRcvBuffer;
    PLIST_ENTRY  pTmpListEntry;

    DEBUGMSG(DBG_FUNC, ("+IrsirReturnPacket\n"));

    //
    // The context is just the pointer to the current ir device object.
    //

    pThisDev = CONTEXT_TO_DEV(Context);

    pThisDev->packetsReceived++;

    {
        PPACKET_RESERVED_BLOCK   PacketReserved;

        PacketReserved=(PPACKET_RESERVED_BLOCK)&pReturnedPacket->MiniportReservedEx[0];

        pRcvBuffer=PacketReserved->Context;
    }

    ProcessReturnPacket(pThisDev, pRcvBuffer);


    DEBUGMSG(DBG_FUNC, ("-IrsirReturnPacket\n"));

    return;
}


VOID
SerialWaitCallback(PIR_WORK_ITEM pWorkItem)
/*++

Routine Description:



Arguments:

Return Value:
    none

--*/
{
    PIR_DEVICE      pThisDev = pWorkItem->pIrDevice;
    NTSTATUS        Status;
    ULONG           BytesRead;

    FreeWorkItem(pWorkItem);

    do
    {
        SerialSynchronousRead(pThisDev->pSerialDevObj,
                              pThisDev->pRcvIrpBuffer,
                              SERIAL_RECEIVE_BUFFER_LENGTH,
                              &BytesRead);

        if (BytesRead>0)
        {
            ProcessData(pThisDev, pThisDev->pRcvIrpBuffer, BytesRead);
        }

    } while ( BytesRead == SERIAL_RECEIVE_BUFFER_LENGTH );

    if (InterlockedExchange(&pThisDev->fWaitPending, 1)==0)
    {
        LARGE_INTEGER Time;
        KeQuerySystemTime(&Time);
        LOG_ENTRY('WS', pThisDev, Time.LowPart/10000, Time.HighPart);

        Status = SerialCallbackOnMask(pThisDev->pSerialDevObj,
                                      SerialIoCompleteWait,
                                      &pThisDev->WaitIosb,
                                      DEV_TO_CONTEXT(pThisDev),
                                      &pThisDev->MaskResult);
        if (Status!=STATUS_SUCCESS && Status!=STATUS_PENDING)
        {
            DEBUGMSG(DBG_ERROR, ("IRSIR: SerialCallbackOnMask failed (0x%x:%d)\n", Status));
            ASSERT(0);
        }
    }

    return;
}


NTSTATUS
SerialIoCompleteWait(
            IN PDEVICE_OBJECT pSerialDevObj,
            IN PIRP           pIrp,
            IN PVOID          Context
            )
{
    PIR_DEVICE  pThisDev;
    BOOLEAN     fSwitchSuccessful;
    NDIS_HANDLE hSwitchToMiniport;
    NTSTATUS    status = STATUS_SUCCESS;
    ULONG       BytesRead;
    ULONG       WaitWasPending;

    DEBUGMSG(DBG_FUNC, ("+SerialIoCompleteWait\n"));

    //
    // The context given to IoSetCompletionRoutine is simply the the ir
    // device object pointer.
    //

    pThisDev = CONTEXT_TO_DEV(Context);

    WaitWasPending = InterlockedExchange(&pThisDev->fWaitPending, 0);
    ASSERT(WaitWasPending);

    *pIrp->UserIosb = pIrp->IoStatus;

    LOG_ENTRY('1i', pThisDev, pIrp, 0);
    IoFreeIrp(pIrp);
    //
    // Need to check if there is a pending halt or reset. If there is, we
    // just leave the receive completion. Since we maintain one irp associated
    // with the receive functionality, the irp will be deallocated in
    // the ir device object deinitialization routine.
    //

    if ((pThisDev->fPendingHalt  == TRUE) ||
        (pThisDev->fPendingReset == TRUE))
    {
        //
        // Set the fReceiving boolean so that the halt and reset routines
        // know when it is okay to continue.
        //

        pThisDev->fReceiving = FALSE;

        //
        // Free the irp and associate memory...the rest will be
        // freed in the halt or reset.
        //

        goto done;
    }

    //
    // Next we take care of any pending set speeds.
    //

    //
    // This completion routine is running at IRQL DISPATCH_LEVEL. Therefore,
    // we cannot make a synchronous call to the serial driver. Set an event
    // to notify the PassiveLevelThread to perform the speed change. We will
    // exit this without creating another irp to the serial device object.
    // PassiveLevelThread will call InitializeReceive after the speed has
    // been set.
    //

    if (pThisDev->fPendingSetSpeed == TRUE)
    {
        pThisDev->fReceiving = FALSE;

        goto done;
    }
    //
    // Free the irp and reinit the buffer and status block.
    //


    {
        LARGE_INTEGER Time;
        KeQuerySystemTime(&Time);
        LOG_ENTRY('ES', pThisDev, Time.LowPart/10000, Time.HighPart);
    }
    if (ScheduleWorkItem(0, pThisDev, SerialWaitCallback,
                         (PVOID)0, 0)!=NDIS_STATUS_SUCCESS
       )
    {
        DEBUGMSG(DBG_ERR, ("IRSIR:SerialIoCompleteWait: Timed out and couldn't reschedule Wait.\n"
                           "      We're going down.\n"));
    }

done:
    DEBUGMSG(DBG_FUNC, ("-SerialIoCompleteWait\n"));

    //
    // We return STATUS_MORE_PROCESSING_REQUIRED so that the completion
    // routine (IofCompleteRequest) will stop working on the irp.
    //

    status = STATUS_MORE_PROCESSING_REQUIRED;

    return status;
}