queue.c File Reference

#include "usbport.h"
#include <debug.h>
#include "usbdebug.h"

Include dependency graph for queue.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	NDEBUG_USBPORT_CORE
#define	NDEBUG_USBPORT_QUEUE
#define	NDEBUG_USBPORT_URB

Functions
VOID NTAPI	USBPORT_InsertIdleIrp (IN PIO_CSQ Csq, IN PIRP Irp)
VOID NTAPI	USBPORT_RemoveIdleIrp (IN PIO_CSQ Csq, IN PIRP Irp)
PIRP NTAPI	USBPORT_PeekNextIdleIrp (IN PIO_CSQ Csq, IN PIRP Irp, IN PVOID PeekContext)
VOID NTAPI	USBPORT_AcquireIdleLock (IN PIO_CSQ Csq, IN PKIRQL Irql)
VOID NTAPI	USBPORT_ReleaseIdleLock (IN PIO_CSQ Csq, IN KIRQL Irql)
VOID NTAPI	USBPORT_CompleteCanceledIdleIrp (IN PIO_CSQ Csq, IN PIRP Irp)
VOID NTAPI	USBPORT_InsertBadRequest (IN PIO_CSQ Csq, IN PIRP Irp)
VOID NTAPI	USBPORT_RemoveBadRequest (IN PIO_CSQ Csq, IN PIRP Irp)
PIRP NTAPI	USBPORT_PeekNextBadRequest (IN PIO_CSQ Csq, IN PIRP Irp, IN PVOID PeekContext)
VOID NTAPI	USBPORT_AcquireBadRequestLock (IN PIO_CSQ Csq, IN PKIRQL Irql)
VOID NTAPI	USBPORT_ReleaseBadRequestLock (IN PIO_CSQ Csq, IN KIRQL Irql)
VOID NTAPI	USBPORT_CompleteCanceledBadRequest (IN PIO_CSQ Csq, IN PIRP Irp)
VOID NTAPI	USBPORT_InsertIrpInTable (IN PUSBPORT_IRP_TABLE IrpTable, IN PIRP Irp)
PIRP NTAPI	USBPORT_RemoveIrpFromTable (IN PUSBPORT_IRP_TABLE IrpTable, IN PIRP Irp)
PIRP NTAPI	USBPORT_RemoveActiveTransferIrp (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
PIRP NTAPI	USBPORT_RemovePendingTransferIrp (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
VOID NTAPI	USBPORT_FindUrbInIrpTable (IN PUSBPORT_IRP_TABLE IrpTable, IN PURB Urb, IN PIRP Irp)
PIRP NTAPI	USBPORT_FindIrpInTable (IN PUSBPORT_IRP_TABLE IrpTable, IN PIRP Irp)
PIRP NTAPI	USBPORT_FindActiveTransferIrp (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
VOID NTAPI	USBPORT_CancelPendingTransferIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	USBPORT_CancelActiveTransferIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	USBPORT_FlushAbortList (IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_FlushCancelList (IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_FlushPendingTransfers (IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_QueuePendingUrbToEndpoint (IN PUSBPORT_ENDPOINT Endpoint, IN PURB Urb)
BOOLEAN NTAPI	USBPORT_QueueActiveUrbToEndpoint (IN PUSBPORT_ENDPOINT Endpoint, IN PURB Urb)
VOID NTAPI	USBPORT_QueuePendingTransferIrp (IN PIRP Irp)
VOID NTAPI	USBPORT_QueueTransferUrb (IN PURB Urb)
VOID NTAPI	USBPORT_FlushAllEndpoints (IN PDEVICE_OBJECT FdoDevice)
ULONG NTAPI	USBPORT_KillEndpointActiveTransfers (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_FlushController (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_BadRequestFlush (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_AbortEndpoint (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint, IN PIRP Irp)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 10 of file queue.c.

NDEBUG_USBPORT_CORE

#define NDEBUG_USBPORT_CORE

Definition at line 13 of file queue.c.

NDEBUG_USBPORT_QUEUE

#define NDEBUG_USBPORT_QUEUE

Definition at line 14 of file queue.c.

NDEBUG_USBPORT_URB

#define NDEBUG_USBPORT_URB

Definition at line 15 of file queue.c.

Function Documentation

USBPORT_AbortEndpoint()

VOID NTAPI USBPORT_AbortEndpoint	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint,
		IN PIRP	Irp
	)

Definition at line 1354 of file queue.c.

{
    PLIST_ENTRY PendingList;
    PUSBPORT_TRANSFER PendingTransfer;
    PLIST_ENTRY ActiveList;
    PUSBPORT_TRANSFER ActiveTransfer;
 
    DPRINT_CORE("USBPORT_AbortEndpoint: Irp - %p\n", Irp);
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
 
    if (Irp)
    {
        InsertTailList(&Endpoint->AbortList, &Irp->Tail.Overlay.ListEntry);
    }
 
    PendingList = Endpoint->PendingTransferList.Flink;
 
    while (PendingList && PendingList != &Endpoint->PendingTransferList)
    {
        PendingTransfer = CONTAINING_RECORD(PendingList,
                                            USBPORT_TRANSFER,
                                            TransferLink);
 
        DPRINT_CORE("USBPORT_AbortEndpoint: Abort PendingTransfer - %p\n",
                    PendingTransfer);
 
        PendingTransfer->Flags |= TRANSFER_FLAG_ABORTED;
 
        PendingList = PendingTransfer->TransferLink.Flink;
    }
 
    ActiveList = Endpoint->TransferList.Flink;
 
    while (ActiveList && ActiveList != &Endpoint->TransferList)
    {
        ActiveTransfer = CONTAINING_RECORD(ActiveList,
                                           USBPORT_TRANSFER,
                                           TransferLink);
 
        DPRINT_CORE("USBPORT_AbortEndpoint: Abort ActiveTransfer - %p\n",
                    ActiveTransfer);
 
        ActiveTransfer->Flags |= TRANSFER_FLAG_ABORTED;
 
        if (Endpoint->Flags & ENDPOINT_FLAG_ABORTING)
        {
            ActiveTransfer->Flags |= TRANSFER_FLAG_DEVICE_GONE;
        }
 
        ActiveList = ActiveTransfer->TransferLink.Flink;
    }
 
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    USBPORT_InvalidateEndpointHandler(FdoDevice,
                                      Endpoint,
                                      INVALIDATE_ENDPOINT_INT_NEXT_SOF);
 
    USBPORT_FlushPendingTransfers(Endpoint);
    USBPORT_FlushCancelList(Endpoint);
}

Referenced by USBPORT_AbortPipe(), and USBPORT_AbortTransfers().

USBPORT_AcquireBadRequestLock()

VOID NTAPI USBPORT_AcquireBadRequestLock	(	IN PIO_CSQ	Csq,
		IN PKIRQL	Irql
	)

Definition at line 214 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_AcquireBadRequestLock: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    KeAcquireSpinLock(&FdoExtension->BadRequestIoCsqSpinLock, Irql);
}

Referenced by USBPORT_StartDevice().

USBPORT_AcquireIdleLock()

VOID NTAPI USBPORT_AcquireIdleLock	(	IN PIO_CSQ	Csq,
		IN PKIRQL	Irql
	)

Definition at line 91 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_AcquireIdleLock: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    KeAcquireSpinLock(&FdoExtension->IdleIoCsqSpinLock, Irql);
}

Referenced by USBPORT_StartDevice().

USBPORT_BadRequestFlush()

VOID NTAPI USBPORT_BadRequestFlush

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1328 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PIRP Irp;
 
    DPRINT_QUEUE("USBPORT_BadRequestFlush: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    while (TRUE)
    {
        Irp = IoCsqRemoveNextIrp(&FdoExtension->BadRequestIoCsq, 0);
 
        if (!Irp)
            break;
 
        DPRINT1("USBPORT_BadRequestFlush: Irp - %p\n", Irp);
 
        Irp->IoStatus.Status = STATUS_DEVICE_NOT_CONNECTED;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
}

Referenced by USBHI_FlushTransfers(), and USBPORT_TimerDpc().

USBPORT_CancelActiveTransferIrp()

VOID NTAPI USBPORT_CancelActiveTransferIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 529 of file queue.c.

{
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PURB Urb;
    PUSBPORT_TRANSFER Transfer;
    PUSBPORT_ENDPOINT Endpoint;
    PIRP irp;
    PUSBPORT_TRANSFER SplitTransfer;
    PLIST_ENTRY Entry;
    KIRQL OldIrql;
 
    DPRINT_CORE("USBPORT_CancelActiveTransferIrp: Irp - %p\n", Irp);
 
    PdoExtension = DeviceObject->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
 
    irp = USBPORT_FindActiveTransferIrp(FdoDevice, Irp);
 
    if (!irp)
    {
        KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
        return;
    }
 
    Urb = URB_FROM_IRP(irp);
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    Endpoint = Transfer->Endpoint;
 
    DPRINT_CORE("USBPORT_CancelActiveTransferIrp: irp - %p, Urb - %p, Transfer - %p\n",
                irp,
                Urb,
                Transfer);
 
    KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
 
    Transfer->Flags |= TRANSFER_FLAG_CANCELED;
 
    if (Transfer->Flags & TRANSFER_FLAG_PARENT)
    {
        KeAcquireSpinLockAtDpcLevel(&Transfer->TransferSpinLock);
 
        Entry = Transfer->SplitTransfersList.Flink;
 
        while (Entry && Entry != &Transfer->SplitTransfersList)
        {
            SplitTransfer = CONTAINING_RECORD(Entry,
                                              USBPORT_TRANSFER,
                                              SplitLink);
 
            SplitTransfer->Flags |= TRANSFER_FLAG_CANCELED;
 
            Entry = Entry->Flink;
        }
 
        KeReleaseSpinLockFromDpcLevel(&Transfer->TransferSpinLock);
    }
 
    KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
    KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
    USBPORT_InvalidateEndpointHandler(FdoDevice,
                                      Endpoint,
                                      INVALIDATE_ENDPOINT_WORKER_THREAD);
    return;
}

Referenced by USBPORT_FlushPendingTransfers().

USBPORT_CancelPendingTransferIrp()

VOID NTAPI USBPORT_CancelPendingTransferIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 479 of file queue.c.

{
    PURB Urb;
    PUSBPORT_TRANSFER Transfer;
    PUSBPORT_ENDPOINT Endpoint;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    KIRQL OldIrql;
    PIRP irp;
 
    DPRINT_CORE("USBPORT_CancelPendingTransferIrp: DeviceObject - %p, Irp - %p\n",
                DeviceObject,
                Irp);
 
    Urb = URB_FROM_IRP(Irp);
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    Endpoint = Transfer->Endpoint;
 
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = DeviceObject->DeviceExtension;
 
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    KeAcquireSpinLock(&FdoExtension->FlushPendingTransferSpinLock, &OldIrql);
 
    irp = USBPORT_RemovePendingTransferIrp(FdoDevice, Irp);
 
    if (!irp)
    {
        KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                          OldIrql);
        return;
    }
 
    KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
 
    RemoveEntryList(&Transfer->TransferLink);
 
    Transfer->TransferLink.Flink = NULL;
    Transfer->TransferLink.Blink = NULL;
 
    KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
    KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock, OldIrql);
 
    USBPORT_CompleteTransfer(Transfer->Urb, USBD_STATUS_CANCELED);
}

Referenced by USBPORT_QueuePendingTransferIrp().

USBPORT_CompleteCanceledBadRequest()

VOID NTAPI USBPORT_CompleteCanceledBadRequest	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 246 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_CompleteCanceledBadRequest: Irp - %p\n", Irp);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    InterlockedDecrement(&FdoExtension->BadRequestLockCounter);
 
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by USBPORT_StartDevice().

USBPORT_CompleteCanceledIdleIrp()

VOID NTAPI USBPORT_CompleteCanceledIdleIrp	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 123 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_CompleteCanceledIdleIrp: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    InterlockedDecrement(&FdoExtension->IdleLockCounter);
 
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by USBPORT_StartDevice().

USBPORT_FindActiveTransferIrp()

PIRP NTAPI USBPORT_FindActiveTransferIrp	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 467 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_CORE("USBPORT_FindActiveTransferIrp: Irp - %p\n", Irp);
    FdoExtension = FdoDevice->DeviceExtension;
    return USBPORT_FindIrpInTable(FdoExtension->ActiveIrpTable, Irp);
}

Referenced by USBPORT_CancelActiveTransferIrp().

USBPORT_FindIrpInTable()

PIRP NTAPI USBPORT_FindIrpInTable	(	IN PUSBPORT_IRP_TABLE	IrpTable,
		IN PIRP	Irp
	)

Definition at line 433 of file queue.c.

{
    ULONG ix;
    PIRP irp;
 
    DPRINT_CORE("USBPORT_FindIrpInTable: IrpTable - %p, Irp - %p\n",
                IrpTable,
                Irp);
 
    ASSERT(IrpTable != NULL);
 
    do
    {
        for (ix = 0; ix < 0x200; ix++)
        {
            irp = IrpTable->irp[ix];
 
            if (irp && irp == Irp)
            {
                return irp;
            }
        }
 
        IrpTable = IrpTable->LinkNextTable;
    }
    while (IrpTable->LinkNextTable);
 
    DPRINT_CORE("USBPORT_FindIrpInTable: Not found!!!\n");
    return NULL;
}

Referenced by USBPORT_FindActiveTransferIrp().

USBPORT_FindUrbInIrpTable()

VOID NTAPI USBPORT_FindUrbInIrpTable	(	IN PUSBPORT_IRP_TABLE	IrpTable,
		IN PURB	Urb,
		IN PIRP	Irp
	)

Definition at line 381 of file queue.c.

{
    ULONG ix;
    PIRP irp;
    PURB urbIn;
 
    DPRINT_CORE("USBPORT_FindUrbInIrpTable: IrpTable - %p, Urb - %p, Irp - %p\n",
                IrpTable,
                Urb,
                Irp);
 
    ASSERT(IrpTable != NULL);
 
    do
    {
        for (ix = 0; ix < 0x200; ix++)
        {
            irp = IrpTable->irp[ix];
 
            if (irp)
            {
                urbIn = URB_FROM_IRP(irp);
 
                if (urbIn == Urb)
                {
                    if (irp == Irp)
                    {
                        KeBugCheckEx(BUGCODE_USB_DRIVER,
                                     4,
                                     (ULONG_PTR)irp,
                                     (ULONG_PTR)urbIn,
                                     0);
                    }
 
                    KeBugCheckEx(BUGCODE_USB_DRIVER,
                                 2,
                                 (ULONG_PTR)irp,
                                 (ULONG_PTR)Irp,
                                 (ULONG_PTR)urbIn);
                }
            }
        }
 
        IrpTable = IrpTable->LinkNextTable;
    }
    while (IrpTable);
}

Referenced by USBPORT_FlushPendingTransfers().

USBPORT_FlushAbortList()

VOID NTAPI USBPORT_FlushAbortList

(

IN PUSBPORT_ENDPOINT

Endpoint

)

Definition at line 605 of file queue.c.

{
    PLIST_ENTRY Entry;
    PUSBPORT_TRANSFER Transfer;
    PLIST_ENTRY AbortList;
    LIST_ENTRY List;
    NTSTATUS Status;
    PIRP Irp;
    PURB Urb;
    PUSBPORT_DEVICE_HANDLE DeviceHandle = NULL;
 
    DPRINT_CORE("USBPORT_FlushAbortList: Endpoint - %p\n", Endpoint);
 
    InitializeListHead(&List);
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
 
    if (IsListEmpty(&Endpoint->AbortList))
    {
        KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                          Endpoint->EndpointOldIrql);
        return;
    }
 
    Entry = Endpoint->PendingTransferList.Flink;
 
    while (Entry && Entry != &Endpoint->PendingTransferList)
    {
        Transfer = CONTAINING_RECORD(Entry,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        if (Transfer->Flags & TRANSFER_FLAG_ABORTED)
        {
            DPRINT_CORE("USBPORT_FlushAbortList: Aborted PendingTransfer  - %p\n",
                        Transfer);
 
            KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                              Endpoint->EndpointOldIrql);
            return;
        }
 
        Entry = Transfer->TransferLink.Flink;
    }
 
    Entry = Endpoint->TransferList.Flink;
 
    while (Entry && Entry != &Endpoint->TransferList)
    {
        Transfer = CONTAINING_RECORD(Entry,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        if (Transfer->Flags & TRANSFER_FLAG_ABORTED)
        {
            DPRINT_CORE("USBPORT_FlushAbortList: Aborted ActiveTransfer - %p\n",
                        Transfer);
 
            KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                              Endpoint->EndpointOldIrql);
            return;
        }
 
        Entry = Transfer->TransferLink.Flink;
    }
 
    AbortList = &Endpoint->AbortList;
 
    while (!IsListEmpty(AbortList))
    {
        //DbgBreakPoint();
 
        Irp = CONTAINING_RECORD(AbortList->Flink,
                                IRP,
                                Tail.Overlay.ListEntry);
 
        RemoveHeadList(AbortList);
        InsertTailList(&List, &Irp->Tail.Overlay.ListEntry);
    }
 
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    while (!IsListEmpty(&List))
    {
        //DbgBreakPoint();
 
        Irp = CONTAINING_RECORD(List.Flink,
                                IRP,
                                Tail.Overlay.ListEntry);
 
        RemoveHeadList(&List);
 
        Urb = URB_FROM_IRP(Irp);
 
        DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
        InterlockedDecrement(&DeviceHandle->DeviceHandleLock);
 
        Status = USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_SUCCESS);
 
        DPRINT_CORE("USBPORT_FlushAbortList: complete Irp - %p\n", Irp);
 
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
}

Referenced by USBPORT_EndpointWorker(), and USBPORT_FlushCancelList().

USBPORT_FlushAllEndpoints()

VOID NTAPI USBPORT_FlushAllEndpoints

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1171 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PLIST_ENTRY Entry;
    PUSBPORT_ENDPOINT Endpoint;
    LIST_ENTRY List;
    KIRQL OldIrql;
 
    DPRINT_CORE("USBPORT_FlushAllEndpoints: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
 
    InitializeListHead(&List);
 
    Entry = FdoExtension->EndpointList.Flink;
 
    while (Entry && Entry != &FdoExtension->EndpointList)
    {
        Endpoint = CONTAINING_RECORD(Entry,
                                     USBPORT_ENDPOINT,
                                     EndpointLink);
 
        if (USBPORT_GetEndpointState(Endpoint) != USBPORT_ENDPOINT_CLOSED)
        {
            InsertTailList(&List, &Endpoint->FlushLink);
        }
 
        Entry = Endpoint->EndpointLink.Flink;
    }
 
    KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
 
    while (!IsListEmpty(&List))
    {
        Endpoint = CONTAINING_RECORD(List.Flink,
                                     USBPORT_ENDPOINT,
                                     FlushLink);
 
        RemoveHeadList(&List);
 
        Endpoint->FlushLink.Flink = NULL;
        Endpoint->FlushLink.Blink = NULL;
 
        if (!IsListEmpty(&Endpoint->PendingTransferList))
        {
            USBPORT_FlushPendingTransfers(Endpoint);
        }
    }
 
    DPRINT_CORE("USBPORT_FlushAllEndpoints: exit\n");
}

Referenced by USBPORT_WorkerThreadHandler().

USBPORT_FlushCancelList()

VOID NTAPI USBPORT_FlushCancelList

(

IN PUSBPORT_ENDPOINT

Endpoint

)

Definition at line 714 of file queue.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PUSBPORT_TRANSFER Transfer;
    PIRP Irp;
    KIRQL OldIrql;
    KIRQL PrevIrql;
 
    DPRINT_CORE("USBPORT_FlushCancelList: ... \n");
 
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
    KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
 
    while (!IsListEmpty(&Endpoint->CancelList))
    {
        Transfer = CONTAINING_RECORD(Endpoint->CancelList.Flink,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        RemoveHeadList(&Endpoint->CancelList);
 
        Irp = Transfer->Irp;
 
        if (Irp)
        {
            DPRINT("USBPORT_FlushCancelList: Irp - %p\n", Irp);
 
            IoAcquireCancelSpinLock(&PrevIrql);
            IoSetCancelRoutine(Irp, NULL);
            IoReleaseCancelSpinLock(PrevIrql);
 
            USBPORT_RemoveActiveTransferIrp(FdoDevice, Irp);
        }
 
        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
        KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
        if (Endpoint->Flags & ENDPOINT_FLAG_NUKE)
        {
            USBPORT_CompleteTransfer(Transfer->Urb, USBD_STATUS_DEVICE_GONE);
        }
        else
        {
            if (Transfer->Flags & TRANSFER_FLAG_DEVICE_GONE)
            {
                USBPORT_CompleteTransfer(Transfer->Urb,
                                         USBD_STATUS_DEVICE_GONE);
            }
            else
            {
                USBPORT_CompleteTransfer(Transfer->Urb,
                                         USBD_STATUS_CANCELED);
            }
        }
 
        KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
        KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
    }
 
    KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
    KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
    USBPORT_FlushAbortList(Endpoint);
}

Referenced by USBPORT_AbortEndpoint(), USBPORT_DmaEndpointWorker(), USBPORT_KillEndpointActiveTransfers(), and USBPORT_RootHubEndpointWorker().

USBPORT_FlushController()

VOID NTAPI USBPORT_FlushController

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1259 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PLIST_ENTRY Entry;
    PUSBPORT_ENDPOINT Endpoint;
    ULONG KilledTransfers;
    PLIST_ENTRY EndpointList;
    KIRQL OldIrql;
    LIST_ENTRY FlushList;
 
    DPRINT_CORE("USBPORT_FlushController \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    EndpointList = &FdoExtension->EndpointList;
 
    while (TRUE)
    {
        KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
 
        InitializeListHead(&FlushList);
 
        Entry = EndpointList->Flink;
 
        if (!IsListEmpty(EndpointList))
        {
            while (Entry && Entry != EndpointList)
            {
                Endpoint = CONTAINING_RECORD(Entry,
                                             USBPORT_ENDPOINT,
                                             EndpointLink);
 
                if (Endpoint->StateLast != USBPORT_ENDPOINT_REMOVE &&
                    Endpoint->StateLast != USBPORT_ENDPOINT_CLOSED)
                {
                    InterlockedIncrement(&Endpoint->LockCounter);
                    InsertTailList(&FlushList, &Endpoint->FlushControllerLink);
                }
 
                Entry = Endpoint->EndpointLink.Flink;
            }
        }
 
        KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
 
        KilledTransfers = 0;
        while (!IsListEmpty(&FlushList))
        {
            Endpoint = CONTAINING_RECORD(FlushList.Flink,
                                         USBPORT_ENDPOINT,
                                         FlushControllerLink);
 
            RemoveHeadList(&FlushList);
 
            KilledTransfers += USBPORT_KillEndpointActiveTransfers(FdoDevice,
                                                                   Endpoint);
 
            InterlockedDecrement(&Endpoint->LockCounter);
        }
 
        if (!KilledTransfers)
            break;
 
        USBPORT_Wait(FdoDevice, 100);
    }
}

Referenced by USBPORT_SuspendController().

USBPORT_FlushPendingTransfers()

VOID NTAPI USBPORT_FlushPendingTransfers

(

IN PUSBPORT_ENDPOINT

Endpoint

)

Definition at line 785 of file queue.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    BOOLEAN IsMapTransfer;
    BOOLEAN IsEnd = FALSE;
    PLIST_ENTRY List;
    PUSBPORT_TRANSFER Transfer;
    PURB Urb;
    PIRP Irp;
    KIRQL OldIrql;
    BOOLEAN Result;
 
    DPRINT_CORE("USBPORT_FlushPendingTransfers: Endpoint - %p\n", Endpoint);
 
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    if (InterlockedCompareExchange(&Endpoint->FlushPendingLock, 1, 0))
    {
        DPRINT_CORE("USBPORT_FlushPendingTransfers: Endpoint Locked \n");
        return;
    }
 
    while (TRUE)
    {
        IsMapTransfer = 0;
 
        KeAcquireSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                          &OldIrql);
 
        KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
 
        if (FdoExtension->Flags & USBPORT_FLAG_HC_SUSPEND)
        {
            IsEnd = TRUE;
 
            KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
            KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                              OldIrql);
            goto Next;
        }
 
        if (!(Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0))
        {
            if (!IsListEmpty(&Endpoint->TransferList))
            {
                List = Endpoint->TransferList.Flink;
 
                while (List && List != &Endpoint->TransferList)
                {
                    Transfer = CONTAINING_RECORD(List,
                                                 USBPORT_TRANSFER,
                                                 TransferLink);
 
                    if (!(Transfer->Flags & TRANSFER_FLAG_SUBMITED))
                    {
                        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
                        KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                                          OldIrql);
 
                        IsEnd = TRUE;
                        goto Worker;
                    }
 
                    List = Transfer->TransferLink.Flink;
                }
            }
        }
 
        List = Endpoint->PendingTransferList.Flink;
 
        if (List == NULL || IsListEmpty(&Endpoint->PendingTransferList))
        {
            KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
            KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                              OldIrql);
 
            IsEnd = TRUE;
            goto Worker;
        }
 
        Transfer = CONTAINING_RECORD(List,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        if (Transfer->Irp)
        {
            DPRINT_CORE("USBPORT_FlushPendingTransfers: Transfer->Irp->CancelRoutine - %p\n",
                        Transfer->Irp->CancelRoutine);
        }
 
        if (Transfer->Irp &&
            (IoSetCancelRoutine(Transfer->Irp, NULL) == NULL))
        {
            DPRINT_CORE("USBPORT_FlushPendingTransfers: Transfer->Irp - %p\n",
                        Transfer->Irp);
 
            Transfer = NULL;
            IsEnd = TRUE;
        }
 
        if (!Transfer)
        {
            KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
            KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                              OldIrql);
 
            if (IsMapTransfer)
            {
                USBPORT_FlushMapTransfers(FdoDevice);
                goto Next;
            }
 
            goto Worker;
        }
 
        Irp = Transfer->Irp;
        Urb = Transfer->Urb;
 
        RemoveEntryList(&Transfer->TransferLink);
        Transfer->TransferLink.Flink = NULL;
        Transfer->TransferLink.Blink = NULL;
 
        if (Irp)
        {
            Irp = USBPORT_RemovePendingTransferIrp(FdoDevice, Irp);
        }
 
        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
        KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                          OldIrql);
 
        KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
 
        if (Irp)
        {
            IoSetCancelRoutine(Irp, USBPORT_CancelActiveTransferIrp);
 
            if (Irp->Cancel && IoSetCancelRoutine(Irp, NULL))
            {
                DPRINT_CORE("USBPORT_FlushPendingTransfers: irp - %p\n", Irp);
 
                KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock,
                                  OldIrql);
 
                USBPORT_CompleteTransfer(Transfer->Urb, USBD_STATUS_CANCELED);
                goto Worker;
            }
 
            USBPORT_FindUrbInIrpTable(FdoExtension->ActiveIrpTable, Urb, Irp);
            USBPORT_InsertIrpInTable(FdoExtension->ActiveIrpTable, Irp);
        }
 
        IsMapTransfer = USBPORT_QueueActiveUrbToEndpoint(Endpoint, Urb);
 
        KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
        if (IsMapTransfer)
        {
            USBPORT_FlushMapTransfers(FdoDevice);
            goto Next;
        }
 
