XhciUsbDevice Class Reference

#include <slotdev.h>

Collaboration diagram for XhciUsbDevice:

Classes
struct	ReconfigureWaiter

Public Member Functions
PVOID	InputContext (_In_ ULONG Index) const
PVOID	OutputContext (_In_ ULONG Dci) const
ULONG64	InputContextAddress () const
VOID	ZeroInputContext ()
VOID	BuildSlotContext (_Out_writes_bytes_(ContextSize) PVOID SlotContext, _In_ ULONG ContextSize) const
ULONG	ContextEntries () const
ULONG	SlotId () const
USB_DEVICE_SPEED	Speed () const
UCXUSBDEVICE	Handle () const
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID RingDoorbell(_In_ ULONG Dci
	_IRQL_requires_max_ (DISPATCH_LEVEL) XhciEndpoint *EndpointAt(_In_ ULONG Dci) const
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID AddEndpoint(_In_ XhciEndpoint *Endpoint)
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID RemoveEndpoint(_In_ XhciEndpoint *Endpoint)
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID ReconfigureEndpoint(_In_ XhciEndpoint *Endpoint
_In_	VOID (NTAPI *Done)(_In_ PVOID Context
VOID	OnTransferEvent (_In_ const XHCI_TRB *Event)
VOID	OnDeviceNotificationEvent (_In_ const XHCI_TRB *Event)
VOID	ControllerResetStarting ()
	_IRQL_requires_ (PASSIVE_LEVEL) VOID ControllerResetDone()
VOID	OnHostLost ()
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID SetDisabled()
XhciController *	Controller () const
BOOLEAN	IsSlotEnabled () const
const USB_DEVICE_DESCRIPTOR *	DeviceDescriptor () const
const USB_DEVICE_PORT_PATH *	PortPath () const
ULONG	ContextSize () const
ULONG	EndpointState (_In_ ULONG Dci) const
ULONG64	HardwareDequeuePointer (_In_ ULONG Dci) const
	_IRQL_requires_ (PASSIVE_LEVEL) NTSTATUS Initialize(_In_ XhciController *Controller
VOID	Cleanup (_In_ WDFOBJECT Object)
VOID	Enable (_In_ WDFREQUEST Request, _Inout_ PUSBDEVICE_ENABLE Payload)
VOID	Address (_In_ WDFREQUEST Request, _Inout_ PUSBDEVICE_ADDRESS Payload)
VOID	Update (_In_ WDFREQUEST Request, _Inout_ PUSBDEVICE_UPDATE Payload)
VOID	HubInfo (_In_ WDFREQUEST Request, _In_ const USBDEVICE_HUB_INFO *Payload)
VOID	EndpointsConfigure (_In_ WDFREQUEST Request, _Inout_ PENDPOINTS_CONFIGURE Payload)
VOID	Disable (_In_ WDFREQUEST Request)
VOID	Reset (_In_ WDFREQUEST Request)

Static Public Member Functions
static XhciUsbDevice *	FromUcx (_In_ UCXUSBDEVICE UsbDevice)

Public Attributes
_In_ ULONG	StreamId
_In_ _In_ NTSTATUS	Status
_In_ _In_ NTSTATUS _In_ PVOID	Context
_In_ UCXUSBDEVICE	UsbDevice
_In_ UCXUSBDEVICE _In_ const UCXUSBDEVICE_INFO *	Info

Private Types
enum class	PendingKind : ULONG {   None , Enable , Address , Update ,   Configure , Disable , Reset }
enum class	AfterDisable : ULONG { CompleteSuccess , CompleteFailure , EnableSlot }
typedef VOID(NTAPI *	PFN_RECONFIGURE_DONE) (_In_ PVOID Context, _In_ NTSTATUS Status)

Private Member Functions
VOID	SetPending (_In_ WDFREQUEST Request, _In_ PVOID Payload, _In_ PendingKind Kind, _In_ BOOLEAN MustSucceed)
WDFREQUEST	TakePending ()
VOID	CompletePending (_In_ NTSTATUS Status)
NTSTATUS	LostSlotStatus () const
VOID	PrepareCommand (_In_ ULONG Type)
VOID	SubmitEnableSlot ()
NTSTATUS	SubmitAddressDevice (_In_ BOOLEAN BlockSetAddress)
VOID	SubmitDisableSlot (_In_ AfterDisable Next)
VOID	SubmitSecondConfigure ()
VOID	OnEnableSlotDone (_In_ const XhciCommand *Command)
VOID	OnAddressDeviceDone (_In_ const XhciCommand *Command)
VOID	OnEvaluateContextDone (_In_ const XhciCommand *Command)
VOID	OnConfigureEndpointDone (_In_ const XhciCommand *Command)
VOID	OnDisableSlotDone (_In_ const XhciCommand *Command)
VOID	OnResetDeviceDone (_In_ const XhciCommand *Command)
NTSTATUS	BuildAddressContext ()
VOID	ApplyUpdate (_Inout_ PUSBDEVICE_UPDATE Payload)
BOOLEAN	WantsTunnelStateDsm (_In_ const USBDEVICE_UPDATE *Payload) const
BOOLEAN	QueueTunnelStateDsm (_Inout_ PUSBDEVICE_UPDATE Payload)
	_IRQL_requires_ (PASSIVE_LEVEL) VOID RunTunnelStateDsm(_Inout_ PUSBDEVICE_UPDATE Payload)
VOID	DisableDefaultEndpoint ()
VOID	DisableConfiguredEndpoints (_In_ BOOLEAN ClearTable)
VOID	DisableEndpointList (_In_ ULONG Count, _In_reads_(Count) UCXENDPOINT *Endpoints)
VOID	RecordEnabledEndpoints (_In_ const ENDPOINTS_CONFIGURE *Payload)
VOID	ForgetSlot ()
VOID	StartReconfigure (_In_ const ReconfigureWaiter *Waiter)
VOID	FinishReconfigure (_In_ NTSTATUS Status)
PXHCI_INPUT_CONTROL_CONTEXT	InputControl () const
PXHCI_SLOT_CONTEXT	InputSlot () const
const XHCI_SLOT_CONTEXT *	OutputSlot () const
XhciUsbDevice *	TtHub () const

Static Private Member Functions
static VOID NTAPI	CommandDone (_In_ XhciCommand *Command)
static VOID NTAPI	ReconfigureCommandDone (_In_ XhciCommand *Command)

Private Attributes
UCXUSBDEVICE	m_Handle
XhciController *	m_Controller
UCXUSBDEVICE_INFO	m_Info
ULONG	m_ContextSize
XhciDmaBuffer *	m_Output
XhciDmaBuffer *	m_Input
USB_DEVICE_DESCRIPTOR	m_DeviceDescriptor
BOOLEAN	m_SlotEnabled
ULONG	m_SlotId
BOOLEAN	m_IsHub
ULONG	m_NumberOfPorts
ULONG	m_NumberOfTTs
ULONG	m_TTThinkTime
BOOLEAN	m_LpmEnabled
BOOLEAN	m_ResumeTimeSet
ULONG	m_ContextMask
XhciEndpoint *	m_Endpoints [XHCI_MAX_DCI+1]
volatile LONG	m_EndpointCount
XhciCommand	m_Command
WDFREQUEST	m_PendingRequest
PVOID	m_PendingPayload
PendingKind	m_PendingKind
BOOLEAN	m_MustSucceed
AfterDisable	m_AfterDisable
KSPIN_LOCK	m_ReconfigureLock
BOOLEAN	m_ReconfigureBusy
ULONG	m_ReconfigureQueued
ReconfigureWaiter	m_ReconfigureWaiters [XHCI_MAX_DCI+1]
ReconfigureWaiter	m_ReconfigureCurrent
XhciCommand	m_ReconfigureCommand
XhciDmaBuffer *	m_ReconfigureInput

Static Private Attributes
static EVT_WDF_WORKITEM	TunnelDsmWorker

Detailed Description

One USB device and its xHCI slot. Lives in the UCXUSBDEVICE context.

Definition at line 17 of file slotdev.h.

Member Typedef Documentation

PFN_RECONFIGURE_DONE

typedef VOID(NTAPI * XhciUsbDevice::PFN_RECONFIGURE_DONE) (_In_ PVOID Context, _In_ NTSTATUS Status)

private

Definition at line 150 of file slotdev.h.

Member Enumeration Documentation

AfterDisable

enum class XhciUsbDevice::AfterDisable : ULONG

strongprivate

What a successful Disable Slot does next.

Enumerator
CompleteSuccess
CompleteFailure
EnableSlot

Definition at line 165 of file slotdev.h.

    {
        CompleteSuccess,
        CompleteFailure,
        EnableSlot
    };

PendingKind

enum class XhciUsbDevice::PendingKind : ULONG

strongprivate

Which device request owns the device command block.

Enumerator
None
Enable
Address
Update
Configure
Disable
Reset

Definition at line 153 of file slotdev.h.

    {
        None,
        Enable,
        Address,
        Update,
        Configure,
        Disable,
        Reset
    };

Member Function Documentation

_IRQL_requires_() [1/3]

XhciUsbDevice::_IRQL_requires_

(

PASSIVE_LEVEL

)

_IRQL_requires_() [2/3]

XhciUsbDevice::_IRQL_requires_

(

PASSIVE_LEVEL

)

_IRQL_requires_() [3/3]

XhciUsbDevice::_IRQL_requires_ ( PASSIVE_LEVEL  )

private

_IRQL_requires_max_() [1/6]

XhciUsbDevice::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

_IRQL_requires_max_() [2/6]

XhciUsbDevice::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Configure Endpoint for one endpoint (drop and add) on its own command block and input context, serialized per device, for static streams enable and disable. Done runs once with the result.

_IRQL_requires_max_() [3/6]

XhciUsbDevice::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

_IRQL_requires_max_() [4/6]

XhciUsbDevice::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

_IRQL_requires_max_() [5/6]

XhciUsbDevice::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

The slot was lost without a Disable Slot: drop it and finish any pending request.

_IRQL_requires_max_() [6/6]

XhciUsbDevice::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

const

Address()

VOID XhciUsbDevice::Address	(	_In_ WDFREQUEST	Request,
		_Inout_ PUSBDEVICE_ADDRESS	Payload
	)

Definition at line 839 of file slotdev.cpp.

{
    NTSTATUS Status;
 
    if (!m_SlotEnabled)
    {
        DPRINT1("ADDRESS for device %p without a slot\n", this);
        WdfRequestComplete(Request, STATUS_UNSUCCESSFUL);
        return;
    }
 
    if (!m_Controller->IsAccessible())
    {
        DPRINT1("ADDRESS for device %p with the controller gone\n", this);
        WdfRequestComplete(Request, STATUS_NO_SUCH_DEVICE);
        return;
    }
 
    SetPending(Request, Payload, PendingKind::Address, FALSE);
 
    Status = SubmitAddressDevice(FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Address Device for slot %lu not built: 0x%lx\n", m_SlotId, Status);
        CompletePending(Status);
    }
}

Referenced by XhciEvtUsbDeviceAddress().

ApplyUpdate()

VOID XhciUsbDevice::ApplyUpdate ( _Inout_ PUSBDEVICE_UPDATE  Payload )

private

Definition at line 918 of file slotdev.cpp.

{
    ULONG RootPort = m_Info.PortPath.PortPath[0];
    PUCXHUB_UPDATE_TUNNEL_ANSWER Answer;
 
    /* QUIRK: a device never stops being a hub */
    if (Payload->Flags.UpdateIsHub && Payload->IsHub)
        m_IsHub = TRUE;
 
    if (Payload->Flags.UpdateDeviceDescriptor && Payload->DeviceDescriptor != NULL)
        RtlCopyMemory(&m_DeviceDescriptor, Payload->DeviceDescriptor, sizeof(m_DeviceDescriptor));
 
    if (Payload->Flags.Update20HardwareLpmParameters)
    {
        ASSERT(!m_IsHub);
        m_LpmEnabled = (BOOLEAN)Payload->Usb20HardwareLpmParameters.HardwareLpmEnable;
        m_Controller->m_RootHub.Update20HardwareLpm(RootPort, m_SlotId, &Payload->Usb20HardwareLpmParameters);
    }
 
    if (Payload->Flags.UpdateRootPortResumeTime)
    {
        m_Controller->m_RootHub.ArmPortResumeTimer(RootPort, Payload->RootPortResumeTime);
        m_ResumeTimeSet = TRUE;
    }
 
    /* The ACPI path fills the answer before it gets here */
    if (Payload->Flags.UpdateTunnelState && !m_Controller->HasErrata(XhciErrata::Usb4TunnelFromAcpiDsm))
    {
        Answer = UcxHubUpdateTunnelAnswer(Payload);
        Answer->TunnelState = m_Controller->m_RootHub.QueryTunnelState(RootPort);
        Answer->NativeLink = Answer->TunnelState != UCXHUB_TUNNEL_STATE_TUNNELED &&
                             Answer->TunnelState != UCXHUB_TUNNEL_STATE_UNKNOWN;
    }
}

Referenced by OnEvaluateContextDone(), and Update().

BuildAddressContext()

NTSTATUS XhciUsbDevice::BuildAddressContext ( )

private

Definition at line 651 of file slotdev.cpp.

{
    const USB_DEVICE_PORT_PATH* Path = &m_Info.PortPath;
    PXHCI_SLOT_CONTEXT Slot;
    XhciUsbDevice* Hub;
    ULONG Speed;
    ULONG Route;
    ULONG Tier;
 
    switch (m_Info.DeviceSpeed)
    {
        case UsbLowSpeed:
            Speed = XHCI_SPEED_LOW;
            break;
        case UsbFullSpeed:
            Speed = XHCI_SPEED_FULL;
            break;
        case UsbHighSpeed:
            Speed = XHCI_SPEED_HIGH;
            break;
        case UsbSuperSpeed:
            Speed = XHCI_SPEED_SUPER;
            break;
        default:
            DPRINT1("Device %p has speed %d, which a slot cannot describe\n", this, m_Info.DeviceSpeed);
            return STATUS_INVALID_PARAMETER;
    }
 
    ZeroInputContext();
    InputControl()->AddFlags = XHCI_DEFAULT_CONTEXT_MASK;
    m_ContextMask = XHCI_DEFAULT_CONTEXT_MASK;
 
    /* The root port is not part of the route string (USB 3.2 8.9) */
    Route = 0;
    for (Tier = 1; Tier < Path->PortPathDepth && Tier < MAX_USB_DEVICE_DEPTH; Tier++)
        Route |= min(Path->PortPath[Tier], (ULONG)XHCI_ROUTE_TIER_MAX) << ((Tier - 1) * XHCI_ROUTE_TIER_BITS);
 
    Slot = InputSlot();
    Slot->RouteString = Route;
    Slot->Speed = Speed;
    Slot->ContextEntries = 1;
    Slot->RootHubPortNumber = Path->PortPath[0];
 
    Hub = TtHub();
    if (Hub != NULL)
    {
        Slot->MultiTT = (Hub->m_NumberOfTTs > 1);
        Slot->TTHubSlotId = Hub->m_SlotId;
    }
 
    if (Path->TTHubDepth != 0 && Path->TTHubDepth < MAX_USB_DEVICE_DEPTH)
        Slot->TTPortNumber = Path->PortPath[Path->TTHubDepth];
 
    /* QUIRK: Average TRB Length stays 0 for EP0 */
    m_Endpoints[1]->BuildContext(InputContext(1 + 1), m_ContextSize);
    return STATUS_SUCCESS;
}

Referenced by SubmitAddressDevice().

BuildSlotContext()

VOID XhciUsbDevice::BuildSlotContext	(	_Out_writes_bytes_(ContextSize) PVOID	SlotContext,
		_In_ ULONG	ContextSize
	)		const

Fills the hub fields of an input slot context and applies the multi TT errata rule.

Definition at line 1159 of file slotdev.cpp.

{
    PXHCI_SLOT_CONTEXT Slot = (PXHCI_SLOT_CONTEXT)SlotContext;
    XhciUsbDevice* Hub;
 
    /* Only the hub fields; the caller zeroed the context and owns Context Entries */
    ASSERT(ContextSize >= sizeof(*Slot));
    UNREFERENCED_PARAMETER(ContextSize);
 
    if (m_IsHub)
    {
        Slot->Hub = 1;
        Slot->NumberOfPorts = m_NumberOfPorts;
 
        if (m_Info.DeviceSpeed == UsbHighSpeed)
        {
            Slot->MultiTT = (m_NumberOfTTs > 1);
            Slot->TTThinkTime = m_TTThinkTime;
        }
    }
 
    /* Some controllers need MTT repeated for LS and FS devices behind a multi TT hub */
    if (m_Controller->HasErrata(XhciErrata::CfgMultiTtFromHubData) &&
        !m_IsHub &&
        (m_Info.DeviceSpeed == UsbLowSpeed || m_Info.DeviceSpeed == UsbFullSpeed))
    {
        Hub = TtHub();
        if (Hub != NULL && Hub->m_NumberOfTTs > 1)
            Slot->MultiTT = 1;
    }
}

Referenced by EndpointsConfigure(), StartReconfigure(), and SubmitSecondConfigure().

Cleanup()

VOID XhciUsbDevice::Cleanup

(

_In_ WDFOBJECT

Object

)

Definition at line 221 of file slotdev.cpp.

{
    /* Creation never got far enough to own anything */
    if (m_Handle != (UCXUSBDEVICE)Object)
        return;
 
    ASSERT(m_SlotId == 0);
 
    if (m_Output != NULL)
    {
        m_Controller->m_Buffers.Free(m_Output);
        m_Output = NULL;
    }
 
    if (m_Input != NULL)
    {
        m_Controller->m_Buffers.Free(m_Input);
        m_Input = NULL;
    }
 
    if (m_ReconfigureInput != NULL)
    {
        m_Controller->m_Buffers.Free(m_ReconfigureInput);
        m_ReconfigureInput = NULL;
    }
}

CommandDone()

VOID NTAPI XhciUsbDevice::CommandDone ( _In_ XhciCommand *  Command )

staticprivate

Definition at line 568 of file slotdev.cpp.

{
    XhciUsbDevice* Device = static_cast<XhciUsbDevice*>(Command->Context);
 
    /* Controller gone or a lost slot already finished the request */
    if (Device->m_PendingRequest == NULL)
    {
        DPRINT("Device %p command type %lu completed with no request left\n",
               Device, XhciTrbType(&Command->Trb));
        return;
    }
 
    switch (XhciTrbType(&Command->Trb))
    {
        case static_cast<ULONG>(XhciTrbType::EnableSlot):
            Device->OnEnableSlotDone(Command);
            break;
 
        case static_cast<ULONG>(XhciTrbType::AddressDevice):
            Device->OnAddressDeviceDone(Command);
            break;
 
        case static_cast<ULONG>(XhciTrbType::EvaluateContext):
            Device->OnEvaluateContextDone(Command);
            break;
 
        case static_cast<ULONG>(XhciTrbType::ConfigureEndpoint):
            Device->OnConfigureEndpointDone(Command);
            break;
 
        case static_cast<ULONG>(XhciTrbType::DisableSlot):
            Device->OnDisableSlotDone(Command);
            break;
 
        case static_cast<ULONG>(XhciTrbType::ResetDevice):
            Device->OnResetDeviceDone(Command);
            break;
 
        default:
            ASSERT(FALSE);
            break;
    }
}

Referenced by PrepareCommand(), and Reset().

CompletePending()

VOID XhciUsbDevice::CompletePending ( _In_ NTSTATUS  Status )

private

Definition at line 541 of file slotdev.cpp.

{
    WDFREQUEST Request = TakePending();
 
    if (Request != NULL)
        WdfRequestComplete(Request, Status);
}

Referenced by Address(), EndpointsConfigure(), OnAddressDeviceDone(), OnConfigureEndpointDone(), OnDisableSlotDone(), OnEnableSlotDone(), OnEvaluateContextDone(), and OnResetDeviceDone().

ContextEntries()

ULONG XhciUsbDevice::ContextEntries

(

)

const

Highest DCI the HCD considers configured (Context Entries).

Definition at line 321 of file slotdev.cpp.

{
    ULONG Mask = m_ContextMask;
    ULONG Highest = 0;
 
    ASSERT(Mask != 0);
 
    while ((Mask >>= 1) != 0)
        Highest++;
 
    return Highest;
}

Referenced by XhciEndpoint::BuildEndpointConfigure(), EndpointsConfigure(), and StartReconfigure().

ContextSize()

ULONG XhciUsbDevice::ContextSize

(

)

const

Definition at line 377 of file slotdev.cpp.

{
    return m_ContextSize;
}

Referenced by BuildSlotContext().

Controller()

XhciController * XhciUsbDevice::Controller

(

)

const

Definition at line 353 of file slotdev.cpp.

{
    return m_Controller;
}

Referenced by _IRQL_requires_().

ControllerResetStarting()

VOID XhciUsbDevice::ControllerResetStarting

(

)

Definition at line 1746 of file slotdev.cpp.

{
    ULONG Dci;
 
    for (Dci = 1; Dci <= XHCI_MAX_DCI; Dci++)
    {
        if (m_Endpoints[Dci] != NULL)
            m_Endpoints[Dci]->ControllerResetStarting();
    }
}

DeviceDescriptor()

const USB_DEVICE_DESCRIPTOR * XhciUsbDevice::DeviceDescriptor

(

)

const

Definition at line 365 of file slotdev.cpp.

{
    return &m_DeviceDescriptor;
}

Referenced by XhciEndpoint::BuildContext().

Disable()

VOID XhciUsbDevice::Disable

(

_In_ WDFREQUEST

Request

)

Definition at line 1421 of file slotdev.cpp.

{
    ULONG RootPort = m_Info.PortPath.PortPath[0];
 
    if (!m_SlotEnabled)
    {
        DisableDefaultEndpoint();
        DisableConfiguredEndpoints(TRUE);
        WdfRequestComplete(Request, STATUS_SUCCESS);
        return;
    }
 
    /* QUIRK: neither flag is cleared afterwards */
    if (m_LpmEnabled)
        m_Controller->m_RootHub.DisableLpmForSlot(RootPort, m_SlotId);
    if (m_ResumeTimeSet)
        m_Controller->m_RootHub.DisarmPortResumeTimer(RootPort);
 
    if (!m_Controller->IsAccessible())
    {
        DPRINT("DISABLE for device %p with the controller gone\n", this);
        SetDisabled();
        WdfRequestComplete(Request, STATUS_SUCCESS);
        return;
    }
 
    SetPending(Request, NULL, PendingKind::Disable, TRUE);
    SubmitDisableSlot(AfterDisable::CompleteSuccess);
}

Referenced by XhciEvtUsbDeviceDisable().

DisableConfiguredEndpoints()

VOID XhciUsbDevice::DisableConfiguredEndpoints ( _In_ BOOLEAN  ClearTable )

private

Definition at line 463 of file slotdev.cpp.

{
    ULONG Dci;
 
    for (Dci = 2; Dci <= XHCI_MAX_DCI; Dci++)
    {
        if (m_Endpoints[Dci] == NULL)
            continue;
 
        m_Endpoints[Dci]->Disable(ClearTable);
        if (ClearTable)
            m_Endpoints[Dci] = NULL;
    }
}

Referenced by Disable(), OnDisableSlotDone(), OnResetDeviceDone(), and Reset().

DisableDefaultEndpoint()

VOID XhciUsbDevice::DisableDefaultEndpoint ( )

private

Definition at line 456 of file slotdev.cpp.

{
    if (m_Endpoints[1] != NULL)
        m_Endpoints[1]->Disable(TRUE);
}

Referenced by Disable(), Enable(), OnDisableSlotDone(), and OnEnableSlotDone().

DisableEndpointList()

VOID XhciUsbDevice::DisableEndpointList ( _In_ ULONG  Count, _In_reads_(Count) UCXENDPOINT *  Endpoints  )

private

Definition at line 480 of file slotdev.cpp.

{
    ULONG Index;
 
    for (Index = 0; Index < Count; Index++)
        XhciEndpoint::FromUcx(Endpoints[Index])->Disable();
}

Referenced by EndpointsConfigure(), OnConfigureEndpointDone(), and SubmitSecondConfigure().

Enable()

VOID XhciUsbDevice::Enable	(	_In_ WDFREQUEST	Request,
		_Inout_ PUSBDEVICE_ENABLE	Payload
	)

Definition at line 731 of file slotdev.cpp.

{
    NTSTATUS Status;
 
    if (m_Endpoints[1] == NULL)
    {
        DPRINT1("ENABLE for device %p before its default endpoint exists\n", this);
        WdfRequestComplete(Request, STATUS_UNSUCCESSFUL);
        return;
    }
 
    Status = m_Endpoints[1]->Enable();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Default endpoint of device %p failed to enable: 0x%lx\n", this, Status);
        WdfRequestComplete(Request, Status);
        return;
    }
 
    if (!m_Controller->IsAccessible())
    {
        DPRINT1("ENABLE for device %p with the controller gone\n", this);
        DisableDefaultEndpoint();
        WdfRequestComplete(Request, STATUS_NO_SUCH_DEVICE);
        return;
    }
 
    SetPending(Request, Payload, PendingKind::Enable, FALSE);
    SubmitEnableSlot();
}

Referenced by XhciEvtUsbDeviceEnable().

EndpointsConfigure()

VOID XhciUsbDevice::EndpointsConfigure	(	_In_ WDFREQUEST	Request,
		_Inout_ PENDPOINTS_CONFIGURE	Payload
	)

Definition at line 1194 of file slotdev.cpp.

{
    XhciRequestData* Data = XhciGetRequestData(Request);
    PXHCI_INPUT_CONTROL_CONTEXT Control;
    XhciEndpoint* Endpoint;
    ULONG EnableCount = Payload->EndpointsToEnableCount;
    ULONG DisableCount = Payload->EndpointsToDisableCount;
    ULONG64 InputAddress;
    ULONG AddFlags;
    ULONG DropFlags;
    ULONG Index;
    NTSTATUS Status;
 
    if (Data == NULL)
    {
        DPRINT1("ENDPOINTS_CONFIGURE for device %p carries no request context\n", this);
        WdfRequestComplete(Request, STATUS_INVALID_DEVICE_STATE);
        return;
    }
 
    Data->EndpointsConfigure.EnableFailed = FALSE;
    Data->EndpointsConfigure.FirstCommandFailed = FALSE;
 
    /* Nothing is disabled here: the endpoints to drop never reached the hardware */
    if (!m_SlotEnabled)
    {
        DPRINT1("ENDPOINTS_CONFIGURE for device %p without a slot\n", this);
        WdfRequestComplete(Request, EnableCount != 0 ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS);
        return;
    }
 
    if (!m_Controller->IsAccessible())
    {
        DPRINT1("ENDPOINTS_CONFIGURE for device %p with the controller gone\n", this);
        DisableEndpointList(DisableCount, Payload->EndpointsToDisable);
        WdfRequestComplete(Request, EnableCount != 0 ? STATUS_NO_SUCH_DEVICE : STATUS_SUCCESS);
        return;
    }
 
    SetPending(Request, Payload, PendingKind::Configure, EnableCount == 0);
 
    ZeroInputContext();
    BuildSlotContext(InputSlot(), m_ContextSize);
 
    for (Index = 0; Index < EnableCount; Index++)
    {
        Status = XhciEndpoint::FromUcx(Payload->EndpointsToEnable[Index])->Enable();
        if (NT_SUCCESS(Status))
            continue;
 
        DPRINT1("Endpoint %lu of %lu for device %p failed to enable: 0x%lx\n",
                Index, EnableCount, this, Status);
 
        while (Index-- > 0)
            XhciEndpoint::FromUcx(Payload->EndpointsToEnable[Index])->Disable();
 
        if (DisableCount == 0)
        {
            CompletePending(Status);
            return;
        }
 
        /* The drops still have to reach the controller */
        Data->EndpointsConfigure.EnableFailed = TRUE;
        break;
    }
 
    AddFlags = 1;
    if (!Data->EndpointsConfigure.EnableFailed)
    {
        for (Index = 0; Index < EnableCount; Index++)
        {
            Endpoint = XhciEndpoint::FromUcx(Payload->EndpointsToEnable[Index]);
            Endpoint->BuildContext(InputContext(Endpoint->Dci() + 1), m_ContextSize);
            AddFlags |= 1UL << Endpoint->Dci();
        }
    }
 
    DropFlags = 0;
    for (Index = 0; Index < DisableCount; Index++)
        DropFlags |= 1UL << XhciEndpoint::FromUcx(Payload->EndpointsToDisable[Index])->Dci();
 
    Control = InputControl();
    Control->AddFlags = AddFlags;
    Control->DropFlags = DropFlags;
 
    /* QUIRK: updated before the command result is known and never rolled back */
    m_ContextMask = (m_ContextMask & ~DropFlags) | AddFlags;
    InputSlot()->ContextEntries = ContextEntries();
 
    InputAddress = InputContextAddress();
    PrepareCommand(static_cast<ULONG>(XhciTrbType::ConfigureEndpoint));
    m_Command.Trb.Dword[0] = (ULONG)InputAddress;
    m_Command.Trb.Dword[1] = (ULONG)(InputAddress >> 32);
    m_Controller->m_Commands.Submit(&m_Command);
}

Referenced by XhciEvtUsbDeviceEndpointsConfigure().

EndpointState()

ULONG XhciUsbDevice::EndpointState

(

_In_ ULONG

Dci

)

const

Definition at line 307 of file slotdev.cpp.

{
    return ((const XHCI_ENDPOINT_CONTEXT*)OutputContext(Dci))->EndpointState;
}

Referenced by OnResetDeviceDone().

FinishReconfigure()

VOID XhciUsbDevice::FinishReconfigure ( _In_ NTSTATUS  Status )

private

Definition at line 1671 of file slotdev.cpp.

{
    ReconfigureWaiter Finished = m_ReconfigureCurrent;
    ReconfigureWaiter Next;
    BOOLEAN HaveNext = FALSE;
    KIRQL OldIrql;
    ULONG Dci;
 
    RtlZeroMemory(&m_ReconfigureCurrent, sizeof(m_ReconfigureCurrent));
    Finished.Done(Finished.Context, Status);
 
    KeAcquireSpinLock(&m_ReconfigureLock, &OldIrql);
    if (m_ReconfigureQueued != 0)
    {
        Dci = 0;
        while ((m_ReconfigureQueued & (1UL << Dci)) == 0)
            Dci++;
 
        Next = m_ReconfigureWaiters[Dci];
        m_ReconfigureQueued &= ~(1UL << Dci);
        HaveNext = TRUE;
    }
    else
    {
        m_ReconfigureBusy = FALSE;
    }
    KeReleaseSpinLock(&m_ReconfigureLock, OldIrql);
 
    if (HaveNext)
        StartReconfigure(&Next);
}

Referenced by StartReconfigure().

ForgetSlot()

VOID XhciUsbDevice::ForgetSlot ( )

private

Definition at line 614 of file slotdev.cpp.

{
    if (m_SlotId != 0 && m_Controller->m_Slots.LookupSlot(m_SlotId) == this)
        m_Controller->m_Slots.SetSlot(m_SlotId, this, 0);
 
    m_SlotEnabled = FALSE;
    m_SlotId = 0;
}

Referenced by OnDisableSlotDone().

FromUcx()

XhciUsbDevice * XhciUsbDevice::FromUcx ( _In_ UCXUSBDEVICE  UsbDevice )

static

Definition at line 178 of file slotdev.cpp.

{
    return XhciGetUsbDeviceContext(UsbDevice);
}

Referenced by XhciEndpoint::Initialize(), TtHub(), XhciEvtControllerUsbDeviceAdd(), XhciEvtUsbDeviceAddress(), XhciEvtUsbDeviceDisable(), XhciEvtUsbDeviceEnable(), XhciEvtUsbDeviceEndpointsConfigure(), XhciEvtUsbDeviceHubInfo(), XhciEvtUsbDeviceReset(), and XhciEvtUsbDeviceUpdate().

Handle()

UCXUSBDEVICE XhciUsbDevice::Handle

(

)

const

Definition at line 347 of file slotdev.cpp.

{
    return m_Handle;
}

HardwareDequeuePointer()

ULONG64 XhciUsbDevice::HardwareDequeuePointer

(

_In_ ULONG

Dci

)

const

Definition at line 314 of file slotdev.cpp.

{
    return ((const XHCI_ENDPOINT_CONTEXT*)OutputContext(Dci))->TRDequeuePointer;
}

HubInfo()

VOID XhciUsbDevice::HubInfo	(	_In_ WDFREQUEST	Request,
		_In_ const USBDEVICE_HUB_INFO *	Payload
	)

Definition at line 1142 of file slotdev.cpp.

{
    /* QUIRK: accepted whether or not the device is a hub */
    m_NumberOfPorts = Payload->NumberOfPorts;
    m_NumberOfTTs = Payload->NumberOfTTs;
    m_TTThinkTime = Payload->TTThinkTime;
 
    DPRINT("Hub %p: %lu ports, %lu TTs, think time %lu\n",
           this, m_NumberOfPorts, m_NumberOfTTs, m_TTThinkTime);
    WdfRequestComplete(Request, STATUS_SUCCESS);
}

Referenced by XhciEvtUsbDeviceHubInfo().

InputContext()

PVOID XhciUsbDevice::InputContext

(

_In_ ULONG

Index

)

const

Definition at line 261 of file slotdev.cpp.

{
    ASSERT(Index < XHCI_INPUT_CONTEXT_COUNT);
    return (PUCHAR)m_Input->VirtualAddress + Index * m_ContextSize;
}

Referenced by BuildAddressContext(), EndpointsConfigure(), InputControl(), and InputSlot().

InputContextAddress()

ULONG64 XhciUsbDevice::InputContextAddress

(

)

const

Definition at line 277 of file slotdev.cpp.

{
    return m_Input->LogicalAddress.QuadPart;
}

Referenced by EndpointsConfigure(), SubmitAddressDevice(), SubmitSecondConfigure(), and Update().

InputControl()

PXHCI_INPUT_CONTROL_CONTEXT XhciUsbDevice::InputControl ( ) const

private

Definition at line 289 of file slotdev.cpp.

{
    return (PXHCI_INPUT_CONTROL_CONTEXT)InputContext(0);
}

Referenced by BuildAddressContext(), EndpointsConfigure(), SubmitSecondConfigure(), and Update().

InputSlot()

PXHCI_SLOT_CONTEXT XhciUsbDevice::InputSlot ( ) const

private

Definition at line 295 of file slotdev.cpp.

{
    return (PXHCI_SLOT_CONTEXT)InputContext(1);
}

Referenced by BuildAddressContext(), EndpointsConfigure(), SubmitSecondConfigure(), and Update().

IsSlotEnabled()

BOOLEAN XhciUsbDevice::IsSlotEnabled

(

)

const

Definition at line 359 of file slotdev.cpp.

{
    return m_SlotEnabled;
}

LostSlotStatus()

NTSTATUS XhciUsbDevice::LostSlotStatus ( ) const

private

Definition at line 551 of file slotdev.cpp.

{
    return m_MustSucceed ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
}

Referenced by OnAddressDeviceDone(), and OnEnableSlotDone().

OnAddressDeviceDone()

VOID XhciUsbDevice::OnAddressDeviceDone ( _In_ const XhciCommand *  Command )

private

Definition at line 870 of file slotdev.cpp.

{
    BOOLEAN BlockSetAddress = (Command->Trb.Dword[3] & XHCI_CMD_BLOCK_SET_ADDRESS) != 0;
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        if (BlockSetAddress)
            SetDisabled();
        else
            CompletePending(LostSlotStatus());
        return;
    }
 
    if (Command->Code == XhciCompletionCode::Success)
    {
        if (!BlockSetAddress && m_PendingKind == PendingKind::Address)
            ((PUSBDEVICE_ADDRESS)m_PendingPayload)->Address = OutputSlot()->UsbDeviceAddress;
 
        DPRINT("Slot %lu addressed (BSR %u), USB address %u\n",
               m_SlotId, BlockSetAddress, OutputSlot()->UsbDeviceAddress);
        CompletePending(STATUS_SUCCESS);
        return;
    }
 
    DPRINT1("Address Device (BSR %u) for slot %lu failed with completion code %lu\n",
            BlockSetAddress, m_SlotId, static_cast<ULONG>(Command->Code));
 
    /* The slot stays enabled until the hub sends DISABLE */
    if (!BlockSetAddress)
    {
        CompletePending(STATUS_UNSUCCESSFUL);
        return;
    }
 
    if (m_MustSucceed)
    {
        m_Controller->VerifierCheck(XhciDeviceCheckAddressDefault);
        m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XhciDeviceFatalAddressDefault);
        return;
    }
 
    SubmitDisableSlot(AfterDisable::CompleteFailure);
}

OnConfigureEndpointDone()

VOID XhciUsbDevice::OnConfigureEndpointDone ( _In_ const XhciCommand *  Command )

private

Definition at line 1324 of file slotdev.cpp.

{
    PENDPOINTS_CONFIGURE Payload = (PENDPOINTS_CONFIGURE)m_PendingPayload;
    XhciRequestData* Data = XhciGetRequestData(m_PendingRequest);
    ULONG EnableCount = Payload->EndpointsToEnableCount;
    ULONG DisableCount = Payload->EndpointsToDisableCount;
    ULONG Parameter = Command->Completion.Dword[2] & XHCI_COMPLETION_PARAMETER_MASK;
    BOOLEAN EarlierFailure;
    BOOLEAN SlotLost;
 
    EarlierFailure = Data->EndpointsConfigure.EnableFailed || Data->EndpointsConfigure.FirstCommandFailed;
 
    if (Command->Status != STATUS_NO_SUCH_DEVICE && Command->Code == XhciCompletionCode::Success)
    {
        DisableEndpointList(DisableCount, Payload->EndpointsToDisable);
        if (!EarlierFailure)
            RecordEnabledEndpoints(Payload);
 
        Payload->ExitLatencyDelta = Parameter;
        CompletePending(EarlierFailure ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS);
        return;
    }
 
    SlotLost = (Command->Status == STATUS_NO_SUCH_DEVICE ||
                Command->Code == XhciCompletionCode::SlotNotEnabled);
 
    if (Command->Status != STATUS_NO_SUCH_DEVICE)
    {
        DPRINT1("Configure Endpoint for slot %lu failed with completion code %lu (enable %lu, disable %lu)\n",
                m_SlotId, static_cast<ULONG>(Command->Code), EnableCount, DisableCount);
 
        if (!SlotLost && EnableCount != 0)
        {
            switch (Command->Code)
            {
                case XhciCompletionCode::BandwidthError:
                case XhciCompletionCode::SecondaryBandwidthError:
                    Payload->FailureFlags.InsufficientBandwidth = 1;
                    break;
                case XhciCompletionCode::ResourceError:
                    Payload->FailureFlags.InsufficientHardwareResourcesForEndpoints = 1;
                    break;
                case XhciCompletionCode::MaxExitLatencyTooLarge:
                    Payload->FailureFlags.MaxExitLatencyTooLarge = 1;
                    break;
                default:
                    break;
            }
        }
 
        if (Command->Code == XhciCompletionCode::MaxExitLatencyTooLarge)
            Payload->ExitLatencyDelta = Parameter;
    }
 
    /* Endpoints to enable that an earlier failure already disabled are not disabled again */
    if (SlotLost)
    {
        DisableEndpointList(DisableCount, Payload->EndpointsToDisable);
        if (EnableCount != 0 && !EarlierFailure)
            DisableEndpointList(EnableCount, Payload->EndpointsToEnable);
 
        CompletePending(EnableCount != 0 ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS);
        return;
    }
 
    /* QUIRK: with nothing to enable or disable this fails although UCX expects success */
    if (DisableCount == 0)
    {
        DisableEndpointList(EnableCount, Payload->EndpointsToEnable);
        CompletePending(STATUS_UNSUCCESSFUL);
        return;
    }
 
    if (EnableCount == 0 || EarlierFailure)
    {
        m_Controller->VerifierCheck(XhciDeviceCheckDeconfigure);
        m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XhciDeviceFatalDeconfigure);
        return;
    }
 
    /* The enables failed in hardware; drop the endpoints to disable on their own */
    SubmitSecondConfigure();
}

