hc.cpp File Reference

#include "xhcidrv.h"
#include <ntstrsafe.h>
#include <acpiioct.h>
#include <debug.h>

Include dependency graph for hc.cpp:

Go to the source code of this file.

Classes
struct	_XHCI_ACPI_DEVICE_INFO
struct	_XHCI_FDO_CONTEXT
struct	_XHCI_OBJECT_CONTEXT

Macros
#define	NDEBUG
#define	XHCI_RECOVER_NONE   0x00
#define	XHCI_RECOVER_INTERNAL_RESET   0x01
#define	XHCI_RECOVER_RESET   0x02
#define	XHCI_RECOVER_NO_RESTART   0x04
#define	XHCI_RECOVER_GONE   0x08
#define	XHCI_RECOVER_GONE_PNP   0x10
#define	XHCI_RECOVER_REPORT_FAILED   0x20
#define	XHCI_REASON_NO_LIVE_DUMP   0x0000
#define	XHCI_REASON_HOST_SYSTEM_ERROR   0x1001
#define	XHCI_REASON_HOST_CONTROLLER_ERROR   0x1002
#define	XHCI_REASON_RESET_FAILED   0x1007
#define	XHCI_REASON_RESTART_FAILED   0x1008
#define	XHCI_REASON_STOP_FAILED   0x100B
#define	XHCI_REASON_NOT_SUPPORTED   0x100C
#define	XHCI_REASON_REMOVED   0x100D
#define	XHCI_REASON_OLD_FIRMWARE   0x100F
#define	XHCI_REASON_START_FAILED   0x101C
#define	XHCI_REASON_TEST_RESET   0x103F
#define	XHCI_VERIFY_FIRMWARE_OUTDATED   0x00000001
#define	XHCI_VERIFY_HSE   0x00000002
#define	XHCI_VERIFY_HCE   0x00000004
#define	XHCI_VERIFY_STOP_TIMEOUT   0x00000008
#define	XHCI_VERIFY_RESET_TIMEOUT   0x00000010
#define	XHCI_VERIFY_START_TIMEOUT   0x00000020
#define	XHCI_VERIFY_ALL_ONES   0x00000040
#define	XHCI_VERIFY_SAVE_RESTORE   0x00400000
#define	XHCI_WATCHDOG_PERIOD_MS   5000
#define	XHCI_WATCHDOG_TOLERANCE_MS   1000
#define	XHCI_RESET_LIMIT   10
#define	XHCI_RESET_WINDOW_TICKS   60
#define	XHCI_IDLE_TIMEOUT_LONG_MS   5000
#define	XHCI_IDLE_TIMEOUT_SHORT_MS   1
#define	XHCI_PAD_BUFFER_SIZE   512
#define	XHCI_ACPI_PARENT_ID   0x7FFFFFFF
#define	XHCI_BUGCHECK_USB3_DRIVER   0x144
#define	XHCI_TEST_RESET_IOCTL   0x00220FB7
#define	XHCI_DEVICE_USED_BY_DEBUGGER   0x02000000
#define	XHCI_ACPI_GET_DEVICE_INFORMATION    CTL_CODE(FILE_DEVICE_ACPI, 10, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)

Typedefs
typedef struct _XHCI_ACPI_DEVICE_INFO	XHCI_ACPI_DEVICE_INFO
typedef struct _XHCI_ACPI_DEVICE_INFO *	PXHCI_ACPI_DEVICE_INFO
typedef NTSTATUS(NTAPI *	PFN_XHCI_QUERY_DEVICE_FLAGS) (_In_ PCWSTR DeviceKey, _In_ PCWSTR Category, _Out_ PULONG64 Flags)
typedef struct _XHCI_FDO_CONTEXT	XHCI_FDO_CONTEXT
typedef struct _XHCI_FDO_CONTEXT *	PXHCI_FDO_CONTEXT
typedef struct _XHCI_OBJECT_CONTEXT	XHCI_OBJECT_CONTEXT
typedef struct _XHCI_OBJECT_CONTEXT *	PXHCI_OBJECT_CONTEXT

Functions
static NTSTATUS NTAPI	XhciEvtControllerEnableForwardProgress (_In_ UCXCONTROLLER UcxController)
static NTSTATUS NTAPI	XhciQueryPciIdentity (_In_ WDFDEVICE Device, _Inout_ XhciIdentity *Id)
static VOID NTAPI	XhciCopyAcpiId (_Out_writes_(MAX_VENDOR_ID_STRING_LENGTH) PCHAR Destination, _In_reads_(Length) const CHAR *Source, _In_ ULONG Length)
static NTSTATUS NTAPI	XhciQueryAcpiIdentity (_In_ WDFDEVICE Device, _Inout_ XhciIdentity *Id)
static NTSTATUS NTAPI	XhciQueryIdentity (_In_ WDFDEVICE Device, _Out_ XhciIdentity *Id)
static VOID NTAPI	XhciEvaluateAcpiMethod (_In_ WDFDEVICE Device, _In_reads_bytes_(InputSize) PVOID Input, _In_ ULONG InputSize)
static NTSTATUS NTAPI	XhciCreateFdo (_Inout_ PWDFDEVICE_INIT DeviceInit, _In_ PWDF_OBJECT_ATTRIBUTES Attributes, _Out_ WDFDEVICE *Device)
NTSTATUS NTAPI	XhciEvtDeviceAdd (_In_ WDFDRIVER Driver, _Inout_ PWDFDEVICE_INIT DeviceInit)
static VOID NTAPI	XhciEvtFdoCleanup (_In_ WDFOBJECT Object)
static VOID NTAPI	XhciFirmwareCommandDone (_In_ XhciCommand *Command)
static BOOLEAN NTAPI	XhciSendFirmwareCommand (_In_ XhciController *Controller, _In_ ULONG Type, _Out_ PULONG Parameter)
static LONG64 NTAPI	XhciPackFrameSnapshot (_In_ ULONG Frame, _In_ ULONG64 Now)
static NTSTATUS NTAPI	XhciEvtDevicePrepareHardware (_In_ WDFDEVICE Device, _In_ WDFCMRESLIST ResourcesRaw, _In_ WDFCMRESLIST ResourcesTranslated)
static NTSTATUS NTAPI	XhciEvtDeviceReleaseHardware (_In_ WDFDEVICE Device, _In_ WDFCMRESLIST ResourcesTranslated)
static NTSTATUS NTAPI	XhciEvtDeviceD0Entry (_In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE PreviousState)
static NTSTATUS NTAPI	XhciEvtDeviceD0EntryPostInterruptsEnabled (_In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE PreviousState)
static NTSTATUS NTAPI	XhciEvtDeviceD0ExitPreInterruptsDisabled (_In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE TargetState)
static NTSTATUS NTAPI	XhciEvtDeviceD0Exit (_In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE TargetState)
static NTSTATUS NTAPI	XhciEvtDeviceSelfManagedIoInit (_In_ WDFDEVICE Device)
static VOID NTAPI	XhciEvtDeviceSelfManagedIoCleanup (_In_ WDFDEVICE Device)
static VOID NTAPI	XhciEvtDeviceUsageNotification (_In_ WDFDEVICE Device, _In_ WDF_SPECIAL_FILE_TYPE NotificationType, _In_ BOOLEAN IsInNotificationPath)
static NTSTATUS NTAPI	XhciEvtDeviceArmWakeFromS0 (_In_ WDFDEVICE Device)
static VOID NTAPI	XhciEvtDeviceDisarmWakeFromS0 (_In_ WDFDEVICE Device)
static VOID NTAPI	XhciEvtDeviceWakeFromS0Triggered (_In_ WDFDEVICE Device)
static NTSTATUS NTAPI	XhciEvtDeviceArmWakeFromSx (_In_ WDFDEVICE Device)
static VOID NTAPI	XhciEvtDeviceDisarmWakeFromSx (_In_ WDFDEVICE Device)
static NTSTATUS NTAPI	XhciEvtDeviceFilterRemoveResourceRequirements (_In_ WDFDEVICE Device, _In_ WDFIORESREQLIST IoResourceRequirementsList)
static NTSTATUS NTAPI	XhciEvtDeviceFilterAddResourceRequirements (_In_ WDFDEVICE Device, _In_ WDFIORESREQLIST IoResourceRequirementsList)
static NTSTATUS NTAPI	XhciEvtDeviceRemoveAddedResources (_In_ WDFDEVICE Device, _In_ WDFCMRESLIST ResourcesRaw, _In_ WDFCMRESLIST ResourcesTranslated)
static NTSTATUS NTAPI	XhciEvtPreprocessSetPower (_In_ WDFDEVICE Device, _Inout_ PIRP Irp)
static NTSTATUS NTAPI	XhciEvtPreprocessInternalIoctl (_In_ WDFDEVICE Device, _Inout_ PIRP Irp)
static VOID NTAPI	XhciEvtIoDeviceControl (_In_ WDFQUEUE Queue, _In_ WDFREQUEST Request, _In_ size_t OutputBufferLength, _In_ size_t InputBufferLength, _In_ ULONG IoControlCode)
static VOID NTAPI	XhciEvtWatchdog (_In_ WDFTIMER Timer)
static VOID NTAPI	XhciEvtRecoveryWork (_In_ WDFWORKITEM WorkItem)
static VOID NTAPI	XhciEvtIdleTimeoutWork (_In_ WDFWORKITEM WorkItem)
static NTSTATUS NTAPI	XhciEvtControllerQueryUsbCapability (_In_ UCXCONTROLLER UcxController, _In_ PGUID CapabilityType, _In_ ULONG OutputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _Out_ PULONG ResultLength)
static NTSTATUS NTAPI	XhciEvtControllerGetCurrentFrameNumber (_In_ UCXCONTROLLER UcxController, _Out_ PULONG FrameNumber)
static VOID NTAPI	XhciEvtControllerReset (_In_ UCXCONTROLLER UcxController)