Worker:
        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
        Result = USBPORT_EndpointWorker(Endpoint, FALSE);
        KeLowerIrql(OldIrql);
 
        if (Result)
            USBPORT_InvalidateEndpointHandler(FdoDevice,
                                              Endpoint,
                                              INVALIDATE_ENDPOINT_WORKER_THREAD);
 
Next:
        if (IsEnd)
        {
            InterlockedDecrement(&Endpoint->FlushPendingLock);
            DPRINT_CORE("USBPORT_FlushPendingTransfers: Endpoint Unlocked. Exit\n");
            return;
        }
    }
}

Referenced by USBPORT_AbortEndpoint(), USBPORT_DpcHandler(), USBPORT_FlushAllEndpoints(), USBPORT_KillEndpointActiveTransfers(), and USBPORT_QueueTransferUrb().

USBPORT_InsertBadRequest()

VOID NTAPI USBPORT_InsertBadRequest	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 143 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_InsertBadRequest: Irp - %p\n", Irp);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    InsertTailList(&FdoExtension->BadRequestList,
                   &Irp->Tail.Overlay.ListEntry);
}

Referenced by USBPORT_StartDevice().

USBPORT_InsertIdleIrp()

VOID NTAPI USBPORT_InsertIdleIrp	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 20 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_InsertIdleIrp: Irp - %p\n", Irp);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    InsertTailList(&FdoExtension->IdleIrpList,
                   &Irp->Tail.Overlay.ListEntry);
}