OnDeviceNotificationEvent()

VOID XhciUsbDevice::OnDeviceNotificationEvent

(

_In_ const XHCI_TRB *

Event

)

Definition at line 1728 of file slotdev.cpp.

{
    ULONG Type = (Event->Dword[0] & XHCI_NOTIFICATION_TYPE_MASK) >> XHCI_NOTIFICATION_TYPE_SHIFT;
    ULONG Interface;
 
    if (Type != XHCI_NOTIFICATION_FUNCTION_WAKE)
    {
        DPRINT("Device notification type %lu for slot %lu ignored\n", Type, m_SlotId);
        return;
    }
 
    Interface = (Event->Dword[0] & XHCI_NOTIFICATION_DATA_MASK) >> XHCI_NOTIFICATION_DATA_SHIFT;
    DPRINT("Function wake from interface %lu of slot %lu\n", Interface, m_SlotId);
    UcxUsbDeviceRemoteWakeNotification(m_Handle, Interface);
}

Referenced by XhciSlotTable::OnDeviceNotificationEvent().

OnDisableSlotDone()

VOID XhciUsbDevice::OnDisableSlotDone ( _In_ const XhciCommand *  Command )

private

Definition at line 1453 of file slotdev.cpp.

{
    AfterDisable Next = m_AfterDisable;
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        SetDisabled();
        return;
    }
 
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Disable Slot %lu completed with code %lu\n", m_SlotId, static_cast<ULONG>(Command->Code));
 
        if (Command->Code != XhciCompletionCode::SlotNotEnabled)
        {
            m_Controller->VerifierCheck(XhciDeviceCheckDisableSlot);
            m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XhciDeviceFatalDisableSlot);
            return;
        }
    }
 
    /* The default endpoint keeps its table entry; a re-enable follows for RESET */
    if (Next != AfterDisable::EnableSlot)
        DisableDefaultEndpoint();
 
    DisableConfiguredEndpoints(TRUE);
    ForgetSlot();
 
    if (Next == AfterDisable::EnableSlot)
    {
        SubmitEnableSlot();
        return;
    }
 
    CompletePending(Next == AfterDisable::CompleteSuccess ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}