Variables
static const GUID	XhciGuidBusInterfaceStandard
static const GUID	XhciGuidD3ColdSupport
static const GUID	XhciGuidBusTypeUsb
static const GUID	XhciGuidHostControllerInterface
static const GUID	XhciGuidChainedMdls
static const GUID	XhciGuidStaticStreams
static const GUID	XhciGuidSelectiveSuspend
static const GUID	XhciGuidFunctionSuspend
static const GUID	XhciGuidHighBandwidthIsoch
static const GUID	XhciGuidClearTtBufferOnCancel
static const GUID	XhciGuidDsm
static EVT_WDF_DEVICE_PREPARE_HARDWARE	XhciEvtDevicePrepareHardware
static EVT_WDF_DEVICE_RELEASE_HARDWARE	XhciEvtDeviceReleaseHardware
static EVT_WDF_DEVICE_D0_ENTRY	XhciEvtDeviceD0Entry
static EVT_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED	XhciEvtDeviceD0EntryPostInterruptsEnabled
static EVT_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED	XhciEvtDeviceD0ExitPreInterruptsDisabled
static EVT_WDF_DEVICE_D0_EXIT	XhciEvtDeviceD0Exit
static EVT_WDF_DEVICE_SELF_MANAGED_IO_INIT	XhciEvtDeviceSelfManagedIoInit
static EVT_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP	XhciEvtDeviceSelfManagedIoCleanup
static EVT_WDF_DEVICE_USAGE_NOTIFICATION	XhciEvtDeviceUsageNotification
static EVT_WDF_DEVICE_ARM_WAKE_FROM_S0	XhciEvtDeviceArmWakeFromS0
static EVT_WDF_DEVICE_DISARM_WAKE_FROM_S0	XhciEvtDeviceDisarmWakeFromS0
static EVT_WDF_DEVICE_WAKE_FROM_S0_TRIGGERED	XhciEvtDeviceWakeFromS0Triggered
static EVT_WDF_DEVICE_ARM_WAKE_FROM_SX	XhciEvtDeviceArmWakeFromSx
static EVT_WDF_DEVICE_DISARM_WAKE_FROM_SX	XhciEvtDeviceDisarmWakeFromSx
static EVT_WDF_DEVICE_FILTER_RESOURCE_REQUIREMENTS	XhciEvtDeviceFilterRemoveResourceRequirements
static EVT_WDF_DEVICE_FILTER_RESOURCE_REQUIREMENTS	XhciEvtDeviceFilterAddResourceRequirements
static EVT_WDF_DEVICE_REMOVE_ADDED_RESOURCES	XhciEvtDeviceRemoveAddedResources
static EVT_WDFDEVICE_WDM_IRP_PREPROCESS	XhciEvtPreprocessSetPower
static EVT_WDFDEVICE_WDM_IRP_PREPROCESS	XhciEvtPreprocessInternalIoctl
static EVT_WDF_OBJECT_CONTEXT_CLEANUP	XhciEvtFdoCleanup
static EVT_WDF_IO_QUEUE_IO_DEVICE_CONTROL	XhciEvtIoDeviceControl
static EVT_WDF_TIMER	XhciEvtWatchdog
static EVT_WDF_WORKITEM	XhciEvtRecoveryWork
static EVT_WDF_WORKITEM	XhciEvtIdleTimeoutWork
static EVT_UCX_CONTROLLER_QUERY_USB_CAPABILITY	XhciEvtControllerQueryUsbCapability
static EVT_UCX_CONTROLLER_GET_CURRENT_FRAMENUMBER	XhciEvtControllerGetCurrentFrameNumber
static EVT_UCX_CONTROLLER_RESET	XhciEvtControllerReset

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file hc.cpp.

XHCI_ACPI_GET_DEVICE_INFORMATION

#define XHCI_ACPI_GET_DEVICE_INFORMATION    CTL_CODE(FILE_DEVICE_ACPI, 10, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)

Definition at line 84 of file hc.cpp.

XHCI_ACPI_PARENT_ID

#define XHCI_ACPI_PARENT_ID   0x7FFFFFFF

Definition at line 78 of file hc.cpp.

XHCI_BUGCHECK_USB3_DRIVER

#define XHCI_BUGCHECK_USB3_DRIVER   0x144

Definition at line 80 of file hc.cpp.

XHCI_DEVICE_USED_BY_DEBUGGER

#define XHCI_DEVICE_USED_BY_DEBUGGER   0x02000000

Definition at line 82 of file hc.cpp.

XHCI_IDLE_TIMEOUT_LONG_MS

#define XHCI_IDLE_TIMEOUT_LONG_MS   5000

Definition at line 75 of file hc.cpp.

XHCI_IDLE_TIMEOUT_SHORT_MS

#define XHCI_IDLE_TIMEOUT_SHORT_MS   1

Definition at line 76 of file hc.cpp.

XHCI_PAD_BUFFER_SIZE

#define XHCI_PAD_BUFFER_SIZE   512

Definition at line 77 of file hc.cpp.

XHCI_REASON_HOST_CONTROLLER_ERROR

#define XHCI_REASON_HOST_CONTROLLER_ERROR   0x1002

Definition at line 51 of file hc.cpp.

XHCI_REASON_HOST_SYSTEM_ERROR

#define XHCI_REASON_HOST_SYSTEM_ERROR   0x1001

Definition at line 50 of file hc.cpp.

XHCI_REASON_NO_LIVE_DUMP

#define XHCI_REASON_NO_LIVE_DUMP   0x0000

Definition at line 49 of file hc.cpp.

XHCI_REASON_NOT_SUPPORTED

#define XHCI_REASON_NOT_SUPPORTED   0x100C

Definition at line 55 of file hc.cpp.

XHCI_REASON_OLD_FIRMWARE

#define XHCI_REASON_OLD_FIRMWARE   0x100F

Definition at line 57 of file hc.cpp.

XHCI_REASON_REMOVED

#define XHCI_REASON_REMOVED   0x100D

Definition at line 56 of file hc.cpp.

XHCI_REASON_RESET_FAILED

#define XHCI_REASON_RESET_FAILED   0x1007

Definition at line 52 of file hc.cpp.

XHCI_REASON_RESTART_FAILED

#define XHCI_REASON_RESTART_FAILED   0x1008

Definition at line 53 of file hc.cpp.

XHCI_REASON_START_FAILED

#define XHCI_REASON_START_FAILED   0x101C

Definition at line 58 of file hc.cpp.

XHCI_REASON_STOP_FAILED

#define XHCI_REASON_STOP_FAILED   0x100B

Definition at line 54 of file hc.cpp.

XHCI_REASON_TEST_RESET

#define XHCI_REASON_TEST_RESET   0x103F

Definition at line 59 of file hc.cpp.

