?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Make FD_WINE_NONBLOCKING into a separate field.
[wine.git] / dlls / winebus.sys / bus_udev.c
blob725c50e08fc72ed6cab488d88b8e52683fc33469
1 /*
2 * Plug and Play support for hid devices found through udev
3 *
4 * Copyright 2016 CodeWeavers, 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 #include <errno.h>
23 #include <fcntl.h>
24 #include <stdarg.h>
25 #include <stdlib.h>
26 #include <stdio.h>
27 #ifdef HAVE_UNISTD_H
28 # include <unistd.h>
29 #endif
30 #ifdef HAVE_POLL_H
31 # include <poll.h>
32 #endif
33 #ifdef HAVE_SYS_POLL_H
34 # include <sys/poll.h>
35 #endif
36 #ifdef HAVE_LIBUDEV_H
37 # include <libudev.h>
38 #endif
39 #ifdef HAVE_LINUX_HIDRAW_H
40 # include <linux/hidraw.h>
41 #endif
42 #ifdef HAVE_SYS_IOCTL_H
43 # include <sys/ioctl.h>
44 #endif
45
46 #ifdef HAVE_LINUX_INPUT_H
47 # include <linux/input.h>
48 # undef SW_MAX
49 # if defined(EVIOCGBIT) && defined(EV_ABS) && defined(BTN_PINKIE)
50 # define HAS_PROPER_INPUT_HEADER
51 # endif
52 # ifndef SYN_DROPPED
53 # define SYN_DROPPED 3
54 # endif
55 #endif
56
57 #define NONAMELESSUNION
58
59 #include "ntstatus.h"
60 #define WIN32_NO_STATUS
61 #include "windef.h"
62 #include "winbase.h"
63 #include "winnls.h"
64 #include "winternl.h"
65 #include "ddk/wdm.h"
66 #include "ddk/hidtypes.h"
67 #include "wine/debug.h"
68 #include "wine/heap.h"
69 #include "wine/unicode.h"
70
71 #ifdef HAS_PROPER_INPUT_HEADER
72 # include "hidusage.h"
73 #endif
74
75 #ifdef WORDS_BIGENDIAN
76 #define LE_WORD(x) RtlUshortByteSwap(x)
77 #define LE_DWORD(x) RtlUlongByteSwap(x)
78 #else
79 #define LE_WORD(x) (x)
80 #define LE_DWORD(x) (x)
81 #endif
82
83 #include "controller.h"
84 #include "bus.h"
85
86 WINE_DEFAULT_DEBUG_CHANNEL(plugplay);
87
88 #ifdef HAVE_UDEV
89
90 WINE_DECLARE_DEBUG_CHANNEL(hid_report);
91
92 static struct udev *udev_context = NULL;
93 static DWORD disable_hidraw = 0;
94 static DWORD disable_input = 0;
95 static HANDLE deviceloop_handle;
96 static int deviceloop_control[2];
97
98 static const WCHAR hidraw_busidW[] = {'H','I','D','R','A','W',0};
99 static const WCHAR lnxev_busidW[] = {'L','N','X','E','V',0};
100
101 struct platform_private
102 {
103 struct udev_device *udev_device;
104 int device_fd;
105
106 HANDLE report_thread;
107 int control_pipe[2];
108 };
109
110 static inline struct platform_private *impl_from_DEVICE_OBJECT(DEVICE_OBJECT *device)
111 {
112 return (struct platform_private *)get_platform_private(device);
113 }
114
115 #ifdef HAS_PROPER_INPUT_HEADER
116
117 #include "psh_hid_macros.h"
118
119 static const BYTE REPORT_ABS_AXIS_TAIL[] = {
120 LOGICAL_MINIMUM(4, /* placeholder */ 0x00000000),
121 LOGICAL_MAXIMUM(4, /* placeholder */ 0x000000ff),
122 PHYSICAL_MINIMUM(4, /* placeholder */ 0x00000000),
123 PHYSICAL_MAXIMUM(4, /* placeholder */ 0x000000ff),
124 REPORT_SIZE(1, 32),
125 REPORT_COUNT(1, /* placeholder */ 0),
126 INPUT(1, Data|Var|Abs),
127 };
128 #define IDX_ABS_LOG_MINIMUM 1
129 #define IDX_ABS_LOG_MAXIMUM 6
130 #define IDX_ABS_PHY_MINIMUM 11
131 #define IDX_ABS_PHY_MAXIMUM 16
132 #define IDX_ABS_AXIS_COUNT 23
133
134 #include "pop_hid_macros.h"
135
136 static const BYTE ABS_TO_HID_MAP[][2] = {
137 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X}, /*ABS_X*/
138 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Y}, /*ABS_Y*/
139 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Z}, /*ABS_Z*/
140 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RX}, /*ABS_RX*/
141 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RY}, /*ABS_RY*/
142 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RZ}, /*ABS_RZ*/
143 {HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_THROTTLE}, /*ABS_THROTTLE*/
144 {HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_RUDDER}, /*ABS_RUDDER*/
145 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_WHEEL}, /*ABS_WHEEL*/
146 {HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_ACCELERATOR}, /*ABS_GAS*/
147 {HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_BRAKE}, /*ABS_BRAKE*/
148 {0,0},
149 {0,0},
150 {0,0},
151 {0,0},
152 {0,0},
153 {0,0}, /*ABS_HAT0X*/
154 {0,0}, /*ABS_HAT0Y*/
155 {0,0}, /*ABS_HAT1X*/
156 {0,0}, /*ABS_HAT1Y*/
157 {0,0}, /*ABS_HAT2X*/
158 {0,0}, /*ABS_HAT2Y*/
159 {0,0}, /*ABS_HAT3X*/
160 {0,0}, /*ABS_HAT3Y*/
161 {HID_USAGE_PAGE_DIGITIZER, HID_USAGE_DIGITIZER_TIP_PRESSURE}, /*ABS_PRESSURE*/
162 {0, 0}, /*ABS_DISTANCE*/
163 {HID_USAGE_PAGE_DIGITIZER, HID_USAGE_DIGITIZER_X_TILT}, /*ABS_TILT_X*/
164 {HID_USAGE_PAGE_DIGITIZER, HID_USAGE_DIGITIZER_Y_TILT}, /*ABS_TILT_Y*/
165 {0, 0}, /*ABS_TOOL_WIDTH*/
166 {0, 0},
167 {0, 0},
168 {0, 0},
169 {HID_USAGE_PAGE_CONSUMER, HID_USAGE_CONSUMER_VOLUME} /*ABS_VOLUME*/
170 };
171 #define HID_ABS_MAX (ABS_VOLUME+1)
172 C_ASSERT(ARRAY_SIZE(ABS_TO_HID_MAP) == HID_ABS_MAX);
173 #define TOP_ABS_PAGE (HID_USAGE_PAGE_DIGITIZER+1)
174
175 static const BYTE REL_TO_HID_MAP[][2] = {
176 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X}, /* REL_X */
177 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Y}, /* REL_Y */
178 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Z}, /* REL_Z */
179 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RX}, /* REL_RX */
180 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RY}, /* REL_RY */
181 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_RZ}, /* REL_RZ */
182 {0, 0}, /* REL_HWHEEL */
183 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_DIAL}, /* REL_DIAL */
184 {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_WHEEL}, /* REL_WHEEL */
185 {0, 0} /* REL_MISC */
186 };
187
188 #define HID_REL_MAX (REL_MISC+1)
189 #define TOP_REL_PAGE (HID_USAGE_PAGE_CONSUMER+1)
190
191 struct wine_input_absinfo {
192 struct input_absinfo info;
193 BYTE report_index;
194 };
195
196 struct wine_input_private {
197 struct platform_private base;
198
199 int buffer_length;
200 BYTE *last_report_buffer;
201 BYTE *current_report_buffer;
202 enum { FIRST, NORMAL, DROPPED } report_state;
203
204 int report_descriptor_size;
205 BYTE *report_descriptor;
206
207 int button_start;
208 BYTE button_map[KEY_MAX];
209 BYTE rel_map[HID_REL_MAX];
210 BYTE hat_map[8];
211 int hat_values[8];
212 struct wine_input_absinfo abs_map[HID_ABS_MAX];
213 };
214
215 #define test_bit(arr,bit) (((BYTE*)(arr))[(bit)>>3]&(1<<((bit)&7)))
216
217 static BYTE *add_axis_block(BYTE *report_ptr, BYTE count, BYTE page, BYTE *usages, BOOL absolute, const struct wine_input_absinfo *absinfo)
218 {
219 int i;
220 memcpy(report_ptr, REPORT_AXIS_HEADER, sizeof(REPORT_AXIS_HEADER));
221 report_ptr[IDX_AXIS_PAGE] = page;
222 report_ptr += sizeof(REPORT_AXIS_HEADER);
223 for (i = 0; i < count; i++)
224 {
225 memcpy(report_ptr, REPORT_AXIS_USAGE, sizeof(REPORT_AXIS_USAGE));
226 report_ptr[IDX_AXIS_USAGE] = usages[i];
227 report_ptr += sizeof(REPORT_AXIS_USAGE);
228 }
229 if (absolute)
230 {
231 memcpy(report_ptr, REPORT_ABS_AXIS_TAIL, sizeof(REPORT_ABS_AXIS_TAIL));
232 if (absinfo)
233 {
234 *((int*)&report_ptr[IDX_ABS_LOG_MINIMUM]) = LE_DWORD(absinfo->info.minimum);
235 *((int*)&report_ptr[IDX_ABS_LOG_MAXIMUM]) = LE_DWORD(absinfo->info.maximum);
236 *((int*)&report_ptr[IDX_ABS_PHY_MINIMUM]) = LE_DWORD(absinfo->info.minimum);
237 *((int*)&report_ptr[IDX_ABS_PHY_MAXIMUM]) = LE_DWORD(absinfo->info.maximum);
238 }
239 report_ptr[IDX_ABS_AXIS_COUNT] = count;
240 report_ptr += sizeof(REPORT_ABS_AXIS_TAIL);
241 }
242 else
243 {
244 memcpy(report_ptr, REPORT_REL_AXIS_TAIL, sizeof(REPORT_REL_AXIS_TAIL));
245 report_ptr[IDX_REL_AXIS_COUNT] = count;
246 report_ptr += sizeof(REPORT_REL_AXIS_TAIL);
247 }
248 return report_ptr;
249 }
250
251 static const BYTE* what_am_I(struct udev_device *dev)
252 {
253 static const BYTE Unknown[2] = {HID_USAGE_PAGE_GENERIC, 0};
254 static const BYTE Mouse[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_MOUSE};
255 static const BYTE Keyboard[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_KEYBOARD};
256 static const BYTE Gamepad[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_GAMEPAD};
257 static const BYTE Keypad[2] = {HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_KEYPAD};
258 static const BYTE Tablet[2] = {HID_USAGE_PAGE_DIGITIZER, HID_USAGE_DIGITIZER_PEN};
259 static const BYTE Touchscreen[2] = {HID_USAGE_PAGE_DIGITIZER, HID_USAGE_DIGITIZER_TOUCH_SCREEN};
260 static const BYTE Touchpad[2] = {HID_USAGE_PAGE_DIGITIZER, HID_USAGE_DIGITIZER_TOUCH_PAD};
261
262 struct udev_device *parent = dev;
263
264 /* Look to the parents until we get a clue */
265 while (parent)
266 {
267 if (udev_device_get_property_value(parent, "ID_INPUT_MOUSE"))
268 return Mouse;
269 else if (udev_device_get_property_value(parent, "ID_INPUT_KEYBOARD"))
270 return Keyboard;
271 else if (udev_device_get_property_value(parent, "ID_INPUT_JOYSTICK"))
272 return Gamepad;
273 else if (udev_device_get_property_value(parent, "ID_INPUT_KEY"))
274 return Keypad;
275 else if (udev_device_get_property_value(parent, "ID_INPUT_TOUCHPAD"))
276 return Touchpad;
277 else if (udev_device_get_property_value(parent, "ID_INPUT_TOUCHSCREEN"))
278 return Touchscreen;
279 else if (udev_device_get_property_value(parent, "ID_INPUT_TABLET"))
280 return Tablet;
281
282 parent = udev_device_get_parent_with_subsystem_devtype(parent, "input", NULL);
283 }
284 return Unknown;
285 }
286
287 static void set_button_value(int index, int value, BYTE* buffer)
288 {
289 int bindex = index / 8;
290 int b = index % 8;
291 BYTE mask;
292
293 mask = 1<<b;
294 if (value)
295 buffer[bindex] = buffer[bindex] | mask;
296 else
297 {
298 mask = ~mask;
299 buffer[bindex] = buffer[bindex] & mask;
300 }
301 }
302
303 static void set_abs_axis_value(struct wine_input_private *ext, int code, int value)
304 {
305 int index;
306 /* check for hatswitches */
307 if (code <= ABS_HAT3Y && code >= ABS_HAT0X)
308 {
309 index = code - ABS_HAT0X;
310 ext->hat_values[index] = value;
311 if ((code - ABS_HAT0X) % 2)
312 index--;
313 /* 8 1 2
314 * 7 0 3
315 * 6 5 4 */
316 if (ext->hat_values[index] == 0)
317 {
318 if (ext->hat_values[index+1] == 0)
319 value = 0;
320 else if (ext->hat_values[index+1] < 0)
321 value = 1;
322 else
323 value = 5;
324 }
325 else if (ext->hat_values[index] > 0)
326 {
327 if (ext->hat_values[index+1] == 0)
328 value = 3;
329 else if (ext->hat_values[index+1] < 0)
330 value = 2;
331 else
332 value = 4;
333 }
334 else
335 {
336 if (ext->hat_values[index+1] == 0)
337 value = 7;
338 else if (ext->hat_values[index+1] < 0)
339 value = 8;
340 else
341 value = 6;
342 }
343 ext->current_report_buffer[ext->hat_map[index]] = value;
344 }
345 else if (code < HID_ABS_MAX && ABS_TO_HID_MAP[code][0] != 0)
346 {
347 index = ext->abs_map[code].report_index;
348 *((DWORD*)&ext->current_report_buffer[index]) = LE_DWORD(value);
349 }
350 }
351
352 static void set_rel_axis_value(struct wine_input_private *ext, int code, int value)
353 {
354 int index;
355 if (code < HID_REL_MAX && REL_TO_HID_MAP[code][0] != 0)
356 {
357 index = ext->rel_map[code];
358 if (value > 127) value = 127;
359 if (value < -127) value = -127;
360 ext->current_report_buffer[index] = value;
361 }
362 }
363
364 static INT count_buttons(int device_fd, BYTE *map)
365 {
366 int i;
367 int button_count = 0;
368 BYTE keybits[(KEY_MAX+7)/8];
369
370 if (ioctl(device_fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits) == -1)
371 {
372 WARN("ioctl(EVIOCGBIT, EV_KEY) failed: %d %s\n", errno, strerror(errno));
373 return FALSE;
374 }
375
376 for (i = BTN_MISC; i < KEY_MAX; i++)
377 {
378 if (test_bit(keybits, i))
379 {
380 if (map) map[i] = button_count;
381 button_count++;
382 }
383 }
384 return button_count;
385 }
386
387 static INT count_abs_axis(int device_fd)
388 {
389 BYTE absbits[(ABS_MAX+7)/8];
390 int abs_count = 0;
391 int i;
392
393 if (ioctl(device_fd, EVIOCGBIT(EV_ABS, sizeof(absbits)), absbits) == -1)
394 {
395 WARN("ioctl(EVIOCGBIT, EV_ABS) failed: %d %s\n", errno, strerror(errno));
396 return 0;
397 }
398
399 for (i = 0; i < HID_ABS_MAX; i++)
400 if (test_bit(absbits, i) &&
401 (ABS_TO_HID_MAP[i][1] >= HID_USAGE_GENERIC_X &&
402 ABS_TO_HID_MAP[i][1] <= HID_USAGE_GENERIC_WHEEL))
403 abs_count++;
404 return abs_count;
405 }
406
407 static BOOL build_report_descriptor(struct wine_input_private *ext, struct udev_device *dev)
408 {
409 int abs_pages[TOP_ABS_PAGE][HID_ABS_MAX+1];
410 int rel_pages[TOP_REL_PAGE][HID_REL_MAX+1];
411 BYTE absbits[(ABS_MAX+7)/8];
412 BYTE relbits[(REL_MAX+7)/8];
413 BYTE *report_ptr;
414 INT i, descript_size;
415 INT report_size;
416 INT button_count, abs_count, rel_count, hat_count;
417 const BYTE *device_usage = what_am_I(dev);
418
419 if (ioctl(ext->base.device_fd, EVIOCGBIT(EV_REL, sizeof(relbits)), relbits) == -1)
420 {
421 WARN("ioctl(EVIOCGBIT, EV_REL) failed: %d %s\n", errno, strerror(errno));
422 return FALSE;
423 }
424 if (ioctl(ext->base.device_fd, EVIOCGBIT(EV_ABS, sizeof(absbits)), absbits) == -1)
425 {
426 WARN("ioctl(EVIOCGBIT, EV_ABS) failed: %d %s\n", errno, strerror(errno));
427 return FALSE;
428 }
429
430 descript_size = sizeof(REPORT_HEADER) + sizeof(REPORT_TAIL);
431 report_size = 0;
432
433 abs_count = 0;
434 memset(abs_pages, 0, sizeof(abs_pages));
435 for (i = 0; i < HID_ABS_MAX; i++)
436 if (test_bit(absbits, i))
437 {
438 abs_pages[ABS_TO_HID_MAP[i][0]][0]++;
439 abs_pages[ABS_TO_HID_MAP[i][0]][abs_pages[ABS_TO_HID_MAP[i][0]][0]] = i;
440
441 ioctl(ext->base.device_fd, EVIOCGABS(i), &(ext->abs_map[i]));
442 }
443 /* Skip page 0, aka HID_USAGE_PAGE_UNDEFINED */
444 for (i = 1; i < TOP_ABS_PAGE; i++)
445 if (abs_pages[i][0] > 0)
446 {
447 int j;
448 descript_size += sizeof(REPORT_AXIS_USAGE) * abs_pages[i][0];
449 for (j = 1; j <= abs_pages[i][0]; j++)
450 {
451 ext->abs_map[abs_pages[i][j]].report_index = report_size;
452 report_size+=4;
453 }
454 abs_count++;
455 }
456 descript_size += sizeof(REPORT_AXIS_HEADER) * abs_count;
457 descript_size += sizeof(REPORT_ABS_AXIS_TAIL) * abs_count;
458
459 rel_count = 0;
460 memset(rel_pages, 0, sizeof(rel_pages));
461 for (i = 0; i < HID_REL_MAX; i++)
462 if (test_bit(relbits, i))
463 {
464 rel_pages[REL_TO_HID_MAP[i][0]][0]++;
465 rel_pages[REL_TO_HID_MAP[i][0]][rel_pages[REL_TO_HID_MAP[i][0]][0]] = i;
466 }
467 /* Skip page 0, aka HID_USAGE_PAGE_UNDEFINED */
468 for (i = 1; i < TOP_REL_PAGE; i++)
469 if (rel_pages[i][0] > 0)
470 {
471 int j;
472 descript_size += sizeof(REPORT_AXIS_USAGE) * rel_pages[i][0];
473 for (j = 1; j <= rel_pages[i][0]; j++)
474 {
475 ext->rel_map[rel_pages[i][j]] = report_size;
476 report_size++;
477 }
478 rel_count++;
479 }
480 descript_size += sizeof(REPORT_AXIS_HEADER) * rel_count;
481 descript_size += sizeof(REPORT_REL_AXIS_TAIL) * rel_count;
482
483 /* For now lump all buttons just into incremental usages, Ignore Keys */
484 ext->button_start = report_size;
485 button_count = count_buttons(ext->base.device_fd, ext->button_map);
486 if (button_count)
487 {
488 descript_size += sizeof(REPORT_BUTTONS);
489 if (button_count % 8)
490 descript_size += sizeof(REPORT_PADDING);
491 report_size += (button_count + 7) / 8;
492 }
493
494 hat_count = 0;
495 for (i = ABS_HAT0X; i <=ABS_HAT3X; i+=2)
496 if (test_bit(absbits, i))
497 {
498 ext->hat_map[i - ABS_HAT0X] = report_size;
499 ext->hat_values[i - ABS_HAT0X] = 0;
500 ext->hat_values[i - ABS_HAT0X + 1] = 0;
501 report_size++;
502 hat_count++;
503 }
504 if (hat_count > 0)
505 descript_size += sizeof(REPORT_HATSWITCH);
506
507 TRACE("Report Descriptor will be %i bytes\n", descript_size);
508 TRACE("Report will be %i bytes\n", report_size);
509
510 ext->report_descriptor = HeapAlloc(GetProcessHeap(), 0, descript_size);
511 if (!ext->report_descriptor)
512 {
513 ERR("Failed to alloc report descriptor\n");
514 return FALSE;
515 }
516 report_ptr = ext->report_descriptor;
517
518 memcpy(report_ptr, REPORT_HEADER, sizeof(REPORT_HEADER));
519 report_ptr[IDX_HEADER_PAGE] = device_usage[0];
520 report_ptr[IDX_HEADER_USAGE] = device_usage[1];
521 report_ptr += sizeof(REPORT_HEADER);
522 if (abs_count)
523 {
524 for (i = 1; i < TOP_ABS_PAGE; i++)
525 {
526 if (abs_pages[i][0])
527 {
528 BYTE usages[HID_ABS_MAX];
529 int j;
530 for (j = 0; j < abs_pages[i][0]; j++)
531 usages[j] = ABS_TO_HID_MAP[abs_pages[i][j+1]][1];
532 report_ptr = add_axis_block(report_ptr, abs_pages[i][0], i, usages, TRUE, &ext->abs_map[abs_pages[i][1]]);
533 }
534 }
535 }
536 if (rel_count)
537 {
538 for (i = 1; i < TOP_REL_PAGE; i++)
539 {
540 if (rel_pages[i][0])
541 {
542 BYTE usages[HID_REL_MAX];
543 int j;
544 for (j = 0; j < rel_pages[i][0]; j++)
545 usages[j] = REL_TO_HID_MAP[rel_pages[i][j+1]][1];
546 report_ptr = add_axis_block(report_ptr, rel_pages[i][0], i, usages, FALSE, NULL);
547 }
548 }
549 }
550 if (button_count)
551 {
552 report_ptr = add_button_block(report_ptr, 1, button_count);
553 if (button_count % 8)
554 {
555 BYTE padding = 8 - (button_count % 8);
556 report_ptr = add_padding_block(report_ptr, padding);
557 }
558 }
559 if (hat_count)
560 report_ptr = add_hatswitch(report_ptr, hat_count);
561
562 memcpy(report_ptr, REPORT_TAIL, sizeof(REPORT_TAIL));
563
564 ext->report_descriptor_size = descript_size;
565 ext->buffer_length = report_size;
566 ext->current_report_buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, report_size);
567 if (ext->current_report_buffer == NULL)
568 {
569 ERR("Failed to alloc report buffer\n");
570 HeapFree(GetProcessHeap(), 0, ext->report_descriptor);
571 return FALSE;
572 }
573 ext->last_report_buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, report_size);
574 if (ext->last_report_buffer == NULL)
575 {
576 ERR("Failed to alloc report buffer\n");
577 HeapFree(GetProcessHeap(), 0, ext->report_descriptor);
578 HeapFree(GetProcessHeap(), 0, ext->current_report_buffer);
579 return FALSE;
580 }
581 ext->report_state = FIRST;
582
583 /* Initialize axis in the report */
584 for (i = 0; i < HID_ABS_MAX; i++)
585 if (test_bit(absbits, i))
586 set_abs_axis_value(ext, i, ext->abs_map[i].info.value);
587
588 return TRUE;
589 }
590
591 static BOOL set_report_from_event(struct wine_input_private *ext, struct input_event *ie)
592 {
593 switch(ie->type)
594 {
595 #ifdef EV_SYN
596 case EV_SYN:
597 switch (ie->code)
598 {
599 case SYN_REPORT:
600 if (ext->report_state == NORMAL)
601 {
602 memcpy(ext->last_report_buffer, ext->current_report_buffer, ext->buffer_length);
603 return TRUE;
604 }
605 else
606 {
607 if (ext->report_state == DROPPED)
608 memcpy(ext->current_report_buffer, ext->last_report_buffer, ext->buffer_length);
609 ext->report_state = NORMAL;
610 }
611 break;
612 case SYN_DROPPED:
613 TRACE_(hid_report)("received SY_DROPPED\n");
614 ext->report_state = DROPPED;
615 }
616 return FALSE;
617 #endif
618 #ifdef EV_MSC
619 case EV_MSC:
620 return FALSE;
621 #endif
622 case EV_KEY:
623 set_button_value(ext->button_start + ext->button_map[ie->code], ie->value, ext->current_report_buffer);
624 return FALSE;
625 case EV_ABS:
626 set_abs_axis_value(ext, ie->code, ie->value);
627 return FALSE;
628 case EV_REL:
629 set_rel_axis_value(ext, ie->code, ie->value);
630 return FALSE;
631 default:
632 ERR("TODO: Process Report (%i, %i)\n",ie->type, ie->code);
633 return FALSE;
634 }
635 }
636 #endif
637
638 static inline WCHAR *strdupAtoW(const char *src)
639 {
640 WCHAR *dst;
641 DWORD len;
642 if (!src) return NULL;
643 len = MultiByteToWideChar(CP_UNIXCP, 0, src, -1, NULL, 0);
644 if ((dst = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
645 MultiByteToWideChar(CP_UNIXCP, 0, src, -1, dst, len);
646 return dst;
647 }
648
649 static WCHAR *get_sysattr_string(struct udev_device *dev, const char *sysattr)
650 {
651 const char *attr = udev_device_get_sysattr_value(dev, sysattr);
652 if (!attr)
653 {
654 WARN("Could not get %s from device\n", sysattr);
655 return NULL;
656 }
657 return strdupAtoW(attr);
658 }
659
660 static void hidraw_free_device(DEVICE_OBJECT *device)
661 {
662 struct platform_private *private = impl_from_DEVICE_OBJECT(device);
663
664 if (private->report_thread)
665 {
666 write(private->control_pipe[1], "q", 1);
667 WaitForSingleObject(private->report_thread, INFINITE);
668 close(private->control_pipe[0]);
669 close(private->control_pipe[1]);
670 CloseHandle(private->report_thread);
671 }
672
673 close(private->device_fd);
674 udev_device_unref(private->udev_device);
675 }
676
677 static int compare_platform_device(DEVICE_OBJECT *device, void *platform_dev)
678 {
679 struct udev_device *dev1 = impl_from_DEVICE_OBJECT(device)->udev_device;
680 struct udev_device *dev2 = platform_dev;
681 return strcmp(udev_device_get_syspath(dev1), udev_device_get_syspath(dev2));
682 }
683
684 static NTSTATUS hidraw_get_reportdescriptor(DEVICE_OBJECT *device, BYTE *buffer, DWORD length, DWORD *out_length)
685 {
686 #ifdef HAVE_LINUX_HIDRAW_H
687 struct hidraw_report_descriptor descriptor;
688 struct platform_private *private = impl_from_DEVICE_OBJECT(device);
689
690 if (ioctl(private->device_fd, HIDIOCGRDESCSIZE, &descriptor.size) == -1)
691 {
692 WARN("ioctl(HIDIOCGRDESCSIZE) failed: %d %s\n", errno, strerror(errno));
693 return STATUS_UNSUCCESSFUL;
694 }
695
696 *out_length = descriptor.size;
697
698 if (length < descriptor.size)
699 return STATUS_BUFFER_TOO_SMALL;
700 if (!descriptor.size)
701 return STATUS_SUCCESS;
702
703 if (ioctl(private->device_fd, HIDIOCGRDESC, &descriptor) == -1)
704 {
705 WARN("ioctl(HIDIOCGRDESC) failed: %d %s\n", errno, strerror(errno));
706 return STATUS_UNSUCCESSFUL;
707 }
708
709 memcpy(buffer, descriptor.value, descriptor.size);
710 return STATUS_SUCCESS;
711 #else
712 return STATUS_NOT_IMPLEMENTED;
713 #endif
714 }
715
716 static NTSTATUS hidraw_get_string(DEVICE_OBJECT *device, DWORD index, WCHAR *buffer, DWORD length)
717 {
718 struct udev_device *usbdev;
719 struct platform_private *private = impl_from_DEVICE_OBJECT(device);
720 WCHAR *str = NULL;
721
722 usbdev = udev_device_get_parent_with_subsystem_devtype(private->udev_device, "usb", "usb_device");
723 if (usbdev)
724 {
725 switch (index)
726 {
727 case HID_STRING_ID_IPRODUCT:
728 str = get_sysattr_string(usbdev, "product");
729 break;
730 case HID_STRING_ID_IMANUFACTURER:
731 str = get_sysattr_string(usbdev, "manufacturer");
732 break;
733 case HID_STRING_ID_ISERIALNUMBER:
734 str = get_sysattr_string(usbdev, "serial");
735 break;
736 default:
737 ERR("Unhandled string index %08x\n", index);
738 return STATUS_NOT_IMPLEMENTED;
739 }
740 }
741 else
742 {
743 #ifdef HAVE_LINUX_HIDRAW_H
744 switch (index)
745 {
746 case HID_STRING_ID_IPRODUCT:
747 {
748 char buf[MAX_PATH];
749 if (ioctl(private->device_fd, HIDIOCGRAWNAME(MAX_PATH), buf) == -1)
750 WARN("ioctl(HIDIOCGRAWNAME) failed: %d %s\n", errno, strerror(errno));
751 else
752 str = strdupAtoW(buf);
753 break;
754 }
755 case HID_STRING_ID_IMANUFACTURER:
756 break;
757 case HID_STRING_ID_ISERIALNUMBER:
758 break;
759 default:
760 ERR("Unhandled string index %08x\n", index);
761 return STATUS_NOT_IMPLEMENTED;
762 }
763 #else
764 return STATUS_NOT_IMPLEMENTED;
765 #endif
766 }
767
768 if (!str)
769 {
770 if (!length) return STATUS_BUFFER_TOO_SMALL;
771 buffer[0] = 0;
772 return STATUS_SUCCESS;
773 }
774
775 if (length <= strlenW(str))
776 {
777 HeapFree(GetProcessHeap(), 0, str);
778 return STATUS_BUFFER_TOO_SMALL;
779 }
780
781 strcpyW(buffer, str);
782 HeapFree(GetProcessHeap(), 0, str);
783 return STATUS_SUCCESS;
784 }
785
786 static DWORD CALLBACK device_report_thread(void *args)
787 {
788 DEVICE_OBJECT *device = (DEVICE_OBJECT*)args;
789 struct platform_private *private = impl_from_DEVICE_OBJECT(device);
790 struct pollfd plfds[2];
791
792 plfds[0].fd = private->device_fd;
793 plfds[0].events = POLLIN;
794 plfds[0].revents = 0;
795 plfds[1].fd = private->control_pipe[0];
796 plfds[1].events = POLLIN;
797 plfds[1].revents = 0;
798
799 while (1)
800 {
801 int size;
802 BYTE report_buffer[1024];
803
804 if (poll(plfds, 2, -1) <= 0) continue;
805 if (plfds[1].revents)
806 break;
807 size = read(plfds[0].fd, report_buffer, sizeof(report_buffer));
808 if (size == -1)
809 TRACE_(hid_report)("Read failed. Likely an unplugged device %d %s\n", errno, strerror(errno));
810 else if (size == 0)
811 TRACE_(hid_report)("Failed to read report\n");
812 else
813 process_hid_report(device, report_buffer, size);
814 }
815 return 0;
816 }
817
818 static NTSTATUS begin_report_processing(DEVICE_OBJECT *device)
819 {
820 struct platform_private *private = impl_from_DEVICE_OBJECT(device);
821
822 if (private->report_thread)
823 return STATUS_SUCCESS;
824
825 if (pipe(private->control_pipe) != 0)
826 {
827 ERR("Control pipe creation failed\n");
828 return STATUS_UNSUCCESSFUL;
829 }
830
831 private->report_thread = CreateThread(NULL, 0, device_report_thread, device, 0, NULL);
832 if (!private->report_thread)
833 {
834 ERR("Unable to create device report thread\n");
835 close(private->control_pipe[0]);
836 close(private->control_pipe[1]);
837 return STATUS_UNSUCCESSFUL;
838 }
839 else
840 return STATUS_SUCCESS;
841 }
842
843 static NTSTATUS hidraw_set_output_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *written)
844 {
845 struct platform_private* ext = impl_from_DEVICE_OBJECT(device);
846 int rc;
847
848 if (id != 0)
849 rc = write(ext->device_fd, report, length);
850 else
851 {
852 BYTE report_buffer[1024];
853
854 if (length + 1 > sizeof(report_buffer))
855 {
856 ERR("Output report buffer too small\n");
857 return STATUS_UNSUCCESSFUL;
858 }
859
860 report_buffer[0] = 0;
861 memcpy(&report_buffer[1], report, length);
862 rc = write(ext->device_fd, report_buffer, length + 1);
863 }
864 if (rc > 0)
865 {
866 *written = rc;
867 return STATUS_SUCCESS;
868 }
869 else
870 {
871 TRACE("write failed: %d %d %s\n", rc, errno, strerror(errno));
872 *written = 0;
873 return STATUS_UNSUCCESSFUL;
874 }
875 }
876
877 static NTSTATUS hidraw_get_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *read)
878 {
879 #if defined(HAVE_LINUX_HIDRAW_H) && defined(HIDIOCGFEATURE)
880 int rc;
881 struct platform_private* ext = impl_from_DEVICE_OBJECT(device);
882 report[0] = id;
883 length = min(length, 0x1fff);
884 rc = ioctl(ext->device_fd, HIDIOCGFEATURE(length), report);
885 if (rc >= 0)
886 {
887 *read = rc;
888 return STATUS_SUCCESS;
889 }
890 else
891 {
892 TRACE_(hid_report)("ioctl(HIDIOCGFEATURE(%d)) failed: %d %s\n", length, errno, strerror(errno));
893 *read = 0;
894 return STATUS_UNSUCCESSFUL;
895 }
896 #else
897 *read = 0;
898 return STATUS_NOT_IMPLEMENTED;
899 #endif
900 }
901
902 static NTSTATUS hidraw_set_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *written)
903 {
904 #if defined(HAVE_LINUX_HIDRAW_H) && defined(HIDIOCSFEATURE)
905 int rc;
906 struct platform_private* ext = impl_from_DEVICE_OBJECT(device);
907 BYTE *feature_buffer;
908 BYTE buffer[8192];
909
910 if (id == 0)
911 {
912 if (length + 1 > sizeof(buffer))
913 {
914 ERR("Output feature buffer too small\n");
915 return STATUS_UNSUCCESSFUL;
916 }
917 buffer[0] = 0;
918 memcpy(&buffer[1], report, length);
919 feature_buffer = buffer;
920 length = length + 1;
921 }
922 else
923 feature_buffer = report;
924 length = min(length, 0x1fff);
925 rc = ioctl(ext->device_fd, HIDIOCSFEATURE(length), feature_buffer);
926 if (rc >= 0)
927 {
928 *written = rc;
929 return STATUS_SUCCESS;
930 }
931 else
932 {
933 TRACE_(hid_report)("ioctl(HIDIOCSFEATURE(%d)) failed: %d %s\n", length, errno, strerror(errno));
934 *written = 0;
935 return STATUS_UNSUCCESSFUL;
936 }
937 #else
938 *written = 0;
939 return STATUS_NOT_IMPLEMENTED;
940 #endif
941 }
942
943 static const platform_vtbl hidraw_vtbl =
944 {
945 hidraw_free_device,
946 compare_platform_device,
947 hidraw_get_reportdescriptor,
948 hidraw_get_string,
949 begin_report_processing,
950 hidraw_set_output_report,
951 hidraw_get_feature_report,
952 hidraw_set_feature_report,
953 };
954
955 #ifdef HAS_PROPER_INPUT_HEADER
956
957 static inline struct wine_input_private *input_impl_from_DEVICE_OBJECT(DEVICE_OBJECT *device)
958 {
959 return (struct wine_input_private*)get_platform_private(device);
960 }
961
962 static void lnxev_free_device(DEVICE_OBJECT *device)
963 {
964 struct wine_input_private *ext = input_impl_from_DEVICE_OBJECT(device);
965
966 if (ext->base.report_thread)
967 {
968 write(ext->base.control_pipe[1], "q", 1);
969 WaitForSingleObject(ext->base.report_thread, INFINITE);
970 close(ext->base.control_pipe[0]);
971 close(ext->base.control_pipe[1]);
972 CloseHandle(ext->base.report_thread);
973 }
974
975 HeapFree(GetProcessHeap(), 0, ext->current_report_buffer);
976 HeapFree(GetProcessHeap(), 0, ext->last_report_buffer);
977 HeapFree(GetProcessHeap(), 0, ext->report_descriptor);
978
979 close(ext->base.device_fd);
980 udev_device_unref(ext->base.udev_device);
981 }
982
983 static NTSTATUS lnxev_get_reportdescriptor(DEVICE_OBJECT *device, BYTE *buffer, DWORD length, DWORD *out_length)
984 {
985 struct wine_input_private *ext = input_impl_from_DEVICE_OBJECT(device);
986
987 *out_length = ext->report_descriptor_size;
988
989 if (length < ext->report_descriptor_size)
990 return STATUS_BUFFER_TOO_SMALL;
991
992 memcpy(buffer, ext->report_descriptor, ext->report_descriptor_size);
993
994 return STATUS_SUCCESS;
995 }
996
997 static NTSTATUS lnxev_get_string(DEVICE_OBJECT *device, DWORD index, WCHAR *buffer, DWORD length)
998 {
999 struct wine_input_private *ext = input_impl_from_DEVICE_OBJECT(device);
1000 char str[255];
1001
1002 str[0] = 0;
1003 switch (index)
1004 {
1005 case HID_STRING_ID_IPRODUCT:
1006 ioctl(ext->base.device_fd, EVIOCGNAME(sizeof(str)), str);
1007 break;
1008 case HID_STRING_ID_IMANUFACTURER:
1009 strcpy(str,"evdev");
1010 break;
1011 case HID_STRING_ID_ISERIALNUMBER:
1012 ioctl(ext->base.device_fd, EVIOCGUNIQ(sizeof(str)), str);
1013 break;
1014 default:
1015 ERR("Unhandled string index %i\n", index);
1016 }
1017
1018 MultiByteToWideChar(CP_ACP, 0, str, -1, buffer, length);
1019 return STATUS_SUCCESS;
1020 }
1021
1022 static DWORD CALLBACK lnxev_device_report_thread(void *args)
1023 {
1024 DEVICE_OBJECT *device = (DEVICE_OBJECT*)args;
1025 struct wine_input_private *private = input_impl_from_DEVICE_OBJECT(device);
1026 struct pollfd plfds[2];
1027
1028 plfds[0].fd = private->base.device_fd;
1029 plfds[0].events = POLLIN;
1030 plfds[0].revents = 0;
1031 plfds[1].fd = private->base.control_pipe[0];
1032 plfds[1].events = POLLIN;
1033 plfds[1].revents = 0;
1034
1035 while (1)
1036 {
1037 int size;
1038 struct input_event ie;
1039
1040 if (poll(plfds, 2, -1) <= 0) continue;
1041 if (plfds[1].revents || !private->current_report_buffer || private->buffer_length == 0)
1042 break;
1043 size = read(plfds[0].fd, &ie, sizeof(ie));
1044 if (size == -1)
1045 TRACE_(hid_report)("Read failed. Likely an unplugged device\n");
1046 else if (size == 0)
1047 TRACE_(hid_report)("Failed to read report\n");
1048 else if (set_report_from_event(private, &ie))
1049 process_hid_report(device, private->current_report_buffer, private->buffer_length);
1050 }
1051 return 0;
1052 }
1053
1054 static NTSTATUS lnxev_begin_report_processing(DEVICE_OBJECT *device)
1055 {
1056 struct wine_input_private *private = input_impl_from_DEVICE_OBJECT(device);
1057
1058 if (private->base.report_thread)
1059 return STATUS_SUCCESS;
1060
1061 if (pipe(private->base.control_pipe) != 0)
1062 {
1063 ERR("Control pipe creation failed\n");
1064 return STATUS_UNSUCCESSFUL;
1065 }
1066
1067 private->base.report_thread = CreateThread(NULL, 0, lnxev_device_report_thread, device, 0, NULL);
1068 if (!private->base.report_thread)
1069 {
1070 ERR("Unable to create device report thread\n");
1071 close(private->base.control_pipe[0]);
1072 close(private->base.control_pipe[1]);
1073 return STATUS_UNSUCCESSFUL;
1074 }
1075 return STATUS_SUCCESS;
1076 }
1077
1078 static NTSTATUS lnxev_set_output_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *written)
1079 {
1080 *written = 0;
1081 return STATUS_NOT_IMPLEMENTED;
1082 }
1083
1084 static NTSTATUS lnxev_get_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *read)
1085 {
1086 *read = 0;
1087 return STATUS_NOT_IMPLEMENTED;
1088 }
1089
1090 static NTSTATUS lnxev_set_feature_report(DEVICE_OBJECT *device, UCHAR id, BYTE *report, DWORD length, ULONG_PTR *written)
1091 {
1092 *written = 0;
1093 return STATUS_NOT_IMPLEMENTED;
1094 }
1095
1096 static const platform_vtbl lnxev_vtbl = {
1097 lnxev_free_device,
1098 compare_platform_device,
1099 lnxev_get_reportdescriptor,
1100 lnxev_get_string,
1101 lnxev_begin_report_processing,
1102 lnxev_set_output_report,
1103 lnxev_get_feature_report,
1104 lnxev_set_feature_report,
1105 };
1106 #endif
1107
1108 static int check_same_device(DEVICE_OBJECT *device, void* context)
1109 {
1110 return !compare_platform_device(device, context);
1111 }
1112
1113 static int parse_uevent_info(const char *uevent, DWORD *vendor_id,
1114 DWORD *product_id, WORD *input, WCHAR **serial_number)
1115 {
1116 DWORD bus_type;
1117 char *tmp;
1118 char *saveptr = NULL;
1119 char *line;
1120 char *key;
1121 char *value;
1122
1123 int found_id = 0;
1124 int found_serial = 0;
1125
1126 tmp = heap_alloc(strlen(uevent) + 1);
1127 strcpy(tmp, uevent);
1128 line = strtok_r(tmp, "\n", &saveptr);
1129 while (line != NULL)
1130 {
1131 /* line: "KEY=value" */
1132 key = line;
1133 value = strchr(line, '=');
1134 if (!value)
1135 {
1136 goto next_line;
1137 }
1138 *value = '\0';
1139 value++;
1140
1141 if (strcmp(key, "HID_ID") == 0)
1142 {
1143 /**
1144 * type vendor product
1145 * HID_ID=0003:000005AC:00008242
1146 **/
1147 int ret = sscanf(value, "%x:%x:%x", &bus_type, vendor_id, product_id);
1148 if (ret == 3)
1149 found_id = 1;
1150 }
1151 else if (strcmp(key, "HID_UNIQ") == 0)
1152 {
1153 /* The caller has to free the serial number */
1154 if (*value)
1155 {
1156 *serial_number = strdupAtoW(value);
1157 found_serial = 1;
1158 }
1159 }
1160 else if (strcmp(key, "HID_PHYS") == 0)
1161 {
1162 const char *input_no = strstr(value, "input");
1163 if (input_no)
1164 *input = atoi(input_no+5 );
1165 }
1166
1167 next_line:
1168 line = strtok_r(NULL, "\n", &saveptr);
1169 }
1170
1171 heap_free(tmp);
1172 return (found_id && found_serial);
1173 }
1174
1175 static DWORD a_to_bcd(const char *s)
1176 {
1177 DWORD r = 0;
1178 const char *c;
1179 int shift = strlen(s) - 1;
1180 for (c = s; *c; ++c)
1181 {
1182 r |= (*c - '0') << (shift * 4);
1183 --shift;
1184 }
1185 return r;
1186 }
1187
1188 static void try_add_device(struct udev_device *dev)
1189 {
1190 DWORD vid = 0, pid = 0, version = 0;
1191 struct udev_device *hiddev = NULL, *walk_device;
1192 DEVICE_OBJECT *device = NULL;
1193 const char *subsystem;
1194 const char *devnode;
1195 WCHAR *serial = NULL;
1196 BOOL is_gamepad = FALSE;
1197 WORD input = -1;
1198 int fd;
1199 static const CHAR *base_serial = "0000";
1200
1201 if (!(devnode = udev_device_get_devnode(dev)))
1202 return;
1203
1204 if ((fd = open(devnode, O_RDWR)) == -1)
1205 {
1206 WARN("Unable to open udev device %s: %s\n", debugstr_a(devnode), strerror(errno));
1207 return;
1208 }
1209
1210 subsystem = udev_device_get_subsystem(dev);
1211 hiddev = udev_device_get_parent_with_subsystem_devtype(dev, "hid", NULL);
1212 if (hiddev)
1213 {
1214 const char *bcdDevice = NULL;
1215 #ifdef HAS_PROPER_INPUT_HEADER
1216 const platform_vtbl *other_vtbl = NULL;
1217 DEVICE_OBJECT *dup = NULL;
1218 if (strcmp(subsystem, "hidraw") == 0)
1219 other_vtbl = &lnxev_vtbl;
1220 else if (strcmp(subsystem, "input") == 0)
1221 other_vtbl = &hidraw_vtbl;
1222
1223 if (other_vtbl)
1224 dup = bus_enumerate_hid_devices(other_vtbl, check_same_device, dev);
1225 if (dup)
1226 {
1227 TRACE("Duplicate cross bus device (%p) found, not adding the new one\n", dup);
1228 close(fd);
1229 return;
1230 }
1231 #endif
1232 parse_uevent_info(udev_device_get_sysattr_value(hiddev, "uevent"),
1233 &vid, &pid, &input, &serial);
1234 if (serial == NULL)
1235 serial = strdupAtoW(base_serial);
1236
1237 walk_device = dev;
1238 while (walk_device && !bcdDevice)
1239 {
1240 bcdDevice = udev_device_get_sysattr_value(walk_device, "bcdDevice");
1241 walk_device = udev_device_get_parent(walk_device);
1242 }
1243 if (bcdDevice)
1244 {
1245 version = a_to_bcd(bcdDevice);
1246 }
1247 }
1248 #ifdef HAS_PROPER_INPUT_HEADER
1249 else
1250 {
1251 struct input_id device_id = {0};
1252 char device_uid[255];
1253
1254 if (ioctl(fd, EVIOCGID, &device_id) < 0)
1255 WARN("ioctl(EVIOCGID) failed: %d %s\n", errno, strerror(errno));
1256 device_uid[0] = 0;
1257 if (ioctl(fd, EVIOCGUNIQ(254), device_uid) >= 0 && device_uid[0])
1258 serial = strdupAtoW(device_uid);
1259
1260 vid = device_id.vendor;
1261 pid = device_id.product;
1262 version = device_id.version;
1263 }
1264 #else
1265 else
1266 WARN("Could not get device to query VID, PID, Version and Serial\n");
1267 #endif
1268
1269 if (is_xbox_gamepad(vid, pid))
1270 is_gamepad = TRUE;
1271 #ifdef HAS_PROPER_INPUT_HEADER
1272 else
1273 {
1274 int axes=0, buttons=0;
1275 axes = count_abs_axis(fd);
1276 buttons = count_buttons(fd, NULL);
1277 is_gamepad = (axes == 6 && buttons >= 14);
1278 }
1279 #endif
1280 if (input == (WORD)-1 && is_gamepad)
1281 input = 0;
1282
1283
1284 TRACE("Found udev device %s (vid %04x, pid %04x, version %u, serial %s)\n",
1285 debugstr_a(devnode), vid, pid, version, debugstr_w(serial));
1286
1287 if (strcmp(subsystem, "hidraw") == 0)
1288 {
1289 device = bus_create_hid_device(hidraw_busidW, vid, pid, input, version, 0, serial, is_gamepad,
1290 &hidraw_vtbl, sizeof(struct platform_private));
1291 }
1292 #ifdef HAS_PROPER_INPUT_HEADER
1293 else if (strcmp(subsystem, "input") == 0)
1294 {
1295 device = bus_create_hid_device(lnxev_busidW, vid, pid, input, version, 0, serial, is_gamepad,
1296 &lnxev_vtbl, sizeof(struct wine_input_private));
1297 }
1298 #endif
1299
1300 if (device)
1301 {
1302 struct platform_private *private = impl_from_DEVICE_OBJECT(device);
1303 private->udev_device = udev_device_ref(dev);
1304 private->device_fd = fd;
1305 #ifdef HAS_PROPER_INPUT_HEADER
1306 if (strcmp(subsystem, "input") == 0)
1307 /* FIXME: We should probably move this to IRP_MN_START_DEVICE. */
1308 if (!build_report_descriptor((struct wine_input_private*)private, dev))
1309 {
1310 ERR("Building report descriptor failed, removing device\n");
1311 close(fd);
1312 udev_device_unref(dev);
1313 bus_unlink_hid_device(device);
1314 bus_remove_hid_device(device);
1315 HeapFree(GetProcessHeap(), 0, serial);
1316 return;
1317 }
1318 #endif
1319 IoInvalidateDeviceRelations(bus_pdo, BusRelations);
1320 }
1321 else
1322 {
1323 WARN("Ignoring device %s with subsystem %s\n", debugstr_a(devnode), subsystem);
1324 close(fd);
1325 }
1326
1327 HeapFree(GetProcessHeap(), 0, serial);
1328 }
1329
1330 static void try_remove_device(struct udev_device *dev)
1331 {
1332 DEVICE_OBJECT *device = NULL;
1333
1334 device = bus_find_hid_device(&hidraw_vtbl, dev);
1335 #ifdef HAS_PROPER_INPUT_HEADER
1336 if (device == NULL)
1337 device = bus_find_hid_device(&lnxev_vtbl, dev);
1338 #endif
1339 if (!device) return;
1340
1341 bus_unlink_hid_device(device);
1342 IoInvalidateDeviceRelations(bus_pdo, BusRelations);
1343 }
1344
1345 static void build_initial_deviceset(void)
1346 {
1347 struct udev_enumerate *enumerate;
1348 struct udev_list_entry *devices, *dev_list_entry;
1349
1350 enumerate = udev_enumerate_new(udev_context);
1351 if (!enumerate)
1352 {
1353 WARN("Unable to create udev enumeration object\n");
1354 return;
1355 }
1356
1357 if (!disable_hidraw)
1358 if (udev_enumerate_add_match_subsystem(enumerate, "hidraw") < 0)
1359 WARN("Failed to add subsystem 'hidraw' to enumeration\n");
1360 #ifdef HAS_PROPER_INPUT_HEADER
1361 if (!disable_input)
1362 {
1363 if (udev_enumerate_add_match_subsystem(enumerate, "input") < 0)
1364 WARN("Failed to add subsystem 'input' to enumeration\n");
1365 }
1366 #endif
1367
1368 if (udev_enumerate_scan_devices(enumerate) < 0)
1369 WARN("Enumeration scan failed\n");
1370
1371 devices = udev_enumerate_get_list_entry(enumerate);
1372 udev_list_entry_foreach(dev_list_entry, devices)
1373 {
1374 struct udev_device *dev;
1375 const char *path;
1376
1377 path = udev_list_entry_get_name(dev_list_entry);
1378 if ((dev = udev_device_new_from_syspath(udev_context, path)))
1379 {
1380 try_add_device(dev);
1381 udev_device_unref(dev);
1382 }
1383 }
1384
1385 udev_enumerate_unref(enumerate);
1386 }
1387
1388 static struct udev_monitor *create_monitor(struct pollfd *pfd)
1389 {
1390 struct udev_monitor *monitor;
1391 int systems = 0;
1392
1393 monitor = udev_monitor_new_from_netlink(udev_context, "udev");
1394 if (!monitor)
1395 {
1396 WARN("Unable to get udev monitor object\n");
1397 return NULL;
1398 }
1399
1400 if (!disable_hidraw)
1401 {
1402 if (udev_monitor_filter_add_match_subsystem_devtype(monitor, "hidraw", NULL) < 0)
1403 WARN("Failed to add 'hidraw' subsystem to monitor\n");
1404 else
1405 systems++;
1406 }
1407 #ifdef HAS_PROPER_INPUT_HEADER
1408 if (!disable_input)
1409 {
1410 if (udev_monitor_filter_add_match_subsystem_devtype(monitor, "input", NULL) < 0)
1411 WARN("Failed to add 'input' subsystem to monitor\n");
1412 else
1413 systems++;
1414 }
1415 #endif
1416 if (systems == 0)
1417 {
1418 WARN("No subsystems added to monitor\n");
1419 goto error;
1420 }
1421
1422 if (udev_monitor_enable_receiving(monitor) < 0)
1423 goto error;
1424
1425 if ((pfd->fd = udev_monitor_get_fd(monitor)) >= 0)
1426 {
1427 pfd->events = POLLIN;
1428 return monitor;
1429 }
1430
1431 error:
1432 WARN("Failed to start monitoring\n");
1433 udev_monitor_unref(monitor);
1434 return NULL;
1435 }
1436
1437 static void process_monitor_event(struct udev_monitor *monitor)
1438 {
1439 struct udev_device *dev;
1440 const char *action;
1441
1442 dev = udev_monitor_receive_device(monitor);
1443 if (!dev)
1444 {
1445 FIXME("Failed to get device that has changed\n");
1446 return;
1447 }
1448
1449 action = udev_device_get_action(dev);
1450 TRACE("Received action %s for udev device %s\n", debugstr_a(action),
1451 debugstr_a(udev_device_get_devnode(dev)));
1452
1453 if (!action)
1454 WARN("No action received\n");
1455 else if (strcmp(action, "add") == 0)
1456 try_add_device(dev);
1457 else if (strcmp(action, "remove") == 0)
1458 try_remove_device(dev);
1459 else
1460 WARN("Unhandled action %s\n", debugstr_a(action));
1461
1462 udev_device_unref(dev);
1463 }
1464
1465 static DWORD CALLBACK deviceloop_thread(void *args)
1466 {
1467 struct udev_monitor *monitor;
1468 HANDLE init_done = args;
1469 struct pollfd pfd[2];
1470
1471 pfd[1].fd = deviceloop_control[0];
1472 pfd[1].events = POLLIN;
1473 pfd[1].revents = 0;
1474
1475 monitor = create_monitor(&pfd[0]);
1476 build_initial_deviceset();
1477 SetEvent(init_done);
1478
1479 while (monitor)
1480 {
1481 if (poll(pfd, 2, -1) <= 0) continue;
1482 if (pfd[1].revents) break;
1483 process_monitor_event(monitor);
1484 }
1485
1486 TRACE("Monitor thread exiting\n");
1487 if (monitor)
1488 udev_monitor_unref(monitor);
1489 return 0;
1490 }
1491
1492 void udev_driver_unload( void )
1493 {
1494 TRACE("Unload Driver\n");
1495
1496 if (!deviceloop_handle)
1497 return;
1498
1499 write(deviceloop_control[1], "q", 1);
1500 WaitForSingleObject(deviceloop_handle, INFINITE);
1501 close(deviceloop_control[0]);
1502 close(deviceloop_control[1]);
1503 CloseHandle(deviceloop_handle);
1504 }
1505
1506 NTSTATUS udev_driver_init(void)
1507 {
1508 HANDLE events[2];
1509 DWORD result;
1510 static const WCHAR hidraw_disabledW[] = {'D','i','s','a','b','l','e','H','i','d','r','a','w',0};
1511 static const UNICODE_STRING hidraw_disabled = {sizeof(hidraw_disabledW) - sizeof(WCHAR), sizeof(hidraw_disabledW), (WCHAR*)hidraw_disabledW};
1512 static const WCHAR input_disabledW[] = {'D','i','s','a','b','l','e','I','n','p','u','t',0};
1513 static const UNICODE_STRING input_disabled = {sizeof(input_disabledW) - sizeof(WCHAR), sizeof(input_disabledW), (WCHAR*)input_disabledW};
1514
1515 if (pipe(deviceloop_control) != 0)
1516 {
1517 ERR("Control pipe creation failed\n");
1518 return STATUS_UNSUCCESSFUL;
1519 }
1520
1521 if (!(udev_context = udev_new()))
1522 {
1523 ERR("Can't create udev object\n");
1524 goto error;
1525 }
1526
1527 disable_hidraw = check_bus_option(&hidraw_disabled, 0);
1528 if (disable_hidraw)
1529 TRACE("UDEV hidraw devices disabled in registry\n");
1530
1531 #ifdef HAS_PROPER_INPUT_HEADER
1532 disable_input = check_bus_option(&input_disabled, 0);
1533 if (disable_input)
1534 TRACE("UDEV input devices disabled in registry\n");
1535 #endif
1536
1537 if (!(events[0] = CreateEventW(NULL, TRUE, FALSE, NULL)))
1538 goto error;
1539 if (!(events[1] = CreateThread(NULL, 0, deviceloop_thread, events[0], 0, NULL)))
1540 {
1541 CloseHandle(events[0]);
1542 goto error;
1543 }
1544
1545 result = WaitForMultipleObjects(2, events, FALSE, INFINITE);
1546 CloseHandle(events[0]);
1547 if (result == WAIT_OBJECT_0)
1548 {
1549 deviceloop_handle = events[1];
1550 TRACE("Initialization successful\n");
1551 return STATUS_SUCCESS;
1552 }
1553 CloseHandle(events[1]);
1554
1555 error:
1556 ERR("Failed to initialize udev device thread\n");
1557 close(deviceloop_control[0]);
1558 close(deviceloop_control[1]);
1559 if (udev_context)
1560 {
1561 udev_unref(udev_context);
1562 udev_context = NULL;
1563 }
1564 return STATUS_UNSUCCESSFUL;
1565 }
1566
1567 #else
1568
1569 NTSTATUS udev_driver_init(void)
1570 {
1571 return STATUS_NOT_IMPLEMENTED;
1572 }
1573
1574 void udev_driver_unload( void )
1575 {
1576 TRACE("Stub: Unload Driver\n");
1577 }
1578
1579 #endif /* HAVE_UDEV */
Windows API implementation