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