XHCI_RECOVER_GONE

#define XHCI_RECOVER_GONE   0x08

Definition at line 44 of file hc.cpp.

XHCI_RECOVER_GONE_PNP

#define XHCI_RECOVER_GONE_PNP   0x10

Definition at line 45 of file hc.cpp.

XHCI_RECOVER_INTERNAL_RESET

#define XHCI_RECOVER_INTERNAL_RESET   0x01

Definition at line 41 of file hc.cpp.

XHCI_RECOVER_NO_RESTART

#define XHCI_RECOVER_NO_RESTART   0x04

Definition at line 43 of file hc.cpp.

XHCI_RECOVER_NONE

#define XHCI_RECOVER_NONE   0x00

Definition at line 40 of file hc.cpp.

XHCI_RECOVER_REPORT_FAILED

#define XHCI_RECOVER_REPORT_FAILED   0x20

Definition at line 46 of file hc.cpp.

XHCI_RECOVER_RESET

#define XHCI_RECOVER_RESET   0x02

Definition at line 42 of file hc.cpp.

XHCI_RESET_LIMIT

#define XHCI_RESET_LIMIT   10

Definition at line 73 of file hc.cpp.

XHCI_RESET_WINDOW_TICKS

#define XHCI_RESET_WINDOW_TICKS   60

Definition at line 74 of file hc.cpp.

XHCI_TEST_RESET_IOCTL

#define XHCI_TEST_RESET_IOCTL   0x00220FB7

Definition at line 81 of file hc.cpp.

XHCI_VERIFY_ALL_ONES

#define XHCI_VERIFY_ALL_ONES   0x00000040

Definition at line 68 of file hc.cpp.

XHCI_VERIFY_FIRMWARE_OUTDATED

#define XHCI_VERIFY_FIRMWARE_OUTDATED   0x00000001

Definition at line 62 of file hc.cpp.

XHCI_VERIFY_HCE

#define XHCI_VERIFY_HCE   0x00000004

Definition at line 64 of file hc.cpp.

XHCI_VERIFY_HSE

#define XHCI_VERIFY_HSE   0x00000002

Definition at line 63 of file hc.cpp.

XHCI_VERIFY_RESET_TIMEOUT

#define XHCI_VERIFY_RESET_TIMEOUT   0x00000010

Definition at line 66 of file hc.cpp.

XHCI_VERIFY_SAVE_RESTORE

#define XHCI_VERIFY_SAVE_RESTORE   0x00400000

Definition at line 69 of file hc.cpp.

XHCI_VERIFY_START_TIMEOUT

#define XHCI_VERIFY_START_TIMEOUT   0x00000020

Definition at line 67 of file hc.cpp.

XHCI_VERIFY_STOP_TIMEOUT

#define XHCI_VERIFY_STOP_TIMEOUT   0x00000008

Definition at line 65 of file hc.cpp.

XHCI_WATCHDOG_PERIOD_MS

#define XHCI_WATCHDOG_PERIOD_MS   5000

Definition at line 71 of file hc.cpp.

XHCI_WATCHDOG_TOLERANCE_MS

#define XHCI_WATCHDOG_TOLERANCE_MS   1000

Definition at line 72 of file hc.cpp.

Typedef Documentation

PFN_XHCI_QUERY_DEVICE_FLAGS

typedef NTSTATUS(NTAPI * PFN_XHCI_QUERY_DEVICE_FLAGS) (_In_ PCWSTR DeviceKey, _In_ PCWSTR Category, _Out_ PULONG64 Flags)

Definition at line 110 of file hc.cpp.

PXHCI_ACPI_DEVICE_INFO

typedef struct _XHCI_ACPI_DEVICE_INFO * PXHCI_ACPI_DEVICE_INFO

PXHCI_FDO_CONTEXT

typedef struct _XHCI_FDO_CONTEXT * PXHCI_FDO_CONTEXT

PXHCI_OBJECT_CONTEXT

typedef struct _XHCI_OBJECT_CONTEXT * PXHCI_OBJECT_CONTEXT

XHCI_ACPI_DEVICE_INFO

typedef struct _XHCI_ACPI_DEVICE_INFO XHCI_ACPI_DEVICE_INFO

Output of the ACPI device information IOCTL (public WDK acpiioct.h layout).

XHCI_FDO_CONTEXT

typedef struct _XHCI_FDO_CONTEXT XHCI_FDO_CONTEXT

FDO context; the controller pointer is NULL until AddDevice finished.

XHCI_OBJECT_CONTEXT

typedef struct _XHCI_OBJECT_CONTEXT XHCI_OBJECT_CONTEXT

Context of the watchdog timer and the work items.

Function Documentation

XhciCopyAcpiId()

static VOID NTAPI XhciCopyAcpiId ( _Out_writes_(MAX_VENDOR_ID_STRING_LENGTH) PCHAR  Destination, _In_reads_(Length) const CHAR *  Source, _In_ ULONG  Length  )

static

Copies Length bytes, stopping at a NUL, into a 5 byte id field.

Definition at line 285 of file hc.cpp.

{
    ULONG Index;
 
    /* Clamp the copy to the 5 byte field */
    for (Index = 0; Index < Length && Index < MAX_VENDOR_ID_STRING_LENGTH - 1 && Source[Index] != ANSI_NULL; Index++)
        Destination[Index] = Source[Index];
 
    Destination[Index] = ANSI_NULL;
}

Referenced by XhciQueryAcpiIdentity().

XhciCreateFdo()

static NTSTATUS NTAPI XhciCreateFdo ( _Inout_ PWDFDEVICE_INIT  DeviceInit, _In_ PWDF_OBJECT_ATTRIBUTES  Attributes, _Out_ WDFDEVICE *  Device  )

static

Definition at line 1017 of file hc.cpp.

{
    /* SDDL_DEVOBJ_SYS_ALL_ADM_RWX_WORLD_RW_RES_R: SYSTEM all, Administrators read/write/execute,
     * Everyone read/write, restricted code read only */
    DECLARE_CONST_UNICODE_STRING(Sddl, L"D:P(A;;GA;;;SY)(A;;GRGWGX;;;BA)(A;;GRGW;;;WD)(A;;GR;;;RC)");
    WCHAR Buffer[32];
    UNICODE_STRING Name;
    PNP_BUS_INFORMATION BusInfo;
    ULONG Instance;
    NTSTATUS Status;
 
    for (Instance = 0;; Instance++)
    {
        RtlStringCchPrintfW(Buffer, RTL_NUMBER_OF(Buffer), L"\\Device\\USBFDO-%lu", Instance);
        RtlInitUnicodeString(&Name, Buffer);
 
        Status = WdfDeviceInitAssignName(DeviceInit, &Name);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Assigning the FDO name failed 0x%lx\n", Status);
            return Status;
        }
 
        Status = WdfDeviceInitAssignSDDLString(DeviceInit, &Sddl);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Assigning the FDO security failed 0x%lx\n", Status);
            return Status;
        }
 
        Status = WdfDeviceCreate(&DeviceInit, Attributes, Device);
        if (Status == STATUS_OBJECT_NAME_COLLISION)
        {
            DPRINT1("FDO name %wZ taken, trying the next one\n", &Name);
            continue;
        }
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("WdfDeviceCreate failed 0x%lx\n", Status);
            return Status;
        }
 
        break;
    }
 
    WdfDeviceSetSpecialFileSupport(*Device, WdfSpecialFilePaging, TRUE);
    WdfDeviceSetSpecialFileSupport(*Device, WdfSpecialFileHibernation, TRUE);
    WdfDeviceSetSpecialFileSupport(*Device, WdfSpecialFileDump, TRUE);
    WdfDeviceSetSpecialFileSupport(*Device, WdfSpecialFileBoot, TRUE);
 
    /* User mode tools open \\.\HCDn */
    RtlStringCchPrintfW(Buffer, RTL_NUMBER_OF(Buffer), L"\\DosDevices\\HCD%lu", Instance);
    RtlInitUnicodeString(&Name, Buffer);
    Status = WdfDeviceCreateSymbolicLink(*Device, &Name);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Symbolic link %wZ failed 0x%lx\n", &Name, Status);
        return Status;
    }
 
    BusInfo.BusTypeGuid = XhciGuidBusTypeUsb;
    BusInfo.LegacyBusType = PNPBus;
    BusInfo.BusNumber = 0;
    WdfDeviceSetBusInformationForChildren(*Device, &BusInfo);
 
    /* QUIRK: UCX registers this interface again */
    Status = WdfDeviceCreateDeviceInterface(*Device, &XhciGuidHostControllerInterface, NULL);
    if (!NT_SUCCESS(Status))
        DPRINT1("Host controller interface registration failed 0x%lx\n", Status);
 
    return Status;
}