OnEnableSlotDone()

VOID XhciUsbDevice::OnEnableSlotDone ( _In_ const XhciCommand *  Command )

private

Definition at line 765 of file slotdev.cpp.

{
    ULONG Code = static_cast<ULONG>(Command->Code);
    ULONG SlotId = XhciTrbSlotId(&Command->Completion);
    NTSTATUS Status;
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        DisableDefaultEndpoint();
        CompletePending(LostSlotStatus());
        return;
    }
 
    if (Command->Code != XhciCompletionCode::Success)
    {
        DPRINT1("Enable Slot for device %p failed with completion code %lu\n", this, Code);
 
        /* A RESET payload has no failure flags, only ENABLE does */
        if (Command->Code == XhciCompletionCode::NoSlotsAvailable && m_PendingKind == PendingKind::Enable)
            ((PUSBDEVICE_ENABLE)m_PendingPayload)->FailureFlags.InsufficientHardwareResourcesForDevice = 1;
 
        DisableDefaultEndpoint();
 
        if (m_MustSucceed)
        {
            m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XhciDeviceFatalEnableSlot);
 
            /* Complete the RESET here; the device holds no slot, so no reset walk will */
            CompletePending(STATUS_SUCCESS);
            return;
        }
 
        CompletePending(STATUS_UNSUCCESSFUL);
        return;
    }
 
    m_SlotEnabled = TRUE;
    m_SlotId = SlotId;
 
    RtlZeroMemory(m_Output->VirtualAddress, m_ContextSize * XHCI_DEVICE_CONTEXT_COUNT);
 
    Status = m_Controller->m_Slots.SetSlot(SlotId, this, m_Output->LogicalAddress.QuadPart);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Enable Slot gave device %p slot %lu, which is already in use (0x%lx)\n",
                this, SlotId, Status);
        m_Controller->VerifierCheck(XhciDeviceCheckSlotInUse);
        m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XhciDeviceFatalSlotInUse);
 
        /* Undo the slot state and complete the request, since nothing else would */
        m_SlotEnabled = FALSE;
        m_SlotId = 0;
        DisableDefaultEndpoint();
        CompletePending(LostSlotStatus());
        return;
    }
 
    DPRINT("Device %p got slot %lu\n", this, SlotId);
 
    Status = SubmitAddressDevice(TRUE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Address Device for slot %lu not built: 0x%lx\n", SlotId, Status);
        RtlZeroMemory(&m_Command, sizeof(m_Command));
 
        if (m_MustSucceed)
            m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XhciDeviceFatalAddressDefault);
        else
            SubmitDisableSlot(AfterDisable::CompleteFailure);
    }
}

