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

/*****************************************************************************
*
*  Copyright (c) 1996-1999 Microsoft Corporation
*
*       @doc
*       @module   request.c | IrSIR NDIS Miniport Driver
*       @comm
*
*-----------------------------------------------------------------------------
*
*       Author:   Scott Holden (sholden)
*
*       Date:     10/10/1996 (created)
*
*       Contents: Query and set information handlers.
*
*****************************************************************************/

#include "irsir.h"

VOID
ClearMediaBusyCallback(
    PIR_WORK_ITEM pWorkItem
    );

VOID
QueryMediaBusyCallback(
    PIR_WORK_ITEM pWorkItem
    );

VOID
InitIrDeviceCallback(
    PIR_WORK_ITEM pWorkItem
    );

#pragma alloc_text(PAGE, ClearMediaBusyCallback)
#pragma alloc_text(PAGE, QueryMediaBusyCallback)
#pragma alloc_text(PAGE, InitIrDeviceCallback)

//
//  These are the OIDs we support for querying.
//

UINT supportedOIDs[] =
{
    //
    // General required OIDs.
    //

    OID_GEN_SUPPORTED_LIST,
    OID_GEN_HARDWARE_STATUS,
    OID_GEN_MEDIA_SUPPORTED,
    OID_GEN_MEDIA_IN_USE,
    OID_GEN_MAXIMUM_LOOKAHEAD,
    OID_GEN_MAXIMUM_FRAME_SIZE,
    OID_GEN_LINK_SPEED,
    OID_GEN_TRANSMIT_BUFFER_SPACE,
    OID_GEN_RECEIVE_BUFFER_SPACE,
    OID_GEN_TRANSMIT_BLOCK_SIZE,
    OID_GEN_RECEIVE_BLOCK_SIZE,
    OID_GEN_VENDOR_ID,
    OID_GEN_VENDOR_DESCRIPTION,
    OID_GEN_CURRENT_PACKET_FILTER,
    OID_GEN_CURRENT_LOOKAHEAD,
    OID_GEN_DRIVER_VERSION,
    OID_GEN_MAXIMUM_TOTAL_SIZE,
    OID_GEN_PROTOCOL_OPTIONS,
    OID_GEN_MAC_OPTIONS,
    OID_GEN_MEDIA_CONNECT_STATUS,
    OID_GEN_MAXIMUM_SEND_PACKETS,
    OID_GEN_VENDOR_DRIVER_VERSION,

    //
    // Required statistical OIDs.
    //

    OID_GEN_XMIT_OK,
    OID_GEN_RCV_OK,
    OID_GEN_XMIT_ERROR,
    OID_GEN_RCV_ERROR,
    OID_GEN_RCV_NO_BUFFER,


    //
    // Infrared-specific OIDs.
    //

    OID_IRDA_RECEIVING,
    OID_IRDA_TURNAROUND_TIME,
    OID_IRDA_SUPPORTED_SPEEDS,
    OID_IRDA_LINK_SPEED,
    OID_IRDA_MEDIA_BUSY,
    OID_IRDA_EXTRA_RCV_BOFS

    //
    // Unsupported Infrared-specific OIDs.
    //
    // OID_IRDA_RATE_SNIFF,
    // OID_IRDA_UNICAST_LIST,
    // OID_IRDA_MAX_UNICAST_LIST_SIZE
    //

#if 1
   ,OID_PNP_CAPABILITIES,
    OID_PNP_SET_POWER,
    OID_PNP_QUERY_POWER,
    OID_PNP_ENABLE_WAKE_UP
#endif
};


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

    SERIALPERF_STATS PerfStats;

    //DBGTIME("CLEAR_MEDIA_BUSY");
    DEBUGMSG(DBG_STAT, ("    primPassive = PASSIVE_CLEAR_MEDIA_BUSY\n"));

    status = (NDIS_STATUS) SerialClearStats(pThisDev->pSerialDevObj);

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

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

    }

    FreeWorkItem(pWorkItem);

    return;
}

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

    SERIALPERF_STATS PerfStats;

    ASSERT(pWorkItem->InfoBuf != NULL);
    ASSERT(pWorkItem->InfoBufLen >= sizeof(UINT));

    if (pThisDev->pSerialDevObj)
    {
        status = (NDIS_STATUS) SerialGetStats(pThisDev->pSerialDevObj, &PerfStats);
    }
    else
    {
        PerfStats.ReceivedCount = 1;  // Fake media busy
        status = NDIS_STATUS_SUCCESS;
    }

    if (status == NDIS_STATUS_SUCCESS)
    {
        if (PerfStats.ReceivedCount > 0 ||
            PerfStats.FrameErrorCount > 0 ||
            PerfStats.SerialOverrunErrorCount > 0 ||
            PerfStats.BufferOverrunErrorCount > 0 ||
            PerfStats.ParityErrorCount > 0)
        {
            DBGTIME("QUERY_MEDIA_BUSY:TRUE");
            pThisDev->fMediaBusy = TRUE;
        }
        else
        {
            DBGTIME("QUERY_MEDIA_BUSY:FALSE");
        }
    }
    else
    {
        DEBUGMSG(DBG_ERROR, ("    SerialGetStats failed = 0x%.8x\n", status));
    }

    *(UINT *)pWorkItem->InfoBuf = (UINT)pThisDev->fMediaBusy;
    pWorkItem->InfoBufLen = sizeof(UINT);

    {
        NdisMQueryInformationComplete(pThisDev->hNdisAdapter,
                                (NDIS_STATUS)status);

    }


    FreeWorkItem(pWorkItem);

    return;
}

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

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

    (void)ResetIrDevice(pThisDev);

    {
        NdisMQueryInformationComplete(pThisDev->hNdisAdapter,
                                (NDIS_STATUS)status);

    }


    FreeWorkItem(pWorkItem);

    DEBUGMSG(DBG_FUNC, ("-InitIrDeviceCallback\n"));
    return;
}
/*****************************************************************************
*
*  Function:   IrsirQueryInformation
*
*  Synopsis:   Queries the capabilities and status of the miniport driver.
*
*  Arguments:  MiniportAdapterContext  - miniport context area (PIR_DEVICE)
*              Oid                     - system defined OID_Xxx
*              InformationBuffer       - where to return Oid specific info
*              InformationBufferLength - specifies size of InformationBuffer
*              BytesWritten            - bytes written to InformationBuffer
*              BytesNeeded             - addition bytes required if
*                                        InformationBufferLength is less than
*                                        what the Oid requires to write
*
*  Returns:    NDIS_STATUS_SUCCESS       - success
*              NDIS_STATUS_PENDING       - will complete asynchronously and
*                                          call NdisMQueryInformationComplete
*              NDIS_STATUS_INVALID_OID   - don't recognize the Oid
*              NDIS_STATUS_INVALID_LENGTH- InformationBufferLength does not
*                                          match length for the Oid
*              NDIS_STATUS_NOT_ACCEPTED  - failure
*              NDIS_STATUS_NOT_SUPPORTED - do not support an optional Oid
*              NDIS_STATUS_RESOURCES     - failed allocation of resources
*
*  Algorithm:
*
*  History:    dd-mm-yyyy   Author    Comment
*              10/1/1996    sholden   author
*
*  Notes:
*       Supported OIDs:
*           OID_GEN_MAXIMUM_LOOKAHEAD
*               - indicate the number of bytes of look ahead data the NIC can
*                 provide
*           OID_GEN_MAC_OPTIONS
*               - indicate which NDIS_MAC_OPTION_Xxx the NIC supports
*           OID_GEN_MAXIMUM_SEND_PACKETS
*           OID_IRDA_RECEIVING
*           OID_IRDA_SUPPORTED_SPEEDS
*           OID_IRDA_LINK_SPEED
*           OID_IRDA_MEDIA_BUSY
*           OID_IRDA_TURNAROUND_TIME
*           OID_IRDA_EXTRA_RCV_BOFS
*
*       Unsupported OIDs:
*           OID_IRDA_UNICAST_LIST
*           OID_IRDA_MAX_UNICAST_LIST_SIZE
*           OID_IRDA_RATE_SNIFF
*
*****************************************************************************/