Referenced by XhciEvtDeviceAdd().

XhciEvaluateAcpiMethod()

static VOID NTAPI XhciEvaluateAcpiMethod ( _In_ WDFDEVICE  Device, _In_reads_bytes_(InputSize) PVOID  Input, _In_ ULONG  InputSize  )

static

Definition at line 663 of file hc.cpp.

{
    ACPI_EVAL_OUTPUT_BUFFER Output;
    WDF_MEMORY_DESCRIPTOR InputDescriptor;
    WDF_MEMORY_DESCRIPTOR OutputDescriptor;
    NTSTATUS Status;
 
    RtlZeroMemory(&Output, sizeof(Output));
    WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&InputDescriptor, Input, InputSize);
    WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&OutputDescriptor, &Output, sizeof(Output));
 
    Status = WdfIoTargetSendIoctlSynchronously(WdfDeviceGetIoTarget(Device), NULL, IOCTL_ACPI_EVAL_METHOD,
                                               &InputDescriptor, &OutputDescriptor, NULL, NULL);
    if (!NT_SUCCESS(Status))
        DPRINT("ACPI method evaluation failed 0x%lx\n", Status);
    else if (Output.Signature != ACPI_EVAL_OUTPUT_BUFFER_SIGNATURE)
        DPRINT("ACPI method returned signature 0x%lx\n", Output.Signature);
}

Referenced by XhciController::EvaluateDsm(), and XhciController::EvaluatePrmi().

XhciEvtControllerEnableForwardProgress()

static NTSTATUS NTAPI XhciEvtControllerEnableForwardProgress ( _In_ UCXCONTROLLER  UcxController )

static

Definition at line 2604 of file hc.cpp.

{
    XhciController::FromUcx(UcxController)->m_ReservedIoArmed = TRUE;
    return STATUS_SUCCESS;
}

Referenced by XhciEvtDeviceAdd().

XhciEvtControllerGetCurrentFrameNumber()

static NTSTATUS NTAPI XhciEvtControllerGetCurrentFrameNumber ( _In_ UCXCONTROLLER  UcxController, _Out_ PULONG  FrameNumber  )

static

Definition at line 2583 of file hc.cpp.

{
    /* Outside D0 this returns the clock based estimate, since UCX caches the value */
    *FrameNumber = XhciController::FromUcx(UcxController)->GetFrameNumber(1);
    return STATUS_SUCCESS;
}

XhciEvtControllerQueryUsbCapability()

static NTSTATUS NTAPI XhciEvtControllerQueryUsbCapability ( _In_ UCXCONTROLLER  UcxController, _In_ PGUID  CapabilityType, _In_ ULONG  OutputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID  OutputBuffer, _Out_ PULONG  ResultLength  )

static

Definition at line 2569 of file hc.cpp.

{
    return XhciController::FromUcx(UcxController)->QueryUsbCapability(CapabilityType, OutputBufferLength,
                                                                      OutputBuffer, ResultLength);
}

XhciEvtControllerReset()

static VOID NTAPI XhciEvtControllerReset ( _In_ UCXCONTROLLER  UcxController )

static

Definition at line 2595 of file hc.cpp.

{
    XhciController::FromUcx(UcxController)->UcxReset();
}

XhciEvtDeviceAdd()

NTSTATUS NTAPI XhciEvtDeviceAdd	(	_In_ WDFDRIVER	Driver,
		_Inout_ PWDFDEVICE_INIT	DeviceInit
	)

Definition at line 1096 of file hc.cpp.

{
    WDF_PNPPOWER_EVENT_CALLBACKS PnpPower;
    WDF_POWER_POLICY_EVENT_CALLBACKS PowerPolicy;
    WDF_FDO_EVENT_CALLBACKS FdoCallbacks;
    WDF_OBJECT_ATTRIBUTES Attributes;
    UCX_CONTROLLER_CONFIG Config;
    XhciIdentity Identity;
    XhciController* Controller;
    UCXCONTROLLER Ucx;
    WDFDEVICE Device;
    UCHAR SetPower = IRP_MN_SET_POWER;
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(Driver);
    PAGED_CODE();
 
    Status = UcxInitializeDeviceInit(DeviceInit);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("UcxInitializeDeviceInit failed 0x%lx\n", Status);
        return Status;
    }
 
    /* Requests UCX forwards into the transfer queues are built by this device, so they get this context */
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XhciRequestData);
    WdfDeviceInitSetRequestAttributes(DeviceInit, &Attributes);
 
    WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&PnpPower);
    PnpPower.EvtDevicePrepareHardware = XhciEvtDevicePrepareHardware;
    PnpPower.EvtDeviceReleaseHardware = XhciEvtDeviceReleaseHardware;
    PnpPower.EvtDeviceUsageNotification = XhciEvtDeviceUsageNotification;
    PnpPower.EvtDeviceD0Entry = XhciEvtDeviceD0Entry;
    PnpPower.EvtDeviceD0EntryPostInterruptsEnabled = XhciEvtDeviceD0EntryPostInterruptsEnabled;
    PnpPower.EvtDeviceD0ExitPreInterruptsDisabled = XhciEvtDeviceD0ExitPreInterruptsDisabled;
    PnpPower.EvtDeviceD0Exit = XhciEvtDeviceD0Exit;
    PnpPower.EvtDeviceSelfManagedIoInit = XhciEvtDeviceSelfManagedIoInit;
    PnpPower.EvtDeviceSelfManagedIoCleanup = XhciEvtDeviceSelfManagedIoCleanup;
    WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &PnpPower);
 
    WDF_POWER_POLICY_EVENT_CALLBACKS_INIT(&PowerPolicy);
    PowerPolicy.EvtDeviceArmWakeFromS0 = XhciEvtDeviceArmWakeFromS0;
    PowerPolicy.EvtDeviceDisarmWakeFromS0 = XhciEvtDeviceDisarmWakeFromS0;
    PowerPolicy.EvtDeviceWakeFromS0Triggered = XhciEvtDeviceWakeFromS0Triggered;
    PowerPolicy.EvtDeviceArmWakeFromSx = XhciEvtDeviceArmWakeFromSx;
    PowerPolicy.EvtDeviceDisarmWakeFromSx = XhciEvtDeviceDisarmWakeFromSx;
    WdfDeviceInitSetPowerPolicyEventCallbacks(DeviceInit, &PowerPolicy);
 
    WDF_FDO_EVENT_CALLBACKS_INIT(&FdoCallbacks);
    FdoCallbacks.EvtDeviceFilterRemoveResourceRequirements = XhciEvtDeviceFilterRemoveResourceRequirements;
    FdoCallbacks.EvtDeviceFilterAddResourceRequirements = XhciEvtDeviceFilterAddResourceRequirements;
    FdoCallbacks.EvtDeviceRemoveAddedResources = XhciEvtDeviceRemoveAddedResources;
    WdfFdoInitSetEventCallbacks(DeviceInit, &FdoCallbacks);
 
    WdfDeviceInitSetReleaseHardwareOrderOnFailure(DeviceInit, WdfReleaseHardwareOrderOnFailureAfterDescendants);
 
    Status = WdfDeviceInitAssignWdmIrpPreprocessCallback(DeviceInit, XhciEvtPreprocessSetPower,
                                                         IRP_MJ_POWER, &SetPower, 1);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Power IRP preprocess registration failed 0x%lx\n", Status);
        return Status;
    }
 
    if (XhciDriver.TestMode)
    {
        Status = WdfDeviceInitAssignWdmIrpPreprocessCallback(DeviceInit, XhciEvtPreprocessInternalIoctl,
                                                             IRP_MJ_INTERNAL_DEVICE_CONTROL, NULL, 0);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Internal IOCTL preprocess registration failed 0x%lx\n", Status);
            return Status;
        }
    }
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XHCI_FDO_CONTEXT);
    Attributes.EvtCleanupCallback = XhciEvtFdoCleanup;
 
    Status = XhciCreateFdo(DeviceInit, &Attributes, &Device);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = XhciQueryIdentity(Device, &Identity);
    if (!NT_SUCCESS(Status))
        goto Fail;
 
    UCX_CONTROLLER_CONFIG_INIT(&Config, "USBXHCI");
    Config.EvtControllerUsbDeviceAdd = XhciEvtControllerUsbDeviceAdd;
    Config.EvtControllerGetCurrentFrameNumber = XhciEvtControllerGetCurrentFrameNumber;
    Config.EvtControllerReset = XhciEvtControllerReset;
    Config.EvtControllerQueryUsbCapability = XhciEvtControllerQueryUsbCapability;
    Config.Reserved2 = (HANDLE)XhciEvtControllerEnableForwardProgress;
 
    if (Identity.ParentBus == UcxControllerParentBusTypeAcpi)
    {
        UCX_CONTROLLER_CONFIG_SET_ACPI_INFO(&Config, Identity.AcpiVendorId, Identity.AcpiDeviceId,
                                            Identity.AcpiRevisionId);
    }
    else
    {
        UCX_CONTROLLER_CONFIG_SET_PCI_INFO(&Config, Identity.PciVendorId, Identity.PciDeviceId,
                                           Identity.PciRevisionId, Identity.PciBus,
                                           Identity.PciDevice, Identity.PciFunction);
    }
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XhciController);
    Status = UcxControllerCreate(Device, &Config, &Attributes, &Ucx);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("UcxControllerCreate failed 0x%lx\n", Status);
        goto Fail;
    }
 
    Controller = new (XhciGetControllerContext(Ucx)) XhciController();
 
    /* From here the FDO cleanup owns the PCI interface reference */
    XhciGetFdoContext(Device)->Controller = Controller;
 
    Status = Controller->Initialize(Device, Ucx, &Identity);
    if (!NT_SUCCESS(Status))
        DPRINT1("Controller setup failed 0x%lx\n", Status);
 
    return Status;
 
