[PATCH v5 2/5] winebus.sys: Build device reports for linux event devices
v5: After review from Andrew Eikum Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/winebus.sys/bus_udev.c | 471 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 469 insertions(+), 2 deletions(-)
Signed-off-by: Andrew Eikum <aeikum(a)codeweavers.com> On Fri, Jan 19, 2018 at 07:42:23AM -0600, Aric Stewart wrote:
v5: After review from Andrew Eikum
Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/winebus.sys/bus_udev.c | 471 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 469 insertions(+), 2 deletions(-)
diff --git a/dlls/winebus.sys/bus_udev.c b/dlls/winebus.sys/bus_udev.c index 09d481e014..54d982727b 100644 --- a/dlls/winebus.sys/bus_udev.c +++ b/dlls/winebus.sys/bus_udev.c @@ -63,6 +63,18 @@ #include "wine/debug.h" #include "wine/unicode.h"
+#ifdef HAS_PROPER_INPUT_HEADER +# include "hidusage.h" +#endif + +#ifdef WORDS_BIGENDIAN +#define LE_WORD(x) RtlUshortByteSwap(x) +#define LE_DWORD(x) RtlUlongByteSwap(x) +#else +#define LE_WORD(x) (x) +#define LE_DWORD(x) (x) +#endif + #include "bus.h"
WINE_DEFAULT_DEBUG_CHANNEL(plugplay); @@ -97,6 +109,429 @@ static inline struct platform_private *impl_from_DEVICE_OBJECT(DEVICE_OBJECT *de return (struct platform_private *)get_platform_private(device); }
+#ifdef HAS_PROPER_INPUT_HEADER +static const BYTE REPORT_HEADER[] = { + 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */ + 0x09, 0x00, /* USAGE (??) */ + 0xa1, 0x01, /* COLLECTION (Application) */ + 0x09, 0x01, /* USAGE () */ + 0xa1, 0x00, /* COLLECTION (Physical) */ +}; + +#define IDX_HEADER_PAGE 1 +#define IDX_HEADER_USAGE 3 + +static const BYTE REPORT_BUTTONS[] = { + 0x05, 0x09, /* USAGE_PAGE (Button) */ + 0x19, 0x01, /* USAGE_MINIMUM (Button 1) */ + 0x29, 0x03, /* USAGE_MAXIMUM (Button 3) */ + 0x15, 0x00, /* LOGICAL_MINIMUM (0) */ + 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */ + 0x35, 0x00, /* LOGICAL_MINIMUM (0) */ + 0x45, 0x01, /* LOGICAL_MAXIMUM (1) */ + 0x95, 0x03, /* REPORT_COUNT (3) */ + 0x75, 0x01, /* REPORT_SIZE (1) */ + 0x81, 0x02, /* INPUT (Data,Var,Abs) */ +}; +#define IDX_BUTTON_MIN_USAGE 3 +#define IDX_BUTTON_MAX_USAGE 5 +#define IDX_BUTTON_COUNT 11 + +static const BYTE REPORT_PADDING[] = { + 0x95, 0x03, /* REPORT_COUNT (3) */ + 0x75, 0x01, /* REPORT_SIZE (1) */ + 0x81, 0x03, /* INPUT (Cnst,Var,Abs) */ +}; +#define IDX_PADDING_BIT_COUNT 1 + +static const BYTE REPORT_AXIS_HEADER[] = { + 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */ +}; +#define IDX_AXIS_PAGE 1 + + +static const BYTE REPORT_AXIS_USAGE[] = { + 0x09, 0x30, /* USAGE (X) */ +}; +#define IDX_AXIS_USAGE 1 + +static const BYTE REPORT_ABS_AXIS_TAIL[] = { + 0x17, 0x00, 0x00, 0x00, 0x00, /* LOGICAL_MINIMUM (0) */ + 0x27, 0xff, 0x00, 0x00, 0x00, /* LOGICAL_MAXIMUM (0xff) */ + 0x37, 0x00, 0x00, 0x00, 0x00, /* PHYSICAL_MINIMUM (0) */ + 0x47, 0xff, 0x00, 0x00, 0x00, /* PHYSICAL_MAXIMUM (256) */ + 0x75, 0x20, /* REPORT_SIZE (32) */ + 0x95, 0x00, /* REPORT_COUNT (2) */ + 0x81, 0x02, /* INPUT (Data,Var,Abs) */ +}; +#define IDX_ABS_LOG_MINIMUM 1 +#define IDX_ABS_LOG_MAXIMUM 6 +#define IDX_ABS_PHY_MINIMUM 11 +#define IDX_ABS_PHY_MAXIMUM 16 +#define IDX_ABS_AXIS_COUNT 23 + +static const BYTE REPORT_REL_AXIS_TAIL[] = { + 0x15, 0x81, /* LOGICAL_MINIMUM (0) */ + 0x25, 0x7f, /* LOGICAL_MAXIMUM (0xffff) */ + 0x75, 0x08, /* REPORT_SIZE (16) */ + 0x95, 0x02, /* REPORT_COUNT (2) */ + 0x81, 0x06, /* INPUT (Data,Var,Rel) */ +}; +#define IDX_REL_AXIS_COUNT 7 + +static const BYTE REPORT_HATSWITCH[] = { + 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */ + 0x09, 0x39, /* USAGE (Hatswitch) */ + 0x15, 0x00, /* LOGICAL_MINIMUM (0) */ + 0x25, 0x08, /* LOGICAL_MAXIMUM (0x08) */ + 0x35, 0x00, /* PHYSICAL_MINIMUM (0) */ + 0x45, 0x08, /* PHYSICAL_MAXIMUM (8) */ + 0x75, 0x08, /* REPORT_SIZE (8) */ + 0x95, 0x01, /* REPORT_COUNT (1) */ + 0x81, 0x02, /* INPUT (Data,Var,Abs) */ +}; +#define IDX_HATSWITCH_COUNT 15 + +static const BYTE REPORT_TAIL[] = { + 0xc0, /* END_COLLECTION */ + 0xc0 /* END_COLLECTION */ +}; + +static const BYTE ABS_TO_HID_MAP[][2] = { + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X}, /*ABS_X*/ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Y}, /*ABS_Y*/ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Z}, /*ABS_Z*/ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RX}, /*ABS_RX*/ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RY}, /*ABS_RY*/ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RZ}, /*ABS_RZ*/ + {HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_THROTTLE}, /*ABS_THROTTLE*/ + {HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_RUDDER}, /*ABS_RUDDER*/ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_WHEEL}, /*ABS_WHEEL*/ + {HID_USAGE_PAGE_SIMULATION, 0xC4}, /*ABS_GAS*/ + {HID_USAGE_PAGE_SIMULATION, 0xC5}, /*ABS_BRAKE*/ + {0,0}, /*ABS_HAT0X*/ + {0,0}, /*ABS_HAT0Y*/ + {0,0}, /*ABS_HAT1X*/ + {0,0}, /*ABS_HAT1Y*/ + {0,0}, /*ABS_HAT2X*/ + {0,0}, /*ABS_HAT2Y*/ + {0,0}, /*ABS_HAT3X*/ + {0,0}, /*ABS_HAT3Y*/ + {HID_USAGE_PAGE_DIGITIZER, 0x30}, /*ABS_PRESSURE*/ + {0, 0}, /*ABS_DISTANCE*/ + {HID_USAGE_PAGE_DIGITIZER, 0x3D}, /*ABS_TILT_X*/ + {HID_USAGE_PAGE_DIGITIZER, 0x3F}, /*ABS_TILT_Y*/ + {0, 0}, /*ABS_TOOL_WIDTH*/ + {0, 0}, + {0, 0}, + {0, 0}, + {HID_USAGE_PAGE_CONSUMER, 0xE0} /*ABS_VOLUME*/ +}; +#define HID_ABS_MAX (ABS_VOLUME+1) +#define TOP_ABS_PAGE (HID_USAGE_PAGE_DIGITIZER+1) + +static const BYTE REL_TO_HID_MAP[][2] = { + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X}, /* REL_X */ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Y}, /* REL_Y */ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Z}, /* REL_Z */ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RX}, /* REL_RX */ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RY}, /* REL_RY */ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RZ}, /* REL_RZ */ + {0, 0}, /* REL_HWHEEL */ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_DIAL}, /* REL_DIAL */ + {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_WHEEL}, /* REL_WHEEL */ + {0, 0} /* REL_MISC */ +}; + +#define HID_REL_MAX (REL_MISC+1) +#define TOP_REL_PAGE (HID_USAGE_PAGE_CONSUMER+1) + +struct wine_input_absinfo { + struct input_absinfo info; + BYTE report_index; +}; + +struct wine_input_private { + struct platform_private base; + + int report_descriptor_size; + BYTE *report_descriptor; + + BYTE button_map[KEY_MAX]; + BYTE rel_map[HID_REL_MAX]; + BYTE hat_map[8]; + int hat_values[8]; + struct wine_input_absinfo abs_map[HID_ABS_MAX]; +}; + +#define test_bit(arr,bit) (((BYTE*)(arr))[(bit)>>3]&(1<<((bit)&7))) + +static BYTE *add_button_block(BYTE* report_ptr, BYTE usage_min, BYTE usage_max) +{ + memcpy(report_ptr, REPORT_BUTTONS, sizeof(REPORT_BUTTONS)); + report_ptr[IDX_BUTTON_MIN_USAGE] = usage_min; + report_ptr[IDX_BUTTON_MAX_USAGE] = usage_max; + report_ptr[IDX_BUTTON_COUNT] = (usage_max - usage_min) + 1; + return report_ptr + sizeof(REPORT_BUTTONS); +} + +static BYTE *add_axis_block(BYTE *report_ptr, BYTE count, BYTE page, BYTE *usages, BOOL absolute, const struct wine_input_absinfo *absinfo) +{ + int i; + memcpy(report_ptr, REPORT_AXIS_HEADER, sizeof(REPORT_AXIS_HEADER)); + report_ptr[IDX_AXIS_PAGE] = page; + report_ptr += sizeof(REPORT_AXIS_HEADER); + for (i = 0; i < count; i++) + { + memcpy(report_ptr, REPORT_AXIS_USAGE, sizeof(REPORT_AXIS_USAGE)); + report_ptr[IDX_AXIS_USAGE] = usages[i]; + report_ptr += sizeof(REPORT_AXIS_USAGE); + } + if (absolute) + { + memcpy(report_ptr, REPORT_ABS_AXIS_TAIL, sizeof(REPORT_ABS_AXIS_TAIL)); + if (absinfo) + { + *((int*)&report_ptr[IDX_ABS_LOG_MINIMUM]) = LE_DWORD(absinfo->info.minimum); + *((int*)&report_ptr[IDX_ABS_LOG_MAXIMUM]) = LE_DWORD(absinfo->info.maximum); + *((int*)&report_ptr[IDX_ABS_PHY_MINIMUM]) = LE_DWORD(absinfo->info.minimum); + *((int*)&report_ptr[IDX_ABS_PHY_MAXIMUM]) = LE_DWORD(absinfo->info.maximum); + } + report_ptr[IDX_ABS_AXIS_COUNT] = count; + report_ptr += sizeof(REPORT_ABS_AXIS_TAIL); + } + else + { + memcpy(report_ptr, REPORT_REL_AXIS_TAIL, sizeof(REPORT_REL_AXIS_TAIL)); + report_ptr[IDX_REL_AXIS_COUNT] = count; + report_ptr += sizeof(REPORT_REL_AXIS_TAIL); + } + return report_ptr; +} + +static BYTE *add_padding_block(BYTE *report_ptr, BYTE bitcount) +{ + memcpy(report_ptr, REPORT_PADDING, sizeof(REPORT_PADDING)); + report_ptr[IDX_PADDING_BIT_COUNT] = bitcount; + return report_ptr + sizeof(REPORT_PADDING); +} + +static BYTE *add_hatswitch(BYTE *report_ptr, INT count) +{ + memcpy(report_ptr, REPORT_HATSWITCH, sizeof(REPORT_HATSWITCH)); + report_ptr[IDX_HATSWITCH_COUNT] = count; + return report_ptr + sizeof(REPORT_HATSWITCH); +} + +static const BYTE* what_am_I(struct udev_device *dev) +{ + static const BYTE Unknown[2] = {HID_USAGE_PAGE_GENERIC, 0}; + static const BYTE Mouse[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_MOUSE}; + static const BYTE Keyboard[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_KEYBOARD}; + static const BYTE Gamepad[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_GAMEPAD}; + static const BYTE Keypad[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_KEYPAD}; + static const BYTE Tablet[2] = {HID_USAGE_PAGE_DIGITIZER, 0x2}; + static const BYTE Touchscreen[2] = {HID_USAGE_PAGE_DIGITIZER, 0x4}; + static const BYTE Touchpad[2] = {HID_USAGE_PAGE_DIGITIZER, 0x5}; + + struct udev_device *parent = dev; + + /* Look to the parents until we get a clue */ + while (parent) + { + if (udev_device_get_property_value(parent, "ID_INPUT_MOUSE")) + return Mouse; + else if (udev_device_get_property_value(parent, "ID_INPUT_KEYBOARD")) + return Keyboard; + else if (udev_device_get_property_value(parent, "ID_INPUT_JOYSTICK")) + return Gamepad; + else if (udev_device_get_property_value(parent, "ID_INPUT_KEY")) + return Keypad; + else if (udev_device_get_property_value(parent, "ID_INPUT_TOUCHPAD")) + return Touchpad; + else if (udev_device_get_property_value(parent, "ID_INPUT_TOUCHSCREEN")) + return Touchscreen; + else if (udev_device_get_property_value(parent, "ID_INPUT_TABLET")) + return Tablet; + + parent = udev_device_get_parent_with_subsystem_devtype(parent, "input", NULL); + } + return Unknown; +} + +static VOID build_report_descriptor(struct wine_input_private *ext, struct udev_device *dev) +{ + int abs_pages[TOP_ABS_PAGE][HID_ABS_MAX+1]; + int rel_pages[TOP_REL_PAGE][HID_REL_MAX+1]; + BYTE absbits[(ABS_MAX+7)/8]; + BYTE relbits[(REL_MAX+7)/8]; + BYTE keybits[(KEY_MAX+7)/8]; + BYTE *report_ptr; + INT i, descript_size; + INT report_size; + INT button_count, abs_count, rel_count, hat_count; + const BYTE *device_usage = what_am_I(dev); + + if (ioctl(ext->base.device_fd, EVIOCGBIT(EV_REL, sizeof(relbits)), relbits) == -1) + { + WARN("ioctl(EVIOCGBIT, EV_REL) failed: %d %s\n", errno, strerror(errno)); + return; + } + if (ioctl(ext->base.device_fd, EVIOCGBIT(EV_ABS, sizeof(absbits)), absbits) == -1) + { + WARN("ioctl(EVIOCGBIT, EV_ABS) failed: %d %s\n", errno, strerror(errno)); + return; + } + if (ioctl(ext->base.device_fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits) == -1) + { + WARN("ioctl(EVIOCGBIT, EV_KEY) failed: %d %s\n", errno, strerror(errno)); + return; + } + + descript_size = sizeof(REPORT_HEADER) + sizeof(REPORT_TAIL); + report_size = 0; + + /* For now lump all buttons just into incremental usages, Ignore Keys */ + button_count = 0; + for (i = BTN_MISC; i < KEY_MAX; i++) + { + if (test_bit(keybits, i)) + { + ext->button_map[i] = button_count; + button_count++; + } + } + if (button_count) + { + descript_size += sizeof(REPORT_BUTTONS); + if (button_count % 8) + descript_size += sizeof(REPORT_PADDING); + report_size = (button_count + 7) / 8; + } + + abs_count = 0; + memset(abs_pages, 0, sizeof(abs_pages)); + for (i = 0; i < HID_ABS_MAX; i++) + if (test_bit(absbits, i)) + { + abs_pages[ABS_TO_HID_MAP[i][0]][0]++; + abs_pages[ABS_TO_HID_MAP[i][0]][abs_pages[ABS_TO_HID_MAP[i][0]][0]] = i; + + ioctl(ext->base.device_fd, EVIOCGABS(i), &(ext->abs_map[i])); + if (abs_pages[ABS_TO_HID_MAP[i][0]][0] == 1) + { + descript_size += sizeof(REPORT_AXIS_HEADER); + descript_size += sizeof(REPORT_ABS_AXIS_TAIL); + } + } + /* Skip page 0, aka HID_USAGE_PAGE_UNDEFINED */ + for (i = 1; i < TOP_ABS_PAGE; i++) + if (abs_pages[i][0] > 0) + { + int j; + descript_size += sizeof(REPORT_AXIS_USAGE) * abs_pages[i][0]; + for (j = 1; j <= abs_pages[i][0]; j++) + { + ext->abs_map[abs_pages[i][j]].report_index = report_size; + report_size+=4; + } + abs_count++; + } + + rel_count = 0; + memset(rel_pages, 0, sizeof(rel_pages)); + for (i = 0; i < HID_REL_MAX; i++) + if (test_bit(relbits, i)) + { + rel_pages[REL_TO_HID_MAP[i][0]][0]++; + rel_pages[REL_TO_HID_MAP[i][0]][rel_pages[REL_TO_HID_MAP[i][0]][0]] = i; + if (rel_pages[REL_TO_HID_MAP[i][0]][0] == 1) + { + descript_size += sizeof(REPORT_AXIS_HEADER); + descript_size += sizeof(REPORT_REL_AXIS_TAIL); + } + } + /* Skip page 0, aka HID_USAGE_PAGE_UNDEFINED */ + for (i = 1; i < TOP_REL_PAGE; i++) + if (rel_pages[i][0] > 0) + { + int j; + descript_size += sizeof(REPORT_AXIS_USAGE) * rel_pages[i][0]; + for (j = 1; j <= rel_pages[i][0]; j++) + { + ext->rel_map[rel_pages[i][j]] = report_size; + report_size++; + } + rel_count++; + } + + hat_count = 0; + for (i = ABS_HAT0X; i <=ABS_HAT3X; i+=2) + if (test_bit(absbits, i)) + { + ext->hat_map[i - ABS_HAT0X] = report_size; + ext->hat_values[i - ABS_HAT0X] = 0; + ext->hat_values[i - ABS_HAT0X + 1] = 0; + report_size++; + hat_count++; + } + + TRACE("Report Descriptor will be %i bytes\n", descript_size); + TRACE("Report will be %i bytes\n", report_size); + + ext->report_descriptor = HeapAlloc(GetProcessHeap(), 0, descript_size); + report_ptr = ext->report_descriptor; + + memcpy(report_ptr, REPORT_HEADER, sizeof(REPORT_HEADER)); + report_ptr[IDX_HEADER_PAGE] = device_usage[0]; + report_ptr[IDX_HEADER_USAGE] = device_usage[1]; + report_ptr += sizeof(REPORT_HEADER); + if (button_count) + { + report_ptr = add_button_block(report_ptr, 1, button_count); + if (button_count % 8) + { + BYTE padding = 8 - (button_count % 8); + report_ptr = add_padding_block(report_ptr, padding); + } + } + if (abs_count) + { + for (i = 1; i < TOP_ABS_PAGE; i++) + { + if (abs_pages[i][0]) + { + BYTE usages[HID_ABS_MAX]; + int j; + for (j = 0; j < abs_pages[i][0]; j++) + usages[j] = ABS_TO_HID_MAP[abs_pages[i][j+1]][1]; + report_ptr = add_axis_block(report_ptr, abs_pages[i][0], i, usages, TRUE, &ext->abs_map[abs_pages[i][1]]); + } + } + } + if (rel_count) + { + for (i = 1; i < TOP_REL_PAGE; i++) + { + if (rel_pages[i][0]) + { + BYTE usages[HID_REL_MAX]; + int j; + for (j = 0; j < rel_pages[i][0]; j++) + usages[j] = REL_TO_HID_MAP[rel_pages[i][j+1]][1]; + report_ptr = add_axis_block(report_ptr, rel_pages[i][0], i, usages, FALSE, NULL); + } + } + } + if (hat_count) + report_ptr = add_hatswitch(report_ptr, hat_count); + + memcpy(report_ptr, REPORT_TAIL, sizeof(REPORT_TAIL)); + + ext->report_descriptor_size = descript_size; +} +#endif + static inline WCHAR *strdupAtoW(const char *src) { WCHAR *dst; @@ -406,9 +841,23 @@ static const platform_vtbl hidraw_vtbl =
#ifdef HAS_PROPER_INPUT_HEADER
+static inline struct wine_input_private *input_impl_from_DEVICE_OBJECT(DEVICE_OBJECT *device) +{ + return (struct wine_input_private*)get_platform_private(device); +} + static NTSTATUS lnxev_get_reportdescriptor(DEVICE_OBJECT *device, BYTE *buffer, DWORD length, DWORD *out_length) { - return STATUS_NOT_IMPLEMENTED; + struct wine_input_private *ext = input_impl_from_DEVICE_OBJECT(device); + + *out_length = ext->report_descriptor_size; + + if (length < ext->report_descriptor_size) + return STATUS_BUFFER_TOO_SMALL; + + memcpy(buffer, ext->report_descriptor, ext->report_descriptor_size); + + return STATUS_SUCCESS; }
static NTSTATUS lnxev_get_string(DEVICE_OBJECT *device, DWORD index, WCHAR *buffer, DWORD length) @@ -534,7 +983,7 @@ static void try_add_device(struct udev_device *dev) else if (strcmp(subsystem, "input") == 0) { device = bus_create_hid_device(udev_driver_obj, lnxev_busidW, vid, pid, version, 0, serial, (gamepad != NULL), - &GUID_DEVCLASS_LINUXEVENT, &lnxev_vtbl, sizeof(struct platform_private)); + &GUID_DEVCLASS_LINUXEVENT, &lnxev_vtbl, sizeof(struct wine_input_private)); } #endif
@@ -543,6 +992,10 @@ static void try_add_device(struct udev_device *dev) struct platform_private *private = impl_from_DEVICE_OBJECT(device); private->udev_device = udev_device_ref(dev); private->device_fd = fd; +#ifdef HAS_PROPER_INPUT_HEADER + if (strcmp(subsystem, "input") == 0) + build_report_descriptor((struct wine_input_private*)private, dev); +#endif IoInvalidateDeviceRelations(device, BusRelations); } else @@ -558,11 +1011,17 @@ static void try_remove_device(struct udev_device *dev) { DEVICE_OBJECT *device = NULL; struct platform_private* private; +#ifdef HAS_PROPER_INPUT_HEADER + BOOL is_input = FALSE; +#endif
device = bus_find_hid_device(&hidraw_vtbl, dev); #ifdef HAS_PROPER_INPUT_HEADER if (device == NULL) + { device = bus_find_hid_device(&lnxev_vtbl, dev); + is_input = TRUE; + } #endif if (!device) return;
@@ -579,6 +1038,14 @@ static void try_remove_device(struct udev_device *dev) CloseHandle(private->report_thread); }
+#ifdef HAS_PROPER_INPUT_HEADER + if (is_input) + { + struct wine_input_private *ext = (struct wine_input_private*)private; + HeapFree(GetProcessHeap(), 0, ext->report_descriptor); + } +#endif + dev = private->udev_device; close(private->device_fd); bus_remove_hid_device(device);
participants (2)
-
Andrew Eikum -
Aric Stewart