OnEvaluateContextDone()

VOID XhciUsbDevice::OnEvaluateContextDone ( _In_ const XhciCommand *  Command )

private

Definition at line 1108 of file slotdev.cpp.

{
    PUSBDEVICE_UPDATE Payload = (PUSBDEVICE_UPDATE)m_PendingPayload;
    NTSTATUS Status;
 
    if (Command->Status == STATUS_NO_SUCH_DEVICE)
    {
        Status = STATUS_UNSUCCESSFUL;
    }
    else if (Command->Code == XhciCompletionCode::Success)
    {
        /* The work item completes the request */
        if (WantsTunnelStateDsm(Payload) && QueueTunnelStateDsm(Payload))
            return;
 
        ApplyUpdate(Payload);
        Status = STATUS_SUCCESS;
    }
    else
    {
        DPRINT1("Max Exit Latency %lu for slot %lu rejected with completion code %lu\n",
                Payload->MaxExitLatency, m_SlotId, static_cast<ULONG>(Command->Code));
 
        if (Command->Code == XhciCompletionCode::MaxExitLatencyTooLarge)
            Payload->FailureFlags.MaxExitLatencyTooLarge = 1;
 
        Status = STATUS_UNSUCCESSFUL;
    }
 
    CompletePending(Status);
}

