fbtdev.c

Go to the documentation of this file.

// Copyright (c) 2004, Antony C. Roberts
 
// Use of this file is subject to the terms
// described in the LICENSE.TXT file that
// accompanies this file.
//
// Your use of this file indicates your
// acceptance of the terms described in
// LICENSE.TXT.
//
// http://www.freebt.net
 
#include "fbtusb.h"
#include "fbtpnp.h"
#include "fbtpwr.h"
#include "fbtdev.h"
#include "fbtwmi.h"
#include "fbtrwr.h"
 
#include "fbtusr.h"
 
// Dispatch routine for CreateHandle
NTSTATUS NTAPI FreeBT_DispatchCreate(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    //ULONG                       i;
    NTSTATUS                    ntStatus;
    PFILE_OBJECT                fileObject;
    PDEVICE_EXTENSION           deviceExtension;
    PIO_STACK_LOCATION          irpStack;
    //PFREEBT_PIPE_CONTEXT        pipeContext;
    PUSBD_INTERFACE_INFORMATION interface;
 
    PAGED_CODE();
 
    FreeBT_DbgPrint(3, ("FreeBT_DispatchCreate: Entered\n"));
 
    irpStack = IoGetCurrentIrpStackLocation(Irp);
    fileObject = irpStack->FileObject;
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    if (deviceExtension->DeviceState != Working)
    {
        ntStatus = STATUS_INVALID_DEVICE_STATE;
        goto FreeBT_DispatchCreate_Exit;
 
    }
 
    if (deviceExtension->UsbInterface)
    {
        interface = deviceExtension->UsbInterface;
 
    }
 
    else
    {
        FreeBT_DbgPrint(1, ("UsbInterface not found\n"));
        ntStatus = STATUS_INVALID_DEVICE_STATE;
        goto FreeBT_DispatchCreate_Exit;
 
    }
 
    if (fileObject)
    {
        fileObject->FsContext = NULL;
    }
 
    else
    {
        ntStatus = STATUS_INVALID_PARAMETER;
        goto FreeBT_DispatchCreate_Exit;
 
    }
 
    if (deviceExtension->OpenHandleCount>0)
    {
        ntStatus = STATUS_ACCESS_VIOLATION;
        goto FreeBT_DispatchCreate_Exit;
 
    }
 
    // opening a device as opposed to pipe.
    ntStatus = STATUS_SUCCESS;
 
    InterlockedIncrement(&deviceExtension->OpenHandleCount);
 
    // the device is idle if it has no open handles or pending PnP Irps
    // since we just received an open handle request, cancel idle req.
    if (deviceExtension->SSEnable)
        CancelSelectSuspend(deviceExtension);
 
FreeBT_DispatchCreate_Exit:
    Irp->IoStatus.Status = ntStatus;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    FreeBT_DbgPrint(3, ("FreeBT_DispatchCreate: Leaving\n"));
    return ntStatus;
 
}
 
// Dispatch routine for CloseHandle
NTSTATUS NTAPI FreeBT_DispatchClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    NTSTATUS               ntStatus;
    PFILE_OBJECT           fileObject;
    PDEVICE_EXTENSION      deviceExtension;
    PIO_STACK_LOCATION     irpStack;
    //PFREEBT_PIPE_CONTEXT  pipeContext;
    //PUSBD_PIPE_INFORMATION pipeInformation;
 
    PAGED_CODE();
 
    irpStack = IoGetCurrentIrpStackLocation(Irp);
    fileObject = irpStack->FileObject;
    //pipeContext = NULL;
    //pipeInformation = NULL;
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    FreeBT_DbgPrint(3, ("FreeBT_DispatchClose: Entered\n"));
 
    ntStatus = STATUS_SUCCESS;
    Irp->IoStatus.Status = ntStatus;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    InterlockedDecrement(&deviceExtension->OpenHandleCount);
 
    FreeBT_DbgPrint(3, ("FreeBT_DispatchClose: Leaving\n"));
 
    return ntStatus;
 
}
 
// Called when a HCI Send on the control pipe completes
NTSTATUS NTAPI FreeBT_HCISendCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
{
    //ULONG               stageLength;
    NTSTATUS            ntStatus;
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_HCISendCompletion, status=0x%08X\n", Irp->IoStatus.Status));
 
    if (Irp->PendingReturned)
        IoMarkIrpPending(Irp);
 
    ExFreePool(Context);
    FreeBT_IoDecrement(DeviceObject->DeviceExtension);
    ntStatus = Irp->IoStatus.Status;
    Irp->IoStatus.Information = 0;
 
    return ntStatus;
 
}
 