NDIS_STATUS
IrsirQueryInformation(
            IN  NDIS_HANDLE MiniportAdapterContext,
            IN  NDIS_OID    Oid,
            IN  PVOID       InformationBuffer,
            IN  ULONG       InformationBufferLength,
            OUT PULONG      BytesWritten,
            OUT PULONG      BytesNeeded
            )
{
    PIR_DEVICE      pThisDev;
    NDIS_STATUS     status;
    UINT            speeds;
    UINT            i;
    UINT            infoSizeNeeded;
    UINT            *infoPtr;
    PIR_WORK_ITEM   pWorkItem = NULL;
    ULONG           OidCategory = Oid & 0xFF000000;

    static char vendorDesc[] = "Serial Infrared (COM) Port";

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

    pThisDev = CONTEXT_TO_DEV(MiniportAdapterContext);
    status = NDIS_STATUS_SUCCESS;

    //
    // Figure out buffer size needed.
    // Most OIDs just return a single UINT, but there are exceptions.
    //

    switch (Oid)
    {
        case OID_GEN_SUPPORTED_LIST:
            infoSizeNeeded = sizeof(supportedOIDs);

            break;

        case OID_GEN_DRIVER_VERSION:
            infoSizeNeeded = sizeof(USHORT);

            break;

        case OID_GEN_VENDOR_DESCRIPTION:
            infoSizeNeeded = sizeof(vendorDesc);

            break;

        case OID_IRDA_SUPPORTED_SPEEDS:
            speeds = pThisDev->dongleCaps.supportedSpeedsMask &
                     ALL_SLOW_IRDA_SPEEDS;

            for (infoSizeNeeded = 0; speeds; infoSizeNeeded += sizeof(UINT))
            {
                //
                // This instruction clears the lowest set bit in speeds.
                // Trust me.
                //

                speeds &= (speeds - 1);
            }

            break;

        default:
            infoSizeNeeded = sizeof(UINT);

            break;
    }

    //
    // If the protocol provided a large enough buffer, we can go ahead
    // and complete the query.
    //

    if (InformationBufferLength >= infoSizeNeeded)
    {
        //
        // Set default results.
        //

        *BytesWritten = infoSizeNeeded;
        *BytesNeeded = 0;

        switch (Oid)
        {
            //
            // Generic OIDs.
            //

            case OID_GEN_SUPPORTED_LIST:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_SUPPORTED_LIST)\n"));

                NdisMoveMemory(
                            InformationBuffer,
                            (PVOID)supportedOIDs,
                            sizeof(supportedOIDs)
                            );

                break;

            case OID_GEN_HARDWARE_STATUS:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_HARDWARE_STATUS)\n"));

                //
                // If we can be called with a context, then we are
                // initialized and ready.
                //

                *(UINT *)InformationBuffer = NdisHardwareStatusReady;

                break;

            case OID_GEN_MEDIA_SUPPORTED:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_MEDIA_SUPPORTED)\n"));

                *(UINT *)InformationBuffer = NdisMediumIrda;

                break;

            case OID_GEN_MEDIA_IN_USE:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_MEDIA_IN_USE)\n"));

                *(UINT *)InformationBuffer = NdisMediumIrda;

                break;

            case OID_GEN_MAXIMUM_LOOKAHEAD:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_MAXIMUM_LOOKAHEAD)\n"));

                *(UINT *)InformationBuffer = 256;

                break;

            case OID_GEN_MAXIMUM_FRAME_SIZE:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_MAXIMUM_FRAME_SIZE)\n"));

                *(UINT *)InformationBuffer = MAX_NDIS_DATA_SIZE;

                break;

            case OID_GEN_LINK_SPEED:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_LINK_SPEED)\n"));

                //
                // Return MAXIMUM POSSIBLE speed for this device in units
                // of 100 bits/sec.
                //

                *(UINT *)InformationBuffer = 115200/100;

                break;

            case OID_GEN_TRANSMIT_BUFFER_SPACE:
            case OID_GEN_RECEIVE_BUFFER_SPACE:
            case OID_GEN_TRANSMIT_BLOCK_SIZE:
            case OID_GEN_RECEIVE_BLOCK_SIZE:
                *(UINT *)InformationBuffer = MAX_I_DATA_SIZE;

                break;

            case OID_GEN_VENDOR_ID:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_VENDOR_ID)\n"));

                *(UINT *)InformationBuffer = 0x00ffffff;

                break;

            case OID_GEN_VENDOR_DESCRIPTION:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_VENDOR_DESCRIPTION)\n"));

                NdisMoveMemory(
                            InformationBuffer,
                            (PVOID)vendorDesc,
                            sizeof(vendorDesc)
                            );

                break;

            case OID_GEN_CURRENT_PACKET_FILTER:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_CURRENT_PACKET_FILTER)\n"));

                *(UINT *)InformationBuffer = NDIS_PACKET_TYPE_PROMISCUOUS;

                break;

            case OID_GEN_CURRENT_LOOKAHEAD:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_CURRENT_LOOKAHEAD)\n"));

                *(UINT *)InformationBuffer = 256;

                break;

            case OID_GEN_DRIVER_VERSION:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_DRIVER_VERSION)\n"));

                *(USHORT *)InformationBuffer = ((IRSIR_MAJOR_VERSION << 8) |
                                                 IRSIR_MINOR_VERSION);

                break;

            case OID_GEN_MAXIMUM_TOTAL_SIZE:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_MAXIMUM_TOTAL_SIZE)\n"));

                *(UINT *)InformationBuffer = MAX_NDIS_DATA_SIZE;

                break;

            case OID_GEN_PROTOCOL_OPTIONS:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_PROTOCOL_OPTIONS)\n"));

                DEBUGMSG(DBG_ERROR, ("This is a set-only OID\n"));
                *BytesWritten = 0;
                status = NDIS_STATUS_NOT_SUPPORTED;

                break;

            case OID_GEN_MAC_OPTIONS:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_MAC_OPTIONS)\n"));

                *(UINT *)InformationBuffer =
                    NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
                    NDIS_MAC_OPTION_TRANSFERS_NOT_PEND;

                break;

            case OID_GEN_MEDIA_CONNECT_STATUS:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_MEDIA_CONNECT_STATUS)\n"));

                //
                // Since we are not physically connected to a LAN, we
                // cannot determine whether or not we are connected;
                // so always indicate that we are.
                //

                *(UINT *)InformationBuffer = NdisMediaStateConnected;

                break;

            case OID_GEN_MAXIMUM_SEND_PACKETS:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_MAXIMUM_SEND_PACKETS)\n"));

                *(UINT *)InformationBuffer = 16;

                break;

            case OID_GEN_VENDOR_DRIVER_VERSION:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_VENDOR_DRIVER_VERSION)\n"));

                *(UINT *)InformationBuffer =
                                            ((IRSIR_MAJOR_VERSION << 16) |
                                              IRSIR_MINOR_VERSION);

                break;

            //
            // Required statistical OIDs.
            //

            case OID_GEN_XMIT_OK:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_XMIT_OK)\n"));

                *(UINT *)InformationBuffer =
                                (UINT)pThisDev->packetsSent;

                break;

            case OID_GEN_RCV_OK:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_RCV_OK)\n"));

                *(UINT *)InformationBuffer =
                                (UINT)pThisDev->packetsReceived;

                break;

            case OID_GEN_XMIT_ERROR:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_XMIT_ERROR)\n"));

                *(UINT *)InformationBuffer =
                                (UINT)pThisDev->packetsSentDropped;

                break;

            case OID_GEN_RCV_ERROR:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_RCV_ERROR)\n"));

                *(UINT *)InformationBuffer =
                                (UINT)pThisDev->packetsReceivedDropped;

                break;

            case OID_GEN_RCV_NO_BUFFER:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_GEN_RCV_NO_BUFFER)\n"));

                *(UINT *)InformationBuffer =
                                (UINT)pThisDev->packetsReceivedOverflow;

                break;

            //
            // Infrared OIDs.
            //

            case OID_IRDA_RECEIVING:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_IRDA_RECEIVING)\n"));

                *(UINT *)InformationBuffer = (UINT)pThisDev->fReceiving;

                break;

            case OID_IRDA_TURNAROUND_TIME:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_IRDA_TURNAROUND_TIME)\n"));

                //
                // Indicate that the tranceiver requires at least 5000us
                // (5 millisec) to recuperate after a send.
                //

                *(UINT *)InformationBuffer =
                            pThisDev->dongleCaps.turnAroundTime_usec;

                break;

            case OID_IRDA_SUPPORTED_SPEEDS:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_IRDA_SUPPORTED_SPEEDS)\n"));

                if (!pThisDev->pSerialDevObj)
                {
                    (void)pThisDev->dongle.QueryCaps(&pThisDev->dongleCaps);
                }

                speeds = pThisDev->dongleCaps.supportedSpeedsMask &
                         pThisDev->AllowedSpeedsMask &
                         ALL_SLOW_IRDA_SPEEDS;


                *BytesWritten = 0;

                for (i = 0, infoPtr = (PUINT)InformationBuffer;
                     (i < NUM_BAUDRATES) &&
                     speeds &&
                     (InformationBufferLength >= sizeof(UINT));
                     i++)
                {
                    if (supportedBaudRateTable[i].ndisCode & speeds)
                    {
                        *infoPtr++ = supportedBaudRateTable[i].bitsPerSec;
                        InformationBufferLength -= sizeof(UINT);
                        *BytesWritten += sizeof(UINT);
                        speeds &= ~supportedBaudRateTable[i].ndisCode;
                        DEBUGMSG(DBG_OUT, (" - supporting speed %d bps\n", supportedBaudRateTable[i].bitsPerSec));
                    }
                }

                if (speeds)
                {
                    //
                    // This shouldn't happen, since we checked the
                    // InformationBuffer size earlier.
                    //

                    DEBUGMSG(DBG_ERROR, ("Something's wrong; previous check for buf size failed somehow\n"));

                    for (*BytesNeeded = 0; speeds; *BytesNeeded += sizeof(UINT))
                    {
                        //
                        // This instruction clears the lowest set bit in speeds.
                        // Trust me.
                        //

                        speeds &= (speeds - 1);
                    }

                    status = NDIS_STATUS_INVALID_LENGTH;
                }
                else
                {
                    status = NDIS_STATUS_SUCCESS;
                }

                break;

            case OID_IRDA_LINK_SPEED:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_IRDA_LINK_SPEED)\n"));

                if (pThisDev->linkSpeedInfo)
                {
                    *(UINT *)InformationBuffer =
                                pThisDev->linkSpeedInfo->bitsPerSec;
                }
                else {
                    *(UINT *)InformationBuffer = DEFAULT_BAUD_RATE;
                }

                break;


            case OID_IRDA_MEDIA_BUSY:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_IRDA_MEDIA_BUSY)\n"));

                //
                // If any data has been received, fMediaBusy = TRUE. However,
                // even if fMediaBusy = FALSE, the media may be busy. We need
                // to query the serial device object's performance statistics
                // to see if there are any overrun or framing errors.
                //

                //
                // NOTE: The serial device object's performance stats are
                //       cleared when the protocol set fMediaBusy to
                //       FALSE.
                //

                *(UINT *)InformationBuffer = pThisDev->fMediaBusy;

                if (pThisDev->fMediaBusy == FALSE)
                {
                    if (ScheduleWorkItem(PASSIVE_QUERY_MEDIA_BUSY, pThisDev,
                                QueryMediaBusyCallback, InformationBuffer,
                                InformationBufferLength) != NDIS_STATUS_SUCCESS)
                    {
                        status = NDIS_STATUS_SUCCESS;
                    }
                    else
                    {
                        status = NDIS_STATUS_PENDING;
                    }
                }
                else
                {
                    *(UINT *)InformationBuffer = (UINT)pThisDev->fMediaBusy;
                    status = NDIS_STATUS_SUCCESS;
                }

                break;

            case OID_IRDA_EXTRA_RCV_BOFS:
                DEBUGMSG(DBG_OUT, ("    IrsirQueryInformation(OID_IRDA_EXTRA_RCV_BOFS)\n"));

                //
                // Pass back the number of _extra_ BOFs to be prepended
                // to packets sent to this unit at 115.2 baud, the
                // maximum Slow IR speed.  This will be scaled for other
                // speed according to the table in the
                // 'Infrared Extensions to NDIS' spec.
                //

                *(UINT *)InformationBuffer =
                                pThisDev->dongleCaps.extraBOFsRequired;

                break;

            case OID_IRDA_MAX_RECEIVE_WINDOW_SIZE:
                *(PUINT)InformationBuffer = MAX_RX_PACKETS;
                break;

            case OID_IRDA_MAX_SEND_WINDOW_SIZE:
                *(PUINT)InformationBuffer = MAX_TX_PACKETS;
                break;

            //
            // We don't support these
            //

            case OID_IRDA_RATE_SNIFF:
                DEBUGMSG(DBG_WARN, ("    IrsirQueryInformation(OID_IRDA_RATE_SNIFF) - UNSUPPORTED\n"));

                status = NDIS_STATUS_NOT_SUPPORTED;

                break;

            case OID_IRDA_UNICAST_LIST:
                DEBUGMSG(DBG_WARN, ("    IrsirQueryInformation(OID_IRDA_UNICAST_LIST) - UNSUPPORTED\n"));

                status = NDIS_STATUS_NOT_SUPPORTED;

                break;

            case OID_IRDA_MAX_UNICAST_LIST_SIZE:
                DEBUGMSG(DBG_WARN, ("    IrsirQueryInformation(OID_IRDA_MAX_UNICAST_LIST_SIZE) - UNSUPPORTED\n"));

                status = NDIS_STATUS_NOT_SUPPORTED;

                break;


            // PNP OIDs

            case OID_PNP_CAPABILITIES:
            case OID_PNP_ENABLE_WAKE_UP:
            case OID_PNP_SET_POWER:
            case OID_PNP_QUERY_POWER:
                DEBUGMSG(DBG_WARN, ("IRSIR: PNP OID %x BufLen:%d\n", Oid, InformationBufferLength));
                break;

            default:
                DEBUGMSG(DBG_WARN, ("    IrsirQueryInformation(%d=0x%x), invalid OID\n", Oid, Oid));

                status = NDIS_STATUS_INVALID_OID;

                break;
        }
    }
    else
    {
        *BytesNeeded = infoSizeNeeded - InformationBufferLength;
        *BytesWritten = 0;
        status = NDIS_STATUS_INVALID_LENGTH;
    }


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

    return status;
}

