ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

hidclass.sys: Create separate parent FDO and child PDO objects. 

Signed-off-by: Zebediah Figura <z.figura12@gmail.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Zebediah Figura 2021-04-15 21:04:01 -05:00 committed by Alexandre Julliard
parent 902696de93
commit f34b735eba
4 changed files with 377 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

237
dlls/hidclass.sys/device.c
View File

@ -37,37 +37,6 @@
WINE_DEFAULT_DEBUG_CHANNEL(hid);
WINE_DECLARE_DEBUG_CHANNEL(hid_report);
NTSTATUS HID_CreateDevice(DEVICE_OBJECT *native_device, HID_MINIDRIVER_REGISTRATION *driver, DEVICE_OBJECT **device)
{
WCHAR dev_name[255];
UNICODE_STRING nameW;
NTSTATUS status;
BASE_DEVICE_EXTENSION *ext;
swprintf(dev_name, ARRAY_SIZE(dev_name), L"\\Device\\HID#%p&%p", driver->DriverObject, native_device);
RtlInitUnicodeString( &nameW, dev_name );
TRACE("Create base hid device %s\n", debugstr_w(dev_name));
status = IoCreateDevice(driver->DriverObject, driver->DeviceExtensionSize + sizeof(BASE_DEVICE_EXTENSION), &nameW, 0, 0, FALSE, device);
if (status)
{
FIXME( "failed to create device error %x\n", status );
return status;
}
ext = (*device)->DeviceExtension;
ext->deviceExtension.MiniDeviceExtension = ext + 1;
ext->deviceExtension.PhysicalDeviceObject = *device;
ext->deviceExtension.NextDeviceObject = native_device;
ext->link_name.Buffer = NULL;
IoAttachDeviceToDeviceStack(*device, native_device);
return STATUS_SUCCESS;
}
/* user32 reserves 1 & 2 for winemouse and winekeyboard,
* keep this in sync with user_private.h */
#define WINE_MOUSE_HANDLE 1
@ -83,11 +52,13 @@ NTSTATUS HID_LinkDevice(DEVICE_OBJECT *device)
{
WCHAR device_instance_id[MAX_DEVICE_ID_LEN];
SP_DEVINFO_DATA Data;
NTSTATUS status;
HDEVINFO devinfo;
BASE_DEVICE_EXTENSION *ext;
USAGE usage, page;
ext = device->DeviceExtension;
page = ext->u.pdo.preparsed_data->caps.UsagePage;
usage = ext->u.pdo.preparsed_data->caps.Usage;
lstrcpyW(device_instance_id, ext->device_id);
lstrcatW(device_instance_id, L"\\");
@ -115,26 +86,12 @@ NTSTATUS HID_LinkDevice(DEVICE_OBJECT *device)
}
SetupDiDestroyDeviceInfoList(devinfo);
status = IoRegisterDeviceInterface(device, &GUID_DEVINTERFACE_HID, NULL, &ext->link_name);
if (status != STATUS_SUCCESS)
{
FIXME( "failed to register device interface %x\n", status );
return status;
}
/* FIXME: This should probably be done in mouhid.sys. */
if (ext->preparseData->caps.UsagePage == HID_USAGE_PAGE_GENERIC
&& ext->preparseData->caps.Usage == HID_USAGE_GENERIC_MOUSE)
{
if (!IoRegisterDeviceInterface(device, &GUID_DEVINTERFACE_MOUSE, NULL, &ext->mouse_link_name))
ext->is_mouse = TRUE;
ext->rawinput_handle = WINE_MOUSE_HANDLE;
}
else if (ext->preparseData->caps.UsagePage == HID_USAGE_PAGE_GENERIC
&& ext->preparseData->caps.Usage == HID_USAGE_GENERIC_KEYBOARD)
ext->rawinput_handle = WINE_KEYBOARD_HANDLE;
if (page == HID_USAGE_PAGE_GENERIC && usage == HID_USAGE_GENERIC_MOUSE)
ext->u.pdo.rawinput_handle = WINE_MOUSE_HANDLE;
else if (page == HID_USAGE_PAGE_GENERIC && usage == HID_USAGE_GENERIC_KEYBOARD)
ext->u.pdo.rawinput_handle = WINE_KEYBOARD_HANDLE;
else
ext->rawinput_handle = alloc_rawinput_handle();
ext->u.pdo.rawinput_handle = alloc_rawinput_handle();
return STATUS_SUCCESS;
@ -143,15 +100,15 @@ error:
return STATUS_UNSUCCESSFUL;
}
static IRP *pop_irp_from_queue(BASE_DEVICE_EXTENSION *ext)
IRP *pop_irp_from_queue(BASE_DEVICE_EXTENSION *ext)
{
LIST_ENTRY *entry;
KIRQL old_irql;
IRP *irp = NULL;
KeAcquireSpinLock(&ext->irp_queue_lock, &old_irql);
KeAcquireSpinLock(&ext->u.pdo.irp_queue_lock, &old_irql);
while (!irp && (entry = RemoveHeadList(&ext->irp_queue)) != &ext->irp_queue)
while (!irp && (entry = RemoveHeadList(&ext->u.pdo.irp_queue)) != &ext->u.pdo.irp_queue)
{
irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.s.ListEntry);
if (!IoSetCancelRoutine(irp, NULL))
@ -162,7 +119,7 @@ static IRP *pop_irp_from_queue(BASE_DEVICE_EXTENSION *ext)
}
}
KeReleaseSpinLock(&ext->irp_queue_lock, old_irql);
KeReleaseSpinLock(&ext->u.pdo.irp_queue_lock, old_irql);
return irp;
}
@ -177,47 +134,17 @@ static void WINAPI read_cancel_routine(DEVICE_OBJECT *device, IRP *irp)
IoReleaseCancelSpinLock(irp->CancelIrql);
KeAcquireSpinLock(&ext->irp_queue_lock, &old_irql);
KeAcquireSpinLock(&ext->u.pdo.irp_queue_lock, &old_irql);
RemoveEntryList(&irp->Tail.Overlay.s.ListEntry);
KeReleaseSpinLock(&ext->irp_queue_lock, old_irql);
KeReleaseSpinLock(&ext->u.pdo.irp_queue_lock, old_irql);
irp->IoStatus.u.Status = STATUS_CANCELLED;
irp->IoStatus.Information = 0;
IoCompleteRequest(irp, IO_NO_INCREMENT);
}
void HID_DeleteDevice(DEVICE_OBJECT *device)
{
BASE_DEVICE_EXTENSION *ext;
IRP *irp;
ext = device->DeviceExtension;
if (ext->thread)
{
SetEvent(ext->halt_event);
WaitForSingleObject(ext->thread, INFINITE);
}
CloseHandle(ext->halt_event);
HeapFree(GetProcessHeap(), 0, ext->preparseData);
if (ext->ring_buffer)
RingBuffer_Destroy(ext->ring_buffer);
while((irp = pop_irp_from_queue(ext)))
{
irp->IoStatus.u.Status = STATUS_DEVICE_REMOVED;
IoCompleteRequest(irp, IO_NO_INCREMENT);
}
RtlFreeUnicodeString(&ext->link_name);
IoDetachDevice(ext->deviceExtension.NextDeviceObject);
IoDeleteDevice(device);
}
static NTSTATUS copy_packet_into_buffer(HID_XFER_PACKET *packet, BYTE* buffer, ULONG buffer_length, ULONG *out_length)
{
BOOL zero_id = (packet->reportId == 0);
@ -248,7 +175,7 @@ static void HID_Device_processQueue(DEVICE_OBJECT *device)
{
IRP *irp;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
UINT buffer_size = RingBuffer_GetBufferSize(ext->ring_buffer);
UINT buffer_size = RingBuffer_GetBufferSize(ext->u.pdo.ring_buffer);
HID_XFER_PACKET *packet;
packet = HeapAlloc(GetProcessHeap(), 0, buffer_size);
@ -258,7 +185,7 @@ static void HID_Device_processQueue(DEVICE_OBJECT *device)
int ptr;
ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
RingBuffer_Read(ext->ring_buffer, ptr, packet, &buffer_size);
RingBuffer_Read(ext->u.pdo.ring_buffer, ptr, packet, &buffer_size);
if (buffer_size)
{
NTSTATUS rc;
@ -290,11 +217,12 @@ static DWORD CALLBACK hid_device_thread(void *args)
DWORD rc;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
USHORT report_size = ext->u.pdo.preparsed_data->caps.InputReportByteLength;
packet = HeapAlloc(GetProcessHeap(), 0, sizeof(*packet) + ext->preparseData->caps.InputReportByteLength);
packet = HeapAlloc(GetProcessHeap(), 0, sizeof(*packet) + report_size);
packet->reportBuffer = (BYTE *)packet + sizeof(*packet);
if (ext->information.Polled)
if (ext->u.pdo.information.Polled)
{
while(1)
{
@ -302,22 +230,23 @@ static DWORD CALLBACK hid_device_thread(void *args)
KeInitializeEvent(&event, NotificationEvent, FALSE);
packet->reportBufferLen = ext->preparseData->caps.InputReportByteLength;
packet->reportBufferLen = report_size;
packet->reportId = 0;
irp = IoBuildDeviceIoControlRequest(IOCTL_HID_GET_INPUT_REPORT, device,
irp = IoBuildDeviceIoControlRequest(IOCTL_HID_GET_INPUT_REPORT, ext->u.pdo.parent_fdo,
NULL, 0, packet, sizeof(*packet), TRUE, &event, &irp_status);
if (IoCallDriver(device, irp) == STATUS_PENDING)
if (IoCallDriver(ext->u.pdo.parent_fdo, irp) == STATUS_PENDING)
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
if (irp_status.u.Status == STATUS_SUCCESS)
{
RingBuffer_Write(ext->ring_buffer, packet);
RingBuffer_Write(ext->u.pdo.ring_buffer, packet);
HID_Device_processQueue(device);
}
rc = WaitForSingleObject(ext->halt_event, ext->poll_interval ? ext->poll_interval : DEFAULT_POLL_INTERVAL);
rc = WaitForSingleObject(ext->u.pdo.halt_event,
ext->u.pdo.poll_interval ? ext->u.pdo.poll_interval : DEFAULT_POLL_INTERVAL);
if (rc == WAIT_OBJECT_0)
break;
@ -335,24 +264,24 @@ static DWORD CALLBACK hid_device_thread(void *args)
KeInitializeEvent(&event, NotificationEvent, FALSE);
irp = IoBuildDeviceIoControlRequest(IOCTL_HID_READ_REPORT, device, NULL, 0, packet->reportBuffer,
ext->preparseData->caps.InputReportByteLength, TRUE, &event, &irp_status);
irp = IoBuildDeviceIoControlRequest(IOCTL_HID_READ_REPORT, ext->u.pdo.parent_fdo,
NULL, 0, packet->reportBuffer, report_size, TRUE, &event, &irp_status);
if (IoCallDriver(device, irp) == STATUS_PENDING)
if (IoCallDriver(ext->u.pdo.parent_fdo, irp) == STATUS_PENDING)
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
rc = WaitForSingleObject(ext->halt_event, 0);
rc = WaitForSingleObject(ext->u.pdo.halt_event, 0);
if (rc == WAIT_OBJECT_0)
exit_now = TRUE;
if (!exit_now && irp_status.u.Status == STATUS_SUCCESS)
{
packet->reportBufferLen = irp_status.Information;
if (ext->preparseData->reports[0].reportID)
if (ext->u.pdo.preparsed_data->reports[0].reportID)
packet->reportId = packet->reportBuffer[0];
else
packet->reportId = 0;
RingBuffer_Write(ext->ring_buffer, packet);
RingBuffer_Write(ext->u.pdo.ring_buffer, packet);
HID_Device_processQueue(device);
}
@ -368,11 +297,11 @@ static DWORD CALLBACK hid_device_thread(void *args)
void HID_StartDeviceThread(DEVICE_OBJECT *device)
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
ext->halt_event = CreateEventA(NULL, TRUE, FALSE, NULL);
ext->thread = CreateThread(NULL, 0, hid_device_thread, device, 0, NULL);
ext->u.pdo.halt_event = CreateEventA(NULL, TRUE, FALSE, NULL);
ext->u.pdo.thread = CreateThread(NULL, 0, hid_device_thread, device, 0, NULL);
}
static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_INFORMATION(IRP *irp, BASE_DEVICE_EXTENSION *base)
static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_INFORMATION(IRP *irp, BASE_DEVICE_EXTENSION *ext)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(HID_COLLECTION_INFORMATION))
@ -382,32 +311,33 @@ static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_INFORMATION(IRP *irp, BASE_DEVIC
}
else
{
memcpy(irp->AssociatedIrp.SystemBuffer, &base->information, sizeof(HID_COLLECTION_INFORMATION));
memcpy(irp->AssociatedIrp.SystemBuffer, &ext->u.pdo.information, sizeof(HID_COLLECTION_INFORMATION));
irp->IoStatus.Information = sizeof(HID_COLLECTION_INFORMATION);
irp->IoStatus.u.Status = STATUS_SUCCESS;
}
return STATUS_SUCCESS;
}
static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_DESCRIPTOR(IRP *irp, BASE_DEVICE_EXTENSION *base)
static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_DESCRIPTOR(IRP *irp, BASE_DEVICE_EXTENSION *ext)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
const WINE_HIDP_PREPARSED_DATA *data = ext->u.pdo.preparsed_data;
if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < base->preparseData->dwSize)
if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < data->dwSize)
{
irp->IoStatus.u.Status = STATUS_INVALID_BUFFER_SIZE;
irp->IoStatus.Information = 0;
}
else
{
memcpy(irp->UserBuffer, base->preparseData, base->preparseData->dwSize);
irp->IoStatus.Information = base->preparseData->dwSize;
memcpy(irp->UserBuffer, data, data->dwSize);
irp->IoStatus.Information = data->dwSize;
irp->IoStatus.u.Status = STATUS_SUCCESS;
}
return STATUS_SUCCESS;
}
static NTSTATUS handle_minidriver_string(DEVICE_OBJECT *device, IRP *irp, SHORT index)
static NTSTATUS handle_minidriver_string(BASE_DEVICE_EXTENSION *ext, IRP *irp, SHORT index)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
WCHAR buffer[127];
@ -415,7 +345,8 @@ static NTSTATUS handle_minidriver_string(DEVICE_OBJECT *device, IRP *irp, SHORT
ULONG InputBuffer;
InputBuffer = MAKELONG(index, 0);
status = call_minidriver(IOCTL_HID_GET_STRING, device, ULongToPtr(InputBuffer), sizeof(InputBuffer), buffer, sizeof(buffer));
status = call_minidriver(IOCTL_HID_GET_STRING, ext->u.pdo.parent_fdo,
ULongToPtr(InputBuffer), sizeof(InputBuffer), buffer, sizeof(buffer));
if (status == STATUS_SUCCESS)
{
@ -430,7 +361,7 @@ static NTSTATUS handle_minidriver_string(DEVICE_OBJECT *device, IRP *irp, SHORT
return STATUS_SUCCESS;
}
static NTSTATUS HID_get_feature(DEVICE_OBJECT *device, IRP *irp)
static NTSTATUS HID_get_feature(BASE_DEVICE_EXTENSION *ext, IRP *irp)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
HID_XFER_PACKET *packet;
@ -441,7 +372,7 @@ static NTSTATUS HID_get_feature(DEVICE_OBJECT *device, IRP *irp)
irp->IoStatus.Information = 0;
out_buffer = MmGetSystemAddressForMdlSafe(irp->MdlAddress, NormalPagePriority);
TRACE_(hid_report)("Device %p Buffer length %i Buffer %p\n", device, irpsp->Parameters.DeviceIoControl.OutputBufferLength, out_buffer);
TRACE_(hid_report)("Device %p Buffer length %i Buffer %p\n", ext, irpsp->Parameters.DeviceIoControl.OutputBufferLength, out_buffer);
len = sizeof(*packet) + irpsp->Parameters.DeviceIoControl.OutputBufferLength;
packet = HeapAlloc(GetProcessHeap(), 0, len);
@ -451,7 +382,7 @@ static NTSTATUS HID_get_feature(DEVICE_OBJECT *device, IRP *irp)
TRACE_(hid_report)("(id %i, len %i buffer %p)\n", packet->reportId, packet->reportBufferLen, packet->reportBuffer);
rc = call_minidriver(IOCTL_HID_GET_FEATURE, device, NULL, 0, packet, sizeof(*packet));
rc = call_minidriver(IOCTL_HID_GET_FEATURE, ext->u.pdo.parent_fdo, NULL, 0, packet, sizeof(*packet));
irp->IoStatus.u.Status = rc;
if (irp->IoStatus.u.Status == STATUS_SUCCESS)
@ -473,6 +404,7 @@ static NTSTATUS HID_set_to_device(DEVICE_OBJECT *device, IRP *irp)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
const WINE_HIDP_PREPARSED_DATA *data = ext->u.pdo.preparsed_data;
HID_XFER_PACKET packet;
ULONG max_len;
NTSTATUS rc;
@ -484,18 +416,19 @@ static NTSTATUS HID_set_to_device(DEVICE_OBJECT *device, IRP *irp)
packet.reportBuffer = &((BYTE*)irp->AssociatedIrp.SystemBuffer)[1];
packet.reportBufferLen = irpsp->Parameters.DeviceIoControl.InputBufferLength - 1;
if (irpsp->Parameters.DeviceIoControl.IoControlCode == IOCTL_HID_SET_FEATURE)
max_len = ext->preparseData->caps.FeatureReportByteLength;
max_len = data->caps.FeatureReportByteLength;
else
max_len = ext->preparseData->caps.OutputReportByteLength;
max_len = data->caps.OutputReportByteLength;
}
else
{
packet.reportBuffer = irp->AssociatedIrp.SystemBuffer;
packet.reportBufferLen = irpsp->Parameters.DeviceIoControl.InputBufferLength;
if (irpsp->Parameters.DeviceIoControl.IoControlCode == IOCTL_HID_SET_FEATURE)
max_len = (ext->preparseData->reports[ext->preparseData->reportIdx[HidP_Feature][packet.reportId]].bitSize + 7) / 8;
max_len = data->reports[data->reportIdx[HidP_Feature][packet.reportId]].bitSize;
else
max_len = (ext->preparseData->reports[ext->preparseData->reportIdx[HidP_Output][packet.reportId]].bitSize + 7) / 8;
max_len = data->reports[data->reportIdx[HidP_Output][packet.reportId]].bitSize;
max_len = (max_len + 7) / 8;
}
if (packet.reportBufferLen > max_len)
packet.reportBufferLen = max_len;
@ -503,7 +436,7 @@ static NTSTATUS HID_set_to_device(DEVICE_OBJECT *device, IRP *irp)
TRACE_(hid_report)("(id %i, len %i buffer %p)\n", packet.reportId, packet.reportBufferLen, packet.reportBuffer);
rc = call_minidriver(irpsp->Parameters.DeviceIoControl.IoControlCode,
device, NULL, 0, &packet, sizeof(packet));
ext->u.pdo.parent_fdo, NULL, 0, &packet, sizeof(packet));
irp->IoStatus.u.Status = rc;
if (irp->IoStatus.u.Status == STATUS_SUCCESS)
@ -516,11 +449,11 @@ static NTSTATUS HID_set_to_device(DEVICE_OBJECT *device, IRP *irp)
return rc;
}
NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
NTSTATUS WINAPI pdo_ioctl(DEVICE_OBJECT *device, IRP *irp)
{
NTSTATUS rc = STATUS_SUCCESS;
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
BASE_DEVICE_EXTENSION *extension = device->DeviceExtension;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
irp->IoStatus.Information = 0;
@ -536,7 +469,7 @@ NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
irp->IoStatus.Information = 0;
break;
}
*((ULONG*)irp->AssociatedIrp.SystemBuffer) = extension->poll_interval;
*(ULONG *)irp->AssociatedIrp.SystemBuffer = ext->u.pdo.poll_interval;
irp->IoStatus.Information = sizeof(ULONG);
irp->IoStatus.u.Status = STATUS_SUCCESS;
break;
@ -552,7 +485,7 @@ NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
poll_interval = *(ULONG *)irp->AssociatedIrp.SystemBuffer;
if (poll_interval <= MAX_POLL_INTERVAL_MSEC)
{
extension->poll_interval = poll_interval;
ext->u.pdo.poll_interval = poll_interval;
irp->IoStatus.u.Status = STATUS_SUCCESS;
}
else
@ -561,27 +494,27 @@ NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
}
case IOCTL_HID_GET_PRODUCT_STRING:
{
rc = handle_minidriver_string(device, irp, HID_STRING_ID_IPRODUCT);
rc = handle_minidriver_string(ext, irp, HID_STRING_ID_IPRODUCT);
break;
}
case IOCTL_HID_GET_SERIALNUMBER_STRING:
{
rc = handle_minidriver_string(device, irp, HID_STRING_ID_ISERIALNUMBER);
rc = handle_minidriver_string(ext, irp, HID_STRING_ID_ISERIALNUMBER);
break;
}
case IOCTL_HID_GET_MANUFACTURER_STRING:
{
rc = handle_minidriver_string(device, irp, HID_STRING_ID_IMANUFACTURER);
rc = handle_minidriver_string(ext, irp, HID_STRING_ID_IMANUFACTURER);
break;
}
case IOCTL_HID_GET_COLLECTION_INFORMATION:
{
rc = handle_IOCTL_HID_GET_COLLECTION_INFORMATION(irp, extension);
rc = handle_IOCTL_HID_GET_COLLECTION_INFORMATION(irp, ext);
break;
}
case IOCTL_HID_GET_COLLECTION_DESCRIPTOR:
{
rc = handle_IOCTL_HID_GET_COLLECTION_DESCRIPTOR(irp, extension);
rc = handle_IOCTL_HID_GET_COLLECTION_DESCRIPTOR(irp, ext);
break;
}
case IOCTL_HID_GET_INPUT_REPORT:
@ -593,14 +526,14 @@ NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
packet = HeapAlloc(GetProcessHeap(), 0, packet_size);
if (extension->preparseData->reports[0].reportID)
if (ext->u.pdo.preparsed_data->reports[0].reportID)
packet->reportId = buffer[0];
else
packet->reportId = 0;
packet->reportBuffer = (BYTE *)packet + sizeof(*packet);
packet->reportBufferLen = irpsp->Parameters.DeviceIoControl.OutputBufferLength - 1;
rc = call_minidriver(IOCTL_HID_GET_INPUT_REPORT, device, NULL, 0, packet, sizeof(*packet));
rc = call_minidriver(IOCTL_HID_GET_INPUT_REPORT, ext->u.pdo.parent_fdo, NULL, 0, packet, sizeof(*packet));
if (rc == STATUS_SUCCESS)
{
rc = copy_packet_into_buffer(packet, buffer, irpsp->Parameters.DeviceIoControl.OutputBufferLength, &out_length);
@ -622,7 +555,7 @@ NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
}
else
{
rc = RingBuffer_SetSize(extension->ring_buffer, *(ULONG*)irp->AssociatedIrp.SystemBuffer);
rc = RingBuffer_SetSize(ext->u.pdo.ring_buffer, *(ULONG *)irp->AssociatedIrp.SystemBuffer);
irp->IoStatus.u.Status = rc;
}
break;
@ -635,13 +568,13 @@ NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
}
else
{
*(ULONG*)irp->AssociatedIrp.SystemBuffer = RingBuffer_GetSize(extension->ring_buffer);
*(ULONG *)irp->AssociatedIrp.SystemBuffer = RingBuffer_GetSize(ext->u.pdo.ring_buffer);
rc = irp->IoStatus.u.Status = STATUS_SUCCESS;
}
break;
}
case IOCTL_HID_GET_FEATURE:
rc = HID_get_feature(device, irp);
rc = HID_get_feature(ext, irp);
break;
case IOCTL_HID_SET_FEATURE:
case IOCTL_HID_SET_OUTPUT_REPORT:
@ -664,11 +597,11 @@ NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
return rc;
}
NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp)
NTSTATUS WINAPI pdo_read(DEVICE_OBJECT *device, IRP *irp)
{
HID_XFER_PACKET *packet;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
UINT buffer_size = RingBuffer_GetBufferSize(ext->ring_buffer);
UINT buffer_size = RingBuffer_GetBufferSize(ext->u.pdo.ring_buffer);
NTSTATUS rc = STATUS_SUCCESS;
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
int ptr = -1;
@ -677,7 +610,7 @@ NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp)
ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
irp->IoStatus.Information = 0;
RingBuffer_ReadNew(ext->ring_buffer, ptr, packet, &buffer_size);
RingBuffer_ReadNew(ext->u.pdo.ring_buffer, ptr, packet, &buffer_size);
if (buffer_size)
{
@ -694,27 +627,26 @@ NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp)
}
else
{
BASE_DEVICE_EXTENSION *extension = device->DeviceExtension;
if (extension->poll_interval)
if (ext->u.pdo.poll_interval)
{
KIRQL old_irql;
TRACE_(hid_report)("Queue irp\n");
KeAcquireSpinLock(&ext->irp_queue_lock, &old_irql);
KeAcquireSpinLock(&ext->u.pdo.irp_queue_lock, &old_irql);
IoSetCancelRoutine(irp, read_cancel_routine);
if (irp->Cancel && !IoSetCancelRoutine(irp, NULL))
{
/* IRP was canceled before we set cancel routine */
InitializeListHead(&irp->Tail.Overlay.s.ListEntry);
KeReleaseSpinLock(&ext->irp_queue_lock, old_irql);
KeReleaseSpinLock(&ext->u.pdo.irp_queue_lock, old_irql);
return STATUS_CANCELLED;
}
InsertTailList(&ext->irp_queue, &irp->Tail.Overlay.s.ListEntry);
InsertTailList(&ext->u.pdo.irp_queue, &irp->Tail.Overlay.s.ListEntry);
IoMarkIrpPending(irp);
KeReleaseSpinLock(&ext->irp_queue_lock, old_irql);
KeReleaseSpinLock(&ext->u.pdo.irp_queue_lock, old_irql);
rc = STATUS_PENDING;
}
else
@ -724,7 +656,7 @@ NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp)
packet.reportId = ((BYTE*)irp->AssociatedIrp.SystemBuffer)[0];
packet.reportBuffer = &((BYTE*)irp->AssociatedIrp.SystemBuffer)[1];
packet.reportBufferLen = irpsp->Parameters.Read.Length - 1;
rc = call_minidriver(IOCTL_HID_GET_INPUT_REPORT, device, NULL, 0, &packet, sizeof(packet));
rc = call_minidriver(IOCTL_HID_GET_INPUT_REPORT, ext->u.pdo.parent_fdo, NULL, 0, &packet, sizeof(packet));
if (rc == STATUS_SUCCESS)
{
@ -740,10 +672,11 @@ NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp)
return rc;
}
NTSTATUS WINAPI HID_Device_write(DEVICE_OBJECT *device, IRP *irp)
NTSTATUS WINAPI pdo_write(DEVICE_OBJECT *device, IRP *irp)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
const WINE_HIDP_PREPARSED_DATA *data = ext->u.pdo.preparsed_data;
HID_XFER_PACKET packet;
ULONG max_len;
NTSTATUS rc;
@ -756,20 +689,20 @@ NTSTATUS WINAPI HID_Device_write(DEVICE_OBJECT *device, IRP *irp)
{
packet.reportBuffer = &((BYTE*)irp->AssociatedIrp.SystemBuffer)[1];
packet.reportBufferLen = irpsp->Parameters.Write.Length - 1;
max_len = ext->preparseData->caps.OutputReportByteLength;
max_len = data->caps.OutputReportByteLength;
}
else
{
packet.reportBuffer = irp->AssociatedIrp.SystemBuffer;
packet.reportBufferLen = irpsp->Parameters.Write.Length;
max_len = (ext->preparseData->reports[ext->preparseData->reportIdx[HidP_Output][packet.reportId]].bitSize + 7) / 8;
max_len = (data->reports[data->reportIdx[HidP_Output][packet.reportId]].bitSize + 7) / 8;
}
if (packet.reportBufferLen > max_len)
packet.reportBufferLen = max_len;
TRACE_(hid_report)("(id %i, len %i buffer %p)\n", packet.reportId, packet.reportBufferLen, packet.reportBuffer);
rc = call_minidriver(IOCTL_HID_WRITE_REPORT, device, NULL, 0, &packet, sizeof(packet));
rc = call_minidriver(IOCTL_HID_WRITE_REPORT, ext->u.pdo.parent_fdo, NULL, 0, &packet, sizeof(packet));
irp->IoStatus.u.Status = rc;
if (irp->IoStatus.u.Status == STATUS_SUCCESS)
@ -783,23 +716,23 @@ NTSTATUS WINAPI HID_Device_write(DEVICE_OBJECT *device, IRP *irp)
return rc;
}
NTSTATUS WINAPI HID_Device_create(DEVICE_OBJECT *device, IRP *irp)
NTSTATUS WINAPI pdo_create(DEVICE_OBJECT *device, IRP *irp)
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
TRACE("Open handle on device %p\n", device);
irp->Tail.Overlay.OriginalFileObject->FsContext = UlongToPtr(RingBuffer_AddPointer(ext->ring_buffer));
irp->Tail.Overlay.OriginalFileObject->FsContext = UlongToPtr(RingBuffer_AddPointer(ext->u.pdo.ring_buffer));
irp->IoStatus.u.Status = STATUS_SUCCESS;
IoCompleteRequest( irp, IO_NO_INCREMENT );
return STATUS_SUCCESS;
}
NTSTATUS WINAPI HID_Device_close(DEVICE_OBJECT *device, IRP *irp)
NTSTATUS WINAPI pdo_close(DEVICE_OBJECT *device, IRP *irp)
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
int ptr = PtrToUlong(irp->Tail.Overlay.OriginalFileObject->FsContext);
TRACE("Close handle on device %p\n", device);
RingBuffer_RemovePointer(ext->ring_buffer, ptr);
RingBuffer_RemovePointer(ext->u.pdo.ring_buffer, ptr);
irp->IoStatus.u.Status = STATUS_SUCCESS;
IoCompleteRequest( irp, IO_NO_INCREMENT );
return STATUS_SUCCESS;