Referenced by USBPORT_StartDevice().

USBPORT_InsertIrpInTable()

VOID NTAPI USBPORT_InsertIrpInTable	(	IN PUSBPORT_IRP_TABLE	IrpTable,
		IN PIRP	Irp
	)

Definition at line 266 of file queue.c.

{
    ULONG ix;
 
    DPRINT_CORE("USBPORT_InsertIrpInTable: IrpTable - %p, Irp - %p\n",
                IrpTable,
                Irp);
 
    ASSERT(IrpTable != NULL);
 
    while (TRUE)
    {
        for (ix = 0; ix < 0x200; ix++)
        {
            if (IrpTable->irp[ix] == NULL)
            {
                IrpTable->irp[ix] = Irp;
 
                if (ix > 0)
                {
                    DPRINT_CORE("USBPORT_InsertIrpInTable: ix - %x\n", ix);
                }
 
                return;
            }
        }
 
        if (ix != 0x200)
        {
            KeBugCheckEx(BUGCODE_USB_DRIVER, 1, 0, 0, 0);
        }
 
        IrpTable->LinkNextTable = ExAllocatePoolWithTag(NonPagedPool,
                                                        sizeof(USBPORT_IRP_TABLE),
                                                        USB_PORT_TAG);
 
        if (IrpTable->LinkNextTable == NULL)
        {
            KeBugCheckEx(BUGCODE_USB_DRIVER, 1, 0, 0, 0);
        }
 
        RtlZeroMemory(IrpTable->LinkNextTable, sizeof(USBPORT_IRP_TABLE));
 
        IrpTable = IrpTable->LinkNextTable;
    }
}