/*****************************************************************************
*
*  Function:   IrsirSetInformation
*
*  Synopsis:   IrsirSetInformation allows other layers of the network software
*              (e.g., a transport driver) to control the miniport driver
*              by changing information that the miniport driver maintains
*              in its OIDs, such as the packet filters or multicast addresses.
*
*  Arguments:  MiniportAdapterContext  - miniport context area (PIR_DEVICE)
*              Oid                     - system defined OID_Xxx
*              InformationBuffer       - buffer containing data for the set Oid
*              InformationBufferLength - specifies size of InformationBuffer
*              BytesRead               - bytes read from InformationBuffer
*              BytesNeeded             - addition bytes required if
*                                        InformationBufferLength is less than
*                                        what the Oid requires to read
*
*  Returns:    NDIS_STATUS_SUCCESS       - success
*              NDIS_STATUS_PENDING       - will complete asynchronously and
*                                          call NdisMSetInformationComplete
*              NDIS_STATUS_INVALID_OID   - don't recognize the Oid
*              NDIS_STATUS_INVALID_LENGTH- InformationBufferLength does not
*                                          match length for the Oid
*              NDIS_STATUS_INVALID_DATA  - supplied data was invalid for the
*                                          given Oid
*              NDIS_STATUS_NOT_ACCEPTED  - failure
*              NDIS_STATUS_NOT_SUPPORTED - do not support an optional Oid
*              NDIS_STATUS_RESOURCES     - failed allocation of resources
*
*  Algorithm:
*
*  History:    dd-mm-yyyy   Author    Comment
*              10/1/1996    sholden   author
*
*  Notes:
*
*
*****************************************************************************/