47
dlls/hidclass.sys/hid.h
View File

@ -37,28 +37,47 @@
/* Ring buffer functions */
struct ReportRingBuffer;
typedef struct _BASE_DEVICE_EXTENSION {
HID_DEVICE_EXTENSION deviceExtension;
typedef struct _BASE_DEVICE_EXTENSION
{
union
{
struct
{
/* this must be the first member */
HID_DEVICE_EXTENSION hid_ext;
DEVICE_OBJECT *child_pdo;
} fdo;
struct
{
DEVICE_OBJECT *parent_fdo;
HID_COLLECTION_INFORMATION information;
WINE_HIDP_PREPARSED_DATA *preparseData;
WINE_HIDP_PREPARSED_DATA *preparsed_data;
ULONG poll_interval;
UNICODE_STRING link_name;
WCHAR device_id[MAX_DEVICE_ID_LEN];
WCHAR instance_id[MAX_DEVICE_ID_LEN];
struct ReportRingBuffer *ring_buffer;
HANDLE halt_event;
HANDLE thread;
UINT32 rawinput_handle;
UNICODE_STRING link_name;
KSPIN_LOCK irp_queue_lock;
LIST_ENTRY irp_queue;
BOOL is_mouse;
UNICODE_STRING mouse_link_name;
} pdo;
} u;
/* Minidriver Specific stuff will end up here */
/* These are unique to the parent FDO, but stored in the children as well
* for convenience. */
WCHAR device_id[MAX_DEVICE_ID_LEN];
WCHAR instance_id[MAX_DEVICE_ID_LEN];
BOOL is_fdo;
} BASE_DEVICE_EXTENSION;
void RingBuffer_Write(struct ReportRingBuffer *buffer, void *data) DECLSPEC_HIDDEN;
@ -87,16 +106,16 @@ typedef struct _minidriver
NTSTATUS call_minidriver(ULONG code, DEVICE_OBJECT *device, void *in_buff, ULONG in_size, void *out_buff, ULONG out_size) DECLSPEC_HIDDEN;
/* Internal device functions */
NTSTATUS HID_CreateDevice(DEVICE_OBJECT *native_device, HID_MINIDRIVER_REGISTRATION *driver, DEVICE_OBJECT **device) DECLSPEC_HIDDEN;
NTSTATUS HID_LinkDevice(DEVICE_OBJECT *device) DECLSPEC_HIDDEN;
void HID_DeleteDevice(DEVICE_OBJECT *device) DECLSPEC_HIDDEN;
void HID_StartDeviceThread(DEVICE_OBJECT *device) DECLSPEC_HIDDEN;
NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
NTSTATUS WINAPI HID_Device_write(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
NTSTATUS WINAPI HID_Device_create(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
NTSTATUS WINAPI HID_Device_close(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
IRP *pop_irp_from_queue(BASE_DEVICE_EXTENSION *ext) DECLSPEC_HIDDEN;
NTSTATUS WINAPI pdo_ioctl(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
NTSTATUS WINAPI pdo_read(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
NTSTATUS WINAPI pdo_write(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
NTSTATUS WINAPI pdo_create(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
NTSTATUS WINAPI pdo_close(DEVICE_OBJECT *device, IRP *irp) DECLSPEC_HIDDEN;
/* Parsing HID Report Descriptors into preparsed data */
WINE_HIDP_PREPARSED_DATA* ParseDescriptor(BYTE *descriptor, unsigned int length) DECLSPEC_HIDDEN;

355
dlls/hidclass.sys/pnp.c
View File

@ -22,14 +22,33 @@
#include <unistd.h>
#include <stdarg.h>
#include "hid.h"
#include "ntddmou.h"
#include "ddk/hidtypes.h"
#include "ddk/wdm.h"
#include "regstr.h"
#include "wine/debug.h"
#include "wine/asm.h"
#include "wine/list.h"
WINE_DEFAULT_DEBUG_CHANNEL(hid);
#if defined(__i386__) && !defined(_WIN32)
extern void * WINAPI wrap_fastcall_func1( void *func, const void *a );
__ASM_STDCALL_FUNC( wrap_fastcall_func1, 8,
"popl %ecx\n\t"
"popl %eax\n\t"
"xchgl (%esp),%ecx\n\t"
"jmp *%eax" );
#define call_fastcall_func1(func,a) wrap_fastcall_func1(func,a)
#else
#define call_fastcall_func1(func,a) func(a)
#endif
static struct list minidriver_list = LIST_INIT(minidriver_list);
static minidriver *find_minidriver(DRIVER_OBJECT *driver)
@ -82,74 +101,92 @@ static NTSTATUS get_device_id(DEVICE_OBJECT *device, BUS_QUERY_ID_TYPE type, WCH
return status;
}
static NTSTATUS WINAPI driver_add_device(DRIVER_OBJECT *driver, DEVICE_OBJECT *PDO)
static NTSTATUS WINAPI driver_add_device(DRIVER_OBJECT *driver, DEVICE_OBJECT *bus_pdo)
{
WCHAR device_id[MAX_DEVICE_ID_LEN], instance_id[MAX_DEVICE_ID_LEN];
DEVICE_OBJECT *device = NULL;
WCHAR device_id[MAX_DEVICE_ID_LEN], instance_id[MAX_DEVICE_ID_LEN], pdo_name[255];
BASE_DEVICE_EXTENSION *ext, *pdo_ext;
HID_DEVICE_ATTRIBUTES attr = {0};
DEVICE_OBJECT *fdo, *child_pdo;
UNICODE_STRING string;
NTSTATUS status;
minidriver *minidriver;
HID_DEVICE_ATTRIBUTES attr = {0};
BASE_DEVICE_EXTENSION *ext = NULL;
HID_DESCRIPTOR descriptor;
BYTE *reportDescriptor;
INT i;
if ((status = get_device_id(PDO, BusQueryDeviceID, device_id)))
if ((status = get_device_id(bus_pdo, BusQueryDeviceID, device_id)))
{
ERR("Failed to get PDO device id, status %#x.\n", status);
return status;
}
if ((status = get_device_id(PDO, BusQueryInstanceID, instance_id)))
if ((status = get_device_id(bus_pdo, BusQueryInstanceID, instance_id)))
{
ERR("Failed to get PDO instance id, status %#x.\n", status);
return status;
}
TRACE("Adding device to PDO %p, id %s\\%s.\n", PDO, debugstr_w(device_id), debugstr_w(instance_id));
TRACE("Adding device to PDO %p, id %s\\%s.\n", bus_pdo, debugstr_w(device_id), debugstr_w(instance_id));
minidriver = find_minidriver(driver);
status = HID_CreateDevice(PDO, &minidriver->minidriver, &device);
if (status != STATUS_SUCCESS)
if ((status = IoCreateDevice(driver, sizeof(*ext) + minidriver->minidriver.DeviceExtensionSize,
NULL, FILE_DEVICE_BUS_EXTENDER, 0, FALSE, &fdo)))
{
ERR("Failed to create HID object (%x)\n",status);
ERR("Failed to create bus FDO, status %#x.\n", status);
return status;
}
ext = fdo->DeviceExtension;
ext->is_fdo = TRUE;
ext->u.fdo.hid_ext.MiniDeviceExtension = ext + 1;
ext->u.fdo.hid_ext.PhysicalDeviceObject = fdo;
ext->u.fdo.hid_ext.NextDeviceObject = bus_pdo;
swprintf(ext->device_id, ARRAY_SIZE(ext->device_id), L"HID\\%s", wcsrchr(device_id, '\\') + 1);
wcscpy(ext->instance_id, instance_id);
ext = device->DeviceExtension;
InitializeListHead(&ext->irp_queue);
KeInitializeSpinLock(&ext->irp_queue_lock);
TRACE("Created device %p\n",device);
status = minidriver->AddDevice(minidriver->minidriver.DriverObject, device);
status = minidriver->AddDevice(minidriver->minidriver.DriverObject, fdo);
if (status != STATUS_SUCCESS)
{
ERR("Minidriver AddDevice failed (%x)\n",status);
HID_DeleteDevice(device);
IoDeleteDevice(fdo);
return status;
}
status = call_minidriver(IOCTL_HID_GET_DEVICE_ATTRIBUTES, device,
NULL, 0, &attr, sizeof(attr));
status = call_minidriver(IOCTL_HID_GET_DEVICE_ATTRIBUTES, fdo, NULL, 0, &attr, sizeof(attr));
if (status != STATUS_SUCCESS)
{
ERR("Minidriver failed to get Attributes(%x)\n",status);
HID_DeleteDevice(device);
IoDeleteDevice(fdo);
return status;
}
ext->information.VendorID = attr.VendorID;
ext->information.ProductID = attr.ProductID;
ext->information.VersionNumber = attr.VersionNumber;
ext->information.Polled = minidriver->minidriver.DevicesArePolled;
swprintf(pdo_name, ARRAY_SIZE(pdo_name), L"\\Device\\HID#%p&%p", driver, bus_pdo);
RtlInitUnicodeString(&string, pdo_name);
if ((status = IoCreateDevice(driver, sizeof(*ext), &string, 0, 0, FALSE, &child_pdo)))
{
ERR("Failed to create child PDO, status %#x.\n", status);
IoDeleteDevice(fdo);
return status;
}
ext->u.fdo.child_pdo = child_pdo;
status = call_minidriver(IOCTL_HID_GET_DEVICE_DESCRIPTOR, device, NULL, 0,
&descriptor, sizeof(descriptor));
pdo_ext = child_pdo->DeviceExtension;
pdo_ext->u.pdo.parent_fdo = fdo;
InitializeListHead(&pdo_ext->u.pdo.irp_queue);
KeInitializeSpinLock(&pdo_ext->u.pdo.irp_queue_lock);
wcscpy(pdo_ext->device_id, ext->device_id);
wcscpy(pdo_ext->instance_id, ext->instance_id);
pdo_ext->u.pdo.information.VendorID = attr.VendorID;
pdo_ext->u.pdo.information.ProductID = attr.ProductID;
pdo_ext->u.pdo.information.VersionNumber = attr.VersionNumber;
pdo_ext->u.pdo.information.Polled = minidriver->minidriver.DevicesArePolled;
status = call_minidriver(IOCTL_HID_GET_DEVICE_DESCRIPTOR, fdo, NULL, 0, &descriptor, sizeof(descriptor));
if (status != STATUS_SUCCESS)
{
ERR("Cannot get Device Descriptor(%x)\n",status);
HID_DeleteDevice(device);
IoDeleteDevice(child_pdo);
IoDeleteDevice(fdo);
return status;
}
for (i = 0; i < descriptor.bNumDescriptors; i++)
@ -159,84 +196,114 @@ static NTSTATUS WINAPI driver_add_device(DRIVER_OBJECT *driver, DEVICE_OBJECT *P
if (i >= descriptor.bNumDescriptors)
{
ERR("No Report Descriptor found in reply\n");
HID_DeleteDevice(device);
IoDeleteDevice(child_pdo);
IoDeleteDevice(fdo);
return status;
}
reportDescriptor = HeapAlloc(GetProcessHeap(), 0, descriptor.DescriptorList[i].wReportLength);
status = call_minidriver(IOCTL_HID_GET_REPORT_DESCRIPTOR, device, NULL, 0,
status = call_minidriver(IOCTL_HID_GET_REPORT_DESCRIPTOR, fdo, NULL, 0,
reportDescriptor, descriptor.DescriptorList[i].wReportLength);
if (status != STATUS_SUCCESS)
{
ERR("Cannot get Report Descriptor(%x)\n",status);
HID_DeleteDevice(device);
HeapFree(GetProcessHeap(), 0, reportDescriptor);
IoDeleteDevice(child_pdo);
IoDeleteDevice(fdo);
return status;
}
ext->preparseData = ParseDescriptor(reportDescriptor, descriptor.DescriptorList[i].wReportLength);
pdo_ext->u.pdo.preparsed_data = ParseDescriptor(reportDescriptor, descriptor.DescriptorList[i].wReportLength);
HeapFree(GetProcessHeap(), 0, reportDescriptor);
if (!ext->preparseData)
if (!pdo_ext->u.pdo.preparsed_data)
{
ERR("Cannot parse Report Descriptor\n");
HID_DeleteDevice(device);
IoDeleteDevice(child_pdo);
IoDeleteDevice(fdo);
return STATUS_NOT_SUPPORTED;
}
ext->information.DescriptorSize = ext->preparseData->dwSize;
pdo_ext->u.pdo.information.DescriptorSize = pdo_ext->u.pdo.preparsed_data->dwSize;
lstrcpyW(ext->instance_id, instance_id);
IoAttachDeviceToDeviceStack(fdo, bus_pdo);
lstrcpyW(ext->device_id, L"HID");
lstrcatW(ext->device_id, L"\\");
lstrcatW(ext->device_id, wcschr(device_id, '\\') + 1);
IoInvalidateDeviceRelations(bus_pdo, BusRelations);
HID_LinkDevice(device);
HID_LinkDevice(child_pdo);
ext->poll_interval = DEFAULT_POLL_INTERVAL;
pdo_ext->u.pdo.poll_interval = DEFAULT_POLL_INTERVAL;
ext->ring_buffer = RingBuffer_Create(sizeof(HID_XFER_PACKET) + ext->preparseData->caps.InputReportByteLength);
pdo_ext->u.pdo.ring_buffer = RingBuffer_Create(
sizeof(HID_XFER_PACKET) + pdo_ext->u.pdo.preparsed_data->caps.InputReportByteLength);
HID_StartDeviceThread(device);
HID_StartDeviceThread(child_pdo);
fdo->Flags &= ~DO_DEVICE_INITIALIZING;
return STATUS_SUCCESS;
}
static NTSTATUS remove_device(minidriver *minidriver, DEVICE_OBJECT *device, IRP *irp)
static NTSTATUS fdo_pnp(DEVICE_OBJECT *device, IRP *irp)
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
NTSTATUS rc = STATUS_NOT_SUPPORTED;
rc = IoSetDeviceInterfaceState(&ext->link_name, FALSE);
if (rc)
{
FIXME("failed to disable interface %x\n", rc);
return rc;
}
if (ext->is_mouse)
IoSetDeviceInterfaceState(&ext->mouse_link_name, FALSE);
if (irp)
rc = minidriver->PNPDispatch(device, irp);
HID_DeleteDevice(device);
return rc;
}
static NTSTATUS WINAPI driver_pnp(DEVICE_OBJECT *device, IRP *irp)
{
NTSTATUS rc = STATUS_NOT_SUPPORTED;
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
minidriver *minidriver = find_minidriver(device->DriverObject);
IO_STACK_LOCATION *stack = IoGetCurrentIrpStackLocation(irp);
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
TRACE("%p, %p\n", device, irp);
TRACE("irp %p, minor function %#x.\n", irp, stack->MinorFunction);
switch (stack->MinorFunction)
{
case IRP_MN_QUERY_DEVICE_RELATIONS:
{
DEVICE_RELATIONS *devices;
if (stack->Parameters.QueryDeviceRelations.Type != BusRelations)
return minidriver->PNPDispatch(device, irp);
if (!(devices = ExAllocatePool(PagedPool, offsetof(DEVICE_RELATIONS, Objects[1]))))
{
irp->IoStatus.u.Status = STATUS_NO_MEMORY;
IoCompleteRequest(irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY;
}
devices->Objects[0] = ext->u.fdo.child_pdo;
call_fastcall_func1(ObfReferenceObject, ext->u.fdo.child_pdo);
devices->Count = 1;
irp->IoStatus.Information = (ULONG_PTR)devices;
irp->IoStatus.u.Status = STATUS_SUCCESS;
IoSkipCurrentIrpStackLocation(irp);
return IoCallDriver(ext->u.fdo.hid_ext.NextDeviceObject, irp);
}
case IRP_MN_REMOVE_DEVICE:
{
NTSTATUS ret;
ret = minidriver->PNPDispatch(device, irp);
IoDetachDevice(ext->u.fdo.hid_ext.NextDeviceObject);
IoDeleteDevice(device);
return ret;
}
default:
return minidriver->PNPDispatch(device, irp);
}
}
static NTSTATUS pdo_pnp(DEVICE_OBJECT *device, IRP *irp)
{
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
NTSTATUS status = irp->IoStatus.u.Status;
TRACE("irp %p, minor function %#x.\n", irp, irpsp->MinorFunction);
switch(irpsp->MinorFunction)
{
case IRP_MN_QUERY_ID:
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
WCHAR *id = ExAllocatePool(PagedPool, sizeof(WCHAR) * REGSTR_VAL_MAX_HCID_LEN);
TRACE("IRP_MN_QUERY_ID[%i]\n", irpsp->Parameters.QueryId.IdType);
switch (irpsp->Parameters.QueryId.IdType)
@ -261,18 +328,18 @@ static NTSTATUS WINAPI driver_pnp(DEVICE_OBJECT *device, IRP *irp)
ptr += lstrlenW(L"HID") + 1;
*ptr = 0;
irp->IoStatus.Information = (ULONG_PTR)id;
rc = STATUS_SUCCESS;
status = STATUS_SUCCESS;
break;
}
case BusQueryDeviceID:
lstrcpyW(id, ext->device_id);
irp->IoStatus.Information = (ULONG_PTR)id;
rc = STATUS_SUCCESS;
status = STATUS_SUCCESS;
break;
case BusQueryInstanceID:
lstrcpyW(id, ext->instance_id);
irp->IoStatus.Information = (ULONG_PTR)id;
rc = STATUS_SUCCESS;
status = STATUS_SUCCESS;
break;
case BusQueryContainerID:
@ -283,31 +350,125 @@ static NTSTATUS WINAPI driver_pnp(DEVICE_OBJECT *device, IRP *irp)
}
break;
}
case IRP_MN_QUERY_CAPABILITIES:
{
DEVICE_CAPABILITIES *caps = irpsp->Parameters.DeviceCapabilities.Capabilities;
caps->RawDeviceOK = 1;
status = STATUS_SUCCESS;
break;
}
case IRP_MN_START_DEVICE:
if ((status = IoRegisterDeviceInterface(device, &GUID_DEVINTERFACE_HID, NULL, &ext->u.pdo.link_name)))
{
ERR("Failed to register interface, status %#x.\n", status);
break;
}
/* FIXME: This should probably be done in mouhid.sys. */
if (ext->u.pdo.preparsed_data->caps.UsagePage == HID_USAGE_PAGE_GENERIC
&& ext->u.pdo.preparsed_data->caps.Usage == HID_USAGE_GENERIC_MOUSE)
{
if (!IoRegisterDeviceInterface(device, &GUID_DEVINTERFACE_MOUSE, NULL, &ext->u.pdo.mouse_link_name))
ext->u.pdo.is_mouse = TRUE;
}
IoSetDeviceInterfaceState(&ext->u.pdo.link_name, TRUE);
if (ext->u.pdo.is_mouse)
IoSetDeviceInterfaceState(&ext->u.pdo.mouse_link_name, TRUE);
status = STATUS_SUCCESS;
break;
case IRP_MN_REMOVE_DEVICE:
{
IRP *queued_irp;
IoSetDeviceInterfaceState(&ext->u.pdo.link_name, FALSE);
if (ext->u.pdo.is_mouse)
IoSetDeviceInterfaceState(&ext->u.pdo.mouse_link_name, FALSE);
if (ext->u.pdo.thread)
{
SetEvent(ext->u.pdo.halt_event);
WaitForSingleObject(ext->u.pdo.thread, INFINITE);
}
CloseHandle(ext->u.pdo.halt_event);
HeapFree(GetProcessHeap(), 0, ext->u.pdo.preparsed_data);
if (ext->u.pdo.ring_buffer)
RingBuffer_Destroy(ext->u.pdo.ring_buffer);
while ((queued_irp = pop_irp_from_queue(ext)))
{
queued_irp->IoStatus.u.Status = STATUS_DEVICE_REMOVED;
IoCompleteRequest(queued_irp, IO_NO_INCREMENT);
}
RtlFreeUnicodeString(&ext->u.pdo.link_name);
irp->IoStatus.u.Status = STATUS_SUCCESS;
IoCompleteRequest(irp, IO_NO_INCREMENT);
IoDeleteDevice(device);
return STATUS_SUCCESS;
}
case IRP_MN_SURPRISE_REMOVAL:
status = STATUS_SUCCESS;
break;
default:
FIXME("Unhandled minor function %#x.\n", irpsp->MinorFunction);
}
irp->IoStatus.u.Status = status;
IoCompleteRequest( irp, IO_NO_INCREMENT );
return status;
}
static NTSTATUS WINAPI driver_pnp(DEVICE_OBJECT *device, IRP *irp)
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
rc = minidriver->PNPDispatch(device, irp);
IoSetDeviceInterfaceState(&ext->link_name, TRUE);
if (ext->is_mouse)
IoSetDeviceInterfaceState(&ext->mouse_link_name, TRUE);
return rc;
}
case IRP_MN_REMOVE_DEVICE:
{
return remove_device(minidriver, device, irp);
}
default:
{
/* Forward IRP to the minidriver */
return minidriver->PNPDispatch(device, irp);
}
if (ext->is_fdo)
return fdo_pnp(device, irp);
else
return pdo_pnp(device, irp);
}
irp->IoStatus.u.Status = rc;
static NTSTATUS WINAPI driver_create(DEVICE_OBJECT *device, IRP *irp)
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
if (ext->is_fdo)
{
irp->IoStatus.u.Status = STATUS_UNSUCCESSFUL;
IoCompleteRequest(irp, IO_NO_INCREMENT);
return rc;
return STATUS_UNSUCCESSFUL;
}
return pdo_create(device, irp);
}
static NTSTATUS WINAPI driver_close(DEVICE_OBJECT *device, IRP *irp)
{
return pdo_close(device, irp);
}
static NTSTATUS WINAPI driver_ioctl(DEVICE_OBJECT *device, IRP *irp)
{
return pdo_ioctl(device, irp);
}
static NTSTATUS WINAPI driver_read(DEVICE_OBJECT *device, IRP *irp)
{
return pdo_read(device, irp);
}
static NTSTATUS WINAPI driver_write(DEVICE_OBJECT *device, IRP *irp)
{
return pdo_write(device, irp);
}
static void WINAPI driver_unload(DRIVER_OBJECT *driver)
@ -335,11 +496,11 @@ NTSTATUS WINAPI HidRegisterMinidriver(HID_MINIDRIVER_REGISTRATION *registration)
driver->DriverUnload = registration->DriverObject->DriverUnload;
registration->DriverObject->DriverUnload = driver_unload;
registration->DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = HID_Device_ioctl;
registration->DriverObject->MajorFunction[IRP_MJ_READ] = HID_Device_read;
registration->DriverObject->MajorFunction[IRP_MJ_WRITE] = HID_Device_write;
registration->DriverObject->MajorFunction[IRP_MJ_CREATE] = HID_Device_create;
registration->DriverObject->MajorFunction[IRP_MJ_CLOSE] = HID_Device_close;
registration->DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = driver_ioctl;
registration->DriverObject->MajorFunction[IRP_MJ_READ] = driver_read;
registration->DriverObject->MajorFunction[IRP_MJ_WRITE] = driver_write;
registration->DriverObject->MajorFunction[IRP_MJ_CREATE] = driver_create;
registration->DriverObject->MajorFunction[IRP_MJ_CLOSE] = driver_close;
driver->PNPDispatch = registration->DriverObject->MajorFunction[IRP_MJ_PNP];
registration->DriverObject->MajorFunction[IRP_MJ_PNP] = driver_pnp;

2
dlls/ntoskrnl.exe/tests/driver_hid.c
View File

@ -217,7 +217,7 @@ static NTSTATUS WINAPI driver_add_device(DRIVER_OBJECT *driver, DEVICE_OBJECT *f
ok(!!ext->PhysicalDeviceObject, "expected non-NULL pdo\n");
todo_wine ok(ext->NextDeviceObject == ext->PhysicalDeviceObject, "got pdo %p, next %p\n",
ext->PhysicalDeviceObject, ext->NextDeviceObject);
ok(ext->NextDeviceObject->AttachedDevice == fdo, "wrong attached device\n");
todo_wine ok(ext->NextDeviceObject->AttachedDevice == fdo, "wrong attached device\n");
ret = IoRegisterDeviceInterface(ext->PhysicalDeviceObject, &control_class, NULL, &control_symlink);
ok(!ret, "got %#x\n", ret);