Fail:
    if (Identity.PciInterface.InterfaceDereference != NULL)
        Identity.PciInterface.InterfaceDereference(Identity.PciInterface.Context);
    return Status;
}

XhciEvtDeviceArmWakeFromS0()

static NTSTATUS NTAPI XhciEvtDeviceArmWakeFromS0 ( _In_ WDFDEVICE  Device )

static

Definition at line 2378 of file hc.cpp.

{
    XhciController::FromDevice(Device)->SetPortWake(TRUE);
    return STATUS_SUCCESS;
}

XhciEvtDeviceArmWakeFromSx()

static NTSTATUS NTAPI XhciEvtDeviceArmWakeFromSx ( _In_ WDFDEVICE  Device )

static

Definition at line 2406 of file hc.cpp.

{
    XhciController::FromDevice(Device)->m_WaitWakeQueued = TRUE;
    return STATUS_SUCCESS;
}

XhciEvtDeviceD0Entry()

static NTSTATUS NTAPI XhciEvtDeviceD0Entry ( _In_ WDFDEVICE  Device, _In_ WDF_POWER_DEVICE_STATE  PreviousState  )

static

Definition at line 2304 of file hc.cpp.

{
    return XhciController::FromDevice(Device)->D0Entry(PreviousState);
}

XhciEvtDeviceD0EntryPostInterruptsEnabled()

static NTSTATUS NTAPI XhciEvtDeviceD0EntryPostInterruptsEnabled ( _In_ WDFDEVICE  Device, _In_ WDF_POWER_DEVICE_STATE  PreviousState  )

static

Definition at line 2314 of file hc.cpp.

{
    return XhciController::FromDevice(Device)->D0EntryPostInterruptsEnabled(PreviousState);
}

XhciEvtDeviceD0Exit()

static NTSTATUS NTAPI XhciEvtDeviceD0Exit ( _In_ WDFDEVICE  Device, _In_ WDF_POWER_DEVICE_STATE  TargetState  )

static

Definition at line 2337 of file hc.cpp.

{
    XhciController::FromDevice(Device)->D0Exit(TargetState);
    return STATUS_SUCCESS;
}

XhciEvtDeviceD0ExitPreInterruptsDisabled()

static NTSTATUS NTAPI XhciEvtDeviceD0ExitPreInterruptsDisabled ( _In_ WDFDEVICE  Device, _In_ WDF_POWER_DEVICE_STATE  TargetState  )

static

Definition at line 2324 of file hc.cpp.

{
    UNREFERENCED_PARAMETER(TargetState);
 
    XhciController::FromDevice(Device)->D0ExitPreInterruptsDisabled();
    return STATUS_SUCCESS;
}

XhciEvtDeviceDisarmWakeFromS0()

static VOID NTAPI XhciEvtDeviceDisarmWakeFromS0 ( _In_ WDFDEVICE  Device )

static

Definition at line 2388 of file hc.cpp.

{
    XhciController::FromDevice(Device)->SetPortWake(FALSE);
}

XhciEvtDeviceDisarmWakeFromSx()

static VOID NTAPI XhciEvtDeviceDisarmWakeFromSx ( _In_ WDFDEVICE  Device )

static

Definition at line 2416 of file hc.cpp.

{
    XhciController::FromDevice(Device)->m_WaitWakeQueued = FALSE;
}

XhciEvtDeviceFilterAddResourceRequirements()

static NTSTATUS NTAPI XhciEvtDeviceFilterAddResourceRequirements ( _In_ WDFDEVICE  Device, _In_ WDFIORESREQLIST  IoResourceRequirementsList  )

static

Definition at line 2440 of file hc.cpp.

{
    XhciController* Controller = XhciController::FromDevice(Device);
 
    if (Controller == NULL)
        return STATUS_SUCCESS;
 
    return Controller->m_Interrupters.AffinitizeResourceRequirements(IoResourceRequirementsList);
}

XhciEvtDeviceFilterRemoveResourceRequirements()

static NTSTATUS NTAPI XhciEvtDeviceFilterRemoveResourceRequirements ( _In_ WDFDEVICE  Device, _In_ WDFIORESREQLIST  IoResourceRequirementsList  )

static

Definition at line 2425 of file hc.cpp.

{
    XhciController* Controller = XhciController::FromDevice(Device);
 
    if (Controller == NULL)
        return STATUS_SUCCESS;
 
    return Controller->m_Interrupters.FilterResourceRequirements(IoResourceRequirementsList);
}

XhciEvtDevicePrepareHardware()

static NTSTATUS NTAPI XhciEvtDevicePrepareHardware ( _In_ WDFDEVICE  Device, _In_ WDFCMRESLIST  ResourcesRaw, _In_ WDFCMRESLIST  ResourcesTranslated  )

static

Definition at line 2280 of file hc.cpp.

{
    return XhciController::FromDevice(Device)->PrepareHardware(ResourcesRaw, ResourcesTranslated);
}

XhciEvtDeviceReleaseHardware()

static NTSTATUS NTAPI XhciEvtDeviceReleaseHardware ( _In_ WDFDEVICE  Device, _In_ WDFCMRESLIST  ResourcesTranslated  )

static

Definition at line 2291 of file hc.cpp.

{
    UNREFERENCED_PARAMETER(ResourcesTranslated);
 
    XhciController::FromDevice(Device)->ReleaseHardware();
    return STATUS_SUCCESS;
}

XhciEvtDeviceRemoveAddedResources()

static NTSTATUS NTAPI XhciEvtDeviceRemoveAddedResources ( _In_ WDFDEVICE  Device, _In_ WDFCMRESLIST  ResourcesRaw, _In_ WDFCMRESLIST  ResourcesTranslated  )

static

Definition at line 2455 of file hc.cpp.

{
    UNREFERENCED_PARAMETER(Device);
    UNREFERENCED_PARAMETER(ResourcesRaw);
    UNREFERENCED_PARAMETER(ResourcesTranslated);
 
    return STATUS_SUCCESS;
}

XhciEvtDeviceSelfManagedIoCleanup()

static VOID NTAPI XhciEvtDeviceSelfManagedIoCleanup ( _In_ WDFDEVICE  Device )

static

Definition at line 2358 of file hc.cpp.

{
    XhciController::FromDevice(Device)->SelfManagedIoCleanup();
}

XhciEvtDeviceSelfManagedIoInit()