NDIS_STATUS
IrsirSetInformation(
            IN  NDIS_HANDLE MiniportAdapterContext,
            IN  NDIS_OID    Oid,
            IN  PVOID       InformationBuffer,
            IN  ULONG       InformationBufferLength,
            OUT PULONG      BytesRead,
            OUT PULONG      BytesNeeded
            )
{
    NDIS_STATUS status;
    PIR_DEVICE pThisDev;
    SERIALPERF_STATS PerfStats;

    int i;

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

    status   = NDIS_STATUS_SUCCESS;
    pThisDev = CONTEXT_TO_DEV(MiniportAdapterContext);

    if (InformationBufferLength >= sizeof(UINT))
    {
        //
        //  Set default results.
        //

        UINT info = *(UINT *)InformationBuffer;
        *BytesRead = sizeof(UINT);
        *BytesNeeded = 0;

        switch (Oid)
        {
            //
            //  Generic OIDs.
            //

            case OID_GEN_CURRENT_PACKET_FILTER:
                DEBUGMSG(DBG_OUT, ("    IrsirSetInformation(OID_GEN_CURRENT_PACKET_FILTER, %xh)\n", info));

                //
                // We ignore the packet filter itself.
                //
                // Note:  The protocol may use a NULL filter, in which case
                //        we will not get this OID; so don't wait on
                //        OID_GEN_CURRENT_PACKET_FILTER to start receiving
                //        frames.
                //

                pThisDev->fGotFilterIndication = TRUE;

                break;

            case OID_GEN_CURRENT_LOOKAHEAD:
                DEBUGMSG(DBG_OUT, ("    IrsirSetInformation(OID_GEN_CURRENT_LOOKAHEAD, %xh)\n", info));

                //
                // We always indicate entire receive frames all at once,
                // so just ignore this.
                //

                break;

            case OID_GEN_PROTOCOL_OPTIONS:
                DEBUGMSG(DBG_OUT, ("    IrsirSetInformation(OID_GEN_PROTOCOL_OPTIONS, %xh)\n", info));

                //
                // Ignore.
                //

                break;

            //
            // Infrared OIDs.
            //

            case OID_IRDA_LINK_SPEED:
                DEBUGMSG(DBG_OUT, ("    IrsirSetInformation(OID_IRDA_LINK_SPEED, %xh)\n", info));

                if (pThisDev->currentSpeed == info)
                {
                    //
                    // We are already set to the requested speed.
                    //
                    status = NDIS_STATUS_SUCCESS;

                    DEBUGMSG(DBG_OUT, ("    Link speed already set.\n"));

                    break;
                }

                status = NDIS_STATUS_INVALID_DATA;

                for (i = 0; i < NUM_BAUDRATES; i++)
                {
                    if (supportedBaudRateTable[i].bitsPerSec == info)
                    {
                        //
                        // Keep a pointer to the link speed which has
                        // been requested.
                        //

                        pThisDev->linkSpeedInfo = &supportedBaudRateTable[i];
                        status = NDIS_STATUS_SUCCESS;
                        break;
                    }
                }

                if (status == NDIS_STATUS_SUCCESS)
                {
                    DEBUGMSG(DBG_OUT, ("    Link speed set pending!\n"));
                    //
                    // The requested speed is supported.
                    //

                    if (pThisDev->pSerialDevObj==NULL)
                    {
                        pThisDev->currentSpeed = info;
                        status = NDIS_STATUS_SUCCESS;
                        break;
                    }


                    //
                    // Set fPendingSetSpeed = TRUE.
                    //
                    // The receive completion/timeout routine checks the
                    // fPendingSetSpeed flag, waits for all sends to complete
                    // and then performs the SetSpeed.
                    //

                    pThisDev->fPendingSetSpeed = TRUE;

#if IRSIR_EVENT_DRIVEN
                    if (ScheduleWorkItem(PASSIVE_SET_SPEED, pThisDev,
                                SetSpeedCallback, NULL, 0) != NDIS_STATUS_SUCCESS)
                    {
                        status = NDIS_STATUS_SUCCESS;
                    }
                    else
                    {
                        status = NDIS_STATUS_PENDING;
                    }
#else
                    //
                    // We always return STATUS_PENDING to NDIS.
                    //
                    // After the SetSpeed is complete, the receive completion
                    // routine will call NdisMIndicateSetComplete.
                    //


                    status = NDIS_STATUS_PENDING;
#endif
                }
                else
                {
                    //
                    // status = NDIS_STATUS_INVALID_DATA
                    //

                    DEBUGMSG(DBG_OUT, ("    Invalid link speed\n"));

                    *BytesRead = 0;
                    *BytesNeeded = 0;
                }

                break;

            case OID_IRDA_MEDIA_BUSY:
                DEBUGMSG(DBG_OUT, ("    IrsirSetInformation(OID_IRDA_MEDIA_BUSY, %xh)\n", info));

                pThisDev->fMediaBusy = (BOOLEAN)info;

                if (pThisDev->pSerialDevObj==NULL ||
                    ScheduleWorkItem(PASSIVE_CLEAR_MEDIA_BUSY,
                                     pThisDev, ClearMediaBusyCallback, NULL, 0)!=NDIS_STATUS_SUCCESS)
                {
                    status = NDIS_STATUS_SUCCESS;
                }
                else
                {
                    status = NDIS_STATUS_PENDING;
                }


                break;

            case OID_PNP_CAPABILITIES:
            case OID_PNP_ENABLE_WAKE_UP:
            case OID_PNP_SET_POWER:
            case OID_PNP_QUERY_POWER:
                DEBUGMSG(DBG_WARN, ("IRSIR: PNP OID %x BufLen:%d\n", Oid, InformationBufferLength));
                break;

            case OID_IRDA_RATE_SNIFF:
            case OID_IRDA_UNICAST_LIST:

                //
                // We don't support these
                //

                DEBUGMSG(DBG_ERROR, ("    IrsirSetInformation(OID=%d=0x%x, value=%xh) - unsupported OID\n", Oid, Oid, info));

                *BytesRead = 0;
                *BytesNeeded = 0;
                status = NDIS_STATUS_NOT_SUPPORTED;

                break;

            case OID_IRDA_SUPPORTED_SPEEDS:
            case OID_IRDA_MAX_UNICAST_LIST_SIZE:
            case OID_IRDA_TURNAROUND_TIME:

                //
                // These are query-only parameters (invalid).
                //

            default:
                DEBUGMSG(DBG_ERROR, ("    IrsirSetInformation(OID=%d=0x%x, value=%xh) - invalid OID\n", Oid, Oid, info));

                *BytesRead = 0;
                *BytesNeeded = 0;
                status = NDIS_STATUS_INVALID_OID;

                break;
        }
    }
    else
    {
        //
        // The given data buffer is not large enough for the information
        // to set.
        //

        *BytesRead = 0;
        *BytesNeeded = sizeof(UINT);
        status = NDIS_STATUS_INVALID_LENGTH;
    }

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

    return status;
}