OnHostLost()

VOID XhciUsbDevice::OnHostLost

(

)

Definition at line 1773 of file slotdev.cpp.

{
    WDFREQUEST Request;
    ULONG Dci;
 
    for (Dci = 1; Dci <= XHCI_MAX_DCI; Dci++)
    {
        if (m_Endpoints[Dci] != NULL)
            m_Endpoints[Dci]->ControllerRemoved();
    }
 
    Request = TakePending();
    if (Request != NULL)
        WdfRequestComplete(Request, m_MustSucceed ? STATUS_SUCCESS : STATUS_INTERNAL_ERROR);
}

Referenced by XhciSlotTable::OnHostLost().

OnResetDeviceDone()

VOID XhciUsbDevice::OnResetDeviceDone ( _In_ const XhciCommand *  Command )

private

Definition at line 1541 of file slotdev.cpp.

{
    if (Command->Status != STATUS_NO_SUCH_DEVICE)
    {
        if (Command->Code != XhciCompletionCode::Success)
        {
            DPRINT1("Reset Device for slot %lu failed with completion code %lu\n",
                    m_SlotId, static_cast<ULONG>(Command->Code));
            m_Controller->VerifierCheck(XhciDeviceCheckResetDevice);
            m_Controller->RaiseControllerFault(XhciRecovery::ResetHost, XhciDeviceFatalResetDevice);
            return;
        }
 
        if (EndpointState(1) == XHCI_ENDPOINT_STATE_DISABLED)
            DPRINT1("Reset Device for slot %lu left the default endpoint disabled\n", m_SlotId);
    }
 
    /* The table keeps the endpoints; the hub configures them again */
    DisableConfiguredEndpoints(FALSE);
    m_ContextMask = XHCI_DEFAULT_CONTEXT_MASK;
    CompletePending(STATUS_SUCCESS);
}

OnTransferEvent()