static NTSTATUS NTAPI XhciEvtDeviceSelfManagedIoInit ( _In_ WDFDEVICE  Device )

static

Definition at line 2348 of file hc.cpp.

{
    XhciController::FromDevice(Device)->SelfManagedIoInit();
    return STATUS_SUCCESS;
}

XhciEvtDeviceUsageNotification()

static VOID NTAPI XhciEvtDeviceUsageNotification ( _In_ WDFDEVICE  Device, _In_ WDF_SPECIAL_FILE_TYPE  NotificationType, _In_ BOOLEAN  IsInNotificationPath  )

static

Definition at line 2367 of file hc.cpp.

{
    XhciController::FromDevice(Device)->UsageNotification(NotificationType, IsInNotificationPath);
}

XhciEvtDeviceWakeFromS0Triggered()

static VOID NTAPI XhciEvtDeviceWakeFromS0Triggered ( _In_ WDFDEVICE  Device )

static

Definition at line 2397 of file hc.cpp.

{
    XhciController::FromDevice(Device)->m_RootHub.SignalPortChange();
}

XhciEvtFdoCleanup()

static VOID NTAPI XhciEvtFdoCleanup ( _In_ WDFOBJECT  Object )

static

Definition at line 1242 of file hc.cpp.

{
    XhciController* Controller = XhciGetFdoContext((WDFDEVICE)Object)->Controller;
 
    if (Controller != NULL)
        Controller->FdoCleanup();
}

XhciEvtIdleTimeoutWork()

static VOID NTAPI XhciEvtIdleTimeoutWork ( _In_ WDFWORKITEM  WorkItem )

static

Definition at line 2558 of file hc.cpp.

{
    XhciGetObjectContext(WorkItem)->Controller->IdleTimeoutWorker();
}

XhciEvtIoDeviceControl()

static VOID NTAPI XhciEvtIoDeviceControl ( _In_ WDFQUEUE  Queue, _In_ WDFREQUEST  Request, _In_ size_t  OutputBufferLength, _In_ size_t  InputBufferLength, _In_ ULONG  IoControlCode  )

static

Definition at line 2514 of file hc.cpp.

{
    WDFDEVICE Device = WdfIoQueueGetDevice(Queue);
 
    if (UcxIoDeviceControl(Device, Request, OutputBufferLength, InputBufferLength, IoControlCode))
        return;
 
    if (WdfRequestGetRequestorMode(Request) != UserMode)
    {
        DPRINT1("Kernel mode IOCTL 0x%lx on the controller FDO\n", IoControlCode);
        WdfRequestComplete(Request, STATUS_INVALID_PARAMETER);
        return;
    }
 
    DPRINT1("Unsupported user IOCTL 0x%lx\n", IoControlCode);
    WdfRequestComplete(Request, STATUS_INVALID_DEVICE_REQUEST);
}

XhciEvtPreprocessInternalIoctl()

static NTSTATUS NTAPI XhciEvtPreprocessInternalIoctl ( _In_ WDFDEVICE  Device, _Inout_ PIRP  Irp  )

static

Definition at line 2492 of file hc.cpp.

{
    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
    XhciController* Controller = XhciController::FromDevice(Device);
 
    if (Controller != NULL && Stack->Parameters.DeviceIoControl.IoControlCode == XHCI_TEST_RESET_IOCTL)
    {
        Controller->RaiseControllerFault(XhciRecovery::ResetHost, XHCI_REASON_TEST_RESET);
        Irp->IoStatus.Status = STATUS_SUCCESS;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_SUCCESS;
    }
 
    IoSkipCurrentIrpStackLocation(Irp);
    return WdfDeviceWdmDispatchPreprocessedIrp(Device, Irp);
}

XhciEvtPreprocessSetPower()

static NTSTATUS NTAPI XhciEvtPreprocessSetPower ( _In_ WDFDEVICE  Device, _Inout_ PIRP  Irp  )

static

Definition at line 2470 of file hc.cpp.

{
    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
    XhciController* Controller = XhciController::FromDevice(Device);
    NTSTATUS Status;
 
    if (Controller != NULL && Stack->Parameters.Power.Type == SystemPowerState)
        Controller->TrackSystemPowerIrp(Stack);
 
    IoSkipCurrentIrpStackLocation(Irp);
    Status = WdfDeviceWdmDispatchPreprocessedIrp(Device, Irp);
    if (!NT_SUCCESS(Status))
        DPRINT1("Set power IRP dispatch returned 0x%lx\n", Status);
 
    return Status;
}

XhciEvtRecoveryWork()

static VOID NTAPI XhciEvtRecoveryWork ( _In_ WDFWORKITEM  WorkItem )

static

Definition at line 2549 of file hc.cpp.

{
    XhciGetObjectContext(WorkItem)->Controller->RecoveryWorker();
}

XhciEvtWatchdog()

static VOID NTAPI XhciEvtWatchdog ( _In_ WDFTIMER  Timer )

static

Definition at line 2540 of file hc.cpp.

{
    XhciGetObjectContext(Timer)->Controller->WatchdogTick();
}

XhciFirmwareCommandDone()

static VOID NTAPI XhciFirmwareCommandDone ( _In_ XhciCommand *  Command )

static

Definition at line 1498 of file hc.cpp.

{
    UNREFERENCED_PARAMETER(Command);
}

Referenced by XhciSendFirmwareCommand().

XhciPackFrameSnapshot()

static LONG64 NTAPI XhciPackFrameSnapshot ( _In_ ULONG  Frame, _In_ ULONG64  Now  )

static

Definition at line 1795 of file hc.cpp.

{
    ULONG64 Base = Now - (Frame & 0x7FF);
 
    return (LONG64)((Base << 21) | ((Frame >> 11) & 0x1FFFFF));
}

Referenced by XhciController::InitFrameSnapshot().

XhciQueryAcpiIdentity()

static NTSTATUS NTAPI XhciQueryAcpiIdentity ( _In_ WDFDEVICE  Device, _Inout_ XhciIdentity *  Id  )

static

Definition at line 302 of file hc.cpp.

{
    XHCI_ACPI_DEVICE_INFO Header;
    PXHCI_ACPI_DEVICE_INFO Info;
    WDF_MEMORY_DESCRIPTOR Output;
    WDFIOTARGET Target = WdfDeviceGetIoTarget(Device);
    const CHAR* Strings;
    ULONG_PTR Returned;
    ULONG Size;
    ULONG VendorOffset;
    ULONG DeviceOffset;
    ULONG Length;
    NTSTATUS Status;
 
    Id->PciVendorId = XHCI_ACPI_PARENT_ID;
    Id->PciDeviceId = XHCI_ACPI_PARENT_ID;
 
    RtlZeroMemory(&Header, sizeof(Header));
    WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&Output, &Header, sizeof(Header));
    Status = WdfIoTargetSendIoctlSynchronously(Target, NULL, XHCI_ACPI_GET_DEVICE_INFORMATION,
                                               NULL, &Output, NULL, &Returned);
    if (Status != STATUS_BUFFER_OVERFLOW)
    {
        /* QUIRK: a success here leaves the identity empty and is passed on as is */
        DPRINT1("ACPI device information size query returned 0x%lx\n", Status);
        return Status;
    }
 
    Size = Header.Size;
    if (Size < sizeof(Header))
    {
        DPRINT1("ACPI device information size %lu too small\n", Size);
        return STATUS_ACPI_INVALID_DATA;
    }
 
    Info = (PXHCI_ACPI_DEVICE_INFO)ExAllocatePoolZero(NonPagedPool, Size, XHCI_TAG_CONTROLLER);
    if (Info == NULL)
    {
        DPRINT1("No memory for %lu bytes of ACPI device information\n", Size);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&Output, Info, Size);
    Status = WdfIoTargetSendIoctlSynchronously(Target, NULL, XHCI_ACPI_GET_DEVICE_INFORMATION,
                                               NULL, &Output, NULL, &Returned);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ACPI device information query failed 0x%lx\n", Status);
        ExFreePoolWithTag(Info, XHCI_TAG_CONTROLLER);
        return Status;
    }
 
    RtlStringCbPrintfA(Id->AcpiRevisionId, sizeof(Id->AcpiRevisionId), "%04X", Info->HardwareRevision);
 
    Strings = (const CHAR*)Info;
    VendorOffset = Info->VendorIdStringOffset;
    DeviceOffset = Info->DeviceIdStringOffset;
    Length = Info->VendorStringLength;
    if (VendorOffset > Size || Length > Size - VendorOffset)
        VendorOffset = 0;
 
    if (VendorOffset == 0)
    {
        RtlStringCbCopyA(Id->AcpiVendorId, sizeof(Id->AcpiVendorId), "UKWN");
        RtlStringCbCopyA(Id->AcpiDeviceId, sizeof(Id->AcpiDeviceId), "FFFF");
    }
    else if (DeviceOffset == 0 || DeviceOffset < VendorOffset || DeviceOffset > VendorOffset + Length)
    {
        XhciCopyAcpiId(Id->AcpiVendorId, Strings + VendorOffset, Length);
        RtlStringCbCopyA(Id->AcpiDeviceId, sizeof(Id->AcpiDeviceId), "FFFF");
    }
    else
    {
        XhciCopyAcpiId(Id->AcpiVendorId, Strings + VendorOffset, DeviceOffset - VendorOffset);
        XhciCopyAcpiId(Id->AcpiDeviceId, Strings + DeviceOffset, VendorOffset + Length - DeviceOffset);
    }
 
    ExFreePoolWithTag(Info, XHCI_TAG_CONTROLLER);
    return STATUS_SUCCESS;
}