Referenced by USBPORT_FlushPendingTransfers(), and USBPORT_QueuePendingTransferIrp().

USBPORT_KillEndpointActiveTransfers()

ULONG NTAPI USBPORT_KillEndpointActiveTransfers	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint
	)

Definition at line 1227 of file queue.c.

{
    PLIST_ENTRY ActiveList;
    PUSBPORT_TRANSFER Transfer;
    ULONG KilledTransfers = 0;
 
    DPRINT_CORE("USBPORT_KillEndpointActiveTransfers \n");
 
    ActiveList = Endpoint->TransferList.Flink;
 
    while (ActiveList && ActiveList != &Endpoint->TransferList)
    {
        ++KilledTransfers;
 
        Transfer = CONTAINING_RECORD(ActiveList,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        Transfer->Flags |= TRANSFER_FLAG_ABORTED;
 
        ActiveList = Transfer->TransferLink.Flink;
    }
 
    USBPORT_FlushPendingTransfers(Endpoint);
    USBPORT_FlushCancelList(Endpoint);
 
    return KilledTransfers;
}

Referenced by USBPORT_FlushController().

USBPORT_PeekNextBadRequest()

PIRP NTAPI USBPORT_PeekNextBadRequest	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp,
		IN PVOID	PeekContext
	)

