fbtdev.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
NTSTATUS NTAPI	FreeBT_DispatchCreate (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	FreeBT_DispatchClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	FreeBT_DispatchDevCtrl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	FreeBT_ResetPipe (IN PDEVICE_OBJECT DeviceObject, IN USBD_PIPE_HANDLE PipeInfo)
NTSTATUS NTAPI	FreeBT_ResetDevice (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	FreeBT_GetPortStatus (IN PDEVICE_OBJECT DeviceObject, IN PULONG PortStatus)
NTSTATUS NTAPI	FreeBT_ResetParentPort (IN IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	SubmitIdleRequestIrp (IN PDEVICE_EXTENSION DeviceExtension)
VOID NTAPI	IdleNotificationCallback (IN PDEVICE_EXTENSION DeviceExtension)
NTSTATUS NTAPI	IdleNotificationRequestComplete (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
VOID NTAPI	CancelSelectSuspend (IN PDEVICE_EXTENSION DeviceExtension)
VOID NTAPI	PoIrpCompletionFunc (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
VOID NTAPI	PoIrpAsyncCompletionFunc (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
VOID NTAPI	WWIrpCompletionFunc (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)

Function Documentation

CancelSelectSuspend()

VOID NTAPI CancelSelectSuspend

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 1093 of file fbtdev.c.

{
    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;
 
}

Referenced by FreeBT_DispatchCreate(), and FreeBT_DispatchPnP().

FreeBT_DispatchClose()

NTSTATUS NTAPI FreeBT_DispatchClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 102 of file fbtdev.c.

{
    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;
 
}

Referenced by DriverEntry().

FreeBT_DispatchCreate()

NTSTATUS NTAPI FreeBT_DispatchCreate	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 23 of file fbtdev.c.

{
    //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;
 
}

Referenced by DriverEntry().

FreeBT_DispatchDevCtrl()

NTSTATUS NTAPI FreeBT_DispatchDevCtrl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 412 of file fbtdev.c.

{
    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;
}

Referenced by DriverEntry().

FreeBT_GetPortStatus()

NTSTATUS NTAPI FreeBT_GetPortStatus	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PULONG	PortStatus
	)

FreeBT_ResetDevice()

NTSTATUS NTAPI FreeBT_ResetDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 546 of file fbtdev.c.

{
    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;
 
}

Referenced by FreeBT_DispatchRead(), FreeBT_DispatchWrite(), FreeBT_GetHCIEvent(), and FreeBT_SendHCICommand().

FreeBT_ResetParentPort()

NTSTATUS NTAPI FreeBT_ResetParentPort

(

IN IN PDEVICE_OBJECT

DeviceObject

)

FreeBT_ResetPipe()

NTSTATUS NTAPI FreeBT_ResetPipe	(	IN PDEVICE_OBJECT	DeviceObject,
		IN USBD_PIPE_HANDLE	PipeInfo
	)

Definition at line 506 of file fbtdev.c.

{
    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;
 
}

Referenced by FreeBT_DispatchRead(), FreeBT_DispatchWrite(), and FreeBT_GetHCIEvent().

IdleNotificationCallback()

VOID NTAPI IdleNotificationCallback

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 886 of file fbtdev.c.

{
    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"));
}

Referenced by SubmitIdleRequestIrp().

IdleNotificationRequestComplete()

NTSTATUS NTAPI IdleNotificationRequestComplete	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PDEVICE_EXTENSION	DeviceExtension
	)

Definition at line 981 of file fbtdev.c.

{
    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;
 
}

Referenced by SubmitIdleRequestIrp().

PoIrpAsyncCompletionFunc()

VOID NTAPI PoIrpAsyncCompletionFunc	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	MinorFunction,
		IN POWER_STATE	PowerState,
		IN PVOID	Context,
		IN PIO_STATUS_BLOCK	IoStatus
	)

Definition at line 1179 of file fbtdev.c.

{
    PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION) Context;
    FreeBT_DbgPrint(3, ("PoIrpAsyncCompletionFunc::"));
    FreeBT_IoDecrement(DeviceExtension);
 
    return;
 
}

Referenced by IdleNotificationRequestComplete().

PoIrpCompletionFunc()

VOID NTAPI PoIrpCompletionFunc	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	MinorFunction,
		IN POWER_STATE	PowerState,
		IN PVOID	Context,
		IN PIO_STATUS_BLOCK	IoStatus
	)

Definition at line 1156 of file fbtdev.c.

{
    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;
 
}

Referenced by IdleNotificationCallback().

SubmitIdleRequestIrp()

NTSTATUS NTAPI SubmitIdleRequestIrp

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 669 of file fbtdev.c.

{
    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;
}

Referenced by IdleRequestWorkerRoutine().

WWIrpCompletionFunc()

VOID NTAPI WWIrpCompletionFunc	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	MinorFunction,
		IN POWER_STATE	PowerState,
		IN PVOID	Context,
		IN PIO_STATUS_BLOCK	IoStatus
	)

Definition at line 1189 of file fbtdev.c.

{
    PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION) Context;
 
    FreeBT_DbgPrint(3, ("WWIrpCompletionFunc::"));
    FreeBT_IoDecrement(DeviceExtension);
 
    return;
 
}

Referenced by WaitWakeCallback().