Referenced by XhciQueryIdentity().

XhciQueryIdentity()

static NTSTATUS NTAPI XhciQueryIdentity ( _In_ WDFDEVICE  Device, _Out_ XhciIdentity *  Id  )

static

Definition at line 388 of file hc.cpp.

{
    WCHAR Enumerator[8];
    ULONG Length;
    NTSTATUS Status;
 
    RtlZeroMemory(Id, sizeof(*Id));
    Id->FirmwareVersion = XHCI_FIRMWARE_UNKNOWN;
    Id->ParentBus = UcxControllerParentBusTypePci;
 
    Status = IoGetDeviceProperty(WdfDeviceWdmGetPhysicalDevice(Device), DevicePropertyEnumeratorName,
                                 sizeof(Enumerator), Enumerator, &Length);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Enumerator name query failed 0x%lx, assuming PCI\n", Status);
    }
    else if (_wcsicmp(Enumerator, L"ACPI") == 0)
    {
        Id->ParentBus = UcxControllerParentBusTypeAcpi;
    }
    else if (_wcsicmp(Enumerator, L"URS") == 0)
    {
        /* ReactOS has no USB role switch enumerator */
        UNIMPLEMENTED;
        DPRINT1("Controllers below the role switch enumerator are not supported\n");
        return STATUS_NOT_SUPPORTED;
    }
 
    if (Id->ParentBus == UcxControllerParentBusTypeAcpi)
        Status = XhciQueryAcpiIdentity(Device, Id);
    else
        Status = XhciQueryPciIdentity(Device, Id);
 
    if (!NT_SUCCESS(Status))
        DPRINT1("Controller identity unavailable 0x%lx\n", Status);
 
    return Status;
}

Referenced by XhciEvtDeviceAdd().

XhciQueryPciIdentity()

static NTSTATUS NTAPI XhciQueryPciIdentity ( _In_ WDFDEVICE  Device, _Inout_ XhciIdentity *  Id  )

static

Definition at line 209 of file hc.cpp.