Definition at line 169 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PLIST_ENTRY NextEntry;
    PLIST_ENTRY ListHead;
    PIRP NextIrp = NULL;
 
    DPRINT_QUEUE("USBPORT_PeekNextBadRequest: Irp - %p, PeekContext - %p\n",
                 Irp,
                 PeekContext);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    ListHead = &FdoExtension->BadRequestList;
 
    if (Irp)
    {
        NextEntry = Irp->Tail.Overlay.ListEntry.Flink;
    }
    else
    {
        NextEntry = ListHead->Flink;
    }
 
    while (NextEntry != ListHead)
    {
        NextIrp = CONTAINING_RECORD(NextEntry,
                                    IRP,
                                    Tail.Overlay.ListEntry);
 
        if (!PeekContext)
            break;
 
        NextEntry = NextEntry->Flink;
    }
 
    return NextIrp;
}

Referenced by USBPORT_StartDevice().

USBPORT_PeekNextIdleIrp()

PIRP NTAPI USBPORT_PeekNextIdleIrp	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp,
		IN PVOID	PeekContext
	)

Definition at line 46 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PLIST_ENTRY NextEntry;
    PLIST_ENTRY ListHead;
    PIRP NextIrp = NULL;
 
    DPRINT_QUEUE("USBPORT_PeekNextIdleIrp: Irp - %p, PeekContext - %p\n",
                 Irp,
                 PeekContext);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    ListHead = &FdoExtension->IdleIrpList;
 
    if (Irp)
    {
        NextEntry = Irp->Tail.Overlay.ListEntry.Flink;
    }
    else
    {
        NextEntry = ListHead->Flink;
    }
 
    while (NextEntry != ListHead)
    {
        NextIrp = CONTAINING_RECORD(NextEntry,
                                    IRP,
                                    Tail.Overlay.ListEntry);
 
        if (!PeekContext)
            break;
 
        NextEntry = NextEntry->Flink;
    }
 
    return NextIrp;
}

