dlls/hidclass.sys/device.c

   1 /*
   2  * HIDClass device functions
   3  *
   4  * Copyright (C) 2015 Aric Stewart
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #define NONAMELESSUNION
  23 #define NONAMELESSSTRUCT
  24 #include "hid.h"
  25 #include "winreg.h"
  26 #include "winuser.h"
  27 #include "setupapi.h"
  28
  29 #include "wine/debug.h"
  30 #include "ddk/hidsdi.h"
  31 #include "ddk/hidtypes.h"
  32 #include "ddk/wdm.h"
  33
  34 #include "initguid.h"
  35 #include "devguid.h"
  36 #include "ntddmou.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(hid);
  39 WINE_DECLARE_DEBUG_CHANNEL(hid_report);
  40
  41 NTSTATUS HID_CreateDevice(DEVICE_OBJECT *native_device, HID_MINIDRIVER_REGISTRATION *driver, DEVICE_OBJECT **device)
  42 {
  43     WCHAR dev_name[255];
  44     UNICODE_STRING nameW;
  45     NTSTATUS status;
  46     BASE_DEVICE_EXTENSION *ext;
  47
  48     swprintf(dev_name, ARRAY_SIZE(dev_name), L"\\Device\\HID#%p&%p", driver->DriverObject, native_device);
  49     RtlInitUnicodeString( &nameW, dev_name );
  50
  51     TRACE("Create base hid device %s\n", debugstr_w(dev_name));
  52
  53     status = IoCreateDevice(driver->DriverObject, driver->DeviceExtensionSize + sizeof(BASE_DEVICE_EXTENSION), &nameW, 0, 0, FALSE, device);
  54     if (status)
  55     {
  56         FIXME( "failed to create device error %x\n", status );
  57         return status;
  58     }
  59
  60     ext = (*device)->DeviceExtension;
  61
  62     ext->deviceExtension.MiniDeviceExtension = ext + 1;
  63     ext->deviceExtension.PhysicalDeviceObject = *device;
  64     ext->deviceExtension.NextDeviceObject = native_device;
  65     ext->device_name = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(dev_name) + 1) * sizeof(WCHAR));
  66     lstrcpyW(ext->device_name, dev_name);
  67     ext->link_name.Buffer = NULL;
  68
  69     IoAttachDeviceToDeviceStack(*device, native_device);
  70
  71     return STATUS_SUCCESS;
  72 }
  73
  74 NTSTATUS HID_LinkDevice(DEVICE_OBJECT *device)
  75 {
  76     WCHAR device_instance_id[MAX_DEVICE_ID_LEN];
  77     SP_DEVINFO_DATA Data;
  78     UNICODE_STRING nameW;
  79     NTSTATUS status;
  80     HDEVINFO devinfo;
  81     GUID hidGuid;
  82     BASE_DEVICE_EXTENSION *ext;
  83
  84     HidD_GetHidGuid(&hidGuid);
  85     ext = device->DeviceExtension;
  86
  87     RtlInitUnicodeString( &nameW, ext->device_name);
  88
  89     lstrcpyW(device_instance_id, ext->device_id);
  90     lstrcatW(device_instance_id, L"\\");
  91     lstrcatW(device_instance_id, ext->instance_id);
  92
  93     devinfo = SetupDiCreateDeviceInfoList(&GUID_DEVCLASS_HIDCLASS, NULL);
  94     if (devinfo == INVALID_HANDLE_VALUE)
  95     {
  96         FIXME( "failed to get ClassDevs %x\n", GetLastError());
  97         return STATUS_UNSUCCESSFUL;
  98     }
  99     Data.cbSize = sizeof(Data);
 100     if (SetupDiCreateDeviceInfoW(devinfo, device_instance_id, &GUID_DEVCLASS_HIDCLASS, NULL, NULL, DICD_INHERIT_CLASSDRVS, &Data))
 101     {
 102         if (!SetupDiRegisterDeviceInfo(devinfo, &Data, 0, NULL, NULL, NULL))
 103         {
 104             FIXME( "failed to register device info %x\n", GetLastError());
 105             goto error;
 106         }
 107     }
 108     else if (GetLastError() != ERROR_DEVINST_ALREADY_EXISTS)
 109     {
 110         FIXME( "failed to create device info %x\n", GetLastError());
 111         goto error;
 112     }
 113     SetupDiDestroyDeviceInfoList(devinfo);
 114
 115     status = IoRegisterDeviceInterface(device, &hidGuid, NULL, &ext->link_name);
 116     if (status != STATUS_SUCCESS)
 117     {
 118         FIXME( "failed to register device interface %x\n", status );
 119         return status;
 120     }
 121
 122     /* FIXME: This should probably be done in mouhid.sys. */
 123     if (ext->preparseData->caps.UsagePage == HID_USAGE_PAGE_GENERIC
 124             && ext->preparseData->caps.Usage == HID_USAGE_GENERIC_MOUSE)
 125     {
 126         if (!IoRegisterDeviceInterface(device, &GUID_DEVINTERFACE_MOUSE, NULL, &ext->mouse_link_name))
 127             ext->is_mouse = TRUE;
 128     }
 129
 130     return STATUS_SUCCESS;
 131
 132 error:
 133     SetupDiDestroyDeviceInfoList(devinfo);
 134     return STATUS_UNSUCCESSFUL;
 135 }
 136
 137 static IRP *pop_irp_from_queue(BASE_DEVICE_EXTENSION *ext)
 138 {
 139     LIST_ENTRY *entry;
 140     KIRQL old_irql;
 141     IRP *irp = NULL;
 142
 143     KeAcquireSpinLock(&ext->irp_queue_lock, &old_irql);
 144
 145     while (!irp && (entry = RemoveHeadList(&ext->irp_queue)) != &ext->irp_queue)
 146     {
 147         irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.s.ListEntry);
 148         if (!IoSetCancelRoutine(irp, NULL))
 149         {
 150             /* cancel routine is already cleared, meaning that it was called. let it handle completion. */
 151             InitializeListHead(&irp->Tail.Overlay.s.ListEntry);
 152             irp = NULL;
 153         }
 154     }
 155
 156     KeReleaseSpinLock(&ext->irp_queue_lock, old_irql);
 157     return irp;
 158 }
 159
 160 static void WINAPI read_cancel_routine(DEVICE_OBJECT *device, IRP *irp)
 161 {
 162     BASE_DEVICE_EXTENSION *ext;
 163     KIRQL old_irql;
 164
 165     TRACE("cancel %p IRP on device %p\n", irp, device);
 166
 167     ext = device->DeviceExtension;
 168
 169     IoReleaseCancelSpinLock(irp->CancelIrql);
 170
 171     KeAcquireSpinLock(&ext->irp_queue_lock, &old_irql);
 172
 173     RemoveEntryList(&irp->Tail.Overlay.s.ListEntry);
 174
 175     KeReleaseSpinLock(&ext->irp_queue_lock, old_irql);
 176
 177     irp->IoStatus.u.Status = STATUS_CANCELLED;
 178     irp->IoStatus.Information = 0;
 179     IoCompleteRequest(irp, IO_NO_INCREMENT);
 180 }
 181
 182 void HID_DeleteDevice(DEVICE_OBJECT *device)
 183 {
 184     BASE_DEVICE_EXTENSION *ext;
 185     IRP *irp;
 186
 187     ext = device->DeviceExtension;
 188
 189     if (ext->thread)
 190     {
 191         SetEvent(ext->halt_event);
 192         WaitForSingleObject(ext->thread, INFINITE);
 193     }
 194     CloseHandle(ext->halt_event);
 195
 196     HeapFree(GetProcessHeap(), 0, ext->preparseData);
 197     if (ext->ring_buffer)
 198         RingBuffer_Destroy(ext->ring_buffer);
 199
 200     while((irp = pop_irp_from_queue(ext)))
 201     {
 202         irp->IoStatus.u.Status = STATUS_DEVICE_REMOVED;
 203         IoCompleteRequest(irp, IO_NO_INCREMENT);
 204     }
 205
 206     TRACE("Delete device(%p) %s\n", device, debugstr_w(ext->device_name));
 207     HeapFree(GetProcessHeap(), 0, ext->device_name);
 208     RtlFreeUnicodeString(&ext->link_name);
 209
 210     IoDetachDevice(ext->deviceExtension.NextDeviceObject);
 211     IoDeleteDevice(device);
 212 }
 213
 214 static NTSTATUS copy_packet_into_buffer(HID_XFER_PACKET *packet, BYTE* buffer, ULONG buffer_length, ULONG *out_length)
 215 {
 216     BOOL zero_id = (packet->reportId == 0);
 217
 218     *out_length = 0;
 219
 220     if ((zero_id && buffer_length > packet->reportBufferLen) ||
 221         (!zero_id && buffer_length >= packet->reportBufferLen))
 222     {
 223         if (packet->reportId != 0)
 224         {
 225             memcpy(buffer, packet->reportBuffer, packet->reportBufferLen);
 226             *out_length = packet->reportBufferLen;
 227         }
 228         else
 229         {
 230             buffer[0] = 0;
 231             memcpy(&buffer[1], packet->reportBuffer, packet->reportBufferLen);
 232             *out_length = packet->reportBufferLen + 1;
 233         }
 234         return STATUS_SUCCESS;
 235     }
 236     else
 237         return STATUS_BUFFER_OVERFLOW;
 238 }
 239
 240 static void HID_Device_processQueue(DEVICE_OBJECT *device)
 241 {
 242     IRP *irp;
 243     BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
 244     UINT buffer_size = RingBuffer_GetBufferSize(ext->ring_buffer);
 245     HID_XFER_PACKET *packet;
 246
 247     packet = HeapAlloc(GetProcessHeap(), 0, buffer_size);
 248
 249     while((irp = pop_irp_from_queue(ext)))
 250     {
 251         int ptr;
 252         ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
 253
 254         RingBuffer_Read(ext->ring_buffer, ptr, packet, &buffer_size);
 255         if (buffer_size)
 256         {
 257             NTSTATUS rc;
 258             ULONG out_length;
 259             IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
 260             packet->reportBuffer = (BYTE *)packet + sizeof(*packet);
 261             TRACE_(hid_report)("Processing Request (%i)\n",ptr);
 262             rc = copy_packet_into_buffer(packet, irp->AssociatedIrp.SystemBuffer, irpsp->Parameters.Read.Length, &out_length);
 263             irp->IoStatus.u.Status = rc;
 264             irp->IoStatus.Information = out_length;
 265         }
 266         else
 267         {
 268             irp->IoStatus.Information = 0;
 269             irp->IoStatus.u.Status = STATUS_UNSUCCESSFUL;
 270         }
 271         IoCompleteRequest( irp, IO_NO_INCREMENT );
 272     }
 273     HeapFree(GetProcessHeap(), 0, packet);
 274 }
 275
 276 static NTSTATUS WINAPI read_Completion(DEVICE_OBJECT *deviceObject, IRP *irp, void *context)
 277 {
 278     HANDLE event = context;
 279     SetEvent(event);
 280     return STATUS_MORE_PROCESSING_REQUIRED;
 281 }
 282
 283 static DWORD CALLBACK hid_device_thread(void *args)
 284 {
 285     DEVICE_OBJECT *device = (DEVICE_OBJECT*)args;
 286
 287     IRP *irp;
 288     IO_STATUS_BLOCK irp_status;
 289     HID_XFER_PACKET *packet;
 290     DWORD rc;
 291     HANDLE events[2];
 292     NTSTATUS ntrc;
 293
 294     BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
 295     events[0] = CreateEventA(NULL, TRUE, FALSE, NULL);
 296     events[1] = ext->halt_event;
 297
 298     packet = HeapAlloc(GetProcessHeap(), 0, sizeof(*packet) + ext->preparseData->caps.InputReportByteLength);
 299     packet->reportBuffer = (BYTE *)packet + sizeof(*packet);
 300
 301     if (ext->information.Polled)
 302     {
 303         while(1)
 304         {
 305             ResetEvent(events[0]);
 306
 307             packet->reportBufferLen = ext->preparseData->caps.InputReportByteLength;
 308             packet->reportId = 0;
 309
 310             irp = IoBuildDeviceIoControlRequest(IOCTL_HID_GET_INPUT_REPORT,
 311                 device, NULL, 0, packet, sizeof(*packet), TRUE, NULL,
 312                 &irp_status);
 313
 314             IoSetCompletionRoutine(irp, read_Completion, events[0], TRUE, TRUE, TRUE);
 315             ntrc = IoCallDriver(device, irp);
 316
 317             if (ntrc == STATUS_PENDING)
 318                 WaitForMultipleObjects(2, events, FALSE, INFINITE);
 319
 320             if (irp->IoStatus.u.Status == STATUS_SUCCESS)
 321             {
 322                 RingBuffer_Write(ext->ring_buffer, packet);
 323                 HID_Device_processQueue(device);
 324             }
 325
 326             IoCompleteRequest(irp, IO_NO_INCREMENT );
 327
 328             rc = WaitForSingleObject(ext->halt_event, ext->poll_interval ? ext->poll_interval : DEFAULT_POLL_INTERVAL);
 329
 330             if (rc == WAIT_OBJECT_0)
 331                 break;
 332             else if (rc != WAIT_TIMEOUT)
 333                 ERR("Wait returned unexpected value %x\n",rc);
 334         }
 335     }
 336     else
 337     {
 338         INT exit_now = FALSE;
 339
 340         while(1)
 341         {
 342             ResetEvent(events[0]);
 343
 344             irp = IoBuildDeviceIoControlRequest(IOCTL_HID_READ_REPORT,
 345                 device, NULL, 0, packet->reportBuffer,
 346                 ext->preparseData->caps.InputReportByteLength, TRUE, NULL,
 347                 &irp_status);
 348
 349             IoSetCompletionRoutine(irp, read_Completion, events[0], TRUE, TRUE, TRUE);
 350             ntrc = IoCallDriver(device, irp);
 351
 352             if (ntrc == STATUS_PENDING)
 353             {
 354                 WaitForMultipleObjects(2, events, FALSE, INFINITE);
 355             }
 356
 357             rc = WaitForSingleObject(ext->halt_event, 0);
 358             if (rc == WAIT_OBJECT_0)
 359                 exit_now = TRUE;
 360
 361             if (!exit_now && irp->IoStatus.u.Status == STATUS_SUCCESS)
 362             {
 363                 packet->reportBufferLen = irp->IoStatus.Information;
 364                 if (ext->preparseData->reports[0].reportID)
 365                     packet->reportId = packet->reportBuffer[0];
 366                 else
 367                     packet->reportId = 0;
 368                 RingBuffer_Write(ext->ring_buffer, packet);
 369                 HID_Device_processQueue(device);
 370             }
 371
 372             IoCompleteRequest(irp, IO_NO_INCREMENT );
 373
 374             if (exit_now)
 375                 break;
 376         }
 377     }
 378
 379     /* FIXME: releasing packet requires IRP cancellation support */
 380     CloseHandle(events[0]);
 381
 382     TRACE("Device thread exiting\n");
 383     return 1;
 384 }
 385
 386 void HID_StartDeviceThread(DEVICE_OBJECT *device)
 387 {
 388     BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
 389     ext->halt_event = CreateEventA(NULL, TRUE, FALSE, NULL);
 390     ext->thread = CreateThread(NULL, 0, hid_device_thread, device, 0, NULL);
 391 }
 392
 393 static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_INFORMATION(IRP *irp, BASE_DEVICE_EXTENSION *base)
 394 {
 395     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 396     if (irpsp->Parameters.DeviceIoControl.OutputBufferLength <  sizeof(HID_COLLECTION_INFORMATION))
 397     {
 398         irp->IoStatus.u.Status = STATUS_BUFFER_OVERFLOW;
 399         irp->IoStatus.Information = 0;
 400     }
 401     else
 402     {
 403         memcpy(irp->AssociatedIrp.SystemBuffer, &base->information, sizeof(HID_COLLECTION_INFORMATION));
 404         irp->IoStatus.Information = sizeof(HID_COLLECTION_INFORMATION);
 405         irp->IoStatus.u.Status = STATUS_SUCCESS;
 406     }
 407     return STATUS_SUCCESS;
 408 }
 409
 410 static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_DESCRIPTOR(IRP *irp, BASE_DEVICE_EXTENSION *base)
 411 {
 412     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 413
 414     if (irpsp->Parameters.DeviceIoControl.OutputBufferLength <  base->preparseData->dwSize)
 415     {
 416         irp->IoStatus.u.Status = STATUS_INVALID_BUFFER_SIZE;
 417         irp->IoStatus.Information = 0;
 418     }
 419     else
 420     {
 421         memcpy(irp->UserBuffer, base->preparseData, base->preparseData->dwSize);
 422         irp->IoStatus.Information = base->preparseData->dwSize;
 423         irp->IoStatus.u.Status = STATUS_SUCCESS;
 424     }
 425     return STATUS_SUCCESS;
 426 }
 427
 428 static NTSTATUS handle_minidriver_string(DEVICE_OBJECT *device, IRP *irp, SHORT index)
 429 {
 430     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 431     WCHAR buffer[127];
 432     NTSTATUS status;
 433     ULONG InputBuffer;
 434
 435     InputBuffer = MAKELONG(index, 0);
 436     status = call_minidriver(IOCTL_HID_GET_STRING, device, ULongToPtr(InputBuffer), sizeof(InputBuffer), buffer, sizeof(buffer));
 437
 438     if (status == STATUS_SUCCESS)
 439     {
 440         WCHAR *out_buffer = MmGetSystemAddressForMdlSafe(irp->MdlAddress, NormalPagePriority);
 441         int length = irpsp->Parameters.DeviceIoControl.OutputBufferLength/sizeof(WCHAR);
 442         TRACE("got string %s from minidriver\n",debugstr_w(buffer));
 443         lstrcpynW(out_buffer, buffer, length);
 444         irp->IoStatus.Information = (lstrlenW(buffer)+1) * sizeof(WCHAR);
 445     }
 446     irp->IoStatus.u.Status = status;
 447
 448     return STATUS_SUCCESS;
 449 }
 450
 451 static NTSTATUS HID_get_feature(DEVICE_OBJECT *device, IRP *irp)
 452 {
 453     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 454     HID_XFER_PACKET *packet;
 455     DWORD len;
 456     NTSTATUS rc = STATUS_SUCCESS;
 457     BYTE *out_buffer;
 458
 459     irp->IoStatus.Information = 0;
 460
 461     out_buffer = MmGetSystemAddressForMdlSafe(irp->MdlAddress, NormalPagePriority);
 462     TRACE_(hid_report)("Device %p Buffer length %i Buffer %p\n", device, irpsp->Parameters.DeviceIoControl.OutputBufferLength, out_buffer);
 463
 464     len = sizeof(*packet) + irpsp->Parameters.DeviceIoControl.OutputBufferLength;
 465     packet = HeapAlloc(GetProcessHeap(), 0, len);
 466     packet->reportBufferLen = irpsp->Parameters.DeviceIoControl.OutputBufferLength;
 467     packet->reportBuffer = ((BYTE*)packet) + sizeof(*packet);
 468     packet->reportId = out_buffer[0];
 469
 470     TRACE_(hid_report)("(id %i, len %i buffer %p)\n", packet->reportId, packet->reportBufferLen, packet->reportBuffer);
 471
 472     rc = call_minidriver(IOCTL_HID_GET_FEATURE, device, NULL, 0, packet, sizeof(*packet));
 473
 474     irp->IoStatus.u.Status = rc;
 475     if (irp->IoStatus.u.Status == STATUS_SUCCESS)
 476     {
 477         irp->IoStatus.Information = packet->reportBufferLen;
 478         memcpy(out_buffer, packet->reportBuffer, packet->reportBufferLen);
 479     }
 480     else
 481         irp->IoStatus.Information = 0;
 482
 483     TRACE_(hid_report)("Result 0x%x get %li bytes\n", rc, irp->IoStatus.Information);
 484
 485     HeapFree(GetProcessHeap(), 0, packet);
 486
 487     return rc;
 488 }
 489
 490 static NTSTATUS HID_set_to_device(DEVICE_OBJECT *device, IRP *irp)
 491 {
 492     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
 493     BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
 494     HID_XFER_PACKET packet;
 495     ULONG max_len;
 496     NTSTATUS rc;
 497
 498     TRACE_(hid_report)("Device %p Buffer length %i Buffer %p\n", device, irpsp->Parameters.DeviceIoControl.InputBufferLength, irp->AssociatedIrp.SystemBuffer);
 499     packet.reportId = ((BYTE*)irp->AssociatedIrp.SystemBuffer)[0];
 500     if (packet.reportId == 0)
 501     {
 502         packet.reportBuffer = &((BYTE*)irp->AssociatedIrp.SystemBuffer)[1];
 503         packet.reportBufferLen = irpsp->Parameters.DeviceIoControl.InputBufferLength - 1;
 504         if (irpsp->Parameters.DeviceIoControl.IoControlCode == IOCTL_HID_SET_FEATURE)
 505             max_len = ext->preparseData->caps.FeatureReportByteLength;
 506         else
 507             max_len = ext->preparseData->caps.OutputReportByteLength;
 508     }
 509     else
 510     {
 511         packet.reportBuffer = irp->AssociatedIrp.SystemBuffer;
 512         packet.reportBufferLen = irpsp->Parameters.DeviceIoControl.InputBufferLength;
 513         if (irpsp->Parameters.DeviceIoControl.IoControlCode == IOCTL_HID_SET_FEATURE)
 514             max_len = (ext->preparseData->reports[ext->preparseData->reportIdx[HidP_Feature][packet.reportId]].bitSize + 7) / 8;
 515         else
 516             max_len = (ext->preparseData->reports[ext->preparseData->reportIdx[HidP_Output][packet.reportId]].bitSize + 7) / 8;
 517     }
 518     if (packet.reportBufferLen > max_len)
 519         packet.reportBufferLen = max_len;
 520
 521     TRACE_(hid_report)("(id %i, len %i buffer %p)\n", packet.reportId, packet.reportBufferLen, packet.reportBuffer);
 522
 523     rc = call_minidriver(irpsp->Parameters.DeviceIoControl.IoControlCode,
 524         device, NULL, 0, &packet, sizeof(packet));
 525
 526     irp->IoStatus.u.Status = rc;
 527     if (irp->IoStatus.u.Status == STATUS_SUCCESS)
 528         irp->IoStatus.Information = irpsp->Parameters.DeviceIoControl.InputBufferLength;
 529     else
 530         irp->IoStatus.Information = 0;
 531
 532     TRACE_(hid_report)("Result 0x%x set %li bytes\n", rc, irp->IoStatus.Information);
 533
 534     return rc;
 535 }
 536
 537 NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
 538 {
 539     NTSTATUS rc = STATUS_SUCCESS;
 540     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 541     BASE_DEVICE_EXTENSION *extension = device->DeviceExtension;
 542
 543     irp->IoStatus.Information = 0;
 544
 545     TRACE("device %p ioctl(%x)\n", device, irpsp->Parameters.DeviceIoControl.IoControlCode);
 546
 547     switch (irpsp->Parameters.DeviceIoControl.IoControlCode)
 548     {
 549         case IOCTL_HID_GET_POLL_FREQUENCY_MSEC:
 550             TRACE("IOCTL_HID_GET_POLL_FREQUENCY_MSEC\n");
 551             if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
 552             {
 553                 irp->IoStatus.u.Status = STATUS_BUFFER_OVERFLOW;
 554                 irp->IoStatus.Information = 0;
 555                 break;
 556             }
 557             *((ULONG*)irp->AssociatedIrp.SystemBuffer) = extension->poll_interval;
 558             irp->IoStatus.Information = sizeof(ULONG);
 559             irp->IoStatus.u.Status = STATUS_SUCCESS;
 560             break;
 561         case IOCTL_HID_SET_POLL_FREQUENCY_MSEC:
 562         {
 563             ULONG poll_interval;
 564             TRACE("IOCTL_HID_SET_POLL_FREQUENCY_MSEC\n");
 565             if (irpsp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG))
 566             {
 567                 irp->IoStatus.u.Status = STATUS_BUFFER_TOO_SMALL;
 568                 break;
 569             }
 570             poll_interval = *(ULONG *)irp->AssociatedIrp.SystemBuffer;
 571             if (poll_interval <= MAX_POLL_INTERVAL_MSEC)
 572             {
 573                 extension->poll_interval = poll_interval;
 574                 irp->IoStatus.u.Status = STATUS_SUCCESS;
 575             }
 576             else
 577                 irp->IoStatus.u.Status = STATUS_INVALID_PARAMETER;
 578             break;
 579         }
 580         case IOCTL_HID_GET_PRODUCT_STRING:
 581         {
 582             rc = handle_minidriver_string(device, irp, HID_STRING_ID_IPRODUCT);
 583             break;
 584         }
 585         case IOCTL_HID_GET_SERIALNUMBER_STRING:
 586         {
 587             rc = handle_minidriver_string(device, irp, HID_STRING_ID_ISERIALNUMBER);
 588             break;
 589         }
 590         case IOCTL_HID_GET_MANUFACTURER_STRING:
 591         {
 592             rc = handle_minidriver_string(device, irp, HID_STRING_ID_IMANUFACTURER);
 593             break;
 594         }
 595         case IOCTL_HID_GET_COLLECTION_INFORMATION:
 596         {
 597             rc = handle_IOCTL_HID_GET_COLLECTION_INFORMATION(irp, extension);
 598             break;
 599         }
 600         case IOCTL_HID_GET_COLLECTION_DESCRIPTOR:
 601         {
 602             rc = handle_IOCTL_HID_GET_COLLECTION_DESCRIPTOR(irp, extension);
 603             break;
 604         }
 605         case IOCTL_HID_GET_INPUT_REPORT:
 606         {
 607             HID_XFER_PACKET *packet;
 608             UINT packet_size = sizeof(*packet) + irpsp->Parameters.DeviceIoControl.OutputBufferLength;
 609             BYTE *buffer = MmGetSystemAddressForMdlSafe(irp->MdlAddress, NormalPagePriority);
 610             ULONG out_length;
 611
 612             packet = HeapAlloc(GetProcessHeap(), 0, packet_size);
 613
 614             if (extension->preparseData->reports[0].reportID)
 615                 packet->reportId = buffer[0];
 616             else
 617                 packet->reportId = 0;
 618             packet->reportBuffer = (BYTE *)packet + sizeof(*packet);
 619             packet->reportBufferLen = irpsp->Parameters.DeviceIoControl.OutputBufferLength - 1;
 620
 621             rc = call_minidriver(IOCTL_HID_GET_INPUT_REPORT, device, NULL, 0, packet, sizeof(*packet));
 622             if (rc == STATUS_SUCCESS)
 623             {
 624                 rc = copy_packet_into_buffer(packet, buffer, irpsp->Parameters.DeviceIoControl.OutputBufferLength, &out_length);
 625                 irp->IoStatus.Information = out_length;
 626             }
 627             else
 628                 irp->IoStatus.Information = 0;
 629             irp->IoStatus.u.Status = rc;
 630             HeapFree(GetProcessHeap(), 0, packet);
 631             break;
 632         }
 633         case IOCTL_SET_NUM_DEVICE_INPUT_BUFFERS:
 634         {
 635             irp->IoStatus.Information = 0;
 636
 637             if (irpsp->Parameters.DeviceIoControl.InputBufferLength != sizeof(ULONG))
 638             {
 639                 irp->IoStatus.u.Status = rc = STATUS_BUFFER_OVERFLOW;
 640             }
 641             else
 642             {
 643                 rc = RingBuffer_SetSize(extension->ring_buffer, *(ULONG*)irp->AssociatedIrp.SystemBuffer);
 644                 irp->IoStatus.u.Status = rc;
 645             }
 646             break;
 647         }
 648         case IOCTL_GET_NUM_DEVICE_INPUT_BUFFERS:
 649         {
 650             if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
 651             {
 652                 irp->IoStatus.u.Status = rc = STATUS_BUFFER_TOO_SMALL;
 653             }
 654             else
 655             {
 656                 *(ULONG*)irp->AssociatedIrp.SystemBuffer = RingBuffer_GetSize(extension->ring_buffer);
 657                 rc = irp->IoStatus.u.Status = STATUS_SUCCESS;
 658             }
 659             break;
 660         }
 661         case IOCTL_HID_GET_FEATURE:
 662             rc = HID_get_feature(device, irp);
 663             break;
 664         case IOCTL_HID_SET_FEATURE:
 665         case IOCTL_HID_SET_OUTPUT_REPORT:
 666             rc = HID_set_to_device(device, irp);
 667             break;
 668         default:
 669         {
 670             ULONG code = irpsp->Parameters.DeviceIoControl.IoControlCode;
 671             FIXME("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
 672                   code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
 673             irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
 674             rc = STATUS_UNSUCCESSFUL;
 675             break;
 676         }
 677     }
 678
 679     if (rc != STATUS_PENDING)
 680         IoCompleteRequest( irp, IO_NO_INCREMENT );
 681
 682     return rc;
 683 }
 684
 685 NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp)
 686 {
 687     HID_XFER_PACKET *packet;
 688     BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
 689     UINT buffer_size = RingBuffer_GetBufferSize(ext->ring_buffer);
 690     NTSTATUS rc = STATUS_SUCCESS;
 691     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
 692     int ptr = -1;
 693
 694     packet = HeapAlloc(GetProcessHeap(), 0, buffer_size);
 695     ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
 696
 697     irp->IoStatus.Information = 0;
 698     RingBuffer_ReadNew(ext->ring_buffer, ptr, packet, &buffer_size);
 699
 700     if (buffer_size)
 701     {
 702         IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 703         NTSTATUS rc;
 704         ULONG out_length;
 705         packet->reportBuffer = (BYTE *)packet + sizeof(*packet);
 706         TRACE_(hid_report)("Got Packet %p %i\n", packet->reportBuffer, packet->reportBufferLen);
 707
 708         rc = copy_packet_into_buffer(packet, irp->AssociatedIrp.SystemBuffer, irpsp->Parameters.Read.Length, &out_length);
 709         irp->IoStatus.Information = out_length;
 710         irp->IoStatus.u.Status = rc;
 711         IoCompleteRequest(irp, IO_NO_INCREMENT);
 712     }
 713     else
 714     {
 715         BASE_DEVICE_EXTENSION *extension = device->DeviceExtension;
 716         if (extension->poll_interval)
 717         {
 718             KIRQL old_irql;
 719             TRACE_(hid_report)("Queue irp\n");
 720
 721             KeAcquireSpinLock(&ext->irp_queue_lock, &old_irql);
 722
 723             IoSetCancelRoutine(irp, read_cancel_routine);
 724             if (irp->Cancel && !IoSetCancelRoutine(irp, NULL))
 725             {
 726                 /* IRP was canceled before we set cancel routine */
 727                 InitializeListHead(&irp->Tail.Overlay.s.ListEntry);
 728                 KeReleaseSpinLock(&ext->irp_queue_lock, old_irql);
 729                 return STATUS_CANCELLED;
 730             }
 731
 732             InsertTailList(&ext->irp_queue, &irp->Tail.Overlay.s.ListEntry);
 733             IoMarkIrpPending(irp);
 734
 735             KeReleaseSpinLock(&ext->irp_queue_lock, old_irql);
 736             rc = STATUS_PENDING;
 737         }
 738         else
 739         {
 740             HID_XFER_PACKET packet;
 741             TRACE("No packet, but opportunistic reads enabled\n");
 742             packet.reportId = ((BYTE*)irp->AssociatedIrp.SystemBuffer)[0];
 743             packet.reportBuffer = &((BYTE*)irp->AssociatedIrp.SystemBuffer)[1];
 744             packet.reportBufferLen = irpsp->Parameters.Read.Length - 1;
 745             rc = call_minidriver(IOCTL_HID_GET_INPUT_REPORT, device, NULL, 0, &packet, sizeof(packet));
 746
 747             if (rc == STATUS_SUCCESS)
 748             {
 749                 ((BYTE*)irp->AssociatedIrp.SystemBuffer)[0] = packet.reportId;
 750                 irp->IoStatus.Information = packet.reportBufferLen + 1;
 751                 irp->IoStatus.u.Status = rc;
 752             }
 753             IoCompleteRequest(irp, IO_NO_INCREMENT);
 754         }
 755     }
 756     HeapFree(GetProcessHeap(), 0, packet);
 757
 758     return rc;
 759 }
 760
 761 NTSTATUS WINAPI HID_Device_write(DEVICE_OBJECT *device, IRP *irp)
 762 {
 763     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 764     BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
 765     HID_XFER_PACKET packet;
 766     ULONG max_len;
 767     NTSTATUS rc;
 768
 769     irp->IoStatus.Information = 0;
 770
 771     TRACE_(hid_report)("Device %p Buffer length %i Buffer %p\n", device, irpsp->Parameters.Write.Length, irp->AssociatedIrp.SystemBuffer);
 772     packet.reportId = ((BYTE*)irp->AssociatedIrp.SystemBuffer)[0];
 773     if (packet.reportId == 0)
 774     {
 775         packet.reportBuffer = &((BYTE*)irp->AssociatedIrp.SystemBuffer)[1];
 776         packet.reportBufferLen = irpsp->Parameters.Write.Length - 1;
 777         max_len = ext->preparseData->caps.OutputReportByteLength;
 778     }
 779     else
 780     {
 781         packet.reportBuffer = irp->AssociatedIrp.SystemBuffer;
 782         packet.reportBufferLen = irpsp->Parameters.Write.Length;
 783         max_len = (ext->preparseData->reports[ext->preparseData->reportIdx[HidP_Output][packet.reportId]].bitSize + 7) / 8;
 784     }
 785     if (packet.reportBufferLen > max_len)
 786         packet.reportBufferLen = max_len;
 787
 788     TRACE_(hid_report)("(id %i, len %i buffer %p)\n", packet.reportId, packet.reportBufferLen, packet.reportBuffer);
 789
 790     rc = call_minidriver(IOCTL_HID_WRITE_REPORT, device, NULL, 0, &packet, sizeof(packet));
 791
 792     irp->IoStatus.u.Status = rc;
 793     if (irp->IoStatus.u.Status == STATUS_SUCCESS)
 794         irp->IoStatus.Information = irpsp->Parameters.Write.Length;
 795     else
 796         irp->IoStatus.Information = 0;
 797
 798     TRACE_(hid_report)("Result 0x%x wrote %li bytes\n", rc, irp->IoStatus.Information);
 799
 800     IoCompleteRequest( irp, IO_NO_INCREMENT );
 801     return rc;
 802 }
 803
 804 NTSTATUS WINAPI HID_Device_create(DEVICE_OBJECT *device, IRP *irp)
 805 {
 806     BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
 807
 808     TRACE("Open handle on device %p\n", device);
 809     irp->Tail.Overlay.OriginalFileObject->FsContext = UlongToPtr(RingBuffer_AddPointer(ext->ring_buffer));
 810     irp->IoStatus.u.Status = STATUS_SUCCESS;
 811     IoCompleteRequest( irp, IO_NO_INCREMENT );
 812     return STATUS_SUCCESS;
 813 }
 814
 815 NTSTATUS WINAPI HID_Device_close(DEVICE_OBJECT *device, IRP *irp)
 816 {
 817     BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
 818     int ptr = PtrToUlong(irp->Tail.Overlay.OriginalFileObject->FsContext);
 819     TRACE("Close handle on device %p\n", device);
 820     RingBuffer_RemovePointer(ext->ring_buffer, ptr);
 821     irp->IoStatus.u.Status = STATUS_SUCCESS;
 822     IoCompleteRequest( irp, IO_NO_INCREMENT );
 823     return STATUS_SUCCESS;
 824 }