// Called the DeviceIOControl handler to send an HCI command received from the user
// HCI Commands are sent on the (default) control pipe
NTSTATUS NTAPI FreeBT_SendHCICommand(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID IoBuffer, IN ULONG InputBufferLength)
{
    PDEVICE_EXTENSION   deviceExtension;
    //ULONG               urbFlags;
    //ULONG               stageLength;
    //PVOID               pBuffer;
    PURB                urb;
    NTSTATUS            ntStatus;
    PIO_STACK_LOCATION  nextStack;
    //PFBT_HCI_CMD_HEADER pHCICommand;
    //LARGE_INTEGER       delay;
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
    if (!deviceExtension)
    {
        ntStatus=STATUS_INVALID_PARAMETER;
        FreeBT_DbgPrint(1, ("FBTUSB: FreeBT_SendHCICommand: Failed to get DeviceExtension\n"));
        Irp->IoStatus.Status = ntStatus;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return ntStatus;
 
    }
 
    // The user is doing a reset, reset all the pipes as well, so that any
    // old events or data are removed
    /*pHCICommand=(PFBT_HCI_CMD_HEADER)IoBuffer;
    if (pHCICommand->OpCode==FBT_HCI_CMD_RESET)
    {
        FreeBT_ResetPipe(DeviceObject, deviceExtension->EventPipe.PipeHandle);
        FreeBT_ResetPipe(DeviceObject, deviceExtension->DataInPipe.PipeHandle);
        FreeBT_ResetPipe(DeviceObject, deviceExtension->DataOutPipe.PipeHandle);
        FreeBT_ResetPipe(DeviceObject, deviceExtension->AudioInPipe.PipeHandle);
        FreeBT_ResetPipe(DeviceObject, deviceExtension->AudioOutPipe.PipeHandle);
 
        // Wait a second for the device to recover
        FreeBT_DbgPrint(1, ("FBTUSB: FreeBT_SendHCICommand: Sleeping\n"));
        delay.QuadPart = -10000 * 5000; // 5s
        KeWaitForSingleObject(&deviceExtension->DelayEvent,
                              Executive,
                              UserMode,
                              FALSE,
                              &delay);
 
        FreeBT_DbgPrint(1, ("FBTUSB: FreeBT_SendHCICommand: Finished sleeping\n"));
 
 
    }*/
 
    // Create the URB
    urb = (PURB)ExAllocatePool(NonPagedPool, sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));
    if(urb == NULL)
    {
        FreeBT_DbgPrint(1, ("FBTUSB: FreeBT_SendHCICommand: Failed to alloc mem for urb\n"));
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        Irp->IoStatus.Status = ntStatus;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return ntStatus;
 
    }
 
    UsbBuildVendorRequest(
        urb,
        URB_FUNCTION_CLASS_DEVICE, // This works, for CSR and Silicon Wave
        sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST),
        0,
        0,
        0,
        0,
        0,
        IoBuffer,
        NULL,
        InputBufferLength,
        NULL);
 
    // use the original irp as an internal device control irp
    nextStack = IoGetNextIrpStackLocation(Irp);
    nextStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    nextStack->Parameters.Others.Argument1 = (PVOID) urb;
    nextStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
 
    IoSetCompletionRoutine(
        Irp,
        (PIO_COMPLETION_ROUTINE)FreeBT_HCISendCompletion,
        urb,
        TRUE,
        TRUE,
        TRUE);
 
    // We return STATUS_PENDING; call IoMarkIrpPending.
    IoMarkIrpPending(Irp);
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_SendHCICommand::"));
    FreeBT_IoIncrement(deviceExtension);
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_SendHCICommand: Sending IRP %X to underlying driver\n", Irp));
    ntStatus=IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
    if(!NT_SUCCESS(ntStatus))
    {
        FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_SendHCICommand: IoCallDriver fails with status %X\n", ntStatus));
 
        FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_SendHCICommand::"));
        FreeBT_IoDecrement(deviceExtension);
 
        // If the device was surprise removed out, the pipeInformation field is invalid.
        // similarly if the request was cancelled, then we need not reset the device.
        if((ntStatus != STATUS_CANCELLED) && (ntStatus != STATUS_DEVICE_NOT_CONNECTED))
            ntStatus = FreeBT_ResetDevice(DeviceObject);
 
        else
            FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_SendHCICommand: ntStatus is STATUS_CANCELLED or STATUS_DEVICE_NOT_CONNECTED\n"));
 
        Irp->IoStatus.Status = ntStatus;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return ntStatus;
 
    }
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_SendHCICommand: Completed successfully\n"));
 
    return STATUS_PENDING;
 
}
 
// Called when a HCI Get on the event pipe completes
NTSTATUS NTAPI FreeBT_HCIEventCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
{
    //ULONG               stageLength;
    NTSTATUS            ntStatus;
    PIO_STACK_LOCATION  nextStack;
    PURB                urb;
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_HCIEventCompletion, status=0x%08X\n", Irp->IoStatus.Status));
 
    if (Irp->PendingReturned)
        IoMarkIrpPending(Irp);
 
    // initialize variables
    urb=(PURB)Context;
    ntStatus = Irp->IoStatus.Status;
    Irp->IoStatus.Information = urb->UrbBulkOrInterruptTransfer.TransferBufferLength;
    nextStack = IoGetNextIrpStackLocation(Irp);
 
    ExFreePool(Context);
    FreeBT_IoDecrement(DeviceObject->DeviceExtension);
 
    return ntStatus;
 
}
 