{
    PCI_COMMON_CONFIG Config;
    PBUS_INTERFACE_STANDARD Bus = &Id->PciInterface;
    ULONG Address;
    ULONG Length;
    ULONG Value;
    UCHAR Bytes[3];
    ULONG Index;
    NTSTATUS Status;
 
    /* QUIRK: a missing bus number is only reported */
    Status = WdfDeviceQueryProperty(Device, DevicePropertyBusNumber, sizeof(Id->PciBus), &Id->PciBus, &Length);
    if (!NT_SUCCESS(Status))
        DPRINT1("Bus number query failed 0x%lx\n", Status);
 
    Status = WdfDeviceQueryProperty(Device, DevicePropertyAddress, sizeof(Address), &Address, &Length);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Bus address query failed 0x%lx\n", Status);
        return Status;
    }
    Id->PciDevice = Address >> 16;
    Id->PciFunction = Address & 0xFFFF;
 
    Status = WdfFdoQueryForInterface(Device, &XhciGuidBusInterfaceStandard, (PINTERFACE)Bus,
                                     sizeof(*Bus), 1, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("PCI bus interface query failed 0x%lx\n", Status);
        RtlZeroMemory(Bus, sizeof(*Bus));
        return Status;
    }
 
    if (Bus->GetBusData(Bus->Context, PCI_WHICHSPACE_CONFIG, &Config, 0, sizeof(Config)) != sizeof(Config))
    {
        DPRINT1("PCI config space read came back short\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    Id->PciVendorId = Config.VendorID;
    Id->PciDeviceId = Config.DeviceID;
    Id->PciRevisionId = Config.RevisionID;
    Id->PciSubsystemVendorId = Config.u.type0.SubVendorID;
    Id->PciSubsystemId = Config.u.type0.SubSystemID;
 
    /* VIA keeps its firmware version in config space */
    if (Id->PciVendorId == 0x1106 && Id->PciDeviceId == 0x3432)
    {
        for (Index = 0; Index < RTL_NUMBER_OF(Bytes); Index++)
        {
            if (Bus->GetBusData(Bus->Context, PCI_WHICHSPACE_CONFIG, &Bytes[Index], 0x261 + Index, 1) != 1)
            {
                DPRINT1("VIA firmware version read failed\n");
                return STATUS_SUCCESS;
            }
        }
        Id->FirmwareVersion = ((ULONG)Bytes[2] << 16) | ((ULONG)Bytes[1] << 8) | Bytes[0];
    }
    else if (Id->PciVendorId == 0x1106 && (Id->PciDeviceId == 0x3483 || Id->PciDeviceId == 0x9201))
    {
        if (Bus->GetBusData(Bus->Context, PCI_WHICHSPACE_CONFIG, &Value, 0x50, sizeof(Value)) == sizeof(Value))
            Id->FirmwareVersion = Value;
        else
            DPRINT1("VIA firmware version read failed\n");
    }
 
    return STATUS_SUCCESS;
}

Referenced by XhciQueryIdentity().

XhciSendFirmwareCommand()

static BOOLEAN NTAPI XhciSendFirmwareCommand ( _In_ XhciController *  Controller, _In_ ULONG  Type, _Out_ PULONG  Parameter  )

static

Sends one vendor firmware query; TRUE with the completion parameter on success.

Definition at line 1508 of file hc.cpp.

{
    XhciCommand Command;
    NTSTATUS Status;
 
    RtlZeroMemory(&Command, sizeof(Command));
    Command.Trb.Dword[3] = Type << XHCI_TRB_TYPE_SHIFT;
    Command.Done = XhciFirmwareCommandDone;
    Command.Context = Controller;
    Command.Internal = TRUE;
 
    Status = Controller->m_Commands.SubmitAndWait(&Command);
    if (!NT_SUCCESS(Status) || Command.Code != XhciCompletionCode::Success)
    {
        DPRINT1("Firmware version command %lu failed, status 0x%lx code %lu\n",
                Type, Status, static_cast<ULONG>(Command.Code));
        *Parameter = 0;
        return FALSE;
    }
 
    *Parameter = Command.Completion.Dword[2] & 0x00FFFFFF;
    return TRUE;
}

Referenced by XhciController::RunFirmwareCommands().

Variable Documentation

XhciEvtControllerGetCurrentFrameNumber

EVT_UCX_CONTROLLER_GET_CURRENT_FRAMENUMBER XhciEvtControllerGetCurrentFrameNumber

static

Definition at line 157 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtControllerQueryUsbCapability

EVT_UCX_CONTROLLER_QUERY_USB_CAPABILITY XhciEvtControllerQueryUsbCapability

static

Definition at line 156 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtControllerReset

EVT_UCX_CONTROLLER_RESET XhciEvtControllerReset

static

Definition at line 158 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceArmWakeFromS0

EVT_WDF_DEVICE_ARM_WAKE_FROM_S0 XhciEvtDeviceArmWakeFromS0

static

Definition at line 141 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceArmWakeFromSx

EVT_WDF_DEVICE_ARM_WAKE_FROM_SX XhciEvtDeviceArmWakeFromSx

static

Definition at line 144 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceD0Entry

EVT_WDF_DEVICE_D0_ENTRY XhciEvtDeviceD0Entry

static

Definition at line 134 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceD0EntryPostInterruptsEnabled

EVT_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED XhciEvtDeviceD0EntryPostInterruptsEnabled

static

Definition at line 135 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceD0Exit

EVT_WDF_DEVICE_D0_EXIT XhciEvtDeviceD0Exit

static

Definition at line 137 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceD0ExitPreInterruptsDisabled

EVT_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED XhciEvtDeviceD0ExitPreInterruptsDisabled

static

Definition at line 136 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceDisarmWakeFromS0

EVT_WDF_DEVICE_DISARM_WAKE_FROM_S0 XhciEvtDeviceDisarmWakeFromS0

static

Definition at line 142 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceDisarmWakeFromSx

EVT_WDF_DEVICE_DISARM_WAKE_FROM_SX XhciEvtDeviceDisarmWakeFromSx

static

Definition at line 145 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceFilterAddResourceRequirements

EVT_WDF_DEVICE_FILTER_RESOURCE_REQUIREMENTS XhciEvtDeviceFilterAddResourceRequirements

static

Definition at line 147 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceFilterRemoveResourceRequirements

EVT_WDF_DEVICE_FILTER_RESOURCE_REQUIREMENTS XhciEvtDeviceFilterRemoveResourceRequirements

static

Definition at line 146 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDevicePrepareHardware

EVT_WDF_DEVICE_PREPARE_HARDWARE XhciEvtDevicePrepareHardware

static

Definition at line 132 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceReleaseHardware

EVT_WDF_DEVICE_RELEASE_HARDWARE XhciEvtDeviceReleaseHardware

static

Definition at line 133 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceRemoveAddedResources

EVT_WDF_DEVICE_REMOVE_ADDED_RESOURCES XhciEvtDeviceRemoveAddedResources

static

Definition at line 148 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceSelfManagedIoCleanup

EVT_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP XhciEvtDeviceSelfManagedIoCleanup

static

Definition at line 139 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceSelfManagedIoInit

EVT_WDF_DEVICE_SELF_MANAGED_IO_INIT XhciEvtDeviceSelfManagedIoInit

static

Definition at line 138 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceUsageNotification

EVT_WDF_DEVICE_USAGE_NOTIFICATION XhciEvtDeviceUsageNotification

static

Definition at line 140 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtDeviceWakeFromS0Triggered

EVT_WDF_DEVICE_WAKE_FROM_S0_TRIGGERED XhciEvtDeviceWakeFromS0Triggered

static

Definition at line 143 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtFdoCleanup

EVT_WDF_OBJECT_CONTEXT_CLEANUP XhciEvtFdoCleanup

static

Definition at line 151 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtIdleTimeoutWork

EVT_WDF_WORKITEM XhciEvtIdleTimeoutWork

static

Definition at line 155 of file hc.cpp.

Referenced by XhciController::CreateWdfObjects().

XhciEvtIoDeviceControl

EVT_WDF_IO_QUEUE_IO_DEVICE_CONTROL XhciEvtIoDeviceControl

static

Definition at line 152 of file hc.cpp.

Referenced by XhciController::Initialize().

XhciEvtPreprocessInternalIoctl

EVT_WDFDEVICE_WDM_IRP_PREPROCESS XhciEvtPreprocessInternalIoctl

static

Definition at line 150 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtPreprocessSetPower

EVT_WDFDEVICE_WDM_IRP_PREPROCESS XhciEvtPreprocessSetPower

static

Definition at line 149 of file hc.cpp.

Referenced by XhciEvtDeviceAdd().

XhciEvtRecoveryWork

EVT_WDF_WORKITEM XhciEvtRecoveryWork

static

Definition at line 154 of file hc.cpp.

Referenced by XhciController::CreateWdfObjects().

XhciEvtWatchdog

EVT_WDF_TIMER XhciEvtWatchdog

static

Definition at line 153 of file hc.cpp.

Referenced by XhciController::CreateWdfObjects().

XhciGuidBusInterfaceStandard

const GUID XhciGuidBusInterfaceStandard

static

Initial value:

=
    { 0x496b8280, 0x6f25, 0x11d0, { 0xbe, 0xaf, 0x08, 0x00, 0x2b, 0xe2, 0x09, 0x2f } }

Definition at line 16 of file hc.cpp.

Referenced by XhciQueryPciIdentity().

XhciGuidBusTypeUsb

const GUID XhciGuidBusTypeUsb

static

Initial value:

=
    { 0x9d7debbc, 0xc85d, 0x11d1, { 0x9e, 0xb4, 0x00, 0x60, 0x08, 0xc3, 0xa1, 0x9a } }

Definition at line 20 of file hc.cpp.

Referenced by XhciCreateFdo().

XhciGuidChainedMdls

const GUID XhciGuidChainedMdls

static

Initial value:

=
    { 0xf5ceeb23, 0xad90, 0x458c, { 0x97, 0x9a, 0xd5, 0x9b, 0x3a, 0xd6, 0x88, 0x4f } }

Definition at line 24 of file hc.cpp.

Referenced by XhciController::QueryUsbCapability().

XhciGuidClearTtBufferOnCancel

const GUID XhciGuidClearTtBufferOnCancel

static

Initial value:

=
    { 0x09b76d52, 0x0a6d, 0x4e4f, { 0xa9, 0x11, 0xd0, 0x36, 0xd1, 0x92, 0x94, 0x97 } }

Definition at line 34 of file hc.cpp.

Referenced by XhciController::QueryUsbCapability().

XhciGuidD3ColdSupport

const GUID XhciGuidD3ColdSupport

static

Initial value:

=
    { 0xb38290e5, 0x3cd0, 0x4f9d, { 0x99, 0x37, 0xf5, 0xfe, 0x2b, 0x44, 0xd4, 0x7a } }

Definition at line 18 of file hc.cpp.

Referenced by XhciController::ConfigureS0Idle().

XhciGuidDsm

const GUID XhciGuidDsm

static

Initial value:

=
    { 0xac340cb7, 0xe901, 0x45bf, { 0xb7, 0xe6, 0x2b, 0x34, 0xec, 0x93, 0x1e, 0x23 } }

Definition at line 36 of file hc.cpp.

Referenced by XhciController::EvaluateDsm().

XhciGuidFunctionSuspend

const GUID XhciGuidFunctionSuspend

static

Initial value:

=
    { 0xf4563183, 0xd66e, 0x42bd, { 0xbd, 0x53, 0x1a, 0xc7, 0xb0, 0x4c, 0xd5, 0x9d } }

Definition at line 30 of file hc.cpp.

Referenced by XhciController::QueryUsbCapability().

XhciGuidHighBandwidthIsoch

const GUID XhciGuidHighBandwidthIsoch

static

Initial value:

=
    { 0x9c8a8a27, 0x15f9, 0x42e3, { 0xa3, 0x56, 0xcd, 0xa6, 0xae, 0x97, 0xa8, 0xc8 } }

Definition at line 32 of file hc.cpp.

Referenced by XhciController::QueryUsbCapability().

XhciGuidHostControllerInterface

const GUID XhciGuidHostControllerInterface

static

Initial value:

=
    { 0x3abf6f2d, 0x71c4, 0x462a, { 0x8a, 0x92, 0x1e, 0x68, 0x61, 0xe6, 0xaf, 0x27 } }

Definition at line 22 of file hc.cpp.

Referenced by XhciCreateFdo().

XhciGuidSelectiveSuspend

const GUID XhciGuidSelectiveSuspend

static

Initial value:

=
    { 0x755c630d, 0xc8a0, 0x4765, { 0x94, 0x6f, 0x90, 0xcc, 0x70, 0x38, 0x56, 0xa4 } }

Definition at line 28 of file hc.cpp.

Referenced by XhciController::QueryUsbCapability().

XhciGuidStaticStreams

const GUID XhciGuidStaticStreams

static

Initial value:

=
    { 0x09051e1f, 0x0dc9, 0x4e6b, { 0x8b, 0x12, 0x96, 0x0c, 0xbd, 0x81, 0xaa, 0x8f } }

Definition at line 26 of file hc.cpp.

Referenced by XhciController::QueryUsbCapability().