dlls/hidclass.sys/pnp.c

   1 /*
   2  * WINE HID Pseudo-Plug and Play support
   3  *
   4  * Copyright 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 #define NONAMELESSUNION
  22 #include <unistd.h>
  23 #include <stdarg.h>
  24 #include "hid.h"
  25 #include "ddk/hidtypes.h"
  26 #include "wine/debug.h"
  27 #include "wine/unicode.h"
  28 #include "wine/list.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(hid);
  31
  32 typedef struct _NATIVE_DEVICE {
  33     struct list entry;
  34
  35     DWORD vidpid;
  36     DEVICE_OBJECT *PDO;
  37     DEVICE_OBJECT *FDO;
  38     HID_MINIDRIVER_REGISTRATION *minidriver;
  39
  40 } NATIVE_DEVICE;
  41
  42 static struct list tracked_devices = LIST_INIT(tracked_devices);
  43
  44 NTSTATUS WINAPI PNP_AddDevice(DRIVER_OBJECT *driver, DEVICE_OBJECT *PDO)
  45 {
  46     DEVICE_OBJECT *device = NULL;
  47     NTSTATUS status;
  48     minidriver *minidriver;
  49     HID_DEVICE_ATTRIBUTES attr;
  50     BASE_DEVICE_EXTENSION *ext = NULL;
  51     WCHAR serial[256];
  52     WCHAR interface[256];
  53     DWORD index = HID_STRING_ID_ISERIALNUMBER;
  54     NATIVE_DEVICE *tracked_device, *ptr;
  55     INT interface_index = 1;
  56     HID_DESCRIPTOR descriptor;
  57     BYTE *reportDescriptor;
  58     INT i;
  59
  60     static const WCHAR ig_fmtW[] = {'I','G','_','%','i',0};
  61     static const WCHAR im_fmtW[] = {'I','M','_','%','i',0};
  62
  63
  64     TRACE("PDO add device(%p)\n", PDO);
  65     minidriver = find_minidriver(driver);
  66
  67     status = HID_CreateDevice(PDO, &minidriver->minidriver, &device);
  68     if (status != STATUS_SUCCESS)
  69     {
  70         ERR("Failed to create HID object (%x)\n",status);
  71         return status;
  72     }
  73
  74     TRACE("Created device %p\n",device);
  75     status = minidriver->AddDevice(minidriver->minidriver.DriverObject, device);
  76     if (status != STATUS_SUCCESS)
  77     {
  78         ERR("Minidriver AddDevice failed (%x)\n",status);
  79         HID_DeleteDevice(&minidriver->minidriver, device);
  80         return status;
  81     }
  82
  83     status = call_minidriver(IOCTL_HID_GET_DEVICE_ATTRIBUTES, device,
  84         NULL, 0, &attr, sizeof(attr));
  85
  86     if (status != STATUS_SUCCESS)
  87     {
  88         ERR("Minidriver failed to get Attributes(%x)\n",status);
  89         HID_DeleteDevice(&minidriver->minidriver, device);
  90         return status;
  91     }
  92
  93     ext = device->DeviceExtension;
  94     ext->information.VendorID = attr.VendorID;
  95     ext->information.ProductID = attr.ProductID;
  96     ext->information.VersionNumber = attr.VersionNumber;
  97     ext->information.Polled = minidriver->minidriver.DevicesArePolled;
  98
  99     tracked_device = HeapAlloc(GetProcessHeap(), 0, sizeof(*tracked_device));
 100     tracked_device->vidpid = MAKELONG(attr.VendorID, attr.ProductID);
 101     tracked_device->PDO = PDO;
 102     tracked_device->FDO = device;
 103     tracked_device->minidriver = &minidriver->minidriver;
 104
 105     LIST_FOR_EACH_ENTRY(ptr, &tracked_devices, NATIVE_DEVICE, entry)
 106         if (ptr->vidpid == tracked_device->vidpid) interface_index++;
 107
 108     list_add_tail(&tracked_devices, &tracked_device->entry);
 109
 110     status = call_minidriver(IOCTL_HID_GET_DEVICE_DESCRIPTOR, device, NULL, 0,
 111         &descriptor, sizeof(descriptor));
 112     if (status != STATUS_SUCCESS)
 113     {
 114         ERR("Cannot get Device Descriptor(%x)\n",status);
 115         HID_DeleteDevice(&minidriver->minidriver, device);
 116         return status;
 117     }
 118     for (i = 0; i < descriptor.bNumDescriptors; i++)
 119         if (descriptor.DescriptorList[i].bReportType == HID_REPORT_DESCRIPTOR_TYPE)
 120             break;
 121
 122     if (i >= descriptor.bNumDescriptors)
 123     {
 124         ERR("No Report Descriptor found in reply\n");
 125         HID_DeleteDevice(&minidriver->minidriver, device);
 126         return status;
 127     }
 128
 129     reportDescriptor = HeapAlloc(GetProcessHeap(), 0, descriptor.DescriptorList[i].wReportLength);
 130     status = call_minidriver(IOCTL_HID_GET_REPORT_DESCRIPTOR, device, NULL, 0,
 131         reportDescriptor, descriptor.DescriptorList[i].wReportLength);
 132     if (status != STATUS_SUCCESS)
 133     {
 134         ERR("Cannot get Report Descriptor(%x)\n",status);
 135         HID_DeleteDevice(&minidriver->minidriver, device);
 136         HeapFree(GetProcessHeap(), 0, reportDescriptor);
 137         return status;
 138     }
 139
 140     ext->preparseData = ParseDescriptor(reportDescriptor, descriptor.DescriptorList[0].wReportLength);
 141     ext->information.DescriptorSize = ext->preparseData->dwSize;
 142     HeapFree(GetProcessHeap(), 0, reportDescriptor);
 143
 144     serial[0] = 0;
 145     status = call_minidriver(IOCTL_HID_GET_STRING, device,
 146                              &index, sizeof(DWORD), serial, sizeof(serial));
 147
 148     if (serial[0] == 0)
 149     {
 150         static const WCHAR wZeroSerial[]= {'0','0','0','0',0};
 151         lstrcpyW(serial, wZeroSerial);
 152     }
 153
 154     if (ext->preparseData->caps.UsagePage == HID_USAGE_PAGE_GENERIC &&
 155         (ext->preparseData->caps.Usage == HID_USAGE_GENERIC_GAMEPAD ||
 156          ext->preparseData->caps.Usage == HID_USAGE_GENERIC_JOYSTICK))
 157         sprintfW(interface, ig_fmtW, interface_index);
 158     else
 159         sprintfW(interface, im_fmtW, interface_index);
 160
 161     HID_LinkDevice(device, serial, interface);
 162
 163     ext->poll_interval = DEFAULT_POLL_INTERVAL;
 164     InitializeListHead(&ext->irp_queue);
 165
 166     ext->ring_buffer = RingBuffer_Create(sizeof(HID_XFER_PACKET) + ext->preparseData->caps.InputReportByteLength);
 167
 168     HID_StartDeviceThread(device);
 169
 170     return STATUS_SUCCESS;
 171 }
 172
 173 void PNP_CleanupPNP(DRIVER_OBJECT *driver)
 174 {
 175     NATIVE_DEVICE *tracked_device, *ptr;
 176
 177     LIST_FOR_EACH_ENTRY_SAFE(tracked_device, ptr, &tracked_devices,
 178         NATIVE_DEVICE, entry)
 179     {
 180         if (tracked_device->minidriver->DriverObject == driver)
 181         {
 182             list_remove(&tracked_device->entry);
 183             HID_DeleteDevice(tracked_device->minidriver, tracked_device->FDO);
 184             HeapFree(GetProcessHeap(), 0, tracked_device);
 185         }
 186     }
 187 }