// Called from the DeviceIOControl handler to wait for an event on the interrupt pipe
NTSTATUS NTAPI FreeBT_GetHCIEvent(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID IoBuffer, IN ULONG InputBufferLength)
{
    PDEVICE_EXTENSION   deviceExtension;
    PURB                urb;
    NTSTATUS            ntStatus;
    PIO_STACK_LOCATION  nextStack;
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetHCIEvent: Entered\n"));
 
    urb = NULL;
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    urb = (PURB)ExAllocatePool(NonPagedPool, sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER));
    if (urb==NULL)
    {
        FreeBT_DbgPrint(1, ("FBTUSB: FreeBT_GetHCIEvent: Failed to alloc mem for urb\n"));
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        goto FreeBT_GetHCIEvent_Exit;
 
    }
 
    UsbBuildInterruptOrBulkTransferRequest(
                            urb,
                            sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER),
                            deviceExtension->EventPipe.PipeHandle,
                            IoBuffer,
                            NULL,
                            InputBufferLength,
                            USBD_SHORT_TRANSFER_OK|USBD_TRANSFER_DIRECTION_IN,
                            NULL);
 
    // use the original irp as an internal device control irp, which we send down to the
    // USB class driver in order to get our request out on the wire
    nextStack = IoGetNextIrpStackLocation(Irp);
    nextStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    nextStack->Parameters.Others.Argument1 = (PVOID) urb;
    nextStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
 
    IoSetCompletionRoutine(
        Irp,
        (PIO_COMPLETION_ROUTINE)FreeBT_HCIEventCompletion,
        urb,
        TRUE,
        TRUE,
        TRUE);
 
    // We return STATUS_PENDING; call IoMarkIrpPending.
    IoMarkIrpPending(Irp);
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetHCIEvent::"));
    FreeBT_IoIncrement(deviceExtension);
 
    ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
    if (!NT_SUCCESS(ntStatus))
    {
        FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetHCIEvent: IoCallDriver fails with status %X\n", ntStatus));
 
        FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetHCIEvent::"));
        FreeBT_IoDecrement(deviceExtension);
 
        // If the device was surprise removed out, the pipeInformation field is invalid.
        // similarly if the request was cancelled, then we need not reset the pipe.
        if((ntStatus != STATUS_CANCELLED) && (ntStatus != STATUS_DEVICE_NOT_CONNECTED))
        {
            ntStatus = FreeBT_ResetPipe(DeviceObject, deviceExtension->EventPipe.PipeHandle);
            if(!NT_SUCCESS(ntStatus))
            {
                FreeBT_DbgPrint(1, ("FreeBT_ResetPipe failed\n"));
                ntStatus = FreeBT_ResetDevice(DeviceObject);
 
            }
 
        }
 
        else
        {
            FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetHCIEvent: ntStatus is STATUS_CANCELLED or STATUS_DEVICE_NOT_CONNECTED\n"));
 
        }
 
        goto FreeBT_GetHCIEvent_Exit;
 
    }
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetHCIEvent: Leaving\n"));
 
    // Return STATUS_PENDING, when the lower driver completes the request,
    // the FreeBT_HCIEventCompletion completion routine.
    return STATUS_PENDING;
 
FreeBT_GetHCIEvent_Exit:
    Irp->IoStatus.Status=ntStatus;
    Irp->IoStatus.Information=0;
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetHCIEvent: Failure (0x%08x), completing IRP\n", ntStatus));
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return ntStatus;
 
}
 
