/*++

Copyright (c) 1999  Microsoft Corporation

Module Name:

    ioctl.c

Abstract: POS (serial) interface for USB Point-of-Sale devices

Author:

    Karan Mehra [t-karanm]

Environment:

    Kernel mode

Revision History:


--*/

#include <WDM.H>

#include <usbdi.h>
#include "usbdlib.h"
#include <usbioctl.h>

#include "escpos.h"
#include "debug.h"



NTSTATUS Ioctl(POSPDOEXT *pdoExt, PIRP irp)
{
    NTSTATUS status = STATUS_SUCCESS;
    PIO_STACK_LOCATION irpSp;
    KIRQL oldIrql;

    irp->IoStatus.Information = 0;
    irpSp = IoGetCurrentIrpStackLocation(irp);

    /* 
     *  Private Ioctls for applications to be able to get the device's pretty name and attributes.
     */
    switch (irpSp->Parameters.DeviceIoControl.IoControlCode){

        case IOCTL_SERIAL_QUERY_DEVICE_NAME:
            return QueryDeviceName(pdoExt, irp);

        case IOCTL_SERIAL_QUERY_DEVICE_ATTR: {

            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
                return STATUS_BUFFER_TOO_SMALL; 

            irp->IoStatus.Information = sizeof(ULONG);

            KeAcquireSpinLock(&pdoExt->parentFdoExt->devExtSpinLock, &oldIrql);
            *(PULONG)irp->AssociatedIrp.SystemBuffer = pdoExt->parentFdoExt->posFlag;
            KeReleaseSpinLock(&pdoExt->parentFdoExt->devExtSpinLock, oldIrql);
            return status;
        }
    }
    /* 
     *  The following Ioctl calls are ONLY for Serial Emulation.
     */
    if(!(pdoExt->parentFdoExt->posFlag & SERIAL_EMULATION)) {
        DBGVERBOSE(("Serial Emulation NOT supported by this device - Ioctl Rejected."));
        return STATUS_NOT_SUPPORTED;
    }

    switch (irpSp->Parameters.DeviceIoControl.IoControlCode){

        case IOCTL_SERIAL_GET_STATS: {

            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIALPERF_STATS)) {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }

            irp->IoStatus.Information = sizeof(SERIALPERF_STATS);
            irp->IoStatus.Status = STATUS_SUCCESS;

            KeAcquireSpinLock(&pdoExt->devExtSpinLock, &oldIrql);
            *(PSERIALPERF_STATS)irp->AssociatedIrp.SystemBuffer = pdoExt->fakePerfStats;
            KeReleaseSpinLock(&pdoExt->devExtSpinLock, oldIrql);
            break;
        }

        case IOCTL_SERIAL_CLEAR_STATS: {

            KeAcquireSpinLock(&pdoExt->devExtSpinLock, &oldIrql);
            RtlZeroMemory(&pdoExt->fakePerfStats, sizeof(SERIALPERF_STATS));
            KeReleaseSpinLock(&pdoExt->devExtSpinLock, oldIrql);
            break;
        }

        case IOCTL_SERIAL_GET_PROPERTIES: {

            PSERIAL_COMMPROP properties = (PSERIAL_COMMPROP)irp->AssociatedIrp.SystemBuffer;

            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_COMMPROP)) {
                status = STATUS_BUFFER_TOO_SMALL; 
                break;
            }
		
            irp->IoStatus.Information = sizeof(SERIAL_COMMPROP);
            irp->IoStatus.Status = STATUS_SUCCESS;

            RtlZeroMemory(properties, sizeof(SERIAL_COMMPROP)); 

            properties->PacketLength   = sizeof(SERIAL_COMMPROP);
            properties->PacketVersion  = 2;
            properties->ServiceMask    = SERIAL_SP_SERIALCOMM;
            properties->MaxTxQueue     = 0;
            properties->MaxRxQueue     = 0;

            properties->MaxBaud        = SERIAL_BAUD_115200;
            properties->SettableBaud   = pdoExt->supportedBauds;
            properties->ProvSubType    = SERIAL_SP_MODEM;

            properties->ProvCapabilities = SERIAL_PCF_DTRDSR        | SERIAL_PCF_RTSCTS
              	                         | SERIAL_PCF_SPECIALCHARS  | SERIAL_PCF_PARITY_CHECK
                                         | SERIAL_PCF_TOTALTIMEOUTS | SERIAL_PCF_INTTIMEOUTS;

            properties->SettableParams = SERIAL_SP_PARITY       | SERIAL_SP_BAUD        | SERIAL_SP_DATABITS
                                       | SERIAL_SP_STOPBITS     | SERIAL_SP_HANDSHAKING | SERIAL_SP_PARITY_CHECK 
                                       | SERIAL_SP_CARRIER_DETECT;

            properties->SettableData  = SERIAL_DATABITS_5 | SERIAL_DATABITS_6
                                      | SERIAL_DATABITS_7 | SERIAL_DATABITS_8;

            properties->SettableStopParity = SERIAL_STOPBITS_10 | SERIAL_STOPBITS_15 | SERIAL_STOPBITS_20 
                                           | SERIAL_PARITY_NONE | SERIAL_PARITY_ODD  | SERIAL_PARITY_EVEN 
                                           | SERIAL_PARITY_MARK | SERIAL_PARITY_SPACE;

            properties->CurrentTxQueue = 0;

            KeAcquireSpinLock(&pdoExt->devExtSpinLock, &oldIrql);
            properties->CurrentRxQueue = pdoExt->fakeRxSize;
            KeReleaseSpinLock(&pdoExt->devExtSpinLock, oldIrql);
            break;
        }

        case IOCTL_SERIAL_GET_MODEMSTATUS: {

            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)) {
                status = STATUS_BUFFER_TOO_SMALL; 
                break;
            }

            irp->IoStatus.Information = sizeof(ULONG);
            irp->IoStatus.Status = STATUS_SUCCESS;

            KeAcquireSpinLock(&pdoExt->devExtSpinLock, &oldIrql);
            *(PULONG)irp->AssociatedIrp.SystemBuffer = pdoExt->fakeModemStatus;
            KeReleaseSpinLock(&pdoExt->devExtSpinLock, oldIrql);
            break;
        }
 
        case IOCTL_SERIAL_GET_COMMSTATUS: {

            PSERIAL_STATUS commStatus = (PSERIAL_STATUS)irp->AssociatedIrp.SystemBuffer;

            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_STATUS)) {
                status = STATUS_BUFFER_TOO_SMALL; 
                break;
            }

            irp->IoStatus.Information = sizeof(SERIAL_STATUS);
            irp->IoStatus.Status = STATUS_SUCCESS;

            commStatus->Errors            = 0;
            commStatus->HoldReasons       = 0;
            commStatus->AmountInInQueue   = 100;
            commStatus->AmountInOutQueue  = 0;
            commStatus->EofReceived       = FALSE;
            commStatus->WaitForImmediate  = 0;
            break;
        }

        case IOCTL_SERIAL_RESET_DEVICE: {

            break;								
        }
	    
        case IOCTL_SERIAL_GET_BAUD_RATE: {

            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_BAUD_RATE)) {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }

            irp->IoStatus.Information = sizeof(SERIAL_BAUD_RATE);
            irp->IoStatus.Status = STATUS_SUCCESS;

            KeAcquireSpinLock(&pdoExt->devExtSpinLock, &oldIrql);
            ((PSERIAL_BAUD_RATE)irp->AssociatedIrp.SystemBuffer)->BaudRate = pdoExt->baudRate;
            KeReleaseSpinLock(&pdoExt->devExtSpinLock, oldIrql);
            break;
        }

        case IOCTL_SERIAL_SET_BAUD_RATE: {

            if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_BAUD_RATE)) {
                status = STATUS_BUFFER_TOO_SMALL; 
                break;
            }

            irp->IoStatus.Status = STATUS_SUCCESS;

            KeAcquireSpinLock(&pdoExt->devExtSpinLock, &oldIrql);
            pdoExt->baudRate = ((PSERIAL_BAUD_RATE)irp->AssociatedIrp.SystemBuffer)->BaudRate;
            KeReleaseSpinLock(&pdoExt->devExtSpinLock, oldIrql);
            break;
        }

        case IOCTL_SERIAL_GET_LINE_CONTROL: {

            if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_LINE_CONTROL)) {
                status = STATUS_BUFFER_TOO_SMALL; 
                break;
            }

            irp->IoStatus.Information = sizeof(SERIAL_LINE_CONTROL);
            irp->IoStatus.Status = STATUS_SUCCESS;

            KeAcquireSpinLock(&pdoExt->devExtSpinLock, &oldIrql);
            *(PSERIAL_LINE_CONTROL)irp->AssociatedIrp.SystemBuffer = pdoExt->fakeLineControl;
            KeReleaseSpinLock(&pdoExt->devExtSpinLock, oldIrql);
            break;
        }

        case IOCTL_SERIAL_SET_LINE_CONTROL: {

            if (irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_LINE_CONTROL)) {
                status = STATUS_BUFFER_TOO_SMALL; 
                break;
            }
	    
            irp->IoStatus.Status = STATUS_SUCCESS;

            KeAcquireSpinLock(&pdoExt->devExtSpinLock, &oldIrql);
            pdoExt->fakeLineControl = *(PSERIAL_LINE_CONTROL)irp->AssociatedIrp.SystemBuffer;
            KeReleaseSpinLock(&pdoExt->devExtSpinLock, oldIrql);
            break;
        }