VOID XhciUsbDevice::OnTransferEvent

(

_In_ const XHCI_TRB *

Event

)

Definition at line 1707 of file slotdev.cpp.

{
    ULONG Dci = (Event->Dword[3] & XHCI_TRB_ENDPOINT_MASK) >> XHCI_TRB_ENDPOINT_SHIFT;
    XhciEndpoint* Endpoint = EndpointAt(Dci);
 
    if (Endpoint != NULL)
    {
        Endpoint->OnTransferEvent(Event);
        return;
    }
 
    /* QUIRK: isochronous leftovers after a deconfigure are dropped without a word */
    if ((Event->Dword[0] & XHCI_EVENT_DATA_TYPE_MASK) != USB_ENDPOINT_TYPE_ISOCHRONOUS)
    {
        DPRINT1("Transfer event for slot %lu DCI %lu code %lu has no endpoint, dropped\n",
                m_SlotId, Dci, XhciTrbCompletionCode(Event));
    }
}

OutputContext()

PVOID XhciUsbDevice::OutputContext

(

_In_ ULONG

Dci

)

const

Definition at line 269 of file slotdev.cpp.

{
    ASSERT(Dci < XHCI_DEVICE_CONTEXT_COUNT);
    return (PUCHAR)m_Output->VirtualAddress + Dci * m_ContextSize;
}

Referenced by XhciEndpoint::BuildEndpointConfigure(), EndpointState(), HardwareDequeuePointer(), XhciEndpoint::OutputEndpointState(), OutputSlot(), XhciEndpointMachine::ReconfigureAfterStop(), and XhciEndpointMachine::ReconfigureForReset().

OutputSlot()

const XHCI_SLOT_CONTEXT * XhciUsbDevice::OutputSlot ( ) const

private

Definition at line 301 of file slotdev.cpp.

{
    return (const XHCI_SLOT_CONTEXT*)OutputContext(0);
}

Referenced by OnAddressDeviceDone(), and Reset().

PortPath()

const USB_DEVICE_PORT_PATH * XhciUsbDevice::PortPath

(

)

const

Definition at line 371 of file slotdev.cpp.

{
    return &m_Info.PortPath;
}

Referenced by XhciEndpoint::BuildContext().

PrepareCommand()

VOID XhciUsbDevice::PrepareCommand ( _In_ ULONG  Type )

private

Definition at line 557 of file slotdev.cpp.

{
    RtlZeroMemory(&m_Command, sizeof(m_Command));
    m_Command.Trb.Dword[3] = (Type << XHCI_TRB_TYPE_SHIFT) | (m_SlotId << XHCI_TRB_SLOT_SHIFT);
    m_Command.Done = CommandDone;
    m_Command.Context = this;
}

Referenced by EndpointsConfigure(), SubmitAddressDevice(), SubmitDisableSlot(), SubmitEnableSlot(), SubmitSecondConfigure(), and Update().

QueueTunnelStateDsm()

BOOLEAN XhciUsbDevice::QueueTunnelStateDsm ( _Inout_ PUSBDEVICE_UPDATE  Payload )

private

FALSE when the work item could not be created; the caller then completes the request itself.

Definition at line 963 of file slotdev.cpp.

{
    WDF_WORKITEM_CONFIG Config;
    WDF_OBJECT_ATTRIBUTES Attributes;
    PXHCI_TUNNEL_DSM_WORK Work;
    WDFWORKITEM Item;
    NTSTATUS Status;
 
    WDF_WORKITEM_CONFIG_INIT(&Config, TunnelDsmWorker);
 
    /* QUIRK: the controller device has no synchronization scope, so this serializes nothing */
    Config.AutomaticSerialization = TRUE;
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XHCI_TUNNEL_DSM_WORK);
    Attributes.ParentObject = m_Controller->m_Device;
 
    Status = WdfWorkItemCreate(&Config, &Attributes, &Item);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("No tunnel state work item for root port %lu, 0x%lx\n", m_Info.PortPath.PortPath[0], Status);
 
        /* QUIRK: the native link flag keeps the hub's value */
        UcxHubUpdateTunnelAnswer(Payload)->TunnelState = UCXHUB_TUNNEL_STATE_UNKNOWN;
        return FALSE;
    }
 
    /* Keeps this context alive even if a removal completes the request first */
    WdfObjectReference(m_Handle);
 
    Work = XhciGetTunnelDsmWork(Item);
    Work->Device = this;
    Work->Payload = Payload;
    WdfWorkItemEnqueue(Item);
    return TRUE;
}

Referenced by OnEvaluateContextDone(), and Update().

ReconfigureCommandDone()

VOID NTAPI XhciUsbDevice::ReconfigureCommandDone ( _In_ XhciCommand *  Command )

staticprivate

Definition at line 1653 of file slotdev.cpp.

{
    XhciUsbDevice* Device = static_cast<XhciUsbDevice*>(Command->Context);
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (!XhciCommandSucceeded(Command))
    {
        DPRINT1("Reconfigure of DCI %lu on slot %lu failed: status 0x%lx, code %lu\n",
                Device->m_ReconfigureCurrent.Endpoint->Dci(), Device->m_SlotId,
                Command->Status, static_cast<ULONG>(Command->Code));
        Status = STATUS_UNSUCCESSFUL;
    }
 
    Device->FinishReconfigure(Status);
}

Referenced by StartReconfigure().

RecordEnabledEndpoints()

VOID XhciUsbDevice::RecordEnabledEndpoints ( _In_ const ENDPOINTS_CONFIGURE *  Payload )

private

Definition at line 491 of file slotdev.cpp.

{
    XhciEndpoint* Endpoint;
    XhciEndpoint* Previous;
    ULONG Index;
    ULONG Dci;
 
    for (Index = 0; Index < Payload->EndpointsToEnableCount; Index++)
    {
        Endpoint = XhciEndpoint::FromUcx(Payload->EndpointsToEnable[Index]);
        Dci = Endpoint->Dci();
 
        Previous = m_Endpoints[Dci];
        if (Previous != NULL && Previous != Endpoint)
        {
            DPRINT("DCI %lu of device %p moves from endpoint %p to %p\n", Dci, this, Previous, Endpoint);
            Previous->Disable(TRUE);
            m_Endpoints[Dci] = NULL;
        }
 
        m_Endpoints[Dci] = Endpoint;
    }
}

Referenced by OnConfigureEndpointDone().

Reset()

VOID XhciUsbDevice::Reset

(

_In_ WDFREQUEST

Request

)

Definition at line 1493 of file slotdev.cpp.

{
    ULONG Type;
 
    if (!m_SlotEnabled)
    {
        WdfRequestComplete(Request, STATUS_SUCCESS);
        return;
    }
 
    /* Enabled or Default: nothing to reset */
    if (OutputSlot()->SlotState <= XHCI_SLOT_STATE_DEFAULT)
    {
        WdfRequestComplete(Request, STATUS_SUCCESS);
        return;
    }
 
    if (!m_Controller->IsAccessible())
    {
        DPRINT("RESET for device %p with the controller gone\n", this);
        DisableConfiguredEndpoints(FALSE);
        m_ContextMask = XHCI_DEFAULT_CONTEXT_MASK;
        WdfRequestComplete(Request, STATUS_SUCCESS);
        return;
    }
 
    SetPending(Request, NULL, PendingKind::Reset, TRUE);
 
    if (m_Controller->HasErrata(XhciErrata::EpResetViaSlotCycle))
    {
        Type = static_cast<ULONG>(XhciTrbType::DisableSlot);
        m_AfterDisable = AfterDisable::EnableSlot;
    }
    else
    {
        Type = static_cast<ULONG>(XhciTrbType::ResetDevice);
    }
 
    /* QUIRK: the block is not cleared, so the reserved TRB fields keep the last command's bits */
    m_Command.Trb.Dword[3] &= ~(XHCI_TRB_TYPE_MASK | (0xFFUL << XHCI_TRB_SLOT_SHIFT));
    m_Command.Trb.Dword[3] |= (Type << XHCI_TRB_TYPE_SHIFT) | (m_SlotId << XHCI_TRB_SLOT_SHIFT);
    m_Command.Done = CommandDone;
    m_Command.Context = this;
    m_Controller->m_Commands.Submit(&m_Command);
}

Referenced by XhciEvtUsbDeviceReset().

SetPending()

VOID XhciUsbDevice::SetPending ( _In_ WDFREQUEST  Request, _In_ PVOID  Payload, _In_ PendingKind  Kind, _In_ BOOLEAN  MustSucceed  )

private

Definition at line 519 of file slotdev.cpp.

{
    /* UCX and the hub send one device management request at a time */
    ASSERT(m_PendingRequest == NULL);
 
    m_PendingPayload = Payload;
    m_PendingKind = Kind;
    m_MustSucceed = MustSucceed;
    m_PendingRequest = Request;
}

Referenced by Address(), Disable(), Enable(), EndpointsConfigure(), Reset(), and Update().

SlotId()

ULONG XhciUsbDevice::SlotId

(

)

const

Definition at line 335 of file slotdev.cpp.

{
    return m_SlotId;
}

Referenced by _IRQL_requires_max_(), XhciEndpoint::BuildEndpointConfigure(), XhciEndpoint::BuildSetDequeue(), OnEnableSlotDone(), XhciControlRing::OnEventDataEvent(), XhciEndpointMachine::ResetDefaultPipe(), XhciEndpointMachine::ResetEndpoint(), and XhciEndpointMachine::SendStopCommand().

Speed()

USB_DEVICE_SPEED XhciUsbDevice::Speed

(

)

const

Definition at line 341 of file slotdev.cpp.

{
    return m_Info.DeviceSpeed;
}

Referenced by BuildAddressContext(), XhciEndpoint::BuildContext(), XhciEndpoint::Initialize(), and XhciEndpoint::MaxBurst().