// DeviceIOControl dispatch
NTSTATUS NTAPI FreeBT_DispatchDevCtrl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    ULONG              code;
    PVOID              ioBuffer;
    ULONG              inputBufferLength;
    ULONG              outputBufferLength;
    ULONG              info;
    NTSTATUS           ntStatus;
    PDEVICE_EXTENSION  deviceExtension;
    PIO_STACK_LOCATION irpStack;
 
    info = 0;
    irpStack = IoGetCurrentIrpStackLocation(Irp);
    code = irpStack->Parameters.DeviceIoControl.IoControlCode;
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    ioBuffer           = Irp->AssociatedIrp.SystemBuffer;
    inputBufferLength  = irpStack->Parameters.DeviceIoControl.InputBufferLength;
    outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    if (deviceExtension->DeviceState != Working)
    {
        FreeBT_DbgPrint(1, ("FBTUSB: Invalid device state\n"));
        ntStatus = STATUS_INVALID_DEVICE_STATE;
        goto FreeBT_DispatchDevCtrlExit;
 
    }
 
    FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchDevCtrl::"));
 
    // Make sure that any selective suspend request has been completed.
    if (deviceExtension->SSEnable)
    {
        FreeBT_DbgPrint(3, ("Waiting on the IdleReqPendEvent\n"));
        KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
 
    }
 
    switch(code)
    {
    case IOCTL_FREEBT_HCI_SEND_CMD:
        FreeBT_DbgPrint(3, ("FBTUSB: IOCTL_FREEBT_HCI_SEND_CMD received\n"));
        if (inputBufferLength<FBT_HCI_CMD_MIN_SIZE)
        {
            ntStatus = STATUS_BUFFER_TOO_SMALL;
            FreeBT_DbgPrint(3, ("FBTUSB: IOCTL_FREEBT_HCI_SEND_CMD: Buffer too small\n"));
            goto FreeBT_DispatchDevCtrlExit;
 
        }
 
        if (inputBufferLength>FBT_HCI_CMD_MAX_SIZE)
        {
            ntStatus = STATUS_INVALID_BUFFER_SIZE;
            FreeBT_DbgPrint(3, ("FBTUSB: IOCTL_FREEBT_HCI_SEND_CMD: Buffer too long\n"));
            goto FreeBT_DispatchDevCtrlExit;
 
        }
 
        return FreeBT_SendHCICommand(DeviceObject, Irp, ioBuffer, inputBufferLength);
        break;
 
    case IOCTL_FREEBT_HCI_GET_EVENT:
        FreeBT_DbgPrint(3, ("FBTUSB: IOCTL_FREEBT_HCI_GET_EVENT received\n"));
        if (outputBufferLength<FBT_HCI_EVENT_MAX_SIZE)
        {
            ntStatus = STATUS_BUFFER_TOO_SMALL;
            FreeBT_DbgPrint(3, ("FBTUSB: IOCTL_FREEBT_HCI_GET_EVENT: Buffer too small\n"));
            goto FreeBT_DispatchDevCtrlExit;
 
        }
 
        return FreeBT_GetHCIEvent(DeviceObject, Irp, ioBuffer, outputBufferLength);
        break;
 
    default:
        FreeBT_DbgPrint(3, ("FBTUSB: Invalid IOCTL 0x%08x received\n", code));
        ntStatus = STATUS_INVALID_DEVICE_REQUEST;
        break;
 
    }
 
FreeBT_DispatchDevCtrlExit:
    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = ntStatus;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return ntStatus;
}
 
// Submit URB_FUNCTION_RESET_PIPE
NTSTATUS NTAPI FreeBT_ResetPipe(IN PDEVICE_OBJECT DeviceObject, IN USBD_PIPE_HANDLE PipeHandle)
{
    PURB              urb;
    NTSTATUS          ntStatus;
    PDEVICE_EXTENSION deviceExtension;
 
    urb = NULL;
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    urb = (PURB)ExAllocatePool(NonPagedPool, sizeof(struct _URB_PIPE_REQUEST));
    if (urb)
    {
        urb->UrbHeader.Length = (USHORT) sizeof(struct _URB_PIPE_REQUEST);
        urb->UrbHeader.Function = URB_FUNCTION_RESET_PIPE;
        urb->UrbPipeRequest.PipeHandle = PipeHandle;
 
        ntStatus = CallUSBD(DeviceObject, urb);
 
        ExFreePool(urb);
 
    }
 
    else
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
 
    if(NT_SUCCESS(ntStatus))
    {
        FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_ResetPipe - success\n"));
        ntStatus = STATUS_SUCCESS;
 
    }
 
    else
        FreeBT_DbgPrint(1, ("FBTUSB: FreeBT_ResetPipe - failed\n"));
 
    return ntStatus;
 
}
 
// Call FreeBT_ResetParentPort to reset the device
NTSTATUS NTAPI FreeBT_ResetDevice(IN PDEVICE_OBJECT DeviceObject)
{
    NTSTATUS ntStatus;
    ULONG    portStatus;
 
    FreeBT_DbgPrint(3, ("FreeBT_ResetDevice: Entered\n"));
 
    ntStatus = FreeBT_GetPortStatus(DeviceObject, &portStatus);
 
    if ( (NT_SUCCESS(ntStatus)) && (!(portStatus & USBD_PORT_ENABLED)) && (portStatus & USBD_PORT_CONNECTED))
        ntStatus=FreeBT_ResetParentPort(DeviceObject);
 
    FreeBT_DbgPrint(3, ("FreeBT_ResetDevice: Leaving\n"));
 
    return ntStatus;
 
}
 