Referenced by USBPORT_StartDevice().

USBPORT_QueueActiveUrbToEndpoint()

BOOLEAN NTAPI USBPORT_QueueActiveUrbToEndpoint	(	IN PUSBPORT_ENDPOINT	Endpoint,
		IN PURB	Urb
	)

Definition at line 988 of file queue.c.

{
    PUSBPORT_TRANSFER Transfer;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    KIRQL OldIrql;
 
    DPRINT_CORE("USBPORT_QueueActiveUrbToEndpoint: Endpoint - %p, Urb - %p\n",
                Endpoint,
                Urb);
 
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
                      &Endpoint->EndpointOldIrql);
 
    if ((Endpoint->Flags & ENDPOINT_FLAG_NUKE) ||
        (Transfer->Flags & TRANSFER_FLAG_ABORTED))
    {
        InsertTailList(&Endpoint->CancelList, &Transfer->TransferLink);
 
        KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                          Endpoint->EndpointOldIrql);
 
        //DPRINT_CORE("USBPORT_QueueActiveUrbToEndpoint: return FALSE\n");
        return FALSE;
    }
 
    if (Transfer->TransferParameters.TransferBufferLength == 0 ||
        !(Endpoint->Flags & ENDPOINT_FLAG_DMA_TYPE))
    {
        InsertTailList(&Endpoint->TransferList, &Transfer->TransferLink);
 
        KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                          Endpoint->EndpointOldIrql);
 
        //DPRINT_CORE("USBPORT_QueueActiveUrbToEndpoint: return FALSE\n");
        return FALSE;
    }
 
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    KeAcquireSpinLock(&FdoExtension->MapTransferSpinLock, &OldIrql);
 
    InsertTailList(&FdoExtension->MapTransferList, &Transfer->TransferLink);
 
    DeviceHandle = Transfer->Urb->UrbHeader.UsbdDeviceHandle;
    InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
 
    KeReleaseSpinLock(&FdoExtension->MapTransferSpinLock, OldIrql);
 
    //DPRINT_CORE("USBPORT_QueueActiveUrbToEndpoint: return TRUE\n");
    return TRUE;
}