StartReconfigure()

VOID XhciUsbDevice::StartReconfigure ( _In_ const ReconfigureWaiter *  Waiter )

private

Definition at line 1600 of file slotdev.cpp.

{
    PXHCI_INPUT_CONTROL_CONTEXT Control;
    PXHCI_SLOT_CONTEXT Slot;
    XhciEndpoint* Endpoint;
    PUCHAR Base;
    ULONG64 InputAddress;
    ULONG Dci;
 
    m_ReconfigureCurrent = *Waiter;
    Endpoint = m_ReconfigureCurrent.Endpoint;
    Dci = Endpoint->Dci();
 
    if (m_ReconfigureInput == NULL)
    {
        m_ReconfigureInput = m_Controller->m_Buffers.Acquire(m_ContextSize * XHCI_INPUT_CONTEXT_COUNT);
        if (m_ReconfigureInput == NULL)
        {
            DPRINT1("No input context to reconfigure DCI %lu of slot %lu\n", Dci, m_SlotId);
            FinishReconfigure(STATUS_INSUFFICIENT_RESOURCES);
            return;
        }
    }
 
    Base = (PUCHAR)m_ReconfigureInput->VirtualAddress;
    RtlZeroMemory(Base, m_ContextSize * XHCI_INPUT_CONTEXT_COUNT);
 
    Control = (PXHCI_INPUT_CONTROL_CONTEXT)Base;
    Slot = (PXHCI_SLOT_CONTEXT)(Base + m_ContextSize);
 
    BuildSlotContext(Slot, m_ContextSize);
    Endpoint->BuildContext(Base + (Dci + 1) * m_ContextSize, m_ContextSize);
    Slot->ContextEntries = ContextEntries();
 
    /* Drop and add of the same DCI reconfigures it in place (xHCI 4.6.6) */
    Control->AddFlags = 1 | (1UL << Dci);
    Control->DropFlags = 1UL << Dci;
 
    InputAddress = m_ReconfigureInput->LogicalAddress.QuadPart;
    RtlZeroMemory(&m_ReconfigureCommand, sizeof(m_ReconfigureCommand));
    m_ReconfigureCommand.Trb.Dword[0] = (ULONG)InputAddress;
    m_ReconfigureCommand.Trb.Dword[1] = (ULONG)(InputAddress >> 32);
    m_ReconfigureCommand.Trb.Dword[3] =
        (static_cast<ULONG>(XhciTrbType::ConfigureEndpoint) << XHCI_TRB_TYPE_SHIFT) |
        (m_SlotId << XHCI_TRB_SLOT_SHIFT);
    m_ReconfigureCommand.Done = ReconfigureCommandDone;
    m_ReconfigureCommand.Context = this;
    m_Controller->m_Commands.Submit(&m_ReconfigureCommand);
}

Referenced by FinishReconfigure().

SubmitAddressDevice()

NTSTATUS XhciUsbDevice::SubmitAddressDevice ( _In_ BOOLEAN  BlockSetAddress )

private

Definition at line 710 of file slotdev.cpp.

{
    ULONG64 InputAddress = InputContextAddress();
    NTSTATUS Status;
 
    Status = BuildAddressContext();
    if (!NT_SUCCESS(Status))
        return Status;
 
    PrepareCommand(static_cast<ULONG>(XhciTrbType::AddressDevice));
    m_Command.Trb.Dword[0] = (ULONG)InputAddress;
    m_Command.Trb.Dword[1] = (ULONG)(InputAddress >> 32);
    if (BlockSetAddress)
        m_Command.Trb.Dword[3] |= XHCI_CMD_BLOCK_SET_ADDRESS;
 
    m_Controller->m_Commands.Submit(&m_Command);
    return STATUS_SUCCESS;
}

Referenced by Address(), and OnEnableSlotDone().

SubmitDisableSlot()

VOID XhciUsbDevice::SubmitDisableSlot ( _In_ AfterDisable  Next )

private

Definition at line 1412 of file slotdev.cpp.

{
    m_AfterDisable = Next;
    PrepareCommand(static_cast<ULONG>(XhciTrbType::DisableSlot));
    m_Controller->m_Commands.Submit(&m_Command);
}

Referenced by Disable(), OnAddressDeviceDone(), and OnEnableSlotDone().

SubmitEnableSlot()

VOID XhciUsbDevice::SubmitEnableSlot ( )

private

Definition at line 641 of file slotdev.cpp.

{
    ASSERT(m_SlotId == 0);
 
    /* QUIRK: Slot Type is always 0 */
    PrepareCommand(static_cast<ULONG>(XhciTrbType::EnableSlot));
    m_Controller->m_Commands.Submit(&m_Command);
}

Referenced by Enable(), and OnDisableSlotDone().

SubmitSecondConfigure()

VOID XhciUsbDevice::SubmitSecondConfigure ( )

private

Definition at line 1294 of file slotdev.cpp.

{
    PENDPOINTS_CONFIGURE Payload = (PENDPOINTS_CONFIGURE)m_PendingPayload;
    XhciRequestData* Data = XhciGetRequestData(m_PendingRequest);
    ULONG64 InputAddress;
    ULONG DropFlags;
    ULONG Index;
 
    Data->EndpointsConfigure.FirstCommandFailed = TRUE;
    DisableEndpointList(Payload->EndpointsToEnableCount, Payload->EndpointsToEnable);
 
    /* QUIRK: Context Entries stays 0 in this one */
    ZeroInputContext();
    BuildSlotContext(InputSlot(), m_ContextSize);
 
    DropFlags = 0;
    for (Index = 0; Index < Payload->EndpointsToDisableCount; Index++)
        DropFlags |= 1UL << XhciEndpoint::FromUcx(Payload->EndpointsToDisable[Index])->Dci();
 
    InputControl()->AddFlags = 1;
    InputControl()->DropFlags = DropFlags;
 
    InputAddress = InputContextAddress();
    PrepareCommand(static_cast<ULONG>(XhciTrbType::ConfigureEndpoint));
    m_Command.Trb.Dword[0] = (ULONG)InputAddress;
    m_Command.Trb.Dword[1] = (ULONG)(InputAddress >> 32);
    m_Controller->m_Commands.Submit(&m_Command);
}

Referenced by OnConfigureEndpointDone().

TakePending()

WDFREQUEST XhciUsbDevice::TakePending ( )

private

Definition at line 535 of file slotdev.cpp.

{
    return (WDFREQUEST)InterlockedExchangePointer((PVOID*)&m_PendingRequest, NULL);
}

Referenced by CompletePending(), OnHostLost(), and Update().

TtHub()

XhciUsbDevice * XhciUsbDevice::TtHub ( ) const

private

Definition at line 383 of file slotdev.cpp.

{
    if (m_Info.TtHub == NULL)
        return NULL;
 
    return FromUcx(m_Info.TtHub);
}

Referenced by BuildAddressContext(), and BuildSlotContext().

Update()

VOID XhciUsbDevice::Update	(	_In_ WDFREQUEST	Request,
		_Inout_ PUSBDEVICE_UPDATE	Payload
	)

Definition at line 1059 of file slotdev.cpp.

{
    PXHCI_SLOT_CONTEXT Slot;
    ULONG64 InputAddress;
 
    if (!Payload->Flags.UpdateMaxExitLatency)
    {
        if (WantsTunnelStateDsm(Payload))
        {
            /* Record the request first so the work item has one to complete */
            SetPending(Request, Payload, PendingKind::Update, FALSE);
            if (QueueTunnelStateDsm(Payload))
                return;
 
            TakePending();
        }
 
        ApplyUpdate(Payload);
        WdfRequestComplete(Request, STATUS_SUCCESS);
        return;
    }
 
    /* Evaluate Context with only the slot flagged (xHCI 4.6.7) */
    ZeroInputContext();
    InputControl()->AddFlags = 1;
    Slot = InputSlot();
    Slot->MaxExitLatency = Payload->MaxExitLatency & 0xFFFF;
    Slot->InterrupterTarget = 0;
 
    /* QUIRK: a device without a slot sends this with Slot ID 0 */
    InputAddress = InputContextAddress();
    PrepareCommand(static_cast<ULONG>(XhciTrbType::EvaluateContext));
    m_Command.Trb.Dword[0] = (ULONG)InputAddress;
    m_Command.Trb.Dword[1] = (ULONG)(InputAddress >> 32);
 
    if (!m_Controller->IsAccessible())
    {
        DPRINT1("UPDATE for device %p with the controller gone\n", this);
        WdfRequestComplete(Request, STATUS_NO_SUCH_DEVICE);
        return;
    }
 
    SetPending(Request, Payload, PendingKind::Update, FALSE);
    m_Controller->m_Commands.Submit(&m_Command);
}

Referenced by XhciEvtUsbDeviceUpdate().

VOID()

_In_ XhciUsbDevice::VOID

(

NTAPI *

Done

)

WantsTunnelStateDsm()

BOOLEAN XhciUsbDevice::WantsTunnelStateDsm ( _In_ const USBDEVICE_UPDATE *  Payload ) const

private

Definition at line 955 of file slotdev.cpp.

{
    return Payload->Flags.UpdateTunnelState && m_Controller->HasErrata(XhciErrata::Usb4TunnelFromAcpiDsm);
}

Referenced by OnEvaluateContextDone(), and Update().

ZeroInputContext()

VOID XhciUsbDevice::ZeroInputContext

(

)

Definition at line 283 of file slotdev.cpp.

{
    RtlZeroMemory(m_Input->VirtualAddress, m_ContextSize * XHCI_INPUT_CONTEXT_COUNT);
}

Referenced by BuildAddressContext(), EndpointsConfigure(), SubmitSecondConfigure(), and Update().

Member Data Documentation

Context