// Read port status from the lower driver (USB class driver)
NTSTATUS NTAPI FreeBT_GetPortStatus(IN PDEVICE_OBJECT DeviceObject, IN OUT PULONG PortStatus)
{
    NTSTATUS           ntStatus;
    KEVENT             event;
    PIRP               irp;
    IO_STATUS_BLOCK    ioStatus;
    PIO_STACK_LOCATION nextStack;
    PDEVICE_EXTENSION  deviceExtension;
 
    FreeBT_DbgPrint(3, ("FreeBT_GetPortStatus: Entered\n"));
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
    *PortStatus = 0;
 
    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(
                    IOCTL_INTERNAL_USB_GET_PORT_STATUS,
                    deviceExtension->TopOfStackDeviceObject,
                    NULL,
                    0,
                    NULL,
                    0,
                    TRUE,
                    &event,
                    &ioStatus);
 
    if (NULL == irp)
    {
        FreeBT_DbgPrint(1, ("memory alloc for irp failed\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
 
    }
 
    nextStack = IoGetNextIrpStackLocation(irp);
    ASSERT(nextStack != NULL);
    nextStack->Parameters.Others.Argument1 = PortStatus;
 
    ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, irp);
    if (STATUS_PENDING==ntStatus)
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
 
    else
        ioStatus.Status = ntStatus;
 
    ntStatus = ioStatus.Status;
    FreeBT_DbgPrint(3, ("FreeBT_GetPortStatus: Leaving\n"));
 
    return ntStatus;
 
}
 
// Sends an IOCTL_INTERNAL_USB_RESET_PORT via the lower driver
NTSTATUS NTAPI FreeBT_ResetParentPort(IN PDEVICE_OBJECT DeviceObject)
{
    NTSTATUS           ntStatus;
    KEVENT             event;
    PIRP               irp;
    IO_STATUS_BLOCK    ioStatus;
    PIO_STACK_LOCATION nextStack;
    PDEVICE_EXTENSION  deviceExtension;
 
    FreeBT_DbgPrint(3, ("FreeBT_ResetParentPort: Entered\n"));
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    KeInitializeEvent(&event, NotificationEvent, FALSE);
    irp = IoBuildDeviceIoControlRequest(
                    IOCTL_INTERNAL_USB_RESET_PORT,
                    deviceExtension->TopOfStackDeviceObject,
                    NULL,
                    0,
                    NULL,
                    0,
                    TRUE,
                    &event,
                    &ioStatus);
 
    if (NULL == irp)
    {
        FreeBT_DbgPrint(1, ("memory alloc for irp failed\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
 
    }
 
    nextStack = IoGetNextIrpStackLocation(irp);
    ASSERT(nextStack != NULL);
 
    ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, irp);
    if(STATUS_PENDING == ntStatus)
        KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
 
    else
        ioStatus.Status = ntStatus;
 
 
    ntStatus = ioStatus.Status;
 
    FreeBT_DbgPrint(3, ("FreeBT_ResetParentPort: Leaving\n"));
 
    return ntStatus;
 
}
 
// Send an idle request to the lower driver
NTSTATUS NTAPI SubmitIdleRequestIrp(IN PDEVICE_EXTENSION DeviceExtension)
{
    PIRP                    irp;
    NTSTATUS                ntStatus;
    KIRQL                   oldIrql;
    PUSB_IDLE_CALLBACK_INFO idleCallbackInfo;
    PIO_STACK_LOCATION      nextStack;
 
    FreeBT_DbgPrint(3, ("SubmitIdleRequest: Entered\n"));
 
    irp = NULL;
    idleCallbackInfo = NULL;
 
    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 
    if(PowerDeviceD0 != DeviceExtension->DevPower) {
 
        ntStatus = STATUS_POWER_STATE_INVALID;
 
        goto SubmitIdleRequestIrp_Exit;
    }
 
    KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
 
    if(InterlockedExchange(&DeviceExtension->IdleReqPend, 1)) {
 
        FreeBT_DbgPrint(1, ("Idle request pending..\n"));
 
        KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
 
        ntStatus = STATUS_DEVICE_BUSY;
 
        goto SubmitIdleRequestIrp_Exit;
    }
 
    //
    // clear the NoIdleReqPendEvent because we are about
    // to submit an idle request. Since we are so early
    // to clear this event, make sure that if we fail this
    // request we set back the event.
    //
    KeClearEvent(&DeviceExtension->NoIdleReqPendEvent);
 
    idleCallbackInfo = (PUSB_IDLE_CALLBACK_INFO)ExAllocatePool(NonPagedPool, sizeof(struct _USB_IDLE_CALLBACK_INFO));
 
    if(idleCallbackInfo) {
 
        idleCallbackInfo->IdleCallback = (USB_IDLE_CALLBACK)IdleNotificationCallback;
 
        idleCallbackInfo->IdleContext = (PVOID)DeviceExtension;
 
        ASSERT(DeviceExtension->IdleCallbackInfo == NULL);
 
        DeviceExtension->IdleCallbackInfo = idleCallbackInfo;
 
        //
        // we use IoAllocateIrp to create an irp to selectively suspend the
        // device. This irp lies pending with the hub driver. When appropriate
        // the hub driver will invoked callback, where we power down. The completion
        // routine is invoked when we power back.
        //
        irp = IoAllocateIrp(DeviceExtension->TopOfStackDeviceObject->StackSize,
                            FALSE);
 
        if(irp == NULL) {
 
            FreeBT_DbgPrint(1, ("cannot build idle request irp\n"));
 
            KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
                       IO_NO_INCREMENT,
                       FALSE);
 
            InterlockedExchange(&DeviceExtension->IdleReqPend, 0);
 
            KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
 
            ExFreePool(idleCallbackInfo);
 
            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
 
            goto SubmitIdleRequestIrp_Exit;
        }
 
        nextStack = IoGetNextIrpStackLocation(irp);
 
        nextStack->MajorFunction =
                    IRP_MJ_INTERNAL_DEVICE_CONTROL;
 
        nextStack->Parameters.DeviceIoControl.IoControlCode =
                    IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION;
 
        nextStack->Parameters.DeviceIoControl.Type3InputBuffer =
                    idleCallbackInfo;
 
        nextStack->Parameters.DeviceIoControl.InputBufferLength =
                    sizeof(struct _USB_IDLE_CALLBACK_INFO);
 
 
        IoSetCompletionRoutine(irp,
                               (PIO_COMPLETION_ROUTINE)IdleNotificationRequestComplete,
                               DeviceExtension,
                               TRUE,
                               TRUE,
                               TRUE);
 
        DeviceExtension->PendingIdleIrp = irp;
 
        //
        // we initialize the count to 2.
        // The reason is, if the CancelSelectSuspend routine manages
        // to grab the irp from the device extension, then the last of the
        // CancelSelectSuspend routine/IdleNotificationRequestComplete routine
        // to execute will free this irp. We need to have this schema so that
        // 1. completion routine does not attempt to touch the irp freed by
        //    CancelSelectSuspend routine.
        // 2. CancelSelectSuspend routine doesnt wait for ever for the completion
        //    routine to complete!
        //
        DeviceExtension->FreeIdleIrpCount = 2;
 
        KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
 
        //
        // check if the device is idle.
        // A check here ensures that a race condition did not
        // completely reverse the call sequence of SubmitIdleRequestIrp
        // and CancelSelectiveSuspend
        //
 
        if(!CanDeviceSuspend(DeviceExtension) ||
           PowerDeviceD0 != DeviceExtension->DevPower) {
 
            //
            // IRPs created using IoBuildDeviceIoControlRequest should be
            // completed by calling IoCompleteRequest and not merely
            // deallocated.
            //
 
            FreeBT_DbgPrint(1, ("Device is not idle\n"));
 
            KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
 
            DeviceExtension->IdleCallbackInfo = NULL;
 
            DeviceExtension->PendingIdleIrp = NULL;
 
            KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
                       IO_NO_INCREMENT,
                       FALSE);
 
            InterlockedExchange(&DeviceExtension->IdleReqPend, 0);
 
            KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
 
            if(idleCallbackInfo) {
 
                ExFreePool(idleCallbackInfo);
            }
 
            //
            // it is still safe to touch the local variable "irp" here.
            // the irp has not been passed down the stack, the irp has
            // no cancellation routine. The worse position is that the
            // CancelSelectSuspend has run after we released the spin
            // lock above. It is still essential to free the irp.
            //
            if(irp) {
 
                IoFreeIrp(irp);
            }
 
            ntStatus = STATUS_UNSUCCESSFUL;
 
            goto SubmitIdleRequestIrp_Exit;
        }
 
        FreeBT_DbgPrint(3, ("Cancel the timers\n"));
        //
        // Cancel the timer so that the DPCs are no longer fired.
        // Thus, we are making judicious usage of our resources.
        // we do not need DPCs because we already have an idle irp pending.
        // The timers are re-initialized in the completion routine.
        //
        KeCancelTimer(&DeviceExtension->Timer);
 
        ntStatus = IoCallDriver(DeviceExtension->TopOfStackDeviceObject, irp);
 
        if(!NT_SUCCESS(ntStatus)) {
 
            FreeBT_DbgPrint(1, ("IoCallDriver failed\n"));
 
            goto SubmitIdleRequestIrp_Exit;
        }
    }
    else {
 
        FreeBT_DbgPrint(1, ("Memory allocation for idleCallbackInfo failed\n"));
 
        KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
                   IO_NO_INCREMENT,
                   FALSE);
 
        InterlockedExchange(&DeviceExtension->IdleReqPend, 0);
 
        KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
 
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
    }
 