Referenced by USBPORT_FlushPendingTransfers().

USBPORT_QueuePendingTransferIrp()

VOID NTAPI USBPORT_QueuePendingTransferIrp

(

IN PIRP

Irp

)

Definition at line 1049 of file queue.c.

{
    PURB Urb;
    PUSBPORT_TRANSFER Transfer;
    PUSBPORT_ENDPOINT Endpoint;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_CORE("USBPORT_QueuePendingTransferIrp: Irp - %p\n", Irp);
 
    Urb = URB_FROM_IRP(Irp);
 
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    Endpoint = Transfer->Endpoint;
 
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    Irp->IoStatus.Status = STATUS_PENDING;
    IoMarkIrpPending(Irp);
 
    IoSetCancelRoutine(Irp, USBPORT_CancelPendingTransferIrp);
 
    if (Irp->Cancel && IoSetCancelRoutine(Irp, NULL))
    {
        USBPORT_CompleteTransfer(Urb, USBD_STATUS_CANCELED);
    }
    else
    {
        USBPORT_InsertIrpInTable(FdoExtension->PendingIrpTable, Irp);
        USBPORT_QueuePendingUrbToEndpoint(Endpoint, Urb);
    }
}

Referenced by USBPORT_QueueTransferUrb().

USBPORT_QueuePendingUrbToEndpoint()

VOID NTAPI USBPORT_QueuePendingUrbToEndpoint	(	IN PUSBPORT_ENDPOINT	Endpoint,
		IN PURB	Urb
	)

Definition at line 971 of file queue.c.

{
    PUSBPORT_TRANSFER Transfer;
 
    DPRINT_CORE("USBPORT_QueuePendingUrbToEndpoint: Endpoint - %p, Urb - %p\n",
                Endpoint,
                Urb);
 
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    //FIXME USBPORT_ResetEndpointIdle();
    InsertTailList(&Endpoint->PendingTransferList, &Transfer->TransferLink);
    Urb->UrbHeader.Status = USBD_STATUS_PENDING;
}

Referenced by USBPORT_QueuePendingTransferIrp(), and USBPORT_QueueTransferUrb().

USBPORT_QueueTransferUrb()

VOID NTAPI USBPORT_QueueTransferUrb

(

IN PURB

Urb

)

Definition at line 1085 of file queue.c.

