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

hidclass.sys: Create separate report queue for each opened handle. 

Signed-off-by: Rémi Bernon <rbernon@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Rémi Bernon 2021-08-10 11:31:15 +02:00 committed by Alexandre Julliard
parent 2e3a0dac84
commit 3a3e0ed2e9
4 changed files with 95 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -24,11 +24,13 @@
#include "winreg.h"
#include "winuser.h"
#include "wine/debug.h"
#include "ddk/hidsdi.h"
#include "ddk/hidtypes.h"
#include "ddk/wdm.h"
#include "wine/debug.h"
#include "wine/list.h"
WINE_DEFAULT_DEBUG_CHANNEL(hid);
WINE_DECLARE_DEBUG_CHANNEL(hid_report);
@ -77,27 +79,26 @@ static void WINAPI read_cancel_routine(DEVICE_OBJECT *device, IRP *irp)
IoCompleteRequest(irp, IO_NO_INCREMENT);
}
static void hid_device_send_input(DEVICE_OBJECT *device, HID_XFER_PACKET *packet)
static void hid_device_queue_input( DEVICE_OBJECT *device, HID_XFER_PACKET *packet )
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
struct hid_report_queue *queue;
RAWINPUT *rawinput;
ULONG data_size;
ULONG size;
KIRQL irql;
size = offsetof( RAWINPUT, data.hid.bRawData[packet->reportBufferLen] );
if (!(rawinput = malloc( size ))) ERR( "Failed to allocate rawinput data!\n" );
else
{
INPUT input;
data_size = offsetof(RAWINPUT, data.hid.bRawData) + packet->reportBufferLen;
if (!(rawinput = malloc(data_size)))
{
ERR("Failed to allocate rawinput data!\n");
return;
}
rawinput->header.dwType = RIM_TYPEHID;
rawinput->header.dwSize = data_size;
rawinput->header.dwSize = size;
rawinput->header.hDevice = ULongToHandle( ext->u.pdo.rawinput_handle );
rawinput->header.wParam = RIM_INPUT;
rawinput->data.hid.dwCount = 1;
rawinput->data.hid.dwSizeHid = data_size - offsetof(RAWINPUT, data.hid.bRawData);
rawinput->data.hid.dwSizeHid = packet->reportBufferLen;
memcpy( rawinput->data.hid.bRawData, packet->reportBuffer, packet->reportBufferLen );
input.type = INPUT_HARDWARE;
@ -109,24 +110,29 @@ static void hid_device_send_input(DEVICE_OBJECT *device, HID_XFER_PACKET *packet
free( rawinput );
}
KeAcquireSpinLock( &ext->u.pdo.report_queues_lock, &irql );
LIST_FOR_EACH_ENTRY( queue, &ext->u.pdo.report_queues, struct hid_report_queue, entry )
RingBuffer_Write( queue->buffer, packet );
KeReleaseSpinLock( &ext->u.pdo.report_queues_lock, irql );
}
static void HID_Device_processQueue(DEVICE_OBJECT *device)
{
IRP *irp;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
UINT buffer_size = RingBuffer_GetBufferSize(ext->u.pdo.ring_buffer);
struct hid_preparsed_data *preparsed = ext->u.pdo.preparsed_data;
struct hid_report_queue *queue;
HID_XFER_PACKET *packet;
UINT buffer_size;
IRP *irp;
packet = malloc(buffer_size);
packet = malloc( sizeof(*packet) + preparsed->caps.InputReportByteLength );
while((irp = pop_irp_from_queue(ext)))
{
int ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
RingBuffer_Read(ext->u.pdo.ring_buffer, ptr, packet, &buffer_size);
queue = irp->Tail.Overlay.OriginalFileObject->FsContext;
RingBuffer_Read( queue->buffer, 0, packet, &buffer_size );
if (buffer_size)
{
TRACE_(hid_report)("Processing Request (%i)\n",ptr);
memcpy( irp->AssociatedIrp.SystemBuffer, packet + 1, preparsed->caps.InputReportByteLength );
irp->IoStatus.Information = packet->reportBufferLen;
irp->IoStatus.Status = STATUS_SUCCESS;
@ -180,8 +186,7 @@ static DWORD CALLBACK hid_device_thread(void *args)
packet->reportBuffer = buffer;
packet->reportBufferLen = io.Information;
RingBuffer_Write(ext->u.pdo.ring_buffer, packet);
hid_device_send_input(device, packet);
hid_device_queue_input( device, packet );
HID_Device_processQueue(device);
}
@ -223,8 +228,7 @@ static DWORD CALLBACK hid_device_thread(void *args)
packet->reportBuffer = buffer;
packet->reportBufferLen = io.Information;
RingBuffer_Write(ext->u.pdo.ring_buffer, packet);
hid_device_send_input(device, packet);
hid_device_queue_input( device, packet );
HID_Device_processQueue(device);
}
@ -393,6 +397,7 @@ static void hid_device_xfer_report( BASE_DEVICE_EXTENSION *ext, ULONG code, IRP
NTSTATUS WINAPI pdo_ioctl(DEVICE_OBJECT *device, IRP *irp)
{
struct hid_report_queue *queue = irp->Tail.Overlay.OriginalFileObject->FsContext;
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
NTSTATUS status;
@ -480,7 +485,7 @@ NTSTATUS WINAPI pdo_ioctl(DEVICE_OBJECT *device, IRP *irp)
if (irpsp->Parameters.DeviceIoControl.InputBufferLength != sizeof(ULONG))
irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW;
else
irp->IoStatus.Status = RingBuffer_SetSize( ext->u.pdo.ring_buffer, *(ULONG *)irp->AssociatedIrp.SystemBuffer );
irp->IoStatus.Status = RingBuffer_SetSize( queue->buffer, *(ULONG *)irp->AssociatedIrp.SystemBuffer );
break;
}
case IOCTL_GET_NUM_DEVICE_INPUT_BUFFERS:
@ -492,7 +497,7 @@ NTSTATUS WINAPI pdo_ioctl(DEVICE_OBJECT *device, IRP *irp)
}
else
{
*(ULONG *)irp->AssociatedIrp.SystemBuffer = RingBuffer_GetSize(ext->u.pdo.ring_buffer);
*(ULONG *)irp->AssociatedIrp.SystemBuffer = RingBuffer_GetSize( queue->buffer );
irp->IoStatus.Information = sizeof(ULONG);
irp->IoStatus.Status = STATUS_SUCCESS;
}
@ -521,12 +526,13 @@ NTSTATUS WINAPI pdo_ioctl(DEVICE_OBJECT *device, IRP *irp)
NTSTATUS WINAPI pdo_read(DEVICE_OBJECT *device, IRP *irp)
{
HID_XFER_PACKET *packet;
struct hid_report_queue *queue = irp->Tail.Overlay.OriginalFileObject->FsContext;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
struct hid_preparsed_data *preparsed = ext->u.pdo.preparsed_data;
UINT buffer_size = RingBuffer_GetBufferSize(ext->u.pdo.ring_buffer);
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
BYTE report_id = HID_INPUT_VALUE_CAPS( preparsed )->report_id;
HID_XFER_PACKET *packet;
UINT buffer_size;
NTSTATUS status;
int ptr = -1;
BOOL removed;
@ -550,11 +556,11 @@ NTSTATUS WINAPI pdo_read(DEVICE_OBJECT *device, IRP *irp)
return STATUS_INVALID_BUFFER_SIZE;
}
packet = malloc(buffer_size);
packet = malloc( sizeof(*packet) + preparsed->caps.InputReportByteLength );
ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
irp->IoStatus.Information = 0;
RingBuffer_ReadNew(ext->u.pdo.ring_buffer, ptr, packet, &buffer_size);
RingBuffer_ReadNew( queue->buffer, ptr, packet, &buffer_size );
if (buffer_size)
{
@ -631,20 +637,51 @@ NTSTATUS WINAPI pdo_write(DEVICE_OBJECT *device, IRP *irp)
NTSTATUS WINAPI pdo_create(DEVICE_OBJECT *device, IRP *irp)
{
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
struct hid_preparsed_data *preparsed = ext->u.pdo.preparsed_data;
struct hid_report_queue *queue;
KIRQL irql;
TRACE("Open handle on device %p\n", device);
irp->Tail.Overlay.OriginalFileObject->FsContext = UlongToPtr(RingBuffer_AddPointer(ext->u.pdo.ring_buffer));
if (!(queue = malloc( sizeof(*queue) )) ||
!(queue->buffer = RingBuffer_Create( sizeof(HID_XFER_PACKET) + preparsed->caps.InputReportByteLength )))
{
free( queue );
irp->IoStatus.Status = STATUS_NO_MEMORY;
}
else
{
RingBuffer_AddPointer( queue->buffer );
KeAcquireSpinLock( &ext->u.pdo.report_queues_lock, &irql );
list_add_tail( &ext->u.pdo.report_queues, &queue->entry );
KeReleaseSpinLock( &ext->u.pdo.report_queues_lock, irql );
irp->Tail.Overlay.OriginalFileObject->FsContext = queue;
irp->IoStatus.Status = STATUS_SUCCESS;
}
IoCompleteRequest( irp, IO_NO_INCREMENT );
return STATUS_SUCCESS;
}
NTSTATUS WINAPI pdo_close(DEVICE_OBJECT *device, IRP *irp)
{
struct hid_report_queue *queue = irp->Tail.Overlay.OriginalFileObject->FsContext;
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
int ptr = PtrToUlong(irp->Tail.Overlay.OriginalFileObject->FsContext);
KIRQL irql;
TRACE("Close handle on device %p\n", device);
RingBuffer_RemovePointer(ext->u.pdo.ring_buffer, ptr);
if (queue)
{
KeAcquireSpinLock( &ext->u.pdo.report_queues_lock, &irql );
list_remove( &queue->entry );
KeReleaseSpinLock( &ext->u.pdo.report_queues_lock, irql );
RingBuffer_Destroy( queue->buffer );
free( queue );
}
irp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest( irp, IO_NO_INCREMENT );
return STATUS_SUCCESS;

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

@ -57,11 +57,13 @@ typedef struct _BASE_DEVICE_EXTENSION
struct hid_preparsed_data *preparsed_data;
ULONG poll_interval;
struct ReportRingBuffer *ring_buffer;
HANDLE halt_event;
HANDLE thread;
UINT32 rawinput_handle;
KSPIN_LOCK report_queues_lock;
struct list report_queues;
UNICODE_STRING link_name;
KSPIN_LOCK irp_queue_lock;
@ -85,6 +87,12 @@ typedef struct _BASE_DEVICE_EXTENSION
BOOL is_fdo;
} BASE_DEVICE_EXTENSION;
struct hid_report_queue
{
struct list entry;
struct ReportRingBuffer *buffer;
};
void RingBuffer_Write(struct ReportRingBuffer *buffer, void *data) DECLSPEC_HIDDEN;
UINT RingBuffer_AddPointer(struct ReportRingBuffer *buffer) DECLSPEC_HIDDEN;
void RingBuffer_RemovePointer(struct ReportRingBuffer *ring, UINT index) DECLSPEC_HIDDEN;

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

@ -212,6 +212,8 @@ static void create_child(minidriver *minidriver, DEVICE_OBJECT *fdo)
pdo_ext = child_pdo->DeviceExtension;
pdo_ext->u.pdo.parent_fdo = fdo;
list_init( &pdo_ext->u.pdo.report_queues );
KeInitializeSpinLock( &pdo_ext->u.pdo.report_queues_lock );
InitializeListHead(&pdo_ext->u.pdo.irp_queue);
KeInitializeSpinLock(&pdo_ext->u.pdo.irp_queue_lock);
wcscpy(pdo_ext->device_id, fdo_ext->device_id);
@ -284,9 +286,6 @@ static void create_child(minidriver *minidriver, DEVICE_OBJECT *fdo)
pdo_ext->u.pdo.poll_interval = DEFAULT_POLL_INTERVAL;
pdo_ext->u.pdo.ring_buffer = RingBuffer_Create(
sizeof(HID_XFER_PACKET) + pdo_ext->u.pdo.preparsed_data->caps.InputReportByteLength);
HID_StartDeviceThread(child_pdo);
send_wm_input_device_change(pdo_ext, GIDC_ARRIVAL);
@ -490,8 +489,6 @@ static NTSTATUS pdo_pnp(DEVICE_OBJECT *device, IRP *irp)
CloseHandle(ext->u.pdo.halt_event);
free(ext->u.pdo.preparsed_data);
if (ext->u.pdo.ring_buffer)
RingBuffer_Destroy(ext->u.pdo.ring_buffer);
RtlFreeUnicodeString(&ext->u.pdo.link_name);

4
dlls/ntoskrnl.exe/tests/ntoskrnl.c
View File

@ -2797,7 +2797,7 @@ static void test_hid_device(DWORD report_id, DWORD polled)
SetLastError(0xdeadbeef);
ret = HidD_GetNumInputBuffers(async_file, &count);
ok(ret, "HidD_GetNumInputBuffers failed last error %u\n", GetLastError());
todo_wine ok(count == 32, "HidD_GetNumInputBuffers returned %u\n", count);
ok(count == 32, "HidD_GetNumInputBuffers returned %u\n", count);
SetLastError(0xdeadbeef);
ret = HidD_SetNumInputBuffers(async_file, 2);
@ -2812,7 +2812,7 @@ static void test_hid_device(DWORD report_id, DWORD polled)
SetLastError(0xdeadbeef);
ret = HidD_GetNumInputBuffers(file, &count);
ok(ret, "HidD_GetNumInputBuffers failed last error %u\n", GetLastError());
todo_wine ok(count == 16, "HidD_GetNumInputBuffers returned %u\n", count);
ok(count == 16, "HidD_GetNumInputBuffers returned %u\n", count);
if (polled)
{