dlls/winebus.sys/main.c

   1 /*
   2  * WINE Platform native bus driver
   3  *
   4  * Copyright 2016 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 #include "config.h"
  21 #include <stdarg.h>
  22
  23 #define NONAMELESSUNION
  24 #define NONAMELESSSTRUCT
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include "winternl.h"
  29 #include "winioctl.h"
  30 #include "hidusage.h"
  31 #include "ddk/wdm.h"
  32 #include "ddk/hidport.h"
  33 #include "ddk/hidtypes.h"
  34 #include "wine/asm.h"
  35 #include "wine/debug.h"
  36 #include "wine/unicode.h"
  37 #include "wine/list.h"
  38
  39 #include "bus.h"
  40 #include "controller.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(plugplay);
  43 WINE_DECLARE_DEBUG_CHANNEL(hid_report);
  44
  45 #if defined(__i386__) && !defined(_WIN32)
  46
  47 extern void * WINAPI wrap_fastcall_func1( void *func, const void *a );
  48 __ASM_STDCALL_FUNC( wrap_fastcall_func1, 8,
  49                    "popl %ecx\n\t"
  50                    "popl %eax\n\t"
  51                    "xchgl (%esp),%ecx\n\t"
  52                    "jmp *%eax" );
  53
  54 #define call_fastcall_func1(func,a) wrap_fastcall_func1(func,a)
  55
  56 #else
  57
  58 #define call_fastcall_func1(func,a) func(a)
  59
  60 #endif
  61
  62 struct product_desc
  63 {
  64     WORD vid;
  65     WORD pid;
  66     const WCHAR* manufacturer;
  67     const WCHAR* product;
  68     const WCHAR* serialnumber;
  69 };
  70
  71 #define VID_MICROSOFT 0x045e
  72
  73 static const WCHAR xbox360_product_string[] = {
  74     'C','o','n','t','r','o','l','l','e','r',' ','(','X','B','O','X',' ','3','6','0',' ','F','o','r',' ','W','i','n','d','o','w','s',')',0
  75 };
  76
  77 static const WCHAR xboxone_product_string[] = {
  78     'C','o','n','t','r','o','l','l','e','r',' ','(','X','B','O','X',' ','O','n','e',' ','F','o','r',' ','W','i','n','d','o','w','s',')',0
  79 };
  80
  81 static const struct product_desc XBOX_CONTROLLERS[] = {
  82     {VID_MICROSOFT, 0x0202, NULL, NULL, NULL}, /* Xbox Controller */
  83     {VID_MICROSOFT, 0x0285, NULL, NULL, NULL}, /* Xbox Controller S */
  84     {VID_MICROSOFT, 0x0289, NULL, NULL, NULL}, /* Xbox Controller S */
  85     {VID_MICROSOFT, 0x028e, NULL, xbox360_product_string, NULL}, /* Xbox360 Controller */
  86     {VID_MICROSOFT, 0x028f, NULL, xbox360_product_string, NULL}, /* Xbox360 Wireless Controller */
  87     {VID_MICROSOFT, 0x02d1, NULL, xboxone_product_string, NULL}, /* Xbox One Controller */
  88     {VID_MICROSOFT, 0x02dd, NULL, xboxone_product_string, NULL}, /* Xbox One Controller (Covert Forces/Firmware 2015) */
  89     {VID_MICROSOFT, 0x02e0, NULL, NULL, NULL}, /* Xbox One X Controller */
  90     {VID_MICROSOFT, 0x02e3, NULL, xboxone_product_string, NULL}, /* Xbox One Elite Controller */
  91     {VID_MICROSOFT, 0x02e6, NULL, NULL, NULL}, /* Wireless XBox Controller Dongle */
  92     {VID_MICROSOFT, 0x02ea, NULL, xboxone_product_string, NULL}, /* Xbox One S Controller */
  93     {VID_MICROSOFT, 0x02fd, NULL, xboxone_product_string, NULL}, /* Xbox One S Controller (Firmware 2017) */
  94     {VID_MICROSOFT, 0x0719, NULL, xbox360_product_string, NULL}, /* Xbox 360 Wireless Adapter */
  95 };
  96
  97 static DRIVER_OBJECT *driver_obj;
  98
  99 static DEVICE_OBJECT *mouse_obj;
 100 static DEVICE_OBJECT *keyboard_obj;
 101
 102 /* The root-enumerated device stack. */
 103 DEVICE_OBJECT *bus_pdo;
 104 static DEVICE_OBJECT *bus_fdo;
 105
 106 HANDLE driver_key;
 107
 108 struct pnp_device
 109 {
 110     struct list entry;
 111     DEVICE_OBJECT *device;
 112 };
 113
 114 struct device_extension
 115 {
 116     CRITICAL_SECTION cs;
 117
 118     BOOL removed;
 119
 120     struct pnp_device *pnp_device;
 121
 122     WORD vid, pid, input;
 123     DWORD uid, version, index;
 124     BOOL is_gamepad;
 125     WCHAR *serial;
 126     const WCHAR *busid;  /* Expected to be a static constant */
 127
 128     const platform_vtbl *vtbl;
 129
 130     BYTE *last_report;
 131     DWORD last_report_size;
 132     BOOL last_report_read;
 133     DWORD buffer_size;
 134     LIST_ENTRY irp_queue;
 135
 136     BYTE platform_private[1];
 137 };
 138
 139 static CRITICAL_SECTION device_list_cs;
 140 static CRITICAL_SECTION_DEBUG critsect_debug =
 141 {
 142     0, 0, &device_list_cs,
 143     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 144       0, 0, { (DWORD_PTR)(__FILE__ ": device_list_cs") }
 145 };
 146 static CRITICAL_SECTION device_list_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 147
 148 static struct list pnp_devset = LIST_INIT(pnp_devset);
 149
 150 static const WCHAR zero_serialW[]= {'0','0','0','0',0};
 151 static const WCHAR miW[] = {'M','I',0};
 152 static const WCHAR igW[] = {'I','G',0};
 153
 154 static inline WCHAR *strdupW(const WCHAR *src)
 155 {
 156     WCHAR *dst;
 157     if (!src) return NULL;
 158     dst = HeapAlloc(GetProcessHeap(), 0, (strlenW(src) + 1)*sizeof(WCHAR));
 159     if (dst) strcpyW(dst, src);
 160     return dst;
 161 }
 162
 163 void *get_platform_private(DEVICE_OBJECT *device)
 164 {
 165     struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
 166     return ext->platform_private;
 167 }
 168
 169 static DWORD get_device_index(WORD vid, WORD pid, WORD input)
 170 {
 171     struct pnp_device *ptr;
 172     DWORD index = 0;
 173
 174     LIST_FOR_EACH_ENTRY(ptr, &pnp_devset, struct pnp_device, entry)
 175     {
 176         struct device_extension *ext = (struct device_extension *)ptr->device->DeviceExtension;
 177         if (ext->vid == vid && ext->pid == pid && ext->input == input)
 178             index = max(ext->index + 1, index);
 179     }
 180
 181     return index;
 182 }
 183
 184 static WCHAR *get_instance_id(DEVICE_OBJECT *device)
 185 {
 186     static const WCHAR formatW[] =  {'%','i','&','%','s','&','%','x','&','%','i',0};
 187     struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
 188     const WCHAR *serial = ext->serial ? ext->serial : zero_serialW;
 189     DWORD len = strlenW(serial) + 33;
 190     WCHAR *dst;
 191
 192     if ((dst = ExAllocatePool(PagedPool, len * sizeof(WCHAR))))
 193         sprintfW(dst, formatW, ext->version, serial, ext->uid, ext->index);
 194
 195     return dst;
 196 }
 197
 198 static WCHAR *get_device_id(DEVICE_OBJECT *device)
 199 {
 200     static const WCHAR formatW[] = {'%','s','\\','v','i','d','_','%','0','4','x',
 201             '&','p','i','d','_','%','0','4','x',0};
 202     static const WCHAR format_inputW[] = {'%','s','\\','v','i','d','_','%','0','4','x',
 203             '&','p','i','d','_','%','0','4','x','&','%','s','_','%','0','2','i',0};
 204     struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
 205     DWORD len = strlenW(ext->busid) + 34;
 206     WCHAR *dst;
 207
 208     if ((dst = ExAllocatePool(PagedPool, len * sizeof(WCHAR))))
 209     {
 210         if (ext->input == (WORD)-1)
 211         {
 212             sprintfW(dst, formatW, ext->busid, ext->vid, ext->pid);
 213         }
 214         else
 215         {
 216             sprintfW(dst, format_inputW, ext->busid, ext->vid, ext->pid,
 217                     ext->is_gamepad ? igW : miW, ext->input);
 218         }
 219     }
 220
 221     return dst;
 222 }
 223
 224 static WCHAR *get_compatible_ids(DEVICE_OBJECT *device)
 225 {
 226     struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
 227     WCHAR *dst;
 228
 229     if ((dst = ExAllocatePool(PagedPool, (strlenW(ext->busid) + 2) * sizeof(WCHAR))))
 230     {
 231         strcpyW(dst, ext->busid);
 232         dst[strlenW(dst) + 1] = 0;
 233     }
 234
 235     return dst;
 236 }
 237
 238 static void remove_pending_irps(DEVICE_OBJECT *device)
 239 {
 240     struct device_extension *ext = device->DeviceExtension;
 241     LIST_ENTRY *entry;
 242
 243     while ((entry = RemoveHeadList(&ext->irp_queue)) != &ext->irp_queue)
 244     {
 245         IRP *queued_irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.s.ListEntry);
 246         queued_irp->IoStatus.u.Status = STATUS_DELETE_PENDING;
 247         queued_irp->IoStatus.Information = 0;
 248         IoCompleteRequest(queued_irp, IO_NO_INCREMENT);
 249     }
 250 }
 251
 252 DEVICE_OBJECT *bus_create_hid_device(const WCHAR *busidW, WORD vid, WORD pid,
 253                                      WORD input, DWORD version, DWORD uid, const WCHAR *serialW, BOOL is_gamepad,
 254                                      const platform_vtbl *vtbl, DWORD platform_data_size)
 255 {
 256     static const WCHAR device_name_fmtW[] = {'\\','D','e','v','i','c','e','\\','%','s','#','%','p',0};
 257     struct device_extension *ext;
 258     struct pnp_device *pnp_dev;
 259     DEVICE_OBJECT *device;
 260     UNICODE_STRING nameW;
 261     WCHAR dev_name[256];
 262     NTSTATUS status;
 263     DWORD length;
 264
 265     TRACE("(%s, %04x, %04x, %04x, %u, %u, %s, %u, %p, %u)\n",
 266             debugstr_w(busidW), vid, pid, input, version, uid, debugstr_w(serialW),
 267             is_gamepad, vtbl, platform_data_size);
 268
 269     if (!(pnp_dev = HeapAlloc(GetProcessHeap(), 0, sizeof(*pnp_dev))))
 270         return NULL;
 271
 272     sprintfW(dev_name, device_name_fmtW, busidW, pnp_dev);
 273     RtlInitUnicodeString(&nameW, dev_name);
 274     length = FIELD_OFFSET(struct device_extension, platform_private[platform_data_size]);
 275     status = IoCreateDevice(driver_obj, length, &nameW, 0, 0, FALSE, &device);
 276     if (status)
 277     {
 278         FIXME("failed to create device error %x\n", status);
 279         HeapFree(GetProcessHeap(), 0, pnp_dev);
 280         return NULL;
 281     }
 282
 283     EnterCriticalSection(&device_list_cs);
 284
 285     /* fill out device_extension struct */
 286     ext = (struct device_extension *)device->DeviceExtension;
 287     ext->pnp_device         = pnp_dev;
 288     ext->vid                = vid;
 289     ext->pid                = pid;
 290     ext->input              = input;
 291     ext->uid                = uid;
 292     ext->version            = version;
 293     ext->index              = get_device_index(vid, pid, input);
 294     ext->is_gamepad         = is_gamepad;
 295     ext->serial             = strdupW(serialW);
 296     ext->busid              = busidW;
 297     ext->vtbl               = vtbl;
 298     ext->last_report        = NULL;
 299     ext->last_report_size   = 0;
 300     ext->last_report_read   = TRUE;
 301     ext->buffer_size        = 0;
 302
 303     memset(ext->platform_private, 0, platform_data_size);
 304
 305     InitializeListHead(&ext->irp_queue);
 306     InitializeCriticalSection(&ext->cs);
 307     ext->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": cs");
 308
 309     /* add to list of pnp devices */
 310     pnp_dev->device = device;
 311     list_add_tail(&pnp_devset, &pnp_dev->entry);
 312
 313     LeaveCriticalSection(&device_list_cs);
 314     return device;
 315 }
 316
 317 DEVICE_OBJECT *bus_find_hid_device(const platform_vtbl *vtbl, void *platform_dev)
 318 {
 319     struct pnp_device *dev;
 320     DEVICE_OBJECT *ret = NULL;
 321
 322     TRACE("(%p, %p)\n", vtbl, platform_dev);
 323
 324     EnterCriticalSection(&device_list_cs);
 325     LIST_FOR_EACH_ENTRY(dev, &pnp_devset, struct pnp_device, entry)
 326     {
 327         struct device_extension *ext = (struct device_extension *)dev->device->DeviceExtension;
 328         if (ext->vtbl != vtbl) continue;
 329         if (ext->vtbl->compare_platform_device(dev->device, platform_dev) == 0)
 330         {
 331             ret = dev->device;
 332             break;
 333         }
 334     }
 335     LeaveCriticalSection(&device_list_cs);
 336
 337     TRACE("returning %p\n", ret);
 338     return ret;
 339 }
 340
 341 DEVICE_OBJECT* bus_enumerate_hid_devices(const platform_vtbl *vtbl, enum_func function, void* context)
 342 {
 343     struct pnp_device *dev, *dev_next;
 344     DEVICE_OBJECT *ret = NULL;
 345     int cont;
 346
 347     TRACE("(%p)\n", vtbl);
 348
 349     EnterCriticalSection(&device_list_cs);
 350     LIST_FOR_EACH_ENTRY_SAFE(dev, dev_next, &pnp_devset, struct pnp_device, entry)
 351     {
 352         struct device_extension *ext = (struct device_extension *)dev->device->DeviceExtension;
 353         if (ext->vtbl != vtbl) continue;
 354         LeaveCriticalSection(&device_list_cs);
 355         cont = function(dev->device, context);
 356         EnterCriticalSection(&device_list_cs);
 357         if (!cont)
 358         {
 359             ret = dev->device;
 360             break;
 361         }
 362     }
 363     LeaveCriticalSection(&device_list_cs);
 364     return ret;
 365 }
 366
 367 void bus_unlink_hid_device(DEVICE_OBJECT *device)
 368 {
 369     struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
 370     struct pnp_device *pnp_device = ext->pnp_device;
 371
 372     EnterCriticalSection(&device_list_cs);
 373     list_remove(&pnp_device->entry);
 374     LeaveCriticalSection(&device_list_cs);
 375 }
 376
 377 void bus_remove_hid_device(DEVICE_OBJECT *device)
 378 {
 379     struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
 380     struct pnp_device *pnp_device = ext->pnp_device;
 381
 382     TRACE("(%p)\n", device);
 383
 384     ext->cs.DebugInfo->Spare[0] = 0;
 385     DeleteCriticalSection(&ext->cs);
 386
 387     HeapFree(GetProcessHeap(), 0, ext->serial);
 388     HeapFree(GetProcessHeap(), 0, ext->last_report);
 389     IoDeleteDevice(device);
 390
 391     /* pnp_device must be released after the device is gone */
 392     HeapFree(GetProcessHeap(), 0, pnp_device);
 393 }
 394
 395 static NTSTATUS build_device_relations(DEVICE_RELATIONS **devices)
 396 {
 397     int i;
 398     struct pnp_device *ptr;
 399
 400     EnterCriticalSection(&device_list_cs);
 401     *devices = ExAllocatePool(PagedPool, offsetof(DEVICE_RELATIONS, Objects[list_count(&pnp_devset)]));
 402
 403     if (!*devices)
 404     {
 405         LeaveCriticalSection(&device_list_cs);
 406         return STATUS_INSUFFICIENT_RESOURCES;
 407     }
 408
 409     i = 0;
 410     LIST_FOR_EACH_ENTRY(ptr, &pnp_devset, struct pnp_device, entry)
 411     {
 412         (*devices)->Objects[i] = ptr->device;
 413         call_fastcall_func1(ObfReferenceObject, ptr->device);
 414         i++;
 415     }
 416     LeaveCriticalSection(&device_list_cs);
 417     (*devices)->Count = i;
 418     return STATUS_SUCCESS;
 419 }
 420
 421 static NTSTATUS handle_IRP_MN_QUERY_DEVICE_RELATIONS(IRP *irp)
 422 {
 423     NTSTATUS status = irp->IoStatus.u.Status;
 424     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 425
 426     TRACE("IRP_MN_QUERY_DEVICE_RELATIONS\n");
 427     switch (irpsp->Parameters.QueryDeviceRelations.Type)
 428     {
 429         case EjectionRelations:
 430         case RemovalRelations:
 431         case TargetDeviceRelation:
 432         case PowerRelations:
 433             FIXME("Unhandled Device Relation %x\n",irpsp->Parameters.QueryDeviceRelations.Type);
 434             break;
 435         case BusRelations:
 436             status = build_device_relations((DEVICE_RELATIONS**)&irp->IoStatus.Information);
 437             break;
 438         default:
 439             FIXME("Unknown Device Relation %x\n",irpsp->Parameters.QueryDeviceRelations.Type);
 440             break;
 441     }
 442
 443     return status;
 444 }
 445
 446 static NTSTATUS handle_IRP_MN_QUERY_ID(DEVICE_OBJECT *device, IRP *irp)
 447 {
 448     NTSTATUS status = irp->IoStatus.u.Status;
 449     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 450     BUS_QUERY_ID_TYPE type = irpsp->Parameters.QueryId.IdType;
 451
 452     TRACE("(%p, %p)\n", device, irp);
 453
 454     switch (type)
 455     {
 456         case BusQueryHardwareIDs:
 457             TRACE("BusQueryHardwareIDs\n");
 458             irp->IoStatus.Information = (ULONG_PTR)get_compatible_ids(device);
 459             break;
 460         case BusQueryCompatibleIDs:
 461             TRACE("BusQueryCompatibleIDs\n");
 462             irp->IoStatus.Information = (ULONG_PTR)get_compatible_ids(device);
 463             break;
 464         case BusQueryDeviceID:
 465             TRACE("BusQueryDeviceID\n");
 466             irp->IoStatus.Information = (ULONG_PTR)get_device_id(device);
 467             break;
 468         case BusQueryInstanceID:
 469             TRACE("BusQueryInstanceID\n");
 470             irp->IoStatus.Information = (ULONG_PTR)get_instance_id(device);
 471             break;
 472         default:
 473             FIXME("Unhandled type %08x\n", type);
 474             return status;
 475     }
 476
 477     status = irp->IoStatus.Information ? STATUS_SUCCESS : STATUS_NO_MEMORY;
 478     return status;
 479 }
 480
 481 static void mouse_free_device(DEVICE_OBJECT *device)
 482 {
 483 }
 484
 485 static NTSTATUS mouse_get_reportdescriptor(DEVICE_OBJECT *device, BYTE *buffer, DWORD length, DWORD *ret_length)
 486 {
 487     TRACE("buffer %p, length %u.\n", buffer, length);
 488
 489     *ret_length = sizeof(REPORT_HEADER) + sizeof(REPORT_BUTTONS) + sizeof(REPORT_TAIL);
 490     if (length < sizeof(REPORT_HEADER) + sizeof(REPORT_BUTTONS) + sizeof(REPORT_TAIL))
 491         return STATUS_BUFFER_TOO_SMALL;
 492
 493     memcpy(buffer, REPORT_HEADER, sizeof(REPORT_HEADER));
 494     add_button_block(buffer + sizeof(REPORT_HEADER), 1, 3);
 495     memcpy(buffer + sizeof(REPORT_HEADER) + sizeof(REPORT_BUTTONS), REPORT_TAIL, sizeof(REPORT_TAIL));
 496     buffer[IDX_HEADER_PAGE] = HID_USAGE_PAGE_GENERIC;
 497     buffer[IDX_HEADER_USAGE] = HID_USAGE_GENERIC_MOUSE;
 498
 499     return STATUS_SUCCESS;
 500 }
 501
 502 static NTSTATUS mouse_get_string(DEVICE_OBJECT *device, DWORD index, WCHAR *buffer, DWORD length)
 503 {
 504     static const WCHAR nameW[] = {'W','i','n','e',' ','H','I','D',' ','m','o','u','s','e',0};
 505     if (index != HID_STRING_ID_IPRODUCT)
 506         return STATUS_NOT_IMPLEMENTED;
 507     if (length < ARRAY_SIZE(nameW))
 508         return STATUS_BUFFER_TOO_SMALL;
 509     strcpyW(buffer, nameW);
 510     return STATUS_SUCCESS;
 511 }
 512
 513 static NTSTATUS mouse_begin_report_processing(DEVICE_OBJECT *device)
 514 {
 515     return STATUS_SUCCESS;
 516 }
 517
 518 static NTSTATUS mouse_set_output_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *ret_length)
 519 {
 520     FIXME("id %u, stub!\n", id);
 521     return STATUS_NOT_IMPLEMENTED;
 522 }
 523
 524 static NTSTATUS mouse_get_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *ret_length)
 525 {
 526     FIXME("id %u, stub!\n", id);
 527     return STATUS_NOT_IMPLEMENTED;
 528 }
 529
 530 static NTSTATUS mouse_set_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *ret_length)
 531 {
 532     FIXME("id %u, stub!\n", id);
 533     return STATUS_NOT_IMPLEMENTED;
 534 }
 535
 536 static const platform_vtbl mouse_vtbl =
 537 {
 538     .free_device = mouse_free_device,
 539     .get_reportdescriptor = mouse_get_reportdescriptor,
 540     .get_string = mouse_get_string,
 541     .begin_report_processing = mouse_begin_report_processing,
 542     .set_output_report = mouse_set_output_report,
 543     .get_feature_report = mouse_get_feature_report,
 544     .set_feature_report = mouse_set_feature_report,
 545 };
 546
 547 static void mouse_device_create(void)
 548 {
 549     static const WCHAR busidW[] = {'W','I','N','E','M','O','U','S','E',0};
 550
 551     mouse_obj = bus_create_hid_device(busidW, 0, 0, -1, 0, 0, busidW, FALSE, &mouse_vtbl, 0);
 552     IoInvalidateDeviceRelations(bus_pdo, BusRelations);
 553 }
 554
 555 static void keyboard_free_device(DEVICE_OBJECT *device)
 556 {
 557 }
 558
 559 static NTSTATUS keyboard_get_reportdescriptor(DEVICE_OBJECT *device, BYTE *buffer, DWORD length, DWORD *ret_length)
 560 {
 561     TRACE("buffer %p, length %u.\n", buffer, length);
 562
 563     *ret_length = sizeof(REPORT_HEADER) + sizeof(REPORT_BUTTONS) + sizeof(REPORT_TAIL);
 564     if (length < sizeof(REPORT_HEADER) + sizeof(REPORT_BUTTONS) + sizeof(REPORT_TAIL))
 565         return STATUS_BUFFER_TOO_SMALL;
 566
 567     memcpy(buffer, REPORT_HEADER, sizeof(REPORT_HEADER));
 568     add_button_block(buffer + sizeof(REPORT_HEADER), 0, 101);
 569     buffer[sizeof(REPORT_HEADER) + IDX_BUTTON_USAGE_PAGE] = HID_USAGE_PAGE_KEYBOARD;
 570     memcpy(buffer + sizeof(REPORT_HEADER) + sizeof(REPORT_BUTTONS), REPORT_TAIL, sizeof(REPORT_TAIL));
 571     buffer[IDX_HEADER_PAGE] = HID_USAGE_PAGE_GENERIC;
 572     buffer[IDX_HEADER_USAGE] = HID_USAGE_GENERIC_KEYBOARD;
 573
 574     return STATUS_SUCCESS;
 575 }
 576
 577 static NTSTATUS keyboard_get_string(DEVICE_OBJECT *device, DWORD index, WCHAR *buffer, DWORD length)
 578 {
 579     static const WCHAR nameW[] = {'W','i','n','e',' ','H','I','D',' ','k','e','y','b','o','a','r','d',0};
 580     if (index != HID_STRING_ID_IPRODUCT)
 581         return STATUS_NOT_IMPLEMENTED;
 582     if (length < ARRAY_SIZE(nameW))
 583         return STATUS_BUFFER_TOO_SMALL;
 584     strcpyW(buffer, nameW);
 585     return STATUS_SUCCESS;
 586 }
 587
 588 static NTSTATUS keyboard_begin_report_processing(DEVICE_OBJECT *device)
 589 {
 590     return STATUS_SUCCESS;
 591 }
 592
 593 static NTSTATUS keyboard_set_output_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *ret_length)
 594 {
 595     FIXME("id %u, stub!\n", id);
 596     return STATUS_NOT_IMPLEMENTED;
 597 }
 598
 599 static NTSTATUS keyboard_get_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *ret_length)
 600 {
 601     FIXME("id %u, stub!\n", id);
 602     return STATUS_NOT_IMPLEMENTED;
 603 }
 604
 605 static NTSTATUS keyboard_set_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *ret_length)
 606 {
 607     FIXME("id %u, stub!\n", id);
 608     return STATUS_NOT_IMPLEMENTED;
 609 }
 610
 611 static const platform_vtbl keyboard_vtbl =
 612 {
 613     .free_device = keyboard_free_device,
 614     .get_reportdescriptor = keyboard_get_reportdescriptor,
 615     .get_string = keyboard_get_string,
 616     .begin_report_processing = keyboard_begin_report_processing,
 617     .set_output_report = keyboard_set_output_report,
 618     .get_feature_report = keyboard_get_feature_report,
 619     .set_feature_report = keyboard_set_feature_report,
 620 };
 621
 622 static void keyboard_device_create(void)
 623 {
 624     static const WCHAR busidW[] = {'W','I','N','E','K','E','Y','B','O','A','R','D',0};
 625
 626     keyboard_obj = bus_create_hid_device(busidW, 0, 0, -1, 0, 0, busidW, FALSE, &keyboard_vtbl, 0);
 627     IoInvalidateDeviceRelations(bus_pdo, BusRelations);
 628 }
 629
 630 static NTSTATUS fdo_pnp_dispatch(DEVICE_OBJECT *device, IRP *irp)
 631 {
 632     static const WCHAR SDL_enabledW[] = {'E','n','a','b','l','e',' ','S','D','L',0};
 633     static const UNICODE_STRING SDL_enabled = {sizeof(SDL_enabledW) - sizeof(WCHAR), sizeof(SDL_enabledW), (WCHAR*)SDL_enabledW};
 634     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
 635     NTSTATUS ret;
 636
 637     switch (irpsp->MinorFunction)
 638     {
 639     case IRP_MN_QUERY_DEVICE_RELATIONS:
 640         irp->IoStatus.u.Status = handle_IRP_MN_QUERY_DEVICE_RELATIONS(irp);
 641         break;
 642     case IRP_MN_START_DEVICE:
 643         mouse_device_create();
 644         keyboard_device_create();
 645
 646         if (check_bus_option(&SDL_enabled, 1))
 647         {
 648             if (sdl_driver_init() == STATUS_SUCCESS)
 649             {
 650                 irp->IoStatus.u.Status = STATUS_SUCCESS;
 651                 break;
 652             }
 653         }
 654         udev_driver_init();
 655         iohid_driver_init();
 656         irp->IoStatus.u.Status = STATUS_SUCCESS;
 657         break;
 658     case IRP_MN_SURPRISE_REMOVAL:
 659         irp->IoStatus.u.Status = STATUS_SUCCESS;
 660         break;
 661     case IRP_MN_REMOVE_DEVICE:
 662         udev_driver_unload();
 663         iohid_driver_unload();
 664         sdl_driver_unload();
 665
 666         irp->IoStatus.u.Status = STATUS_SUCCESS;
 667         IoSkipCurrentIrpStackLocation(irp);
 668         ret = IoCallDriver(bus_pdo, irp);
 669         IoDetachDevice(bus_pdo);
 670         IoDeleteDevice(device);
 671         return ret;
 672     default:
 673         FIXME("Unhandled minor function %#x.\n", irpsp->MinorFunction);
 674     }
 675
 676     IoSkipCurrentIrpStackLocation(irp);
 677     return IoCallDriver(bus_pdo, irp);
 678 }
 679
 680 static NTSTATUS pdo_pnp_dispatch(DEVICE_OBJECT *device, IRP *irp)
 681 {
 682     struct device_extension *ext = device->DeviceExtension;
 683     NTSTATUS status = irp->IoStatus.u.Status;
 684     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
 685
 686     TRACE("device %p, irp %p, minor function %#x.\n", device, irp, irpsp->MinorFunction);
 687
 688     switch (irpsp->MinorFunction)
 689     {
 690         case IRP_MN_QUERY_ID:
 691             status = handle_IRP_MN_QUERY_ID(device, irp);
 692             break;
 693
 694         case IRP_MN_QUERY_CAPABILITIES:
 695             status = STATUS_SUCCESS;
 696             break;
 697
 698         case IRP_MN_START_DEVICE:
 699             status = STATUS_SUCCESS;
 700             break;
 701
 702         case IRP_MN_SURPRISE_REMOVAL:
 703             EnterCriticalSection(&ext->cs);
 704             remove_pending_irps(device);
 705             ext->removed = TRUE;
 706             LeaveCriticalSection(&ext->cs);
 707             break;
 708
 709         case IRP_MN_REMOVE_DEVICE:
 710         {
 711             struct pnp_device *pnp_device = ext->pnp_device;
 712
 713             remove_pending_irps(device);
 714
 715             ext->vtbl->free_device(device);
 716
 717             ext->cs.DebugInfo->Spare[0] = 0;
 718             DeleteCriticalSection(&ext->cs);
 719
 720             HeapFree(GetProcessHeap(), 0, ext->serial);
 721             HeapFree(GetProcessHeap(), 0, ext->last_report);
 722
 723             irp->IoStatus.u.Status = STATUS_SUCCESS;
 724             IoCompleteRequest(irp, IO_NO_INCREMENT);
 725
 726             IoDeleteDevice(device);
 727
 728             /* pnp_device must be released after the device is gone */
 729             HeapFree(GetProcessHeap(), 0, pnp_device);
 730
 731             return STATUS_SUCCESS;
 732         }
 733
 734         default:
 735             FIXME("Unhandled function %08x\n", irpsp->MinorFunction);
 736             /* fall through */
 737
 738         case IRP_MN_QUERY_DEVICE_RELATIONS:
 739             break;
 740     }
 741
 742     irp->IoStatus.u.Status = status;
 743     IoCompleteRequest(irp, IO_NO_INCREMENT);
 744     return status;
 745 }
 746
 747 static NTSTATUS WINAPI common_pnp_dispatch(DEVICE_OBJECT *device, IRP *irp)
 748 {
 749     if (device == bus_fdo)
 750         return fdo_pnp_dispatch(device, irp);
 751     return pdo_pnp_dispatch(device, irp);
 752 }
 753
 754 static NTSTATUS deliver_last_report(struct device_extension *ext, DWORD buffer_length, BYTE* buffer, ULONG_PTR *out_length)
 755 {
 756     if (buffer_length < ext->last_report_size)
 757     {
 758         *out_length = 0;
 759         return STATUS_BUFFER_TOO_SMALL;
 760     }
 761     else
 762     {
 763         if (ext->last_report)
 764             memcpy(buffer, ext->last_report, ext->last_report_size);
 765         *out_length = ext->last_report_size;
 766         return STATUS_SUCCESS;
 767     }
 768 }
 769
 770 static NTSTATUS hid_get_native_string(DEVICE_OBJECT *device, DWORD index, WCHAR *buffer, DWORD length)
 771 {
 772     struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
 773     const struct product_desc *vendor_products;
 774     unsigned int i, vendor_products_size = 0;
 775
 776     if (ext->vid == VID_MICROSOFT)
 777     {
 778         vendor_products = XBOX_CONTROLLERS;
 779         vendor_products_size = ARRAY_SIZE(XBOX_CONTROLLERS);
 780     }
 781
 782     for (i = 0; i < vendor_products_size; i++)
 783     {
 784         if (ext->pid == vendor_products[i].pid)
 785             break;
 786     }
 787
 788     if (i >= vendor_products_size)
 789         return STATUS_UNSUCCESSFUL;
 790
 791     switch (index)
 792     {
 793     case HID_STRING_ID_IPRODUCT:
 794         if (vendor_products[i].product)
 795         {
 796             strcpyW(buffer, vendor_products[i].product);
 797             return STATUS_SUCCESS;
 798         }
 799         break;
 800     case HID_STRING_ID_IMANUFACTURER:
 801         if (vendor_products[i].manufacturer)
 802         {
 803             strcpyW(buffer, vendor_products[i].manufacturer);
 804             return STATUS_SUCCESS;
 805         }
 806         break;
 807     case HID_STRING_ID_ISERIALNUMBER:
 808         if (vendor_products[i].serialnumber)
 809         {
 810             strcpyW(buffer, vendor_products[i].serialnumber);
 811             return STATUS_SUCCESS;
 812         }
 813         break;
 814     }
 815
 816     return STATUS_UNSUCCESSFUL;
 817 }
 818
 819 static NTSTATUS WINAPI hid_internal_dispatch(DEVICE_OBJECT *device, IRP *irp)
 820 {
 821     NTSTATUS status = irp->IoStatus.u.Status;
 822     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation(irp);
 823     struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
 824
 825     TRACE("(%p, %p)\n", device, irp);
 826
 827     if (device == bus_fdo)
 828     {
 829         IoSkipCurrentIrpStackLocation(irp);
 830         return IoCallDriver(bus_pdo, irp);
 831     }
 832
 833     EnterCriticalSection(&ext->cs);
 834
 835     if (ext->removed)
 836     {
 837         LeaveCriticalSection(&ext->cs);
 838         irp->IoStatus.u.Status = STATUS_DELETE_PENDING;
 839         IoCompleteRequest(irp, IO_NO_INCREMENT);
 840         return STATUS_DELETE_PENDING;
 841     }
 842
 843     switch (irpsp->Parameters.DeviceIoControl.IoControlCode)
 844     {
 845         case IOCTL_HID_GET_DEVICE_ATTRIBUTES:
 846         {
 847             HID_DEVICE_ATTRIBUTES *attr = (HID_DEVICE_ATTRIBUTES *)irp->UserBuffer;
 848             TRACE("IOCTL_HID_GET_DEVICE_ATTRIBUTES\n");
 849
 850             if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(*attr))
 851             {
 852                 irp->IoStatus.u.Status = status = STATUS_BUFFER_TOO_SMALL;
 853                 break;
 854             }
 855
 856             memset(attr, 0, sizeof(*attr));
 857             attr->Size = sizeof(*attr);
 858             attr->VendorID = ext->vid;
 859             attr->ProductID = ext->pid;
 860             attr->VersionNumber = ext->version;
 861
 862             irp->IoStatus.u.Status = status = STATUS_SUCCESS;
 863             irp->IoStatus.Information = sizeof(*attr);
 864             break;
 865         }
 866         case IOCTL_HID_GET_DEVICE_DESCRIPTOR:
 867         {
 868             HID_DESCRIPTOR *descriptor = (HID_DESCRIPTOR *)irp->UserBuffer;
 869             DWORD length;
 870             TRACE("IOCTL_HID_GET_DEVICE_DESCRIPTOR\n");
 871
 872             if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(*descriptor))
 873             {
 874                 irp->IoStatus.u.Status = status = STATUS_BUFFER_TOO_SMALL;
 875                 break;
 876             }
 877
 878             status = ext->vtbl->get_reportdescriptor(device, NULL, 0, &length);
 879             if (status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
 880             {
 881                 WARN("Failed to get platform report descriptor length\n");
 882                 irp->IoStatus.u.Status = status;
 883                 break;
 884             }
 885
 886             memset(descriptor, 0, sizeof(*descriptor));
 887             descriptor->bLength = sizeof(*descriptor);
 888             descriptor->bDescriptorType = HID_HID_DESCRIPTOR_TYPE;
 889             descriptor->bcdHID = HID_REVISION;
 890             descriptor->bCountry = 0;
 891             descriptor->bNumDescriptors = 1;
 892             descriptor->DescriptorList[0].bReportType = HID_REPORT_DESCRIPTOR_TYPE;
 893             descriptor->DescriptorList[0].wReportLength = length;
 894
 895             irp->IoStatus.u.Status = status = STATUS_SUCCESS;
 896             irp->IoStatus.Information = sizeof(*descriptor);
 897             break;
 898         }
 899         case IOCTL_HID_GET_REPORT_DESCRIPTOR:
 900         {
 901             DWORD length = irpsp->Parameters.DeviceIoControl.OutputBufferLength;
 902             TRACE("IOCTL_HID_GET_REPORT_DESCRIPTOR\n");
 903
 904             irp->IoStatus.u.Status = status = ext->vtbl->get_reportdescriptor(device, irp->UserBuffer, length, &length);
 905             irp->IoStatus.Information = length;
 906             break;
 907         }
 908         case IOCTL_HID_GET_STRING:
 909         {
 910             DWORD length = irpsp->Parameters.DeviceIoControl.OutputBufferLength / sizeof(WCHAR);
 911             DWORD index = (ULONG_PTR)irpsp->Parameters.DeviceIoControl.Type3InputBuffer;
 912             TRACE("IOCTL_HID_GET_STRING[%08x]\n", index);
 913
 914             irp->IoStatus.u.Status = status = hid_get_native_string(device, index, (WCHAR *)irp->UserBuffer, length);
 915             if (status != STATUS_SUCCESS)
 916                 irp->IoStatus.u.Status = status = ext->vtbl->get_string(device, index, (WCHAR *)irp->UserBuffer, length);
 917             if (status == STATUS_SUCCESS)
 918                 irp->IoStatus.Information = (strlenW((WCHAR *)irp->UserBuffer) + 1) * sizeof(WCHAR);
 919             break;
 920         }
 921         case IOCTL_HID_GET_INPUT_REPORT:
 922         {
 923             HID_XFER_PACKET *packet = (HID_XFER_PACKET*)(irp->UserBuffer);
 924             TRACE_(hid_report)("IOCTL_HID_GET_INPUT_REPORT\n");
 925             status = ext->vtbl->begin_report_processing(device);
 926             if (status != STATUS_SUCCESS)
 927             {
 928                 irp->IoStatus.u.Status = status;
 929                 LeaveCriticalSection(&ext->cs);
 930                 break;
 931             }
 932
 933             irp->IoStatus.u.Status = status = deliver_last_report(ext,
 934                 packet->reportBufferLen, packet->reportBuffer,
 935                 &irp->IoStatus.Information);
 936
 937             if (status == STATUS_SUCCESS)
 938                 packet->reportBufferLen = irp->IoStatus.Information;
 939             break;
 940         }
 941         case IOCTL_HID_READ_REPORT:
 942         {
 943             TRACE_(hid_report)("IOCTL_HID_READ_REPORT\n");
 944             status = ext->vtbl->begin_report_processing(device);
 945             if (status != STATUS_SUCCESS)
 946             {
 947                 irp->IoStatus.u.Status = status;
 948                 LeaveCriticalSection(&ext->cs);
 949                 break;
 950             }
 951             if (!ext->last_report_read)
 952             {
 953                 irp->IoStatus.u.Status = status = deliver_last_report(ext,
 954                     irpsp->Parameters.DeviceIoControl.OutputBufferLength,
 955                     irp->UserBuffer, &irp->IoStatus.Information);
 956                 ext->last_report_read = TRUE;
 957             }
 958             else
 959             {
 960                 InsertTailList(&ext->irp_queue, &irp->Tail.Overlay.s.ListEntry);
 961                 status = STATUS_PENDING;
 962             }
 963             break;
 964         }
 965         case IOCTL_HID_SET_OUTPUT_REPORT:
 966         case IOCTL_HID_WRITE_REPORT:
 967         {
 968             HID_XFER_PACKET *packet = (HID_XFER_PACKET*)(irp->UserBuffer);
 969             TRACE_(hid_report)("IOCTL_HID_WRITE_REPORT / IOCTL_HID_SET_OUTPUT_REPORT\n");
 970             irp->IoStatus.u.Status = status = ext->vtbl->set_output_report(
 971                 device, packet->reportId, packet->reportBuffer,
 972                 packet->reportBufferLen, &irp->IoStatus.Information);
 973             break;
 974         }
 975         case IOCTL_HID_GET_FEATURE:
 976         {
 977             HID_XFER_PACKET *packet = (HID_XFER_PACKET*)(irp->UserBuffer);
 978             TRACE_(hid_report)("IOCTL_HID_GET_FEATURE\n");
 979             irp->IoStatus.u.Status = status = ext->vtbl->get_feature_report(
 980                 device, packet->reportId, packet->reportBuffer,
 981                 packet->reportBufferLen, &irp->IoStatus.Information);
 982             packet->reportBufferLen = irp->IoStatus.Information;
 983             break;
 984         }
 985         case IOCTL_HID_SET_FEATURE:
 986         {
 987             HID_XFER_PACKET *packet = (HID_XFER_PACKET*)(irp->UserBuffer);
 988             TRACE_(hid_report)("IOCTL_HID_SET_FEATURE\n");
 989             irp->IoStatus.u.Status = status = ext->vtbl->set_feature_report(
 990                 device, packet->reportId, packet->reportBuffer,
 991                 packet->reportBufferLen, &irp->IoStatus.Information);
 992             break;
 993         }
 994         default:
 995         {
 996             ULONG code = irpsp->Parameters.DeviceIoControl.IoControlCode;
 997             FIXME("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
 998                   code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
 999             break;
1000         }
1001     }
1002
1003     LeaveCriticalSection(&ext->cs);
1004
1005     if (status != STATUS_PENDING)
1006         IoCompleteRequest(irp, IO_NO_INCREMENT);
1007
1008     return status;
1009 }
1010
1011 void process_hid_report(DEVICE_OBJECT *device, BYTE *report, DWORD length)
1012 {
1013     struct device_extension *ext = (struct device_extension*)device->DeviceExtension;
1014     IRP *irp;
1015     LIST_ENTRY *entry;
1016
1017     if (!length || !report)
1018         return;
1019
1020     EnterCriticalSection(&ext->cs);
1021     if (length > ext->buffer_size)
1022     {
1023         HeapFree(GetProcessHeap(), 0, ext->last_report);
1024         ext->last_report = HeapAlloc(GetProcessHeap(), 0, length);
1025         if (!ext->last_report)
1026         {
1027             ERR_(hid_report)("Failed to alloc last report\n");
1028             ext->buffer_size = 0;
1029             ext->last_report_size = 0;
1030             ext->last_report_read = TRUE;
1031             LeaveCriticalSection(&ext->cs);
1032             return;
1033         }
1034         else
1035             ext->buffer_size = length;
1036     }
1037
1038     memcpy(ext->last_report, report, length);
1039     ext->last_report_size = length;
1040     ext->last_report_read = FALSE;
1041
1042     while ((entry = RemoveHeadList(&ext->irp_queue)) != &ext->irp_queue)
1043     {
1044         IO_STACK_LOCATION *irpsp;
1045         TRACE_(hid_report)("Processing Request\n");
1046         irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.s.ListEntry);
1047         irpsp = IoGetCurrentIrpStackLocation(irp);
1048         irp->IoStatus.u.Status = deliver_last_report(ext,
1049             irpsp->Parameters.DeviceIoControl.OutputBufferLength,
1050             irp->UserBuffer, &irp->IoStatus.Information);
1051         ext->last_report_read = TRUE;
1052         IoCompleteRequest(irp, IO_NO_INCREMENT);
1053     }
1054     LeaveCriticalSection(&ext->cs);
1055 }
1056
1057 DWORD check_bus_option(const UNICODE_STRING *option, DWORD default_value)
1058 {
1059     char buffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[sizeof(DWORD)])];
1060     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION*)buffer;
1061     DWORD size;
1062
1063     if (NtQueryValueKey(driver_key, option, KeyValuePartialInformation, info, sizeof(buffer), &size) == STATUS_SUCCESS)
1064     {
1065         if (info->Type == REG_DWORD)
1066             return *(DWORD*)info->Data;
1067     }
1068
1069     return default_value;
1070 }
1071
1072 BOOL is_xbox_gamepad(WORD vid, WORD pid)
1073 {
1074     int i;
1075
1076     if (vid != VID_MICROSOFT)
1077         return FALSE;
1078
1079     for (i = 0; i < ARRAY_SIZE(XBOX_CONTROLLERS); i++)
1080         if (pid == XBOX_CONTROLLERS[i].pid) return TRUE;
1081
1082     return FALSE;
1083 }
1084
1085 static NTSTATUS WINAPI driver_add_device(DRIVER_OBJECT *driver, DEVICE_OBJECT *pdo)
1086 {
1087     NTSTATUS ret;
1088
1089     TRACE("driver %p, pdo %p.\n", driver, pdo);
1090
1091     if ((ret = IoCreateDevice(driver, 0, NULL, FILE_DEVICE_BUS_EXTENDER, 0, FALSE, &bus_fdo)))
1092     {
1093         ERR("Failed to create FDO, status %#x.\n", ret);
1094         return ret;
1095     }
1096
1097     IoAttachDeviceToDeviceStack(bus_fdo, pdo);
1098     bus_pdo = pdo;
1099
1100     bus_fdo->Flags &= ~DO_DEVICE_INITIALIZING;
1101
1102     return STATUS_SUCCESS;
1103 }
1104
1105 static void WINAPI driver_unload(DRIVER_OBJECT *driver)
1106 {
1107     NtClose(driver_key);
1108 }
1109
1110 NTSTATUS WINAPI DriverEntry( DRIVER_OBJECT *driver, UNICODE_STRING *path )
1111 {
1112     OBJECT_ATTRIBUTES attr = {0};
1113     NTSTATUS ret;
1114
1115     TRACE( "(%p, %s)\n", driver, debugstr_w(path->Buffer) );
1116
1117     attr.Length = sizeof(attr);
1118     attr.ObjectName = path;
1119     attr.Attributes = OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE;
1120     if ((ret = NtOpenKey(&driver_key, KEY_ALL_ACCESS, &attr)) != STATUS_SUCCESS)
1121         ERR("Failed to open driver key, status %#x.\n", ret);
1122
1123     driver_obj = driver;
1124
1125     driver->MajorFunction[IRP_MJ_PNP] = common_pnp_dispatch;
1126     driver->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = hid_internal_dispatch;
1127     driver->DriverExtension->AddDevice = driver_add_device;
1128     driver->DriverUnload = driver_unload;
1129
1130     return STATUS_SUCCESS;
1131 }