{
    PUSBPORT_TRANSFER Transfer;
    PUSBPORT_ENDPOINT Endpoint;
    PIRP Irp;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    PUSBPORT_TRANSFER_PARAMETERS Parameters;
 
    DPRINT_CORE("USBPORT_QueueTransferUrb: Urb - %p\n", Urb);
 
    if (Urb->UrbControlTransfer.TransferFlags & USBD_DEFAULT_PIPE_TRANSFER)
        Urb->UrbHeader.Function = URB_FUNCTION_CONTROL_TRANSFER;
 
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    Parameters = &Transfer->TransferParameters;
 
    Endpoint = Transfer->Endpoint;
    Endpoint->Flags &= ~ENDPOINT_FLAG_QUEUENE_EMPTY;
 
    Parameters->TransferBufferLength = Urb->UrbControlTransfer.TransferBufferLength;
    Parameters->TransferFlags = Urb->UrbControlTransfer.TransferFlags;
 
    Transfer->TransferBufferMDL = Urb->UrbControlTransfer.TransferBufferMDL;
 
    if (Urb->UrbControlTransfer.TransferFlags & USBD_TRANSFER_DIRECTION_IN)
    {
        Transfer->Direction = USBPORT_DMA_DIRECTION_FROM_DEVICE;
    }
    else
    {
        Transfer->Direction = USBPORT_DMA_DIRECTION_TO_DEVICE;
    }
 
    if (Endpoint->EndpointProperties.TransferType == USBPORT_TRANSFER_TYPE_CONTROL)
    {
        RtlCopyMemory(&Parameters->SetupPacket,
                      Urb->UrbControlTransfer.SetupPacket,
                      sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
    }
 
    DPRINT_URB("... URB TransferBufferLength - %x\n",
           Urb->UrbControlTransfer.TransferBufferLength);
 
    Urb->UrbControlTransfer.TransferBufferLength = 0;
 
    Irp = Transfer->Irp;
 
    if (Irp)
    {
        USBPORT_QueuePendingTransferIrp(Irp);
    }
    else
    {
        USBPORT_QueuePendingUrbToEndpoint(Endpoint, Urb);
    }
 
    DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
    InterlockedDecrement(&DeviceHandle->DeviceHandleLock);
 
    USBPORT_FlushPendingTransfers(Endpoint);
 
    DPRINT_URB("... URB TransferBufferLength - %x\n",
           Urb->UrbControlTransfer.TransferBufferLength);
 
    if (Urb->UrbControlTransfer.TransferBufferLength)
    {
        PULONG Buffer;
        ULONG BufferLength;
        ULONG_PTR BufferEnd;
        ULONG ix;
 
        Buffer = Urb->UrbControlTransfer.TransferBuffer;
        BufferLength = Urb->UrbControlTransfer.TransferBufferLength;
        BufferEnd = (ULONG_PTR)Buffer + BufferLength;
 
        DPRINT_URB("URB TransferBuffer - %p\n", Buffer);
 
        for (ix = 0; (ULONG_PTR)(Buffer + ix) < BufferEnd; ix++)
        {
            DPRINT_URB("Buffer[%02X] - %p\n", ix, Buffer[ix]);
        }
    }
}

Referenced by USBPORT_HandleDataTransfers(), USBPORT_HandleGetConfiguration(), USBPORT_HandleGetSetDescriptor(), USBPORT_HandleGetStatus(), USBPORT_HandleSetOrClearFeature(), USBPORT_HandleVendorOrClass(), and USBPORT_SendSetupPacket().

USBPORT_ReleaseBadRequestLock()

VOID NTAPI USBPORT_ReleaseBadRequestLock	(	IN PIO_CSQ	Csq,
		IN KIRQL	Irql
	)

Definition at line 230 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_ReleaseBadRequestLock: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    KeReleaseSpinLock(&FdoExtension->BadRequestIoCsqSpinLock, Irql);
}

Referenced by USBPORT_StartDevice().

USBPORT_ReleaseIdleLock()

VOID NTAPI USBPORT_ReleaseIdleLock	(	IN PIO_CSQ	Csq,
		IN KIRQL	Irql
	)

Definition at line 107 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_ReleaseIdleLock: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    KeReleaseSpinLock(&FdoExtension->IdleIoCsqSpinLock, Irql);
}

Referenced by USBPORT_StartDevice().

USBPORT_RemoveActiveTransferIrp()

PIRP NTAPI USBPORT_RemoveActiveTransferIrp	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 357 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_CORE("USBPORT_RemoveActiveTransferIrp: Irp - %p\n", Irp);
    FdoExtension = FdoDevice->DeviceExtension;
    return USBPORT_RemoveIrpFromTable(FdoExtension->ActiveIrpTable, Irp);
}

Referenced by USBPORT_DoneTransfer(), and USBPORT_FlushCancelList().

USBPORT_RemoveBadRequest()

VOID NTAPI USBPORT_RemoveBadRequest	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 160 of file queue.c.

{
    DPRINT_QUEUE("USBPORT_RemoveBadRequest: Irp - %p\n", Irp);
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}

Referenced by USBPORT_StartDevice().

USBPORT_RemoveIdleIrp()

VOID NTAPI USBPORT_RemoveIdleIrp	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 37 of file queue.c.

{
    DPRINT_QUEUE("USBPORT_RemoveIdleIrp: Irp - %p\n", Irp);
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}

Referenced by USBPORT_StartDevice().

USBPORT_RemoveIrpFromTable()

PIRP NTAPI USBPORT_RemoveIrpFromTable	(	IN PUSBPORT_IRP_TABLE	IrpTable,
		IN PIRP	Irp
	)

Definition at line 316 of file queue.c.

{
    ULONG ix;
 
    DPRINT_CORE("USBPORT_RemoveIrpFromTable: IrpTable - %p, Irp - %p\n",
                IrpTable,
                Irp);
 
    ASSERT(IrpTable != NULL);
 
    while (TRUE)
    {
        for (ix = 0; ix < 0x200; ix++)
        {
            if (IrpTable->irp[ix] == Irp)
            {
                IrpTable->irp[ix] = NULL;
 
                if (ix > 0)
                {
                    DPRINT_CORE("USBPORT_RemoveIrpFromTable: ix - %x\n", ix);
                }
 
                return Irp;
            }
        }
 
        if (IrpTable->LinkNextTable == NULL)
            break;
 
        IrpTable = IrpTable->LinkNextTable;
        continue;
    }
 
    DPRINT1("USBPORT_RemoveIrpFromTable: return NULL. ix - %x\n", ix);
    return NULL;
}

Referenced by USBPORT_RemoveActiveTransferIrp(), and USBPORT_RemovePendingTransferIrp().

USBPORT_RemovePendingTransferIrp()

PIRP NTAPI USBPORT_RemovePendingTransferIrp	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 369 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_CORE("USBPORT_RemovePendingTransferIrp: Irp - %p\n", Irp);
    FdoExtension = FdoDevice->DeviceExtension;
    return USBPORT_RemoveIrpFromTable(FdoExtension->PendingIrpTable, Irp);
}

Referenced by USBPORT_CancelPendingTransferIrp(), and USBPORT_FlushPendingTransfers().