archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/drivers/wdm/usb/driver/hub.pnp/ioctli.c

3128 lines
97 KiB
Raw Blame History

/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
IOCTLI.C
Abstract:
This module implements usb IOCTL requests to usb hub.
Author:
jdunn
Environment:
kernel mode only
Notes:
Revision History:
1-2-97 : re-wriiten
--*/
/*
//
// ** User mode IOCTLS **
//
//
// IOCTL_USB_GET_NODE_INFORMATION
//
input:
None
output:
outputbufferlength = sizeof(USB_BUS_NODE_INFORMATION)
outputbuffer = filled in with USB_BUS_NODE_INFORMATION structure.
//
// IOCTL_USB_GET_NODE_CONNECTION_INFORMATION
//
input:
inputbufferlength = size of user supplied buffer
inpubuffer = ptr to USB_NODE_CONNECTION_INFORMATION structure with
connectionIndex set to the requested connection.
output:
outputbufferlength = size of user supplied buffer
outputbuffer = filled in with USB_NODE_CONNECTION_INFORMATION structure.
//
// IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION
//
input:
inputbufferlength = size of user supplied buffer.
inputbuffer = ptr to USB_DESCRIPTOR_REQUEST, includes setup packet
and connection index.
output:
outputbufferlength = length of descriptor data plus sizeof sizeof(USB_DESCRIPTOR_REQUEST).
outputbuffer = ptr to USB_DESCRIPTOR_REQUEST filled in with returned data.
//
// ** Internal IOCTLS **
//
//
// IOCTL_INTERNAL_USB_RESET_PORT
//
*/
#include <wdm.h>
#ifdef WMI_SUPPORT
#include <wmilib.h>
#include <wmistr.h>
#include <wdmguid.h>
#endif /* WMI_SUPPORT */
#include "usbhub.h"
#ifdef PAGE_CODE
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, USBH_IoctlGetNodeInformation)
#pragma alloc_text(PAGE, USBH_IoctlGetHubCapabilities)
#pragma alloc_text(PAGE, USBH_IoctlGetNodeConnectionInformation)
#pragma alloc_text(PAGE, USBH_IoctlGetNodeConnectionDriverKeyName)
#pragma alloc_text(PAGE, USBH_IoctlGetNodeName)
#pragma alloc_text(PAGE, USBH_PdoIoctlGetPortStatus)
#pragma alloc_text(PAGE, USBH_PdoIoctlEnablePort)
#pragma alloc_text(PAGE, USBH_IoctlGetDescriptorForPDO)
#pragma alloc_text(PAGE, USBH_SystemControl)
#pragma alloc_text(PAGE, USBH_PortSystemControl)
#pragma alloc_text(PAGE, USBH_ExecuteWmiMethod)
#pragma alloc_text(PAGE, USBH_QueryWmiRegInfo)
#pragma alloc_text(PAGE, USBH_CheckLeafHubsIdle)
#endif
#endif
NTSTATUS
USBH_IoctlGetNodeInformation(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN PIRP Irp
)
/* ++
*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
PUSB_NODE_INFORMATION outputBuffer;
ULONG outputBufferLength;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_IoctlGetNodeInformation\n"));
//
// Get a pointer to the current location in the Irp. This is where
// the function codes and parameters are located.
//
ioStack = IoGetCurrentIrpStackLocation(Irp);
//
// Get the pointer to the input/output buffer and it's length
//
outputBuffer = (PUSB_NODE_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
outputBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength;
RtlZeroMemory(outputBuffer, outputBufferLength);
if (outputBufferLength >= sizeof(USB_NODE_INFORMATION)) {
//
// for now everything is a hub
//
outputBuffer->NodeType = UsbHub;
RtlCopyMemory(&outputBuffer->u.HubInformation.HubDescriptor,
DeviceExtensionHub->HubDescriptor,
sizeof(*DeviceExtensionHub->HubDescriptor));
// 100 milliamps/port means bus powered
outputBuffer->u.HubInformation.HubIsBusPowered =
USBH_HubIsBusPowered(DeviceExtensionHub->FunctionalDeviceObject,
DeviceExtensionHub->ConfigurationDescriptor);
Irp->IoStatus.Information = sizeof(USB_NODE_INFORMATION);
} else {
ntStatus = STATUS_BUFFER_TOO_SMALL;
}
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_IoctlCycleHubPort(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN PIRP Irp
)
/* ++
*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
PULONG buffer;
ULONG bufferLength;
ULONG port;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_IoctlCycleHubPort\n"));
ioStack = IoGetCurrentIrpStackLocation(Irp);
//
// Get the pointer to the input/output buffer and its length.
//
buffer = (PULONG) Irp->AssociatedIrp.SystemBuffer;
bufferLength = ioStack->Parameters.DeviceIoControl.InputBufferLength;
if (bufferLength < sizeof(port)) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
goto USBH_IoctlCycleHubPort_Done;
}
// port number is input only
port = *buffer;
Irp->IoStatus.Information = 0;
USBH_KdPrint((1,"'Request Cycle Port %d\n", port));
if (port <= DeviceExtensionHub->HubDescriptor->bNumberOfPorts &&
port > 0) {
PPORT_DATA portData;
PDEVICE_EXTENSION_PORT deviceExtensionPort;
portData = &DeviceExtensionHub->PortData[port-1];
if (portData->DeviceObject) {
deviceExtensionPort = portData->DeviceObject->DeviceExtension;
USBH_InternalCyclePort(DeviceExtensionHub,
(USHORT) port,
deviceExtensionPort);
} else {
ntStatus = STATUS_UNSUCCESSFUL;
}
USBH_KdPrint((1,"'Cycle Port %d %x\n", port, ntStatus));
}
USBH_IoctlCycleHubPort_Done:
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_IoctlGetHubCapabilities(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN PIRP Irp
)
/* ++
*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
PUSB_HUB_CAPABILITIES outputBuffer;
ULONG outputBufferLength, copyLen;
USB_HUB_CAPABILITIES localBuffer;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_IoctlGetHubCapabilities\n"));
RtlZeroMemory(&localBuffer, sizeof(USB_HUB_CAPABILITIES));
// Fill in the data in the local buffer first, then copy as much of
// this data to the user's buffer as requested (as indicated by the
// size of the request buffer).
localBuffer.HubIs2xCapable =
(DeviceExtensionHub->HubFlags & HUBFLAG_USB20_HUB) ? 1:0;
//
// Get a pointer to the current location in the Irp. This is where
// the function codes and parameters are located.
//
ioStack = IoGetCurrentIrpStackLocation(Irp);
//
// Get the pointer to the input/output buffer and its length.
//
outputBuffer = (PUSB_HUB_CAPABILITIES) Irp->AssociatedIrp.SystemBuffer;
outputBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength;
if (outputBufferLength <= sizeof(localBuffer)) {
copyLen = outputBufferLength;
} else {
copyLen = sizeof(localBuffer);
}
// zero buffer passed in
RtlZeroMemory(outputBuffer,
outputBufferLength);
// Only give the user the amount of data that they ask for
// this may only be part of our info strucure
RtlCopyMemory(outputBuffer,
&localBuffer,
copyLen);
Irp->IoStatus.Information = copyLen;
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_IoctlGetNodeConnectionDriverKeyName(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN PIRP Irp
)
/* ++
*
* Description:
*
* Arguments:
*
* ConnectionIndex - The one-based port index to which a device is attached.
* The devnode name of the will be returned, if there is sufficient buffer space.
*
* ActualLength - The structure size in bytes necessary to hold the NULL
* terminated name. This includes the entire structure, not
* just the name.
*
* NodeName - The UNICODE NULL terminated name of the devnode for the device
* attached to this port.
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
PUSB_NODE_CONNECTION_DRIVERKEY_NAME outputBuffer;
ULONG outputBufferLength, length, i;
PPORT_DATA portData;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_IoctlGetNodeConnectionDriverKeyName\n"));
portData = DeviceExtensionHub->PortData;
//
// Get a pointer to the current location in the Irp. This is where
// the function codes and parameters are located.
//
ioStack = IoGetCurrentIrpStackLocation(Irp);
//
// Get the pointer to the input/output buffer and it's length
//
outputBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength;
outputBuffer = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME) Irp->AssociatedIrp.SystemBuffer;
// find the PDO
if (outputBufferLength >= sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME)) {
USBH_KdPrint((2,"'Connection = %d\n", outputBuffer->ConnectionIndex));
ntStatus = STATUS_INVALID_PARAMETER;
for(i=1; i<=DeviceExtensionHub->HubDescriptor->bNumberOfPorts; i++) {
PDEVICE_EXTENSION_PORT deviceExtensionPort;
if (i == outputBuffer->ConnectionIndex) {
portData = &DeviceExtensionHub->PortData[outputBuffer->ConnectionIndex - 1];
if (portData->DeviceObject) {
deviceExtensionPort = portData->DeviceObject->DeviceExtension;
// Validate the PDO for PnP purposes. (PnP will bugcheck
// if passed a not-quite-initialized PDO.)
if (deviceExtensionPort->PortPdoFlags &
PORTPDO_VALID_FOR_PNP_FUNCTION) {
// we have the PDO, now attempt to
// get the devnode name and return it
length = outputBufferLength -
sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME);
USBH_KdPrint((1,"'Get DKN length = %d\n", length));
ntStatus = IoGetDeviceProperty(
portData->DeviceObject,
DevicePropertyDriverKeyName,
length,
outputBuffer->DriverKeyName,
&length);
USBH_KdPrint((1,"'Get DKN prop length = %d %x\n",
length, ntStatus));
if (ntStatus == STATUS_BUFFER_TOO_SMALL) {
ntStatus = STATUS_SUCCESS;
}
outputBuffer->ActualLength =
length + sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME);
USBH_KdPrint((1,"'DKN actual length = %d \n",
outputBuffer->ActualLength));
// see how much data we actully copied
if (outputBufferLength >= outputBuffer->ActualLength) {
// user buffer is bigger, just indicate how much we copied
Irp->IoStatus.Information = outputBuffer->ActualLength;
} else {
// it is not clear that IoGetDeviceProperty
// returns anything in the case of BUFFER_TOO_SMALL
// so to avoid returning unitialized memory we will
// just return the structure passed in
outputBuffer->DriverKeyName[0] = 0;
Irp->IoStatus.Information =
sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME);
}
} else {
ntStatus = STATUS_INVALID_DEVICE_STATE;
}
}
}
}
} else {
ntStatus = STATUS_BUFFER_TOO_SMALL;
}
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_IoctlGetNodeConnectionInformation(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN PIRP Irp,
IN BOOLEAN ExApi
)
/* ++
*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
PUSB_NODE_CONNECTION_INFORMATION_EX outputBuffer;
ULONG outputBufferLength, length, i;
PPORT_DATA portData;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_IoctlGetNodeConnectionInformation\n"));
portData = DeviceExtensionHub->PortData;
//
// Get a pointer to the current location in the Irp. This is where
// the function codes and parameters are located.
//
ioStack = IoGetCurrentIrpStackLocation(Irp);
//
// Get the pointer to the input/output buffer and it's length
//
outputBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength;
outputBuffer = (PUSB_NODE_CONNECTION_INFORMATION_EX) Irp->AssociatedIrp.SystemBuffer;
if (outputBufferLength >= sizeof(USB_NODE_CONNECTION_INFORMATION)) {
ULONG index;
USBH_KdPrint((2,"'Connection = %d\n", outputBuffer->ConnectionIndex));
// Clear the buffer in case we don't call USBD_GetDeviceInformation
// below, but make sure to keep the ConnectionIndex!
index = outputBuffer->ConnectionIndex;
RtlZeroMemory(outputBuffer, outputBufferLength);
outputBuffer->ConnectionIndex = index;
ntStatus = STATUS_INVALID_PARAMETER;
for(i=1; i<=DeviceExtensionHub->HubDescriptor->bNumberOfPorts; i++) {
PDEVICE_EXTENSION_PORT deviceExtensionPort;
if (i == outputBuffer->ConnectionIndex) {
length = sizeof(USB_NODE_CONNECTION_INFORMATION);
if (portData->DeviceObject) {
deviceExtensionPort = portData->DeviceObject->DeviceExtension;
outputBuffer->ConnectionStatus =
portData->ConnectionStatus;
outputBuffer->DeviceIsHub =
(deviceExtensionPort->PortPdoFlags & PORTPDO_DEVICE_IS_HUB)
? TRUE : FALSE;
USBH_KdPrint((2,"'outputbuffer = %x\n", outputBuffer));
RtlCopyMemory(&outputBuffer->DeviceDescriptor,
&deviceExtensionPort->DeviceDescriptor,
sizeof(outputBuffer->DeviceDescriptor));
if (deviceExtensionPort->DeviceData) {
#ifdef USB2
USBH_KdPrint((2,"'devicedata = %x\n",
deviceExtensionPort->DeviceData));
ntStatus = USBD_GetDeviceInformationEx(
deviceExtensionPort,
DeviceExtensionHub,
outputBuffer,
outputBufferLength,
deviceExtensionPort->DeviceData);
#else
ntStatus = USBD_GetDeviceInformation(outputBuffer,
outputBufferLength,
deviceExtensionPort->DeviceData);
#endif
} else {
//
// We have a device connected, but it failed to start.
// Since it hasn't started, there are no open pipes, so
// we don't need to get pipe information. We are going
// to return some relevant information, however, so
// return STATUS_SUCCESS.
//
ntStatus = STATUS_SUCCESS;
}
USBH_KdPrint((2,"'status from USBD_GetDeviceInformation %x\n",
ntStatus));
if (NT_SUCCESS(ntStatus)) {
ULONG j;
USBH_KdPrint((2,"'status %x \n", outputBuffer->ConnectionStatus));
// USBH_KdPrint((2,"'NodeName %s\n", outputBuffer->NodeName));
USBH_KdPrint((2,"'PID 0x%x\n",
outputBuffer->DeviceDescriptor.idProduct));
USBH_KdPrint((2,"'VID 0x%x\n",
outputBuffer->DeviceDescriptor.idVendor));
USBH_KdPrint((2,"'Current Configuration Value 0x%x\n",
outputBuffer->CurrentConfigurationValue));
// map the speed field for the old API which returned
// a BOOLEAN
if (!ExApi) {
PUSB_NODE_CONNECTION_INFORMATION tmp =
(PUSB_NODE_CONNECTION_INFORMATION) outputBuffer;
tmp->LowSpeed = (outputBuffer->Speed == UsbLowSpeed)
? TRUE : FALSE;
}
USBH_KdPrint((2,"'Speed = %x\n", outputBuffer->Speed));
USBH_KdPrint((2,"'Address = %x\n", outputBuffer->DeviceAddress));
USBH_KdPrint((2,"'NumberOfOpenPipes = %d\n",
outputBuffer->NumberOfOpenPipes));
for(j=0; j< outputBuffer->NumberOfOpenPipes; j++) {
USBH_KdPrint((2,"'Max Packet %x\n",
outputBuffer->PipeList[j].EndpointDescriptor.wMaxPacketSize));
USBH_KdPrint((2,"'Interval %x \n",
outputBuffer->PipeList[j].EndpointDescriptor.bInterval));
}
Irp->IoStatus.Information =
sizeof(USB_NODE_CONNECTION_INFORMATION) +
sizeof(USB_PIPE_INFO) * outputBuffer->NumberOfOpenPipes;
} else if (ntStatus == STATUS_BUFFER_TOO_SMALL) {
Irp->IoStatus.Information =
sizeof(USB_NODE_CONNECTION_INFORMATION);
ntStatus = STATUS_SUCCESS;
}
} else { //no device object
// This assert is no longer valid because we now support
// displaying the UI on device enumeration failure.
//
// USBH_ASSERT(portData->ConnectionStatus == NoDeviceConnected ||
// portData->ConnectionStatus == DeviceCausedOvercurrent);
outputBuffer->ConnectionStatus = portData->ConnectionStatus;
Irp->IoStatus.Information =
sizeof(USB_NODE_CONNECTION_INFORMATION);
ntStatus = STATUS_SUCCESS;
}
break;
}
portData++;
} /* for */
} else {
ntStatus = STATUS_BUFFER_TOO_SMALL;
}
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_IoctlGetNodeConnectionAttributes(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN PIRP Irp
)
/* ++
*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
PUSB_NODE_CONNECTION_ATTRIBUTES outputBuffer;
ULONG outputBufferLength, length, i;
PPORT_DATA portData;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_IoctlGetNodeConnectionInformation\n"));
portData = DeviceExtensionHub->PortData;
//
// Get a pointer to the current location in the Irp. This is where
// the function codes and parameters are located.
//
ioStack = IoGetCurrentIrpStackLocation(Irp);
//
// Get the pointer to the input/output buffer and it's length
//
outputBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength;
outputBuffer = (PUSB_NODE_CONNECTION_ATTRIBUTES) Irp->AssociatedIrp.SystemBuffer;
if (outputBufferLength >= sizeof(USB_NODE_CONNECTION_ATTRIBUTES)) {
ULONG index;
USBH_KdPrint((2,"'Connection = %d\n", outputBuffer->ConnectionIndex));
// Clear the buffer in case we don't call USBD_GetDeviceInformation
// below, but make sure to keep the ConnectionIndex!
index = outputBuffer->ConnectionIndex;
RtlZeroMemory(outputBuffer, outputBufferLength);
outputBuffer->ConnectionIndex = index;
ntStatus = STATUS_INVALID_PARAMETER;
for(i=1; i<=DeviceExtensionHub->HubDescriptor->bNumberOfPorts; i++) {
if (i == outputBuffer->ConnectionIndex) {
length = sizeof(USB_NODE_CONNECTION_ATTRIBUTES);
outputBuffer->ConnectionStatus =
portData->ConnectionStatus;
USBH_KdPrint((2,"'outputbuffer = %x\n", outputBuffer));
// map extended hub info here
outputBuffer->PortAttributes = portData->PortAttributes;
Irp->IoStatus.Information =
sizeof(USB_NODE_CONNECTION_ATTRIBUTES);
ntStatus = STATUS_SUCCESS;
break;
}
portData++;
} /* for */
} else {
ntStatus = STATUS_BUFFER_TOO_SMALL;
}
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_IoctlHubSymbolicName(
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort,
IN PIRP Irp
)
/* ++
*
* Description:
*
* Takes as input and output a pointer to the following structure:
*
* typedef struct _USB_HUB_NAME {
* ULONG ActualLength; // OUTPUT
* WCHAR HubName[1]; // OUTPUT
* } USB_HUB_NAME;
*
* Arguments:
*
* ActualLength - The structure size in bytes necessary to hold the NULL
* terminated symbolic link name. This includes the entire structure, not
* just the name.
*
* NodeName - The UNICODE NULL terminated symbolic link name of the external
* hub attached to the port. If there is no external hub attached to the port
* a single NULL is returned.
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
PUSB_HUB_NAME outputBuffer;
ULONG outputBufferLength;
PAGED_CODE();
// Get a pointer to the current location in the Irp. This is where
// the function codes and parameters are located.
//
ioStack = IoGetCurrentIrpStackLocation(Irp);
// Get the pointer to the input/output buffer and it's length
//
outputBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength;
outputBuffer = (PUSB_HUB_NAME) Irp->AssociatedIrp.SystemBuffer;
// Make sure that the output buffer is large enough for the base
// structure that will be returned.
//
if (outputBufferLength < sizeof(USB_HUB_NAME)) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
goto GetHubDone;
}
if ((DeviceExtensionPort->PortPdoFlags & PORTPDO_DEVICE_IS_HUB) &&
(DeviceExtensionPort->PortPdoFlags & PORTPDO_STARTED) &&
(DeviceExtensionPort->PortPdoFlags & PORTPDO_SYM_LINK)) {
PUNICODE_STRING hubNameUnicodeString;
ULONG length, offset=0;
WCHAR *pwch;
// Device is a hub, get the name of the hub
//
hubNameUnicodeString = &DeviceExtensionPort->SymbolicLinkName;
// assuming the string is \n\name strip of '\n\' where
// n is zero or more chars
pwch = &hubNameUnicodeString->Buffer[0];
USBH_ASSERT(*pwch == '\\');
if (*pwch == '\\') {
pwch++;
while (*pwch != '\\' && *pwch) {
pwch++;
}
USBH_ASSERT(*pwch == '\\');
if (*pwch == '\\') {
pwch++;
}
offset = (ULONG)((PUCHAR)pwch -
(PUCHAR)&hubNameUnicodeString->Buffer[0]);
}
// Strip off the '\DosDevices\' prefix.
// Length does not include a terminating NULL.
//
length = hubNameUnicodeString->Length - offset;
RtlZeroMemory(outputBuffer, outputBufferLength);
if (outputBufferLength >= length +
sizeof(USB_HUB_NAME)) {
RtlCopyMemory(&outputBuffer->HubName[0],
&hubNameUnicodeString->Buffer[offset/2],
length);
Irp->IoStatus.Information = length+
sizeof(USB_HUB_NAME);
outputBuffer->ActualLength = (ULONG)Irp->IoStatus.Information;
ntStatus = STATUS_SUCCESS;
} else {
// Output buffer is too small to hold the entire
// string. Return just the length needed to hold
// the entire string.
//
outputBuffer->ActualLength =
length + sizeof(USB_HUB_NAME);
outputBuffer->HubName[0] = (WCHAR)0;
Irp->IoStatus.Information = sizeof(USB_HUB_NAME);
}
} else {
// Device is not a hub or does not currently have a symbolic link
// allocated, just return a NULL terminated string.
//
outputBuffer->ActualLength = sizeof(USB_HUB_NAME);
outputBuffer->HubName[0] = 0;
Irp->IoStatus.Information = sizeof(USB_HUB_NAME);
}
GetHubDone:
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_IoctlGetNodeName(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN PIRP Irp
)
/* ++
*
* Description:
*
* Takes as input and output a pointer to the following structure:
*
* typedef struct _USB_NODE_CONNECTION_NAME {
* ULONG ConnectionIndex; // INPUT
* ULONG ActualLength; // OUTPUT
* WCHAR NodeName[1]; // OUTPUT
* } USB_NODE_CONNECTION_NAME;
*
* Arguments:
*
* ConnectionIndex - The one-based port index to which a device is attached.
* If an external hub is attached to this port, the symbolic link name of the
* hub will be returned, if there is sufficient buffer space.
*
* ActualLength - The structure size in bytes necessary to hold the NULL
* terminated symbolic link name. This includes the entire structure, not
* just the name.
*
* NodeName - The UNICODE NULL terminated symbolic link name of the external
* hub attached to the port. If there is no external hub attached to the port
* a single NULL is returned.
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
PUSB_NODE_CONNECTION_NAME outputBuffer;
ULONG outputBufferLength;
PPORT_DATA portData;
PDEVICE_EXTENSION_PORT deviceExtensionPort;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_IoctlGetNodeName\n"));
// Get a pointer to the current location in the Irp. This is where
// the function codes and parameters are located.
//
ioStack = IoGetCurrentIrpStackLocation(Irp);
// Get the pointer to the input/output buffer and it's length
//
outputBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength;
outputBuffer = (PUSB_NODE_CONNECTION_NAME) Irp->AssociatedIrp.SystemBuffer;
// Make sure that the output buffer is large enough for the base
// structure that will be returned.
//
if (outputBufferLength < sizeof(USB_NODE_CONNECTION_NAME)) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
goto GetNodeNameDone;
}
USBH_KdPrint((2,"'Connection = %d\n", outputBuffer->ConnectionIndex));
// Make sure that the (one-based) port index is valid.
//
if ((outputBuffer->ConnectionIndex == 0) ||
(outputBuffer->ConnectionIndex >
DeviceExtensionHub->HubDescriptor->bNumberOfPorts)) {
ntStatus = STATUS_INVALID_PARAMETER;
goto GetNodeNameDone;
}
// Get a pointer to the data associated with the specified (one-based) port
//
portData = &DeviceExtensionHub->PortData[outputBuffer->ConnectionIndex - 1];
if (portData->DeviceObject) {
deviceExtensionPort = portData->DeviceObject->DeviceExtension;
if ((deviceExtensionPort->PortPdoFlags & PORTPDO_DEVICE_IS_HUB) &&
(deviceExtensionPort->PortPdoFlags & PORTPDO_STARTED) &&
(deviceExtensionPort->PortPdoFlags & PORTPDO_SYM_LINK)) {
PUNICODE_STRING nodeNameUnicodeString;
ULONG length, offset=0;
WCHAR *pwch;
// Device is a hub, get the name of the hub
//
nodeNameUnicodeString = &deviceExtensionPort->SymbolicLinkName;
// assuming the string is \n\name strip of '\n\' where
// n is zero or more chars
pwch = &nodeNameUnicodeString->Buffer[0];
USBH_ASSERT(*pwch == '\\');
if (*pwch == '\\') {
pwch++;
while (*pwch != '\\' && *pwch) {
pwch++;
}
USBH_ASSERT(*pwch == '\\');
if (*pwch == '\\') {
pwch++;
}
offset = (ULONG)((PUCHAR)pwch -
(PUCHAR)&nodeNameUnicodeString->Buffer[0]);
}
// Strip off the '\DosDevices\' prefix.
// Length does not include a terminating NULL.
//
length = nodeNameUnicodeString->Length - offset;
RtlZeroMemory(&outputBuffer->ActualLength,
outputBufferLength - sizeof(outputBuffer->ConnectionIndex));
if (outputBufferLength >= length +
sizeof(USB_NODE_CONNECTION_NAME)) {
RtlCopyMemory(&outputBuffer->NodeName[0],
&nodeNameUnicodeString->Buffer[offset/2],
length);
Irp->IoStatus.Information = length+
sizeof(USB_NODE_CONNECTION_NAME);
outputBuffer->ActualLength = (ULONG)Irp->IoStatus.Information;
ntStatus = STATUS_SUCCESS;
} else {
// Output buffer is too small to hold the entire
// string. Return just the length needed to hold
// the entire string.
//
outputBuffer->ActualLength =
length + sizeof(USB_NODE_CONNECTION_NAME);
outputBuffer->NodeName[0] = (WCHAR)0;
Irp->IoStatus.Information = sizeof(USB_NODE_CONNECTION_NAME);
}
} else {
// Device is not a hub or does not currently have a symbolic link
// allocated, just return a NULL terminated string.
//
outputBuffer->ActualLength = sizeof(USB_NODE_CONNECTION_NAME);
outputBuffer->NodeName[0] = 0;
Irp->IoStatus.Information = sizeof(USB_NODE_CONNECTION_NAME);
}
} else {
// No device attached, just return a NULL terminated string.
Irp->IoStatus.Information = sizeof(USB_NODE_CONNECTION_NAME);
outputBuffer->ActualLength = sizeof(USB_NODE_CONNECTION_NAME);
outputBuffer->NodeName[0] = 0;
}
GetNodeNameDone:
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_PdoIoctlGetPortStatus(
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort,
IN PIRP Irp
)
/*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStackLocation; // our stack location
PDEVICE_EXTENSION_HUB deviceExtensionHub;
PDEVICE_OBJECT deviceObject;
PPORT_DATA portData;
PULONG portStatus;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_PdoIoctlGetPortStatus DeviceExtension %x Irp %x\n",
DeviceExtensionPort, Irp));
deviceExtensionHub = DeviceExtensionPort->DeviceExtensionHub;
USBH_KdPrint((2,"'***WAIT hub mutex %x\n", deviceExtensionHub));
USBH_INC_PENDING_IO_COUNT(deviceExtensionHub);
KeWaitForSingleObject(&deviceExtensionHub->HubMutex,
Executive,
KernelMode,
FALSE,
NULL);
USBH_KdPrint((2,"'***WAIT hub mutex done %x\n", deviceExtensionHub));
portData = &deviceExtensionHub->PortData[DeviceExtensionPort->PortNumber - 1];
deviceObject = DeviceExtensionPort->PortPhysicalDeviceObject;
ioStackLocation = IoGetCurrentIrpStackLocation(Irp);
portStatus = ioStackLocation->Parameters.Others.Argument1;
USBH_ASSERT(portStatus != NULL);
*portStatus = 0;
// Refresh our notion of what the port status actually is.
ntStatus = USBH_SyncGetPortStatus(deviceExtensionHub,
DeviceExtensionPort->PortNumber,
(PUCHAR) &portData->PortState,
sizeof(portData->PortState));
if (DeviceExtensionPort->PortPhysicalDeviceObject == portData->DeviceObject) {
// translate hup port status bits
if (portData->PortState.PortStatus & PORT_STATUS_ENABLE) {
*portStatus |= USBD_PORT_ENABLED;
}
if (portData->PortState.PortStatus & PORT_STATUS_CONNECT ) {
*portStatus |= USBD_PORT_CONNECTED;
}
}
USBH_KdPrint((2,"'***RELEASE hub mutex %x\n", deviceExtensionHub));
KeReleaseSemaphore(&deviceExtensionHub->HubMutex,
LOW_REALTIME_PRIORITY,
1,
FALSE);
USBH_DEC_PENDING_IO_COUNT(deviceExtensionHub);
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_PdoIoctlEnablePort(
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort,
IN PIRP Irp
)
/*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStackLocation; // our stack location
PDEVICE_EXTENSION_HUB deviceExtensionHub;
PDEVICE_OBJECT deviceObject;
PPORT_DATA portData;
PORT_STATE portState;
USBH_KdPrint((2,"'USBH_PdoIoctlEnablePort DeviceExtension %x Irp %x\n",
DeviceExtensionPort, Irp));
deviceExtensionHub = DeviceExtensionPort->DeviceExtensionHub;
USBH_KdPrint((2,"'***WAIT hub mutex %x\n", deviceExtensionHub));
USBH_INC_PENDING_IO_COUNT(deviceExtensionHub);
KeWaitForSingleObject(&deviceExtensionHub->HubMutex,
Executive,
KernelMode,
FALSE,
NULL);
USBH_KdPrint((2,"'***WAIT hub mutex done %x\n", deviceExtensionHub));
portData = &deviceExtensionHub->PortData[DeviceExtensionPort->PortNumber - 1];
deviceObject = DeviceExtensionPort->PortPhysicalDeviceObject;
ioStackLocation = IoGetCurrentIrpStackLocation(Irp);
// validate that there is actually a device still conected
ntStatus = USBH_SyncGetPortStatus(deviceExtensionHub,
DeviceExtensionPort->PortNumber,
(PUCHAR) &portState,
sizeof(portState));
if ((NT_SUCCESS(ntStatus) &&
(portState.PortStatus & PORT_STATUS_CONNECT))) {
LOGENTRY(LOG_PNP, "estE",
deviceExtensionHub,
DeviceExtensionPort->PortNumber,
0);
ntStatus = USBH_SyncEnablePort(deviceExtensionHub,
DeviceExtensionPort->PortNumber);
} else {
// error or no device connected or
// can't be sure, fail the request
LOGENTRY(LOG_PNP, "estx",
deviceExtensionHub,
DeviceExtensionPort->PortNumber,
0);
ntStatus = STATUS_UNSUCCESSFUL;
}
USBH_KdPrint((2,"'***RELEASE hub mutex %x\n", deviceExtensionHub));
KeReleaseSemaphore(&deviceExtensionHub->HubMutex,
LOW_REALTIME_PRIORITY,
1,
FALSE);
USBH_DEC_PENDING_IO_COUNT(deviceExtensionHub);
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_IoctlGetDescriptorForPDO(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN PIRP Irp
)
/* ++
*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION ioStack;
ULONG outputBufferLength;
PUCHAR outputBuffer;
PUSB_DESCRIPTOR_REQUEST request;
PPORT_DATA portData;
ULONG i;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_IoctlDescriptorRequest\n"));
portData = DeviceExtensionHub->PortData;
//
// Get a pointer to the current location in the Irp. This is where
// the function codes and parameters are located.
//
ioStack = IoGetCurrentIrpStackLocation(Irp);
//
// Get the pointer to the input/output buffer and it's length
//
outputBufferLength = ioStack->Parameters.DeviceIoControl.OutputBufferLength;
if (outputBufferLength < sizeof(USB_DESCRIPTOR_REQUEST)) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
goto USBH_IoctlGetDescriptorForPDO_Complete;
}
request = (PUSB_DESCRIPTOR_REQUEST) Irp->AssociatedIrp.SystemBuffer;
outputBuffer = &request->Data[0];
//
// do some parameter checking
//
// the wLength in the setup packet better be the size of the
// outputbuffer minus header
//
if (request->SetupPacket.wLength >
outputBufferLength - sizeof(USB_DESCRIPTOR_REQUEST)) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
goto USBH_IoctlGetDescriptorForPDO_Complete;
} else {
// request won't return more than wLength
outputBufferLength = request->SetupPacket.wLength;
}
// return invalid parameter if conn index is out
// of bounds
ntStatus = STATUS_INVALID_PARAMETER;
for(i=1; i<=DeviceExtensionHub->HubDescriptor->bNumberOfPorts; i++) {
if (i == request->ConnectionIndex) {
PDEVICE_EXTENSION_PORT deviceExtensionPort;
// make sure we have a valid devobj for this index
if (portData->DeviceObject == NULL) {
goto USBH_IoctlGetDescriptorForPDO_Complete;
}
deviceExtensionPort =
portData->DeviceObject->DeviceExtension;
if (request->SetupPacket.wValue ==
((USB_CONFIGURATION_DESCRIPTOR_TYPE << 8) | 0) &&
outputBufferLength == sizeof(USB_CONFIGURATION_DESCRIPTOR)) {
//
// Only wants the basic configuration descriptor without the
// rest of them tacked on (ie. interface, endpoint descriptors).
//
USBH_ASSERT(deviceExtensionPort->ExtensionType == EXTENSION_TYPE_PORT);
RtlCopyMemory(outputBuffer,
&deviceExtensionPort->ConfigDescriptor,
outputBufferLength);
Irp->IoStatus.Information =
outputBufferLength + sizeof(USB_DESCRIPTOR_REQUEST);
ntStatus = STATUS_SUCCESS;
} else {
PURB urb;
//
// OK send the request
//
USBH_KdPrint((2,"'sending descriptor request for ioclt\n"));
//
// Allocate an Urb and descriptor buffer.
//
urb = UsbhExAllocatePool(NonPagedPool, sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
if (urb) {
UsbBuildGetDescriptorRequest(urb,
(USHORT) sizeof (struct _URB_CONTROL_DESCRIPTOR_REQUEST),
request->SetupPacket.wValue >> 8,
request->SetupPacket.wValue & 0xff,
0,
outputBuffer,
NULL,
outputBufferLength,
NULL);
RtlCopyMemory(&urb->UrbControlDescriptorRequest.Reserved1,
&request->SetupPacket.bmRequest,
8);
ntStatus = USBH_SyncSubmitUrb(deviceExtensionPort->PortPhysicalDeviceObject, urb);
Irp->IoStatus.Information =
urb->UrbControlDescriptorRequest.TransferBufferLength +
sizeof(USB_DESCRIPTOR_REQUEST);
UsbhExFreePool(urb);
} else {
USBH_KdBreak(("SyncGetDeviceConfigurationDescriptor fail alloc Urb\n"));
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
}
}
break;
}
portData++;
}
USBH_IoctlGetDescriptorForPDO_Complete:
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
NTSTATUS
USBH_PdoIoctlResetPort(
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort,
IN PIRP Irp
)
/*
* Description:
*
* driver is requesting us to reset the port to which the device
* is attached.
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PDEVICE_EXTENSION_HUB deviceExtensionHub;
PPORT_DATA portData;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_PdoIoctlResetPort DeviceExtension %x Irp %x\n",
DeviceExtensionPort, Irp));
deviceExtensionHub = DeviceExtensionPort->DeviceExtensionHub;
if (!deviceExtensionHub) {
ntStatus = STATUS_UNSUCCESSFUL;
goto USBH_PdoIoctlResetPortExit;
}
USBH_KdPrint((2,"'***WAIT hub mutex %x\n", deviceExtensionHub));
USBH_INC_PENDING_IO_COUNT(deviceExtensionHub);
KeWaitForSingleObject(&deviceExtensionHub->HubMutex,
Executive,
KernelMode,
FALSE,
NULL);
USBH_KdPrint((2,"'***WAIT hub mutex done %x\n", deviceExtensionHub));
portData =
&deviceExtensionHub->PortData[DeviceExtensionPort->PortNumber - 1];
LOGENTRY(LOG_PNP, "Drst", deviceExtensionHub,
DeviceExtensionPort->PortPhysicalDeviceObject,
portData->DeviceObject);
if (DeviceExtensionPort->PortPhysicalDeviceObject ==
portData->DeviceObject && DeviceExtensionPort->DeviceData != NULL) {
#ifdef USB2
USBD_RemoveDeviceEx(deviceExtensionHub,
DeviceExtensionPort->DeviceData,
deviceExtensionHub->RootHubPdo,
USBD_MARK_DEVICE_BUSY);
#else
USBD_RemoveDevice(DeviceExtensionPort->DeviceData,
deviceExtensionHub->RootHubPdo,
USBD_MARK_DEVICE_BUSY);
#endif
ntStatus = USBH_ResetDevice(deviceExtensionHub,
DeviceExtensionPort->PortNumber,
TRUE,
0); // RetryIteration
} else {
ntStatus = STATUS_INVALID_PARAMETER;
}
USBH_KdPrint((1,"'Warning: driver has reset the port (%x)\n",
ntStatus));
USBH_KdPrint((2,"'***RELEASE hub mutex %x\n", deviceExtensionHub));
KeReleaseSemaphore(&deviceExtensionHub->HubMutex,
LOW_REALTIME_PRIORITY,
1,
FALSE);
USBH_DEC_PENDING_IO_COUNT(deviceExtensionHub);
USBH_PdoIoctlResetPortExit:
// Must do this before completing the IRP because client driver may want
// to post URB transfers in the completion routine. These transfers will
// fail if this flag is still set.
DeviceExtensionPort->PortPdoFlags &= ~PORTPDO_RESET_PENDING;
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
VOID
USBH_InternalCyclePort(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN USHORT PortNumber,
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort
)
/*
* Description:
*
* "Cycles" the requested port, i.e. causes PnP REMOVE and reenumeration
* of the device.
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
PPORT_DATA portData;
PWCHAR sernumbuf = NULL;
portData = &DeviceExtensionHub->PortData[PortNumber-1];
LOGENTRY(LOG_PNP, "WMIo", DeviceExtensionHub,
PortNumber,
DeviceExtensionPort);
// synchronize with QBR
USBH_KdPrint((2,"'***WAIT reset device mutex %x\n", DeviceExtensionHub));
USBH_INC_PENDING_IO_COUNT(DeviceExtensionHub);
KeWaitForSingleObject(&DeviceExtensionHub->ResetDeviceMutex,
Executive,
KernelMode,
FALSE,
NULL);
USBH_KdPrint((2,"'***WAIT reset device mutex done %x\n", DeviceExtensionHub));
{
PDEVICE_OBJECT pdo;
pdo = portData->DeviceObject;
portData->DeviceObject = NULL;
portData->ConnectionStatus = NoDeviceConnected;
if (pdo) {
// device should be present if we do this
USBH_ASSERT(PDO_EXT(pdo)->PnPFlags & PDO_PNPFLAG_DEVICE_PRESENT);
InsertTailList(&DeviceExtensionHub->DeletePdoList,
&PDO_EXT(pdo)->DeletePdoLink);
}
}
// in some overcurrent scenarios we may not have a PDO.
// this function is synchronous, so the device should have
// no tranfsers on completion
if (DeviceExtensionPort) {
USBD_RemoveDeviceEx(DeviceExtensionHub,
DeviceExtensionPort->DeviceData,
DeviceExtensionHub->RootHubPdo,
0);
DeviceExtensionPort->DeviceData = NULL;
// this prevents resets by the client
DeviceExtensionPort->PortPdoFlags |= PORTPDO_CYCLED;
// keep ref until removeal of hub OR child
//DeviceExtensionPort->DeviceExtensionHub = NULL;
// disable the port so no traffic passes to the device until reset
USBH_SyncDisablePort(DeviceExtensionHub,
DeviceExtensionPort->PortNumber);
sernumbuf = InterlockedExchangePointer(
&DeviceExtensionPort->SerialNumberBuffer,
NULL);
}
if (sernumbuf) {
UsbhExFreePool(sernumbuf);
}
USBH_KdPrint((2,"'***RELEASE reset device mutex %x\n", DeviceExtensionHub));
KeReleaseSemaphore(&DeviceExtensionHub->ResetDeviceMutex,
LOW_REALTIME_PRIORITY,
1,
FALSE);
USBH_DEC_PENDING_IO_COUNT(DeviceExtensionHub);
USBH_IoInvalidateDeviceRelations(DeviceExtensionHub->PhysicalDeviceObject,
BusRelations);
}
NTSTATUS
USBH_PdoIoctlCyclePort(
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort,
IN PIRP Irp
)
/*
* Description:
*
* driver is requesting us to reset the port to which the device
* is attached.
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PDEVICE_EXTENSION_HUB deviceExtensionHub;
USHORT portNumber;
PAGED_CODE();
USBH_KdPrint((2,"'USBH_PdoIoctlResetPort DeviceExtension %x Irp %x\n",
DeviceExtensionPort, Irp));
deviceExtensionHub = DeviceExtensionPort->DeviceExtensionHub;
portNumber = DeviceExtensionPort->PortNumber;
USBH_InternalCyclePort(deviceExtensionHub, portNumber, DeviceExtensionPort);
USBH_CompleteIrp(Irp, ntStatus);
return ntStatus;
}
#ifdef WMI_SUPPORT
NTSTATUS
USBH_BuildConnectionNotification(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN USHORT PortNumber,
IN PUSB_CONNECTION_NOTIFICATION Notification
)
/*
* Description:
*
* driver is requesting us to reset the port to which the device
* is attached.
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS, status;
USB_CONNECTION_STATUS connectStatus;
USB_HUB_NAME hubName;
PPORT_DATA portData;
PDEVICE_EXTENSION_PORT deviceExtensionPort;
portData =
&DeviceExtensionHub->PortData[PortNumber-1];
if (portData->DeviceObject &&
portData->ConnectionStatus != DeviceHubNestedTooDeeply) {
deviceExtensionPort = portData->DeviceObject->DeviceExtension;
connectStatus = UsbhGetConnectionStatus(deviceExtensionPort);
} else {
deviceExtensionPort = NULL;
connectStatus = portData->ConnectionStatus;
}
RtlZeroMemory(Notification, sizeof(*Notification));
Notification->ConnectionNumber = PortNumber;
if (IS_ROOT_HUB(DeviceExtensionHub)) {
hubName.ActualLength = sizeof(hubName) - sizeof(hubName.ActualLength);
status = USBHUB_GetRootHubName(DeviceExtensionHub,
&hubName.HubName,
&hubName.ActualLength);
} else {
status = USBH_SyncGetHubName(DeviceExtensionHub->TopOfStackDeviceObject,
&hubName,
sizeof(hubName));
}
USBH_KdPrint((1,"'Notification, hub name length = %d\n",
hubName.ActualLength));
if (NT_SUCCESS(status)) {
Notification->HubNameLength = hubName.ActualLength;
} else {
Notification->HubNameLength = 0;
}
switch(connectStatus) {
case DeviceFailedEnumeration:
// need to track some some reasons
if (deviceExtensionPort) {
Notification->EnumerationFailReason =
deviceExtensionPort->FailReasonId;
} else {
Notification->EnumerationFailReason = 0;
}
Notification->NotificationType = EnumerationFailure;
break;
case DeviceCausedOvercurrent:
Notification->NotificationType = OverCurrent;
break;
case DeviceNotEnoughPower:
Notification->NotificationType = InsufficentPower;
if (deviceExtensionPort) {
Notification->PowerRequested =
deviceExtensionPort->PowerRequested;
}
break;
case DeviceNotEnoughBandwidth:
Notification->NotificationType = InsufficentBandwidth;
if (deviceExtensionPort) {
Notification->RequestedBandwidth =
deviceExtensionPort->RequestedBandwidth;
}
break;
case DeviceHubNestedTooDeeply:
Notification->NotificationType = HubNestedTooDeeply;
break;
case DeviceInLegacyHub:
Notification->NotificationType = ModernDeviceInLegacyHub;
break;
case DeviceGeneralFailure:
default:
// nothing wrong?
ntStatus = STATUS_UNSUCCESSFUL;
}
return ntStatus;
}
#endif
NTSTATUS
USBH_PdoEvent(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN USHORT PortNumber
)
/*
* Description:
*
* Triggers a WMI event based on the current connection status of the port
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
#ifdef WMI_SUPPORT
PDEVICE_EXTENSION_PORT deviceExtensionPort;
PPORT_DATA portData;
PUSB_CONNECTION_NOTIFICATION notification;
portData =
&DeviceExtensionHub->PortData[PortNumber-1];
if (portData->DeviceObject) {
deviceExtensionPort = portData->DeviceObject->DeviceExtension;
}
USBH_KdPrint((1,"'Fire WMI Event for Port Ext %x on hub ext %x\n",
deviceExtensionPort, DeviceExtensionHub));
LOGENTRY(LOG_PNP, "WMIe", DeviceExtensionHub,
deviceExtensionPort,
0);
notification = ExAllocatePoolWithTag(PagedPool,
sizeof(USB_CONNECTION_NOTIFICATION),
USBHUB_HEAP_TAG);
if (notification) {
ntStatus = USBH_BuildConnectionNotification(
DeviceExtensionHub,
PortNumber,
notification);
if (NT_SUCCESS(ntStatus)) {
ntStatus = WmiFireEvent(
DeviceExtensionHub->FunctionalDeviceObject,
(LPGUID)&GUID_USB_WMI_STD_NOTIFICATION,
0,
sizeof(*notification),
notification);
} else {
// Since we did not call WmiFireEvent then we must free the buffer
// ourselves.
ExFreePool(notification);
}
} else {
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
}
#endif /* WMI_SUPPORT */
return ntStatus;
}
#ifdef WMI_SUPPORT
NTSTATUS
USBH_SystemControl (
IN PDEVICE_EXTENSION_FDO DeviceExtensionFdo,
IN PIRP Irp
)
/*++
Routine Description
We have just received a System Control IRP.
Assume that this is a WMI IRP and
call into the WMI system library and let it handle this IRP for us.
--*/
{
SYSCTL_IRP_DISPOSITION IrpDisposition;
NTSTATUS ntStatus = STATUS_SUCCESS;
ntStatus = WmiSystemControl(
&DeviceExtensionFdo->WmiLibInfo,
DeviceExtensionFdo->FunctionalDeviceObject,
Irp,
&IrpDisposition);
switch (IrpDisposition)
{
case IrpProcessed:
{
//
// This irp has been processed and may be completed or pending.
break;
}
case IrpNotCompleted:
{
//
// This irp has not been completed, but has been fully processed.
// we will complete it now
IoCompleteRequest(Irp, IO_NO_INCREMENT);
break;
}
case IrpForward:
case IrpNotWmi:
{
//
// This irp is either not a WMI irp or is a WMI irp targetted
// at a device lower in the stack.
ntStatus = USBH_PassIrp(Irp, DeviceExtensionFdo->TopOfStackDeviceObject);
break;
}
default:
{
//
// We really should never get here, but if we do just forward....
ASSERT(FALSE);
ntStatus = USBH_PassIrp(Irp, DeviceExtensionFdo->TopOfStackDeviceObject);
break;
}
}
return(ntStatus);
}
NTSTATUS
USBH_PortSystemControl (
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort,
IN PIRP Irp
)
/*++
Routine Description
We have just received a System Control IRP.
Assume that this is a WMI IRP and
call into the WMI system library and let it handle this IRP for us.
--*/
{
SYSCTL_IRP_DISPOSITION IrpDisposition;
NTSTATUS ntStatus = STATUS_SUCCESS;
ntStatus = WmiSystemControl(
&DeviceExtensionPort->WmiLibInfo,
DeviceExtensionPort->PortPhysicalDeviceObject,
Irp,
&IrpDisposition);
switch (IrpDisposition)
{
case IrpNotWmi:
// Don't change status of IRP we don't know about.
ntStatus = Irp->IoStatus.Status;
// fall through
case IrpNotCompleted:
case IrpForward:
default:
USBH_CompleteIrp(Irp, ntStatus);
break;
case IrpProcessed:
// Don't complete the IRP in this case.
break;
}
return(ntStatus);
}
PDEVICE_EXTENSION_PORT
USBH_GetPortPdoExtension(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN ULONG PortNumber
)
/*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
PPORT_DATA portData;
USHORT nextPortNumber;
USHORT numberOfPorts;
portData = DeviceExtensionHub->PortData;
//
// hub descriptor will be null if the hub is already stopped
//
if (portData &&
DeviceExtensionHub->HubDescriptor) {
numberOfPorts = DeviceExtensionHub->HubDescriptor->bNumberOfPorts;
for (nextPortNumber = 1;
nextPortNumber <= numberOfPorts;
nextPortNumber++, portData++) {
USBH_KdPrint((1,"'portdata %x, do %x\n", portData, portData->DeviceObject));
if (PortNumber == nextPortNumber) {
if (portData->DeviceObject)
return portData->DeviceObject->DeviceExtension;
else
return NULL;
}
}
}
return NULL;
}
VOID
USBH_CheckLeafHubsIdle(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub
)
/* ++
*
* Description:
*
* This function walks the chain of hubs downstream from the specified hub,
* and idles the leaf hubs if ready.
*
* Arguments:
*
* DeviceExtensionHub
*
* Return:
*
* NTSTATUS
*
* -- */
{
PDEVICE_EXTENSION_PORT childDeviceExtensionPort;
PDEVICE_EXTENSION_HUB childDeviceExtensionHub;
BOOLEAN bHaveChildrenHubs = FALSE;
ULONG i;
PAGED_CODE();
// Ensure that child port configuration does not change while in this
// function, i.e. don't allow QBR.
// USBH_KdPrint((2,"'***WAIT reset device mutex %x\n", DeviceExtensionHub));
// USBH_INC_PENDING_IO_COUNT(DeviceExtensionHub);
// KeWaitForSingleObject(&DeviceExtensionHub->ResetDeviceMutex,
// Executive,
// KernelMode,
// FALSE,
// NULL);
// USBH_KdPrint((2,"'***WAIT reset device mutex done %x\n", DeviceExtensionHub));
for (i = 0; i < DeviceExtensionHub->HubDescriptor->bNumberOfPorts; i++) {
if (DeviceExtensionHub->PortData[i].DeviceObject) {
childDeviceExtensionPort = DeviceExtensionHub->PortData[i].DeviceObject->DeviceExtension;
if (childDeviceExtensionPort->PortPdoFlags & PORTPDO_DEVICE_IS_HUB) {
PDRIVER_OBJECT hubDriver;
PDEVICE_OBJECT childHubPdo, childHubFdo;
// We have a child hub. This means that we are not a leaf hub.
// Indicate this and recurse down to the child hub.
bHaveChildrenHubs = TRUE;
hubDriver = DeviceExtensionHub->FunctionalDeviceObject->DriverObject;
childHubPdo = childDeviceExtensionPort->PortPhysicalDeviceObject;
do {
childHubFdo = childHubPdo->AttachedDevice;
childHubPdo = childHubFdo;
} while (childHubFdo->DriverObject != hubDriver);
childDeviceExtensionHub = childHubFdo->DeviceExtension;
USBH_CheckLeafHubsIdle(childDeviceExtensionHub);
}
}
}
// USBH_KdPrint((2,"'***RELEASE reset device mutex %x\n", DeviceExtensionHub));
// KeReleaseSemaphore(&DeviceExtensionHub->ResetDeviceMutex,
// LOW_REALTIME_PRIORITY,
// 1,
// FALSE);
//
// USBH_DEC_PENDING_IO_COUNT(DeviceExtensionHub);
if (!bHaveChildrenHubs) {
// If this hub has no children then it is a leaf hub. See if
// it is ready to be idled out.
USBH_CheckHubIdle(DeviceExtensionHub);
}
}
//
// WMI System Call back functions
//
NTSTATUS
USBH_SetWmiDataBlock(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN ULONG GuidIndex,
IN ULONG InstanceIndex,
IN ULONG BufferSize,
IN PUCHAR Buffer
)
/*++
Routine Description:
This routine is a callback into the driver to set the contents of
a data block. When the driver has finished filling the data block it
must call ClassWmiCompleteRequest to complete the irp. The driver can
return STATUS_PENDING if the irp cannot be completed immediately.
Arguments:
DeviceObject is the device whose data block is being queried
Irp is the Irp that makes this request
GuidIndex is the index into the list of guids provided when the
device registered
InstanceIndex is the index that denotes which instance of the data block
is being queried.
BufferSize has the size of the data block passed
Buffer has the new values for the data block
Return Value:
status
--*/
{
PDEVICE_EXTENSION_FDO deviceExtensionFdo;
PDEVICE_EXTENSION_HUB deviceExtensionHub;
NTSTATUS status;
ULONG size = 0;
BOOLEAN bEnableSS, bSelectiveSuspendEnabled = FALSE, globaDisableSS;
deviceExtensionFdo = (PDEVICE_EXTENSION_FDO) DeviceObject->DeviceExtension;
deviceExtensionHub = (PDEVICE_EXTENSION_HUB) DeviceObject->DeviceExtension;
switch(GuidIndex) {
case WMI_USB_DRIVER_INFORMATION:
status = /*STATUS_WMI_READ_ONLY*/STATUS_INVALID_DEVICE_REQUEST;
break;
case WMI_USB_POWER_DEVICE_ENABLE:
// We only support this for the Root Hub but this WMI request should
// only occur for the Root Hub because we only register this GUID
// for the Root Hub. We perform a sanity check anyway.
USBH_ASSERT(deviceExtensionFdo->ExtensionType == EXTENSION_TYPE_HUB);
USBH_ASSERT(IS_ROOT_HUB(deviceExtensionHub));
USBH_RegQueryUSBGlobalSelectiveSuspend(&globaDisableSS);
if (deviceExtensionFdo->ExtensionType == EXTENSION_TYPE_HUB &&
IS_ROOT_HUB(deviceExtensionHub) &&
!globaDisableSS) {
size = sizeof(BOOLEAN);
if (BufferSize < size) {
status = STATUS_BUFFER_TOO_SMALL;
} else if (0 != InstanceIndex) {
status = STATUS_INVALID_DEVICE_REQUEST;
} else {
bEnableSS = *(PBOOLEAN)Buffer;
status = USBD_QuerySelectiveSuspendEnabled(deviceExtensionHub,
&bSelectiveSuspendEnabled);
if (NT_SUCCESS(status) &&
bEnableSS != bSelectiveSuspendEnabled) {
// Update global flag and registry with new setting.
status = USBD_SetSelectiveSuspendEnabled(deviceExtensionHub,
bEnableSS);
if (NT_SUCCESS(status)) {
if (bEnableSS) {
// We are being asked to enable Selective Suspend
// when it was previously disabled.
// Find the end hubs in the chain and idle them
// out if ready. This will trickle down to
// the parent hubs if all hubs are idle.
USBH_CheckLeafHubsIdle(deviceExtensionHub);
status = STATUS_SUCCESS;
} else {
// We are being asked to disable Selective Suspend
// when it was previously enabled.
if (deviceExtensionHub->CurrentPowerState != PowerDeviceD0 &&
(deviceExtensionHub->HubFlags & HUBFLAG_NEED_CLEANUP)) {
USBH_HubSetD0(deviceExtensionHub);
} else {
USBH_HubCompletePortIdleIrps(deviceExtensionHub,
STATUS_CANCELLED);
}
status = STATUS_SUCCESS;
}
}
}
}
} else {
status = STATUS_INVALID_DEVICE_REQUEST;
}
break;
default:
status = STATUS_WMI_GUID_NOT_FOUND;
}
status = WmiCompleteRequest(DeviceObject,
Irp,
status,
0,
IO_NO_INCREMENT);
return(status);
}
NTSTATUS
USBH_QueryWmiDataBlock(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN ULONG GuidIndex,
IN ULONG InstanceIndex,
IN ULONG InstanceCount,
IN OUT PULONG InstanceLengthArray,
IN ULONG OutBufferSize,
OUT PUCHAR Buffer
)
/*++
Routine Description:
This routine is a callback into the driver to query for the contents of
a data block. When the driver has finished filling the data block it
must call ClassWmiCompleteRequest to complete the irp. The driver can
return STATUS_PENDING if the irp cannot be completed immediately.
Arguments:
DeviceObject is the device whose data block is being queried
Irp is the Irp that makes this request
GuidIndex is the index into the list of guids provided when the
device registered
InstanceIndex is the index that denotes which instance of the data block
is being queried.
InstanceCount is the number of instnaces expected to be returned for
the data block.
InstanceLengthArray is a pointer to an array of ULONG that returns the
lengths of each instance of the data block. If this is NULL then
there was not enough space in the output buffer to fufill the request
so the irp should be completed with the buffer needed.
BufferAvail on has the maximum size available to write the data
block.
Buffer on return is filled with the returned data block
Return Value:
status
--*/
{
PDEVICE_EXTENSION_FDO deviceExtensionFdo;
PUSB_NOTIFICATION notification;
NTSTATUS status;
ULONG size = 0;
PDEVICE_EXTENSION_HUB deviceExtensionHub;
BOOLEAN bSelectiveSuspendEnabled = FALSE,globaDisableSS;
deviceExtensionFdo = (PDEVICE_EXTENSION_FDO) DeviceObject->DeviceExtension;
deviceExtensionHub = (PDEVICE_EXTENSION_HUB) DeviceObject->DeviceExtension;
notification = (PUSB_NOTIFICATION) Buffer;
USBH_KdPrint((1,"'WMI Query Data Block on hub ext %x\n",
deviceExtensionHub));
switch (GuidIndex) {
case WMI_USB_DRIVER_INFORMATION:
if (InstanceLengthArray != NULL) {
*InstanceLengthArray = 0;
status = STATUS_SUCCESS;
} else {
status = STATUS_BUFFER_TOO_SMALL;
}
break;
case WMI_USB_POWER_DEVICE_ENABLE:
// We only support this for the Root Hub but this WMI request should
// only occur for the Root Hub because we only register this GUID
// for the Root Hub. We perform a sanity check anyway.
USBH_ASSERT(deviceExtensionFdo->ExtensionType == EXTENSION_TYPE_HUB);
USBH_ASSERT(IS_ROOT_HUB(deviceExtensionHub));
USBH_RegQueryUSBGlobalSelectiveSuspend(&globaDisableSS);
if (deviceExtensionFdo->ExtensionType == EXTENSION_TYPE_HUB &&
IS_ROOT_HUB(deviceExtensionHub) &&
!globaDisableSS) {
//
// Only registers 1 instance for this GUID.
//
if ((0 != InstanceIndex) || (1 != InstanceCount)) {
status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
size = sizeof(BOOLEAN);
if (OutBufferSize < size) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
status = USBD_QuerySelectiveSuspendEnabled(deviceExtensionHub,
&bSelectiveSuspendEnabled);
if (!NT_SUCCESS(status)) {
break;
}
*(PBOOLEAN)Buffer = bSelectiveSuspendEnabled;
*InstanceLengthArray = size;
status = STATUS_SUCCESS;
} else {
status = STATUS_INVALID_DEVICE_REQUEST;
}
break;
default:
status = STATUS_WMI_GUID_NOT_FOUND;
}
status = WmiCompleteRequest(DeviceObject,
Irp,
status,
size,
IO_NO_INCREMENT);
return status;
}
NTSTATUS
USBH_PortQueryWmiDataBlock(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN ULONG GuidIndex,
IN ULONG InstanceIndex,
IN ULONG InstanceCount,
IN OUT PULONG InstanceLengthArray,
IN ULONG OutBufferSize,
OUT PUCHAR Buffer
)
/*++
Routine Description:
This routine is a callback into the driver to query for the contents of
a data block. When the driver has finished filling the data block it
must call ClassWmiCompleteRequest to complete the irp. The driver can
return STATUS_PENDING if the irp cannot be completed immediately.
Arguments:
DeviceObject is the device whose data block is being queried
Irp is the Irp that makes this request
GuidIndex is the index into the list of guids provided when the
device registered
InstanceIndex is the index that denotes which instance of the data block
is being queried.
InstanceCount is the number of instnaces expected to be returned for
the data block.
InstanceLengthArray is a pointer to an array of ULONG that returns the
lengths of each instance of the data block. If this is NULL then
there was not enough space in the output buffer to fufill the request
so the irp should be completed with the buffer needed.
BufferAvail on has the maximum size available to write the data
block.
Buffer on return is filled with the returned data block
Return Value:
status
--*/
{
PDEVICE_EXTENSION_PORT deviceExtensionPort;
PUSB_DEVICE_UI_FIRMWARE_REVISION fwRevBuf;
NTSTATUS status;
ULONG size = 0;
PWCHAR revstr;
USHORT bcdDevice;
USHORT stringsize;
deviceExtensionPort = (PDEVICE_EXTENSION_PORT) DeviceObject->DeviceExtension;
USBH_KdPrint((1,"'WMI Query Data Block on PORT PDO ext %x\n",
deviceExtensionPort));
switch (GuidIndex) {
case 0:
// Return USB device FW revision # in the following format "xx.xx".
// Need buffer large enough for this string plus NULL terminator.
stringsize = 6 * sizeof(WCHAR);
size = sizeof(USB_DEVICE_UI_FIRMWARE_REVISION) + (ULONG)stringsize;
if (OutBufferSize < size) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
bcdDevice = deviceExtensionPort->DeviceDescriptor.bcdDevice;
fwRevBuf = (PUSB_DEVICE_UI_FIRMWARE_REVISION)Buffer;
revstr = &fwRevBuf->FirmwareRevisionString[0];
*revstr = BcdNibbleToAscii(bcdDevice >> 12);
*(revstr+1) = BcdNibbleToAscii((bcdDevice >> 8) & 0x000f);
*(revstr+2) = '.';
*(revstr+3) = BcdNibbleToAscii((bcdDevice >> 4) & 0x000f);
*(revstr+4) = BcdNibbleToAscii(bcdDevice & 0x000f);
*(revstr+5) = 0;
fwRevBuf->Length = stringsize;
*InstanceLengthArray = size;
status = STATUS_SUCCESS;
USBH_KdPrint((1,"'WMI Query Data Block, returning FW rev # '%ws'\n",
revstr));
break;
default:
status = STATUS_WMI_GUID_NOT_FOUND;
}
status = WmiCompleteRequest(DeviceObject,
Irp,
status,
size,
IO_NO_INCREMENT);
return status;
}
NTSTATUS
USBH_ExecuteWmiMethod(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN ULONG GuidIndex,
IN ULONG InstanceIndex,
IN ULONG MethodId,
IN ULONG InBufferSize,
IN ULONG OutBufferSize,
IN OUT PUCHAR Buffer
)
/*++
Routine Description:
This routine is a callback into the driver to execute a method. When the
driver has finished filling the data block it must call
WmiCompleteRequest to complete the irp. The driver can
return STATUS_PENDING if the irp cannot be completed immediately.
Arguments:
DeviceObject is the device whose data block is being queried
Irp is the Irp that makes this request
GuidIndex is the index into the list of guids provided when the
device registered
InstanceIndex is the index that denotes which instance of the data block
is being called.
MethodId has the id of the method being called
InBufferSize has the size of the data block passed in as the input to
the method.
OutBufferSize on entry has the maximum size available to write the
returned data block.
Buffer on entry has the input data block and on return has the output
output data block.
Return Value:
status
--*/
{
PDEVICE_EXTENSION_FDO deviceExtensionFdo;
PUSB_NOTIFICATION notification;
NTSTATUS ntStatus = STATUS_WMI_GUID_NOT_FOUND;
ULONG size = 0;
PDEVICE_EXTENSION_HUB deviceExtensionHub;
PDEVICE_EXTENSION_PORT portPdoExt;
BOOLEAN bDoCheckHubIdle = FALSE;
deviceExtensionFdo = (PDEVICE_EXTENSION_FDO) DeviceObject->DeviceExtension;
if (deviceExtensionFdo->ExtensionType == EXTENSION_TYPE_PARENT) {
// Looks like a child PDO of a composite device is causing the problem.
// Let's be sure to get the correct device extension for the hub.
portPdoExt = deviceExtensionFdo->PhysicalDeviceObject->DeviceExtension;
deviceExtensionHub = portPdoExt->DeviceExtensionHub;
} else {
deviceExtensionHub = (PDEVICE_EXTENSION_HUB) DeviceObject->DeviceExtension;
}
USBH_ASSERT(EXTENSION_TYPE_HUB == deviceExtensionHub->ExtensionType);
// If this hub is currently Selective Suspended, then we need to
// power up the hub first before sending any requests along to it.
// Make sure hub has been started, though.
if (deviceExtensionHub->CurrentPowerState != PowerDeviceD0 &&
(deviceExtensionHub->HubFlags & HUBFLAG_NEED_CLEANUP)) {
bDoCheckHubIdle = TRUE;
USBH_HubSetD0(deviceExtensionHub);
}
notification = (PUSB_NOTIFICATION) Buffer;
USBH_KdPrint((1,"'WMI Execute Method on hub ext %x\n",
deviceExtensionHub));
switch (GuidIndex) {
case WMI_USB_DRIVER_INFORMATION:
size = sizeof(*notification);
if (OutBufferSize < size) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
// switch(MethodId) {
switch (notification->NotificationType) {
case EnumerationFailure:
{
PUSB_CONNECTION_NOTIFICATION connectionNotification;
USBH_KdPrint((1,"'Method EnumerationFailure %x\n"));
connectionNotification = (PUSB_CONNECTION_NOTIFICATION) Buffer;
size = sizeof(*connectionNotification);
if (OutBufferSize < size) {
USBH_KdPrint((1,"'pwr - buff too small\n"));
ntStatus = STATUS_BUFFER_TOO_SMALL;
} else {
portPdoExt =
USBH_GetPortPdoExtension(deviceExtensionHub,
connectionNotification->ConnectionNumber);
if (portPdoExt) {
connectionNotification->EnumerationFailReason =
portPdoExt->FailReasonId;
ntStatus = STATUS_SUCCESS;
} else {
USBH_KdPrint((1,"'ef - bad connection index\n"));
ntStatus = STATUS_INVALID_PARAMETER;
}
}
}
break;
case InsufficentBandwidth:
{
PUSB_CONNECTION_NOTIFICATION connectionNotification;
USBH_KdPrint((1,"'Method InsufficentBandwidth\n"));
connectionNotification = (PUSB_CONNECTION_NOTIFICATION) Buffer;
size = sizeof(*connectionNotification);
if (OutBufferSize < size) {
USBH_KdPrint((1,"'pwr - buff too small\n"));
ntStatus = STATUS_BUFFER_TOO_SMALL;
} else {
portPdoExt =
USBH_GetPortPdoExtension(deviceExtensionHub,
connectionNotification->ConnectionNumber);
if (portPdoExt) {
connectionNotification->RequestedBandwidth =
portPdoExt->RequestedBandwidth;
ntStatus = STATUS_SUCCESS;
} else {
USBH_KdPrint((1,"'bw - bad connection index\n"));
ntStatus = STATUS_INVALID_PARAMETER;
}
}
}
break;
case OverCurrent:
// nothing to do here
USBH_KdPrint((1,"'Method OverCurrent\n"));
ntStatus = STATUS_SUCCESS;
size = 0;
break;
case InsufficentPower:
{
PUSB_CONNECTION_NOTIFICATION connectionNotification;
USBH_KdPrint((1,"'Method InsufficentPower\n"));
size = sizeof(*connectionNotification);
if (OutBufferSize < size) {
USBH_KdPrint((1,"'pwr - buff too small\n"));
ntStatus = STATUS_BUFFER_TOO_SMALL;
} else {
connectionNotification = (PUSB_CONNECTION_NOTIFICATION) Buffer;
USBH_KdPrint((1,"'pwr - connection %d\n",
connectionNotification->ConnectionNumber));
if (connectionNotification->ConnectionNumber) {
if (portPdoExt = USBH_GetPortPdoExtension(deviceExtensionHub,
connectionNotification->ConnectionNumber)) {
connectionNotification->PowerRequested =
portPdoExt->PowerRequested;
ntStatus = STATUS_SUCCESS;
}
} else {
USBH_KdPrint((1,"'pwr - bad connection index\n"));
ntStatus = STATUS_INVALID_PARAMETER;
}
}
}
break;
case ResetOvercurrent:
{
PUSB_CONNECTION_NOTIFICATION connectionNotification;
USBH_KdPrint((1,"'Method ResetOvercurrent\n"));
size = sizeof(*connectionNotification);
if (OutBufferSize < size) {
USBH_KdPrint((1,"'reset - buff too small\n"));
ntStatus = STATUS_BUFFER_TOO_SMALL;
} else {
connectionNotification = (PUSB_CONNECTION_NOTIFICATION) Buffer;
if (connectionNotification->ConnectionNumber) {
USBH_KdPrint((1,"'reset - port %d\n", connectionNotification->ConnectionNumber));
portPdoExt = USBH_GetPortPdoExtension(deviceExtensionHub,
connectionNotification->ConnectionNumber);
ntStatus = USBH_ResetPortOvercurrent(deviceExtensionHub,
(USHORT)connectionNotification->ConnectionNumber,
portPdoExt);
// } else {
// // bad connection index
// USBH_KdPrint((1,"'reset - bad connection index\n"));
// ntStatus = STATUS_INVALID_PARAMETER;
// }
} else {
// this is a reset for the whole hub
USBH_KdPrint((1,"'not implemented yet\n"));
TEST_TRAP();
ntStatus = STATUS_NOT_IMPLEMENTED;
}
}
}
break;
case AcquireBusInfo:
{
PUSB_BUS_NOTIFICATION busNotification;
USBH_KdPrint((1,"'Method AcquireBusInfo\n"));
size = sizeof(*busNotification);
if (OutBufferSize < size) {
USBH_KdPrint((1,"'AcquireBusInfo - buff too small\n"));
ntStatus = STATUS_BUFFER_TOO_SMALL;
} else {
busNotification = (PUSB_BUS_NOTIFICATION) Buffer;
// ntStatus = USBH_SyncGetControllerInfo(
// deviceExtensionHub->TopOfStackDeviceObject,
// busNotification,
// sizeof(*busNotification),
// IOCTL_INTERNAL_USB_GET_BUS_INFO);
ntStatus = USBHUB_GetBusInfo(deviceExtensionHub,
busNotification,
NULL);
USBH_KdPrint((1,"'Notification, controller name length = %d\n",
busNotification->ControllerNameLength));
}
}
break;
case AcquireHubName:
/*+
we utilize the fact that these structures have some
elements in common
USB_HUB_NAME USB_ACQUIRE_INFO
------------ ----------------
USB_NOTIFICATION_TYPE NotificationType;
ULONG ActualLength; ULONG TotalSize;
WCHAR HubName[1]; WCHAR Buffer[1];
USB_NOTIFICATION_TYPE NotificationType;
+*/
{
PUSB_HUB_NAME hubName;
PUSB_ACQUIRE_INFO acquireInfo;
USBH_KdPrint((1,"'Method AcquireHubName\n"));
size = sizeof(USB_ACQUIRE_INFO);
acquireInfo = (PUSB_ACQUIRE_INFO) Buffer;
if (OutBufferSize < size ||
acquireInfo->TotalSize < size) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
// return the samller of the two as the output length so we don't
// copy more than necessary
size = acquireInfo->TotalSize > OutBufferSize ? OutBufferSize : acquireInfo->TotalSize;
hubName = (PUSB_HUB_NAME) &acquireInfo->TotalSize;
// TotalSize contains the size of the notification type as well
// comsume notification type field
hubName->ActualLength -= sizeof(USB_NOTIFICATION_TYPE);
OutBufferSize -= sizeof(USB_NOTIFICATION_TYPE);
// As long as ActualLength is less than the true output buffer
// length we are safe
if (hubName->ActualLength > OutBufferSize) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
if (IS_ROOT_HUB(deviceExtensionHub)) {
// consume the length field
hubName->ActualLength -= sizeof(hubName->ActualLength);
// this will set HubName to the name plus set the
// actual length field to the true length of the name
// the API needs to return the length of the entire hubname
// structure
ntStatus = USBHUB_GetRootHubName(deviceExtensionHub,
hubName->HubName,
&hubName->ActualLength);
// ActualLength is the length of the entire structure
hubName->ActualLength += sizeof(hubName->ActualLength);
} else {
// passes the hubname strucutre down, ActualLength is the
// length of the entire structure
ntStatus = USBH_SyncGetHubName(
deviceExtensionHub->TopOfStackDeviceObject,
hubName,
hubName->ActualLength);
}
// readjust to previous value
hubName->ActualLength += sizeof(USB_NOTIFICATION_TYPE);
OutBufferSize += sizeof(USB_NOTIFICATION_TYPE);
}
break;
case AcquireControllerName:
/*+
we utilize the fact that these structures have some
elements in common
USB_HUB_NAME USB_ACQUIRE_INFO
------------ ----------------
USB_NOTIFICATION_TYPE NotificationType;
ULONG ActualLength; ULONG TotalSize;
WCHAR HubName[1]; WCHAR Buffer[1];
USB_NOTIFICATION_TYPE NotificationType;
+*/
{
PUSB_HUB_NAME controllerName;
PUSB_ACQUIRE_INFO acquireInfo;
USBH_KdPrint((1,"'Method AcquireControllerName\n"));
size = sizeof(USB_ACQUIRE_INFO);
acquireInfo = (PUSB_ACQUIRE_INFO) Buffer;
if (OutBufferSize < size ||
acquireInfo->TotalSize < size) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
USBH_KdPrint((1,"'TotalSize %d\n", acquireInfo->TotalSize));
USBH_KdPrint((1,"'NotificationType %x\n", acquireInfo->NotificationType));
// use the smaller of the two specified values for the copy
// back to user mode
size = acquireInfo->TotalSize > OutBufferSize ? OutBufferSize : acquireInfo->TotalSize;
controllerName = (PUSB_HUB_NAME) &acquireInfo->TotalSize;
// TotalSize contains the size of the notification type as well
// consume USB_NOTIFICATION_TYPE
controllerName->ActualLength -= sizeof(USB_NOTIFICATION_TYPE);
OutBufferSize -= sizeof(USB_NOTIFICATION_TYPE);
if (controllerName->ActualLength > OutBufferSize) {
ntStatus = STATUS_BUFFER_TOO_SMALL;
break;
}
ntStatus = USBHUB_GetControllerName(deviceExtensionHub,
controllerName,
controllerName->ActualLength);
// readjust to previous value
controllerName->ActualLength += sizeof(USB_NOTIFICATION_TYPE);
OutBufferSize += sizeof(USB_NOTIFICATION_TYPE);
USBH_KdPrint((1,"'Method AcquireControllerName %x - %d\n",
acquireInfo, controllerName->ActualLength));
}
break;
case HubOvercurrent:
USBH_KdPrint((1,"'Method HubOvercurrent\n"));
USBH_KdPrint((1,"'not implemented yet\n"));
ntStatus = STATUS_SUCCESS;
size = 0;
break;
case HubPowerChange:
USBH_KdPrint((1,"'Method HubPowerChange\n"));
USBH_KdPrint((1,"'not implemented yet\n"));
ntStatus = STATUS_SUCCESS;
size = 0;
break;
case HubNestedTooDeeply:
// nothing to do here
USBH_KdPrint((1,"'Method HubNestedTooDeeply\n"));
ntStatus = STATUS_SUCCESS;
size = 0;
break;
case ModernDeviceInLegacyHub:
// nothing to do here
USBH_KdPrint((1,"'Method ModernDeviceInLegacyHub\n"));
ntStatus = STATUS_SUCCESS;
size = 0;
break;
}
break;
default:
ntStatus = STATUS_WMI_GUID_NOT_FOUND;
}
ntStatus = WmiCompleteRequest(DeviceObject,
Irp,
ntStatus,
size,
IO_NO_INCREMENT);
if (bDoCheckHubIdle) {
USBH_CheckHubIdle(deviceExtensionHub);
}
return ntStatus;
}
NTSTATUS
USBH_QueryWmiRegInfo(
IN PDEVICE_OBJECT DeviceObject,
OUT PULONG RegFlags,
OUT PUNICODE_STRING InstanceName,
OUT PUNICODE_STRING *RegistryPath,
OUT PUNICODE_STRING MofResourceName,
OUT PDEVICE_OBJECT *Pdo
)
/*++
Routine Description:
This routine is a callback into the driver to retrieve information about
the guids being registered.
Implementations of this routine may be in paged memory
Arguments:
DeviceObject is the device whose registration information is needed
*RegFlags returns with a set of flags that describe all of the guids being
registered for this device. If the device wants enable and disable
collection callbacks before receiving queries for the registered
guids then it should return the WMIREG_FLAG_EXPENSIVE flag. Also the
returned flags may specify WMIREG_FLAG_INSTANCE_PDO in which case
the instance name is determined from the PDO associated with the
device object. Note that the PDO must have an associated devnode. If
WMIREG_FLAG_INSTANCE_PDO is not set then Name must return a unique
name for the device. These flags are ORed into the flags specified
by the GUIDREGINFO for each guid.
InstanceName returns with the instance name for the guids if
WMIREG_FLAG_INSTANCE_PDO is not set in the returned *RegFlags. The
caller will call ExFreePool with the buffer returned.
*RegistryPath returns with the registry path of the driver. This is
required
MofResourceName returns with the name of the MOF resource attached to
the binary file. If the driver does not have a mof resource attached
then this can be returned unmodified. If a value is returned then
it is NOT freed.
*Pdo returns with the device object for the PDO associated with this
device if the WMIREG_FLAG_INSTANCE_PDO flag is returned in
*RegFlags.
Return Value:
status
--*/
{
PDEVICE_EXTENSION_HUB deviceExtensionHub; // pointer to our device
// extension
deviceExtensionHub = (PDEVICE_EXTENSION_HUB) DeviceObject->DeviceExtension;
*RegFlags = WMIREG_FLAG_INSTANCE_PDO;
*RegistryPath = &UsbhRegistryPath;
*Pdo = deviceExtensionHub->PhysicalDeviceObject;
return STATUS_SUCCESS;
}
NTSTATUS
USBH_PortQueryWmiRegInfo(
IN PDEVICE_OBJECT DeviceObject,
OUT PULONG RegFlags,
OUT PUNICODE_STRING InstanceName,
OUT PUNICODE_STRING *RegistryPath,
OUT PUNICODE_STRING MofResourceName,
OUT PDEVICE_OBJECT *Pdo
)
/*++
Routine Description:
This routine is a callback into the driver to retrieve information about
the guids being registered.
Implementations of this routine may be in paged memory
Arguments:
DeviceObject is the device whose registration information is needed
*RegFlags returns with a set of flags that describe all of the guids being
registered for this device. If the device wants enable and disable
collection callbacks before receiving queries for the registered
guids then it should return the WMIREG_FLAG_EXPENSIVE flag. Also the
returned flags may specify WMIREG_FLAG_INSTANCE_PDO in which case
the instance name is determined from the PDO associated with the
device object. Note that the PDO must have an associated devnode. If
WMIREG_FLAG_INSTANCE_PDO is not set then Name must return a unique
name for the device. These flags are ORed into the flags specified
by the GUIDREGINFO for each guid.
InstanceName returns with the instance name for the guids if
WMIREG_FLAG_INSTANCE_PDO is not set in the returned *RegFlags. The
caller will call ExFreePool with the buffer returned.
*RegistryPath returns with the registry path of the driver. This is
required
MofResourceName returns with the name of the MOF resource attached to
the binary file. If the driver does not have a mof resource attached
then this can be returned unmodified. If a value is returned then
it is NOT freed.
*Pdo returns with the device object for the PDO associated with this
device if the WMIREG_FLAG_INSTANCE_PDO flag is returned in
*RegFlags.
Return Value:
status
--*/
{
PDEVICE_EXTENSION_PORT deviceExtensionPort;
deviceExtensionPort = (PDEVICE_EXTENSION_PORT) DeviceObject->DeviceExtension;
*RegFlags = WMIREG_FLAG_INSTANCE_PDO;
*RegistryPath = &UsbhRegistryPath;
*Pdo = deviceExtensionPort->PortPhysicalDeviceObject;
return STATUS_SUCCESS;
}
#endif /* WMI_SUPPORT */
NTSTATUS
USBH_ResetPortOvercurrent(
IN PDEVICE_EXTENSION_HUB DeviceExtensionHub,
IN USHORT PortNumber,
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort
)
/*
* Description:
*
* Reset the overcurrent condition for a port
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS, status;
PORT_STATE portState;
USBH_KdPrint((0,"'Reset Overcurrent for port %d\n", PortNumber));
// we will need to re-enable and re-power the port
ntStatus = USBH_SyncGetPortStatus(DeviceExtensionHub,
PortNumber,
(PUCHAR) &portState,
sizeof(portState));
//
// port should be powered off at this point
//
LOGENTRY(LOG_PNP, "RPOv", DeviceExtensionHub,
portState.PortStatus,
portState.PortChange);
if (NT_SUCCESS(ntStatus)) {
if (portState.PortStatus & PORT_STATUS_POWER) {
ntStatus = STATUS_INVALID_PARAMETER;
} else {
if (DeviceExtensionPort) {
// clear overcurrent Flags
DeviceExtensionPort->PortPdoFlags &= ~PORTPDO_OVERCURRENT;
}
// power up the port
ntStatus = USBH_SyncPowerOnPort(DeviceExtensionHub,
PortNumber,
TRUE);
USBH_InternalCyclePort(DeviceExtensionHub, PortNumber, DeviceExtensionPort);
}
}
return ntStatus;
}
NTSTATUS
USBH_CalculateInterfaceBandwidth(
IN PDEVICE_EXTENSION_PORT DeviceExtensionPort,
IN PUSBD_INTERFACE_INFORMATION Interface,
IN OUT PULONG Bandwidth // in kenr units?
)
/*
* Description:
*
* Arguments:
*
* Return:
*
* NTSTATUS
*
* -- */
{
NTSTATUS ntStatus = STATUS_SUCCESS;
ULONG i, bw;
// we'll need to walk through the interface
// and figure out how much BW it requires
for (i=0; i<Interface->NumberOfPipes; i++) {
//#ifdef USB2
// bw = USBD_CalculateUsbBandwidthEx(
// (ULONG) Interface->Pipes[i].MaximumPacketSize,
// (UCHAR) Interface->Pipes[i].PipeType,
// (BOOLEAN) (DeviceExtensionPort->PortPdoFlags &
// PORTPDO_LOW_SPEED_DEVICE));
//#else
bw = USBD_CalculateUsbBandwidth(
(ULONG) Interface->Pipes[i].MaximumPacketSize,
(UCHAR) Interface->Pipes[i].PipeType,
(BOOLEAN) (DeviceExtensionPort->PortPdoFlags &
PORTPDO_LOW_SPEED_DEVICE));
//#endif
USBH_KdPrint((1,"'ept = %d packetsize = %d bw = %d\n",
Interface->Pipes[i].PipeType,
Interface->Pipes[i].MaximumPacketSize, bw));
*Bandwidth += bw;
}
return ntStatus;
}