SubmitIdleRequestIrp_Exit:
 
    FreeBT_DbgPrint(3, ("SubmitIdleRequest: Leaving\n"));
 
    return ntStatus;
}
 
 
VOID NTAPI IdleNotificationCallback(IN PDEVICE_EXTENSION DeviceExtension)
{
    NTSTATUS                ntStatus;
    POWER_STATE             powerState;
    KEVENT                  irpCompletionEvent;
    PIRP_COMPLETION_CONTEXT irpContext;
 
    FreeBT_DbgPrint(3, ("FBTUSB: IdleNotificationCallback: Entered\n"));
 
    //
    // Dont idle, if the device was just disconnected or being stopped
    // i.e. return for the following DeviceState(s)
    // NotStarted, Stopped, PendingStop, PendingRemove, SurpriseRemoved, Removed
    //
 
    if(DeviceExtension->DeviceState != Working) {
 
        return;
    }
 
    //
    // If there is not already a WW IRP pending, submit one now
    //
    if(DeviceExtension->WaitWakeEnable) {
 
        IssueWaitWake(DeviceExtension);
    }
 
 
    //
    // power down the device
    //
 
    irpContext = (PIRP_COMPLETION_CONTEXT)
                 ExAllocatePool(NonPagedPool,
                                sizeof(IRP_COMPLETION_CONTEXT));
 
    if(!irpContext) {
 
        FreeBT_DbgPrint(1, ("FBTUSB: IdleNotificationCallback: Failed to alloc memory for irpContext\n"));
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
    }
    else {
 
        //
        // increment the count. In the HoldIoRequestWorkerRoutine, the
        // count is decremented twice (one for the system Irp and the
        // other for the device Irp. An increment here compensates for
        // the sytem irp..The decrement corresponding to this increment
        // is in the completion function
        //
 
        FreeBT_DbgPrint(3, ("FBTUSB: IdleNotificationCallback::"));
        FreeBT_IoIncrement(DeviceExtension);
 
        powerState.DeviceState = (DEVICE_POWER_STATE) DeviceExtension->PowerDownLevel;
 
        KeInitializeEvent(&irpCompletionEvent, NotificationEvent, FALSE);
 
        irpContext->DeviceExtension = DeviceExtension;
        irpContext->Event = &irpCompletionEvent;
 
        ntStatus = PoRequestPowerIrp(
                          DeviceExtension->PhysicalDeviceObject,
                          IRP_MN_SET_POWER,
                          powerState,
                          (PREQUEST_POWER_COMPLETE) PoIrpCompletionFunc,
                          irpContext,
                          NULL);
 
        if(STATUS_PENDING == ntStatus) {
 
            FreeBT_DbgPrint(3, ("FBTUSB: IdleNotificationCallback::"
                           "waiting for the power irp to complete\n"));
 
            KeWaitForSingleObject(&irpCompletionEvent,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
        }
    }
 
    if(!NT_SUCCESS(ntStatus)) {
 
        if(irpContext) {
 
            ExFreePool(irpContext);
        }
    }
 
    FreeBT_DbgPrint(3, ("FBTUSB: IdleNotificationCallback: Leaving\n"));
}
 
 
NTSTATUS NTAPI IdleNotificationRequestComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
{
    NTSTATUS                ntStatus;
    POWER_STATE             powerState;
    KIRQL                   oldIrql;
    LARGE_INTEGER           dueTime;
    PIRP                    idleIrp;
    PUSB_IDLE_CALLBACK_INFO idleCallbackInfo;
 
    FreeBT_DbgPrint(3, ("FBTUSB: IdleNotificationRequestCompete: Entered\n"));
 
    idleIrp = NULL;
 
    ntStatus = Irp->IoStatus.Status;
    if(!NT_SUCCESS(ntStatus) && ntStatus != STATUS_NOT_SUPPORTED)
    {
        FreeBT_DbgPrint(3, ("FBTUSB: IdleNotificationRequestCompete: Idle irp completes with error::"));
        switch(ntStatus)
        {
        case STATUS_INVALID_DEVICE_REQUEST:
            FreeBT_DbgPrint(3, ("STATUS_INVALID_DEVICE_REQUEST\n"));
            break;
 
        case STATUS_CANCELLED:
            FreeBT_DbgPrint(3, ("STATUS_CANCELLED\n"));
            break;
 
        case STATUS_DEVICE_BUSY:
            FreeBT_DbgPrint(3, ("STATUS_DEVICE_BUSY\n"));
            break;
 
        case STATUS_POWER_STATE_INVALID:
            FreeBT_DbgPrint(3, ("STATUS_POWER_STATE_INVALID\n"));
            goto IdleNotificationRequestComplete_Exit;
 
        default:
            FreeBT_DbgPrint(3, ("default: status = %X\n", ntStatus));
            break;
 
        }
 
        // if in error, issue a SetD0
        FreeBT_DbgPrint(3, ("FBTUSB: IdleNotificationRequestComplete::"));
        FreeBT_IoIncrement(DeviceExtension);
 
        powerState.DeviceState = PowerDeviceD0;
        ntStatus = PoRequestPowerIrp(
                          DeviceExtension->PhysicalDeviceObject,
                          IRP_MN_SET_POWER,
                          powerState,
                          (PREQUEST_POWER_COMPLETE) PoIrpAsyncCompletionFunc,
                          DeviceExtension,
                          NULL);
 
        if(!NT_SUCCESS(ntStatus))
            FreeBT_DbgPrint(1, ("PoRequestPowerIrp failed\n"));
 
    }
 
IdleNotificationRequestComplete_Exit:
    KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
    idleCallbackInfo = DeviceExtension->IdleCallbackInfo;
    DeviceExtension->IdleCallbackInfo = NULL;
 
    idleIrp = (PIRP) InterlockedExchangePointer((PVOID*)&DeviceExtension->PendingIdleIrp, NULL);
    InterlockedExchange(&DeviceExtension->IdleReqPend, 0);
 
    KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
 
    if(idleCallbackInfo)
        ExFreePool(idleCallbackInfo);
 
    // Since the irp was created using IoAllocateIrp,
    // the Irp needs to be freed using IoFreeIrp.
    // Also return STATUS_MORE_PROCESSING_REQUIRED so that
    // the kernel does not reference this in the near future.
    if(idleIrp)
    {
        FreeBT_DbgPrint(3, ("completion routine has a valid irp and frees it\n"));
        IoFreeIrp(Irp);
        KeSetEvent(&DeviceExtension->NoIdleReqPendEvent, IO_NO_INCREMENT, FALSE);
 
    }
 
    else
    {
        // The CancelSelectiveSuspend routine has grabbed the Irp from the device
        // extension. Now the last one to decrement the FreeIdleIrpCount should
        // free the irp.
        if (0 == InterlockedDecrement(&DeviceExtension->FreeIdleIrpCount))
        {
            FreeBT_DbgPrint(3, ("completion routine frees the irp\n"));
            IoFreeIrp(Irp);
            KeSetEvent(&DeviceExtension->NoIdleReqPendEvent, IO_NO_INCREMENT, FALSE);
 
        }
 
    }
 
    if(DeviceExtension->SSEnable)
    {
        FreeBT_DbgPrint(3, ("Set the timer to fire DPCs\n"));
        dueTime.QuadPart = -10000 * IDLE_INTERVAL;               // 5000 ms
        KeSetTimerEx(&DeviceExtension->Timer, dueTime, IDLE_INTERVAL, &DeviceExtension->DeferredProcCall);
        FreeBT_DbgPrint(3, ("IdleNotificationRequestCompete: Leaving\n"));
 
    }
 
    return STATUS_MORE_PROCESSING_REQUIRED;
 
}
 
VOID NTAPI CancelSelectSuspend(IN PDEVICE_EXTENSION DeviceExtension)
{
    PIRP  irp;
    KIRQL oldIrql;
 
    FreeBT_DbgPrint(3, ("CancelSelectSuspend: Entered\n"));
 
    irp = NULL;
 
    KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
 
    if(!CanDeviceSuspend(DeviceExtension))
    {
        FreeBT_DbgPrint(3, ("Device is not idle\n"));
        irp = (PIRP) InterlockedExchangePointer((PVOID*)&DeviceExtension->PendingIdleIrp, NULL);
 
    }
 
    KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
 
    // since we have a valid Irp ptr,
    // we can call IoCancelIrp on it,
    // without the fear of the irp
    // being freed underneath us.
    if(irp)
    {
        // This routine has the irp pointer.
        // It is safe to call IoCancelIrp because we know that
        // the compleiton routine will not free this irp unless...
        //
        //
        if(IoCancelIrp(irp))
        {
            FreeBT_DbgPrint(3, ("IoCancelIrp returns TRUE\n"));
 
        }
 
        else
        {
            FreeBT_DbgPrint(3, ("IoCancelIrp returns FALSE\n"));
 
        }
 
        // ....we decrement the FreeIdleIrpCount from 2 to 1.
        // if completion routine runs ahead of us, then this routine
        // decrements the FreeIdleIrpCount from 1 to 0 and hence shall
        // free the irp.
        if(0 == InterlockedDecrement(&DeviceExtension->FreeIdleIrpCount))
        {
            FreeBT_DbgPrint(3, ("CancelSelectSuspend frees the irp\n"));
            IoFreeIrp(irp);
            KeSetEvent(&DeviceExtension->NoIdleReqPendEvent, IO_NO_INCREMENT, FALSE);
 
        }
 
    }
 
    FreeBT_DbgPrint(3, ("CancelSelectSuspend: Leaving\n"));
 
    return;
 
}
 
VOID NTAPI PoIrpCompletionFunc(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
{
    PIRP_COMPLETION_CONTEXT irpContext;
    irpContext = NULL;
 
    FreeBT_DbgPrint(3, ("PoIrpCompletionFunc::"));
 
    if(Context)
        irpContext = (PIRP_COMPLETION_CONTEXT) Context;
 
    // all we do is set the event and decrement the count
    if(irpContext)
    {
        KeSetEvent(irpContext->Event, 0, FALSE);
        FreeBT_IoDecrement(irpContext->DeviceExtension);
        ExFreePool(irpContext);
 
    }
 
    return;
 
}
 
VOID NTAPI PoIrpAsyncCompletionFunc(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
{
    PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION) Context;
    FreeBT_DbgPrint(3, ("PoIrpAsyncCompletionFunc::"));
    FreeBT_IoDecrement(DeviceExtension);
 
    return;
 
}
 
VOID NTAPI WWIrpCompletionFunc(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
{
    PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION) Context;
 
    FreeBT_DbgPrint(3, ("WWIrpCompletionFunc::"));
    FreeBT_IoDecrement(DeviceExtension);
 
    return;
 
}