_In_ _In_ NTSTATUS _In_ PVOID XhciUsbDevice::Context

Definition at line 78 of file slotdev.h.

Info

_In_ UCXUSBDEVICE _In_ const UCXUSBDEVICE_INFO* XhciUsbDevice::Info

Definition at line 118 of file slotdev.h.

m_AfterDisable

AfterDisable XhciUsbDevice::m_AfterDisable

private

Definition at line 306 of file slotdev.h.

Referenced by OnDisableSlotDone(), Reset(), and SubmitDisableSlot().

m_Command

XhciCommand XhciUsbDevice::m_Command

private

Definition at line 301 of file slotdev.h.

Referenced by EndpointsConfigure(), OnEnableSlotDone(), PrepareCommand(), Reset(), SubmitAddressDevice(), SubmitDisableSlot(), SubmitEnableSlot(), SubmitSecondConfigure(), and Update().

m_ContextMask

ULONG XhciUsbDevice::m_ContextMask

private

Bit n set when DCI n is configured as far as this driver knows; bit 0 is the slot.

Definition at line 295 of file slotdev.h.

Referenced by BuildAddressContext(), ContextEntries(), EndpointsConfigure(), OnResetDeviceDone(), and Reset().

m_ContextSize

ULONG XhciUsbDevice::m_ContextSize

private

Definition at line 280 of file slotdev.h.

Referenced by _IRQL_requires_(), BuildAddressContext(), ContextSize(), EndpointsConfigure(), InputContext(), OnEnableSlotDone(), OutputContext(), StartReconfigure(), SubmitSecondConfigure(), and ZeroInputContext().

m_Controller

XhciController* XhciUsbDevice::m_Controller

private

Definition at line 278 of file slotdev.h.

Referenced by _IRQL_requires_(), _IRQL_requires_max_(), Address(), ApplyUpdate(), BuildSlotContext(), Cleanup(), Controller(), Disable(), Enable(), EndpointsConfigure(), ForgetSlot(), OnAddressDeviceDone(), OnConfigureEndpointDone(), OnDisableSlotDone(), OnEnableSlotDone(), OnResetDeviceDone(), QueueTunnelStateDsm(), Reset(), StartReconfigure(), SubmitAddressDevice(), SubmitDisableSlot(), SubmitEnableSlot(), SubmitSecondConfigure(), Update(), and WantsTunnelStateDsm().

m_DeviceDescriptor

USB_DEVICE_DESCRIPTOR XhciUsbDevice::m_DeviceDescriptor

private

Definition at line 284 of file slotdev.h.

Referenced by ApplyUpdate(), and DeviceDescriptor().

m_EndpointCount

volatile LONG XhciUsbDevice::m_EndpointCount

private

Definition at line 298 of file slotdev.h.

m_Endpoints

XhciEndpoint* XhciUsbDevice::m_Endpoints[XHCI_MAX_DCI+1]

private

Definition at line 297 of file slotdev.h.

Referenced by BuildAddressContext(), ControllerResetStarting(), DisableConfiguredEndpoints(), DisableDefaultEndpoint(), Enable(), OnHostLost(), and RecordEnabledEndpoints().

m_Handle

UCXUSBDEVICE XhciUsbDevice::m_Handle

private

Definition at line 277 of file slotdev.h.

Referenced by _IRQL_requires_(), Cleanup(), Handle(), OnDeviceNotificationEvent(), and QueueTunnelStateDsm().

m_Info

UCXUSBDEVICE_INFO XhciUsbDevice::m_Info

private

Definition at line 279 of file slotdev.h.

Referenced by _IRQL_requires_(), ApplyUpdate(), BuildAddressContext(), BuildSlotContext(), Disable(), PortPath(), QueueTunnelStateDsm(), Speed(), and TtHub().

m_Input

XhciDmaBuffer* XhciUsbDevice::m_Input

private

Definition at line 282 of file slotdev.h.

Referenced by _IRQL_requires_(), Cleanup(), InputContext(), InputContextAddress(), and ZeroInputContext().

m_IsHub

BOOLEAN XhciUsbDevice::m_IsHub

private

Definition at line 287 of file slotdev.h.

Referenced by ApplyUpdate(), and BuildSlotContext().

m_LpmEnabled

BOOLEAN XhciUsbDevice::m_LpmEnabled

private

Definition at line 291 of file slotdev.h.

Referenced by ApplyUpdate(), and Disable().

m_MustSucceed

BOOLEAN XhciUsbDevice::m_MustSucceed

private

Definition at line 305 of file slotdev.h.

Referenced by LostSlotStatus(), OnAddressDeviceDone(), OnEnableSlotDone(), OnHostLost(), and SetPending().

m_NumberOfPorts

ULONG XhciUsbDevice::m_NumberOfPorts

private

Definition at line 288 of file slotdev.h.

Referenced by BuildSlotContext(), and HubInfo().

m_NumberOfTTs

ULONG XhciUsbDevice::m_NumberOfTTs

private

Definition at line 289 of file slotdev.h.

Referenced by BuildSlotContext(), and HubInfo().

m_Output

XhciDmaBuffer* XhciUsbDevice::m_Output

private

Definition at line 281 of file slotdev.h.

Referenced by _IRQL_requires_(), Cleanup(), OnEnableSlotDone(), and OutputContext().

m_PendingKind

PendingKind XhciUsbDevice::m_PendingKind

private

Definition at line 304 of file slotdev.h.

Referenced by OnAddressDeviceDone(), OnEnableSlotDone(), and SetPending().

m_PendingPayload

PVOID XhciUsbDevice::m_PendingPayload

private

Definition at line 303 of file slotdev.h.

Referenced by OnAddressDeviceDone(), OnConfigureEndpointDone(), OnEnableSlotDone(), OnEvaluateContextDone(), SetPending(), and SubmitSecondConfigure().

m_PendingRequest

WDFREQUEST XhciUsbDevice::m_PendingRequest

private

Definition at line 302 of file slotdev.h.

Referenced by OnConfigureEndpointDone(), SetPending(), SubmitSecondConfigure(), and TakePending().

m_ReconfigureBusy

BOOLEAN XhciUsbDevice::m_ReconfigureBusy

private

Definition at line 310 of file slotdev.h.

Referenced by FinishReconfigure().

m_ReconfigureCommand

XhciCommand XhciUsbDevice::m_ReconfigureCommand

private

Definition at line 314 of file slotdev.h.

Referenced by StartReconfigure().

m_ReconfigureCurrent

ReconfigureWaiter XhciUsbDevice::m_ReconfigureCurrent

private

Definition at line 313 of file slotdev.h.

Referenced by FinishReconfigure(), and StartReconfigure().

m_ReconfigureInput

XhciDmaBuffer* XhciUsbDevice::m_ReconfigureInput

private

Definition at line 315 of file slotdev.h.

Referenced by Cleanup(), and StartReconfigure().

m_ReconfigureLock

KSPIN_LOCK XhciUsbDevice::m_ReconfigureLock

private

Definition at line 309 of file slotdev.h.

Referenced by _IRQL_requires_(), and FinishReconfigure().

m_ReconfigureQueued

ULONG XhciUsbDevice::m_ReconfigureQueued

private

Definition at line 311 of file slotdev.h.

Referenced by FinishReconfigure().

m_ReconfigureWaiters

ReconfigureWaiter XhciUsbDevice::m_ReconfigureWaiters[XHCI_MAX_DCI+1]

private

Definition at line 312 of file slotdev.h.

Referenced by FinishReconfigure().

m_ResumeTimeSet

BOOLEAN XhciUsbDevice::m_ResumeTimeSet

private

Definition at line 292 of file slotdev.h.

Referenced by ApplyUpdate(), and Disable().

m_SlotEnabled

BOOLEAN XhciUsbDevice::m_SlotEnabled

private

Definition at line 285 of file slotdev.h.

Referenced by Address(), Disable(), EndpointsConfigure(), ForgetSlot(), IsSlotEnabled(), OnEnableSlotDone(), and Reset().

m_SlotId

ULONG XhciUsbDevice::m_SlotId

private

Definition at line 286 of file slotdev.h.

Referenced by _IRQL_requires_max_(), Address(), ApplyUpdate(), Cleanup(), Disable(), ForgetSlot(), OnAddressDeviceDone(), OnConfigureEndpointDone(), OnDeviceNotificationEvent(), OnDisableSlotDone(), OnEnableSlotDone(), OnEvaluateContextDone(), OnResetDeviceDone(), OnTransferEvent(), PrepareCommand(), Reset(), SlotId(), StartReconfigure(), and SubmitEnableSlot().

m_TTThinkTime

ULONG XhciUsbDevice::m_TTThinkTime

private

Definition at line 290 of file slotdev.h.

Referenced by BuildSlotContext(), and HubInfo().

Status

_In_ _In_ NTSTATUS XhciUsbDevice::Status

Definition at line 77 of file slotdev.h.

Referenced by Address(), Enable(), EndpointsConfigure(), OnEnableSlotDone(), OnEvaluateContextDone(), QueueTunnelStateDsm(), and SubmitAddressDevice().

StreamId

_In_ ULONG XhciUsbDevice::StreamId

Definition at line 51 of file slotdev.h.

Referenced by _IRQL_requires_max_().

TunnelDsmWorker

VOID NTAPI XhciUsbDevice::TunnelDsmWorker

staticprivate

Definition at line 239 of file slotdev.h.

Referenced by QueueTunnelStateDsm().

UsbDevice

_In_ UCXUSBDEVICE XhciUsbDevice::UsbDevice

Definition at line 117 of file slotdev.h.

Referenced by _IRQL_requires_().

---

The documentation for this class was generated from the following files:

• drivers/usb/usbxhci/slotdev.h
• drivers/usb/usbxhci/slotdev.cpp