1
2
3
4
5
6
7
8
9
10
11
12
13#ifndef __HID_H
14#define __HID_H
15
16
17#include <linux/bitops.h>
18#include <linux/types.h>
19#include <linux/slab.h>
20#include <linux/list.h>
21#include <linux/mod_devicetable.h>
22#include <linux/timer.h>
23#include <linux/workqueue.h>
24#include <linux/input.h>
25#include <linux/semaphore.h>
26#include <linux/mutex.h>
27#include <linux/power_supply.h>
28#include <uapi/linux/hid.h>
29
30
31
32
33
34
35
36struct hid_item {
37 unsigned format;
38 __u8 size;
39 __u8 type;
40 __u8 tag;
41 union {
42 __u8 u8;
43 __s8 s8;
44 __u16 u16;
45 __s16 s16;
46 __u32 u32;
47 __s32 s32;
48 __u8 *longdata;
49 } data;
50};
51
52
53
54
55
56#define HID_ITEM_FORMAT_SHORT 0
57#define HID_ITEM_FORMAT_LONG 1
58
59
60
61
62
63#define HID_ITEM_TAG_LONG 15
64
65
66
67
68
69#define HID_ITEM_TYPE_MAIN 0
70#define HID_ITEM_TYPE_GLOBAL 1
71#define HID_ITEM_TYPE_LOCAL 2
72#define HID_ITEM_TYPE_RESERVED 3
73
74
75
76
77
78#define HID_MAIN_ITEM_TAG_INPUT 8
79#define HID_MAIN_ITEM_TAG_OUTPUT 9
80#define HID_MAIN_ITEM_TAG_FEATURE 11
81#define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION 10
82#define HID_MAIN_ITEM_TAG_END_COLLECTION 12
83
84
85
86
87
88#define HID_MAIN_ITEM_CONSTANT 0x001
89#define HID_MAIN_ITEM_VARIABLE 0x002
90#define HID_MAIN_ITEM_RELATIVE 0x004
91#define HID_MAIN_ITEM_WRAP 0x008
92#define HID_MAIN_ITEM_NONLINEAR 0x010
93#define HID_MAIN_ITEM_NO_PREFERRED 0x020
94#define HID_MAIN_ITEM_NULL_STATE 0x040
95#define HID_MAIN_ITEM_VOLATILE 0x080
96#define HID_MAIN_ITEM_BUFFERED_BYTE 0x100
97
98
99
100
101
102#define HID_COLLECTION_PHYSICAL 0
103#define HID_COLLECTION_APPLICATION 1
104#define HID_COLLECTION_LOGICAL 2
105
106
107
108
109
110#define HID_GLOBAL_ITEM_TAG_USAGE_PAGE 0
111#define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM 1
112#define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM 2
113#define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM 3
114#define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM 4
115#define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT 5
116#define HID_GLOBAL_ITEM_TAG_UNIT 6
117#define HID_GLOBAL_ITEM_TAG_REPORT_SIZE 7
118#define HID_GLOBAL_ITEM_TAG_REPORT_ID 8
119#define HID_GLOBAL_ITEM_TAG_REPORT_COUNT 9
120#define HID_GLOBAL_ITEM_TAG_PUSH 10
121#define HID_GLOBAL_ITEM_TAG_POP 11
122
123
124
125
126
127#define HID_LOCAL_ITEM_TAG_USAGE 0
128#define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM 1
129#define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM 2
130#define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX 3
131#define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM 4
132#define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM 5
133#define HID_LOCAL_ITEM_TAG_STRING_INDEX 7
134#define HID_LOCAL_ITEM_TAG_STRING_MINIMUM 8
135#define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM 9
136#define HID_LOCAL_ITEM_TAG_DELIMITER 10
137
138
139
140
141
142#define HID_USAGE_PAGE 0xffff0000
143
144#define HID_UP_UNDEFINED 0x00000000
145#define HID_UP_GENDESK 0x00010000
146#define HID_UP_SIMULATION 0x00020000
147#define HID_UP_GENDEVCTRLS 0x00060000
148#define HID_UP_KEYBOARD 0x00070000
149#define HID_UP_LED 0x00080000
150#define HID_UP_BUTTON 0x00090000
151#define HID_UP_ORDINAL 0x000a0000
152#define HID_UP_TELEPHONY 0x000b0000
153#define HID_UP_CONSUMER 0x000c0000
154#define HID_UP_DIGITIZER 0x000d0000
155#define HID_UP_PID 0x000f0000
156#define HID_UP_HPVENDOR 0xff7f0000
157#define HID_UP_HPVENDOR2 0xff010000
158#define HID_UP_MSVENDOR 0xff000000
159#define HID_UP_CUSTOM 0x00ff0000
160#define HID_UP_LOGIVENDOR 0xffbc0000
161#define HID_UP_LOGIVENDOR2 0xff090000
162#define HID_UP_LOGIVENDOR3 0xff430000
163#define HID_UP_LNVENDOR 0xffa00000
164#define HID_UP_SENSOR 0x00200000
165#define HID_UP_ASUSVENDOR 0xff310000
166#define HID_UP_GOOGLEVENDOR 0xffd10000
167
168#define HID_USAGE 0x0000ffff
169
170#define HID_GD_POINTER 0x00010001
171#define HID_GD_MOUSE 0x00010002
172#define HID_GD_JOYSTICK 0x00010004
173#define HID_GD_GAMEPAD 0x00010005
174#define HID_GD_KEYBOARD 0x00010006
175#define HID_GD_KEYPAD 0x00010007
176#define HID_GD_MULTIAXIS 0x00010008
177
178
179
180
181#define HID_GD_WIRELESS_RADIO_CTLS 0x0001000c
182
183
184
185
186#define HID_GD_SYSTEM_MULTIAXIS 0x0001000e
187
188#define HID_GD_X 0x00010030
189#define HID_GD_Y 0x00010031
190#define HID_GD_Z 0x00010032
191#define HID_GD_RX 0x00010033
192#define HID_GD_RY 0x00010034
193#define HID_GD_RZ 0x00010035
194#define HID_GD_SLIDER 0x00010036
195#define HID_GD_DIAL 0x00010037
196#define HID_GD_WHEEL 0x00010038
197#define HID_GD_HATSWITCH 0x00010039
198#define HID_GD_BUFFER 0x0001003a
199#define HID_GD_BYTECOUNT 0x0001003b
200#define HID_GD_MOTION 0x0001003c
201#define HID_GD_START 0x0001003d
202#define HID_GD_SELECT 0x0001003e
203#define HID_GD_VX 0x00010040
204#define HID_GD_VY 0x00010041
205#define HID_GD_VZ 0x00010042
206#define HID_GD_VBRX 0x00010043
207#define HID_GD_VBRY 0x00010044
208#define HID_GD_VBRZ 0x00010045
209#define HID_GD_VNO 0x00010046
210#define HID_GD_FEATURE 0x00010047
211#define HID_GD_RESOLUTION_MULTIPLIER 0x00010048
212#define HID_GD_SYSTEM_CONTROL 0x00010080
213#define HID_GD_UP 0x00010090
214#define HID_GD_DOWN 0x00010091
215#define HID_GD_RIGHT 0x00010092
216#define HID_GD_LEFT 0x00010093
217
218#define HID_GD_RFKILL_BTN 0x000100c6
219#define HID_GD_RFKILL_LED 0x000100c7
220#define HID_GD_RFKILL_SWITCH 0x000100c8
221
222#define HID_DC_BATTERYSTRENGTH 0x00060020
223
224#define HID_CP_CONSUMER_CONTROL 0x000c0001
225#define HID_CP_AC_PAN 0x000c0238
226
227#define HID_DG_DIGITIZER 0x000d0001
228#define HID_DG_PEN 0x000d0002
229#define HID_DG_LIGHTPEN 0x000d0003
230#define HID_DG_TOUCHSCREEN 0x000d0004
231#define HID_DG_TOUCHPAD 0x000d0005
232#define HID_DG_WHITEBOARD 0x000d0006
233#define HID_DG_STYLUS 0x000d0020
234#define HID_DG_PUCK 0x000d0021
235#define HID_DG_FINGER 0x000d0022
236#define HID_DG_TIPPRESSURE 0x000d0030
237#define HID_DG_BARRELPRESSURE 0x000d0031
238#define HID_DG_INRANGE 0x000d0032
239#define HID_DG_TOUCH 0x000d0033
240#define HID_DG_UNTOUCH 0x000d0034
241#define HID_DG_TAP 0x000d0035
242#define HID_DG_TABLETFUNCTIONKEY 0x000d0039
243#define HID_DG_PROGRAMCHANGEKEY 0x000d003a
244#define HID_DG_BATTERYSTRENGTH 0x000d003b
245#define HID_DG_INVERT 0x000d003c
246#define HID_DG_TILT_X 0x000d003d
247#define HID_DG_TILT_Y 0x000d003e
248#define HID_DG_TWIST 0x000d0041
249#define HID_DG_TIPSWITCH 0x000d0042
250#define HID_DG_TIPSWITCH2 0x000d0043
251#define HID_DG_BARRELSWITCH 0x000d0044
252#define HID_DG_ERASER 0x000d0045
253#define HID_DG_TABLETPICK 0x000d0046
254
255#define HID_CP_CONSUMERCONTROL 0x000c0001
256#define HID_CP_NUMERICKEYPAD 0x000c0002
257#define HID_CP_PROGRAMMABLEBUTTONS 0x000c0003
258#define HID_CP_MICROPHONE 0x000c0004
259#define HID_CP_HEADPHONE 0x000c0005
260#define HID_CP_GRAPHICEQUALIZER 0x000c0006
261#define HID_CP_FUNCTIONBUTTONS 0x000c0036
262#define HID_CP_SELECTION 0x000c0080
263#define HID_CP_MEDIASELECTION 0x000c0087
264#define HID_CP_SELECTDISC 0x000c00ba
265#define HID_CP_PLAYBACKSPEED 0x000c00f1
266#define HID_CP_PROXIMITY 0x000c0109
267#define HID_CP_SPEAKERSYSTEM 0x000c0160
268#define HID_CP_CHANNELLEFT 0x000c0161
269#define HID_CP_CHANNELRIGHT 0x000c0162
270#define HID_CP_CHANNELCENTER 0x000c0163
271#define HID_CP_CHANNELFRONT 0x000c0164
272#define HID_CP_CHANNELCENTERFRONT 0x000c0165
273#define HID_CP_CHANNELSIDE 0x000c0166
274#define HID_CP_CHANNELSURROUND 0x000c0167
275#define HID_CP_CHANNELLOWFREQUENCYENHANCEMENT 0x000c0168
276#define HID_CP_CHANNELTOP 0x000c0169
277#define HID_CP_CHANNELUNKNOWN 0x000c016a
278#define HID_CP_APPLICATIONLAUNCHBUTTONS 0x000c0180
279#define HID_CP_GENERICGUIAPPLICATIONCONTROLS 0x000c0200
280
281#define HID_DG_DEVICECONFIG 0x000d000e
282#define HID_DG_DEVICESETTINGS 0x000d0023
283#define HID_DG_AZIMUTH 0x000d003f
284#define HID_DG_CONFIDENCE 0x000d0047
285#define HID_DG_WIDTH 0x000d0048
286#define HID_DG_HEIGHT 0x000d0049
287#define HID_DG_CONTACTID 0x000d0051
288#define HID_DG_INPUTMODE 0x000d0052
289#define HID_DG_DEVICEINDEX 0x000d0053
290#define HID_DG_CONTACTCOUNT 0x000d0054
291#define HID_DG_CONTACTMAX 0x000d0055
292#define HID_DG_SCANTIME 0x000d0056
293#define HID_DG_SURFACESWITCH 0x000d0057
294#define HID_DG_BUTTONSWITCH 0x000d0058
295#define HID_DG_BUTTONTYPE 0x000d0059
296#define HID_DG_BARRELSWITCH2 0x000d005a
297#define HID_DG_TOOLSERIALNUMBER 0x000d005b
298#define HID_DG_LATENCYMODE 0x000d0060
299
300#define HID_VD_ASUS_CUSTOM_MEDIA_KEYS 0xff310076
301
302
303
304
305#define HID_INPUT_REPORT 0
306#define HID_OUTPUT_REPORT 1
307#define HID_FEATURE_REPORT 2
308
309#define HID_REPORT_TYPES 3
310
311
312
313
314
315#define HID_CONNECT_HIDINPUT BIT(0)
316#define HID_CONNECT_HIDINPUT_FORCE BIT(1)
317#define HID_CONNECT_HIDRAW BIT(2)
318#define HID_CONNECT_HIDDEV BIT(3)
319#define HID_CONNECT_HIDDEV_FORCE BIT(4)
320#define HID_CONNECT_FF BIT(5)
321#define HID_CONNECT_DRIVER BIT(6)
322#define HID_CONNECT_DEFAULT (HID_CONNECT_HIDINPUT|HID_CONNECT_HIDRAW| \
323 HID_CONNECT_HIDDEV|HID_CONNECT_FF)
324
325
326
327
328
329
330
331
332#define MAX_USBHID_BOOT_QUIRKS 4
333
334#define HID_QUIRK_INVERT BIT(0)
335#define HID_QUIRK_NOTOUCH BIT(1)
336#define HID_QUIRK_IGNORE BIT(2)
337#define HID_QUIRK_NOGET BIT(3)
338#define HID_QUIRK_HIDDEV_FORCE BIT(4)
339#define HID_QUIRK_BADPAD BIT(5)
340#define HID_QUIRK_MULTI_INPUT BIT(6)
341#define HID_QUIRK_HIDINPUT_FORCE BIT(7)
342
343
344#define HID_QUIRK_ALWAYS_POLL BIT(10)
345#define HID_QUIRK_INPUT_PER_APP BIT(11)
346#define HID_QUIRK_SKIP_OUTPUT_REPORTS BIT(16)
347#define HID_QUIRK_SKIP_OUTPUT_REPORT_ID BIT(17)
348#define HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP BIT(18)
349#define HID_QUIRK_HAVE_SPECIAL_DRIVER BIT(19)
350#define HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE BIT(20)
351#define HID_QUIRK_FULLSPEED_INTERVAL BIT(28)
352#define HID_QUIRK_NO_INIT_REPORTS BIT(29)
353#define HID_QUIRK_NO_IGNORE BIT(30)
354#define HID_QUIRK_NO_INPUT_SYNC BIT(31)
355
356
357
358
359
360
361
362#define HID_GROUP_GENERIC 0x0001
363#define HID_GROUP_MULTITOUCH 0x0002
364#define HID_GROUP_SENSOR_HUB 0x0003
365#define HID_GROUP_MULTITOUCH_WIN_8 0x0004
366
367
368
369
370#define HID_GROUP_RMI 0x0100
371#define HID_GROUP_WACOM 0x0101
372#define HID_GROUP_LOGITECH_DJ_DEVICE 0x0102
373#define HID_GROUP_STEAM 0x0103
374#define HID_GROUP_LOGITECH_27MHZ_DEVICE 0x0104
375#define HID_GROUP_VIVALDI 0x0105
376
377
378
379
380#define HID_REPORT_PROTOCOL 1
381#define HID_BOOT_PROTOCOL 0
382
383
384
385
386
387
388
389struct hid_global {
390 unsigned usage_page;
391 __s32 logical_minimum;
392 __s32 logical_maximum;
393 __s32 physical_minimum;
394 __s32 physical_maximum;
395 __s32 unit_exponent;
396 unsigned unit;
397 unsigned report_id;
398 unsigned report_size;
399 unsigned report_count;
400};
401
402
403
404
405
406#define HID_MAX_USAGES 12288
407#define HID_DEFAULT_NUM_COLLECTIONS 16
408
409struct hid_local {
410 unsigned usage[HID_MAX_USAGES];
411 u8 usage_size[HID_MAX_USAGES];
412 unsigned collection_index[HID_MAX_USAGES];
413 unsigned usage_index;
414 unsigned usage_minimum;
415 unsigned delimiter_depth;
416 unsigned delimiter_branch;
417};
418
419
420
421
422
423
424struct hid_collection {
425 int parent_idx;
426 unsigned type;
427 unsigned usage;
428 unsigned level;
429};
430
431struct hid_usage {
432 unsigned hid;
433 unsigned collection_index;
434 unsigned usage_index;
435 __s8 resolution_multiplier;
436
437
438 __s8 wheel_factor;
439 __u16 code;
440 __u8 type;
441 __s8 hat_min;
442 __s8 hat_max;
443 __s8 hat_dir;
444 __s16 wheel_accumulated;
445};
446
447struct hid_input;
448
449struct hid_field {
450 unsigned physical;
451 unsigned logical;
452 unsigned application;
453 struct hid_usage *usage;
454 unsigned maxusage;
455 unsigned flags;
456 unsigned report_offset;
457 unsigned report_size;
458 unsigned report_count;
459 unsigned report_type;
460 __s32 *value;
461 __s32 logical_minimum;
462 __s32 logical_maximum;
463 __s32 physical_minimum;
464 __s32 physical_maximum;
465 __s32 unit_exponent;
466 unsigned unit;
467 struct hid_report *report;
468 unsigned index;
469
470 struct hid_input *hidinput;
471 __u16 dpad;
472};
473
474#define HID_MAX_FIELDS 256
475
476struct hid_report {
477 struct list_head list;
478 struct list_head hidinput_list;
479 unsigned int id;
480 unsigned int type;
481 unsigned int application;
482 struct hid_field *field[HID_MAX_FIELDS];
483 unsigned maxfield;
484 unsigned size;
485 struct hid_device *device;
486};
487
488#define HID_MAX_IDS 256
489
490struct hid_report_enum {
491 unsigned numbered;
492 struct list_head report_list;
493 struct hid_report *report_id_hash[HID_MAX_IDS];
494};
495
496#define HID_MIN_BUFFER_SIZE 64
497#define HID_MAX_BUFFER_SIZE 16384
498#define HID_CONTROL_FIFO_SIZE 256
499#define HID_OUTPUT_FIFO_SIZE 64
500
501struct hid_control_fifo {
502 unsigned char dir;
503 struct hid_report *report;
504 char *raw_report;
505};
506
507struct hid_output_fifo {
508 struct hid_report *report;
509 char *raw_report;
510};
511
512#define HID_CLAIMED_INPUT BIT(0)
513#define HID_CLAIMED_HIDDEV BIT(1)
514#define HID_CLAIMED_HIDRAW BIT(2)
515#define HID_CLAIMED_DRIVER BIT(3)
516
517#define HID_STAT_ADDED BIT(0)
518#define HID_STAT_PARSED BIT(1)
519#define HID_STAT_DUP_DETECTED BIT(2)
520#define HID_STAT_REPROBED BIT(3)
521
522struct hid_input {
523 struct list_head list;
524 struct hid_report *report;
525 struct input_dev *input;
526 const char *name;
527 bool registered;
528 struct list_head reports;
529 unsigned int application;
530};
531
532enum hid_type {
533 HID_TYPE_OTHER = 0,
534 HID_TYPE_USBMOUSE,
535 HID_TYPE_USBNONE
536};
537
538enum hid_battery_status {
539 HID_BATTERY_UNKNOWN = 0,
540 HID_BATTERY_QUERIED,
541 HID_BATTERY_REPORTED,
542};
543
544struct hid_driver;
545struct hid_ll_driver;
546
547struct hid_device {
548 __u8 *dev_rdesc;
549 unsigned dev_rsize;
550 __u8 *rdesc;
551 unsigned rsize;
552 struct hid_collection *collection;
553 unsigned collection_size;
554 unsigned maxcollection;
555 unsigned maxapplication;
556 __u16 bus;
557 __u16 group;
558 __u32 vendor;
559 __u32 product;
560 __u32 version;
561 enum hid_type type;
562 unsigned country;
563 struct hid_report_enum report_enum[HID_REPORT_TYPES];
564 struct work_struct led_work;
565
566 struct semaphore driver_input_lock;
567 struct device dev;
568 struct hid_driver *driver;
569
570 struct hid_ll_driver *ll_driver;
571 struct mutex ll_open_lock;
572 unsigned int ll_open_count;
573
574#ifdef CONFIG_HID_BATTERY_STRENGTH
575
576
577
578
579
580 struct power_supply *battery;
581 __s32 battery_capacity;
582 __s32 battery_min;
583 __s32 battery_max;
584 __s32 battery_report_type;
585 __s32 battery_report_id;
586 enum hid_battery_status battery_status;
587 bool battery_avoid_query;
588 ktime_t battery_ratelimit_time;
589#endif
590
591 unsigned long status;
592 unsigned claimed;
593 unsigned quirks;
594 bool io_started;
595
596 struct list_head inputs;
597 void *hiddev;
598 void *hidraw;
599
600 char name[128];
601 char phys[64];
602 char uniq[64];
603
604 void *driver_data;
605
606
607 int (*ff_init)(struct hid_device *);
608
609
610 int (*hiddev_connect)(struct hid_device *, unsigned int);
611 void (*hiddev_disconnect)(struct hid_device *);
612 void (*hiddev_hid_event) (struct hid_device *, struct hid_field *field,
613 struct hid_usage *, __s32);
614 void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
615
616
617 unsigned short debug;
618 struct dentry *debug_dir;
619 struct dentry *debug_rdesc;
620 struct dentry *debug_events;
621 struct list_head debug_list;
622 spinlock_t debug_list_lock;
623 wait_queue_head_t debug_wait;
624};
625
626#define to_hid_device(pdev) \
627 container_of(pdev, struct hid_device, dev)
628
629static inline void *hid_get_drvdata(struct hid_device *hdev)
630{
631 return dev_get_drvdata(&hdev->dev);
632}
633
634static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
635{
636 dev_set_drvdata(&hdev->dev, data);
637}
638
639#define HID_GLOBAL_STACK_SIZE 4
640#define HID_COLLECTION_STACK_SIZE 4
641
642#define HID_SCAN_FLAG_MT_WIN_8 BIT(0)
643#define HID_SCAN_FLAG_VENDOR_SPECIFIC BIT(1)
644#define HID_SCAN_FLAG_GD_POINTER BIT(2)
645
646struct hid_parser {
647 struct hid_global global;
648 struct hid_global global_stack[HID_GLOBAL_STACK_SIZE];
649 unsigned int global_stack_ptr;
650 struct hid_local local;
651 unsigned int *collection_stack;
652 unsigned int collection_stack_ptr;
653 unsigned int collection_stack_size;
654 struct hid_device *device;
655 unsigned int scan_flags;
656};
657
658struct hid_class_descriptor {
659 __u8 bDescriptorType;
660 __le16 wDescriptorLength;
661} __attribute__ ((packed));
662
663struct hid_descriptor {
664 __u8 bLength;
665 __u8 bDescriptorType;
666 __le16 bcdHID;
667 __u8 bCountryCode;
668 __u8 bNumDescriptors;
669
670 struct hid_class_descriptor desc[1];
671} __attribute__ ((packed));
672
673#define HID_DEVICE(b, g, ven, prod) \
674 .bus = (b), .group = (g), .vendor = (ven), .product = (prod)
675#define HID_USB_DEVICE(ven, prod) \
676 .bus = BUS_USB, .vendor = (ven), .product = (prod)
677#define HID_BLUETOOTH_DEVICE(ven, prod) \
678 .bus = BUS_BLUETOOTH, .vendor = (ven), .product = (prod)
679#define HID_I2C_DEVICE(ven, prod) \
680 .bus = BUS_I2C, .vendor = (ven), .product = (prod)
681
682#define HID_REPORT_ID(rep) \
683 .report_type = (rep)
684#define HID_USAGE_ID(uhid, utype, ucode) \
685 .usage_hid = (uhid), .usage_type = (utype), .usage_code = (ucode)
686
687#define HID_TERMINATOR (HID_ANY_ID - 1)
688
689struct hid_report_id {
690 __u32 report_type;
691};
692struct hid_usage_id {
693 __u32 usage_hid;
694 __u32 usage_type;
695 __u32 usage_code;
696};
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739struct hid_driver {
740 char *name;
741 const struct hid_device_id *id_table;
742
743 struct list_head dyn_list;
744 spinlock_t dyn_lock;
745
746 bool (*match)(struct hid_device *dev, bool ignore_special_driver);
747 int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
748 void (*remove)(struct hid_device *dev);
749
750 const struct hid_report_id *report_table;
751 int (*raw_event)(struct hid_device *hdev, struct hid_report *report,
752 u8 *data, int size);
753 const struct hid_usage_id *usage_table;
754 int (*event)(struct hid_device *hdev, struct hid_field *field,
755 struct hid_usage *usage, __s32 value);
756 void (*report)(struct hid_device *hdev, struct hid_report *report);
757
758 __u8 *(*report_fixup)(struct hid_device *hdev, __u8 *buf,
759 unsigned int *size);
760
761 int (*input_mapping)(struct hid_device *hdev,
762 struct hid_input *hidinput, struct hid_field *field,
763 struct hid_usage *usage, unsigned long **bit, int *max);
764 int (*input_mapped)(struct hid_device *hdev,
765 struct hid_input *hidinput, struct hid_field *field,
766 struct hid_usage *usage, unsigned long **bit, int *max);
767 int (*input_configured)(struct hid_device *hdev,
768 struct hid_input *hidinput);
769 void (*feature_mapping)(struct hid_device *hdev,
770 struct hid_field *field,
771 struct hid_usage *usage);
772#ifdef CONFIG_PM
773 int (*suspend)(struct hid_device *hdev, pm_message_t message);
774 int (*resume)(struct hid_device *hdev);
775 int (*reset_resume)(struct hid_device *hdev);
776#endif
777
778 struct device_driver driver;
779};
780
781#define to_hid_driver(pdrv) \
782 container_of(pdrv, struct hid_driver, driver)
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799struct hid_ll_driver {
800 int (*start)(struct hid_device *hdev);
801 void (*stop)(struct hid_device *hdev);
802
803 int (*open)(struct hid_device *hdev);
804 void (*close)(struct hid_device *hdev);
805
806 int (*power)(struct hid_device *hdev, int level);
807
808 int (*parse)(struct hid_device *hdev);
809
810 void (*request)(struct hid_device *hdev,
811 struct hid_report *report, int reqtype);
812
813 int (*wait)(struct hid_device *hdev);
814
815 int (*raw_request) (struct hid_device *hdev, unsigned char reportnum,
816 __u8 *buf, size_t len, unsigned char rtype,
817 int reqtype);
818
819 int (*output_report) (struct hid_device *hdev, __u8 *buf, size_t len);
820
821 int (*idle)(struct hid_device *hdev, int report, int idle, int reqtype);
822};
823
824extern struct hid_ll_driver i2c_hid_ll_driver;
825extern struct hid_ll_driver hidp_hid_driver;
826extern struct hid_ll_driver uhid_hid_driver;
827extern struct hid_ll_driver usb_hid_driver;
828
829static inline bool hid_is_using_ll_driver(struct hid_device *hdev,
830 struct hid_ll_driver *driver)
831{
832 return hdev->ll_driver == driver;
833}
834
835#define PM_HINT_FULLON 1<<5
836#define PM_HINT_NORMAL 1<<1
837
838
839
840#define IS_INPUT_APPLICATION(a) \
841 (((a >= HID_UP_GENDESK) && (a <= HID_GD_MULTIAXIS)) \
842 || ((a >= HID_DG_PEN) && (a <= HID_DG_WHITEBOARD)) \
843 || (a == HID_GD_SYSTEM_CONTROL) || (a == HID_CP_CONSUMER_CONTROL) \
844 || (a == HID_GD_WIRELESS_RADIO_CTLS))
845
846
847
848extern int hid_debug;
849
850extern bool hid_ignore(struct hid_device *);
851extern int hid_add_device(struct hid_device *);
852extern void hid_destroy_device(struct hid_device *);
853
854extern struct bus_type hid_bus_type;
855
856extern int __must_check __hid_register_driver(struct hid_driver *,
857 struct module *, const char *mod_name);
858
859
860#define hid_register_driver(driver) \
861 __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
862
863extern void hid_unregister_driver(struct hid_driver *);
864
865
866
867
868
869
870
871
872
873#define module_hid_driver(__hid_driver) \
874 module_driver(__hid_driver, hid_register_driver, \
875 hid_unregister_driver)
876
877extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
878extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
879extern int hidinput_connect(struct hid_device *hid, unsigned int force);
880extern void hidinput_disconnect(struct hid_device *);
881
882int hid_set_field(struct hid_field *, unsigned, __s32);
883int hid_input_report(struct hid_device *, int type, u8 *, u32, int);
884int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
885struct hid_field *hidinput_get_led_field(struct hid_device *hid);
886unsigned int hidinput_count_leds(struct hid_device *hid);
887__s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code);
888void hid_output_report(struct hid_report *report, __u8 *data);
889int __hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype);
890u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags);
891struct hid_device *hid_allocate_device(void);
892struct hid_report *hid_register_report(struct hid_device *device,
893 unsigned int type, unsigned int id,
894 unsigned int application);
895int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
896struct hid_report *hid_validate_values(struct hid_device *hid,
897 unsigned int type, unsigned int id,
898 unsigned int field_index,
899 unsigned int report_counts);
900
901void hid_setup_resolution_multiplier(struct hid_device *hid);
902int hid_open_report(struct hid_device *device);
903int hid_check_keys_pressed(struct hid_device *hid);
904int hid_connect(struct hid_device *hid, unsigned int connect_mask);
905void hid_disconnect(struct hid_device *hid);
906bool hid_match_one_id(const struct hid_device *hdev,
907 const struct hid_device_id *id);
908const struct hid_device_id *hid_match_id(const struct hid_device *hdev,
909 const struct hid_device_id *id);
910const struct hid_device_id *hid_match_device(struct hid_device *hdev,
911 struct hid_driver *hdrv);
912bool hid_compare_device_paths(struct hid_device *hdev_a,
913 struct hid_device *hdev_b, char separator);
914s32 hid_snto32(__u32 value, unsigned n);
915__u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
916 unsigned offset, unsigned n);
917
918
919
920
921
922
923
924
925
926
927static inline void hid_device_io_start(struct hid_device *hid) {
928 if (hid->io_started) {
929 dev_warn(&hid->dev, "io already started\n");
930 return;
931 }
932 hid->io_started = true;
933 up(&hid->driver_input_lock);
934}
935
936
937
938
939
940
941
942
943
944
945
946
947static inline void hid_device_io_stop(struct hid_device *hid) {
948 if (!hid->io_started) {
949 dev_warn(&hid->dev, "io already stopped\n");
950 return;
951 }
952 hid->io_started = false;
953 down(&hid->driver_input_lock);
954}
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970static inline void hid_map_usage(struct hid_input *hidinput,
971 struct hid_usage *usage, unsigned long **bit, int *max,
972 __u8 type, unsigned int c)
973{
974 struct input_dev *input = hidinput->input;
975 unsigned long *bmap = NULL;
976 unsigned int limit = 0;
977
978 switch (type) {
979 case EV_ABS:
980 bmap = input->absbit;
981 limit = ABS_MAX;
982 break;
983 case EV_REL:
984 bmap = input->relbit;
985 limit = REL_MAX;
986 break;
987 case EV_KEY:
988 bmap = input->keybit;
989 limit = KEY_MAX;
990 break;
991 case EV_LED:
992 bmap = input->ledbit;
993 limit = LED_MAX;
994 break;
995 }
996
997 if (unlikely(c > limit || !bmap)) {
998 pr_warn_ratelimited("%s: Invalid code %d type %d\n",
999 input->name, c, type);
1000 *bit = NULL;
1001 return;
1002 }
1003
1004 usage->type = type;
1005 usage->code = c;
1006 *max = limit;
1007 *bit = bmap;
1008}
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023static inline void hid_map_usage_clear(struct hid_input *hidinput,
1024 struct hid_usage *usage, unsigned long **bit, int *max,
1025 __u8 type, __u16 c)
1026{
1027 hid_map_usage(hidinput, usage, bit, max, type, c);
1028 if (*bit)
1029 clear_bit(usage->code, *bit);
1030}
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041static inline int __must_check hid_parse(struct hid_device *hdev)
1042{
1043 return hid_open_report(hdev);
1044}
1045
1046int __must_check hid_hw_start(struct hid_device *hdev,
1047 unsigned int connect_mask);
1048void hid_hw_stop(struct hid_device *hdev);
1049int __must_check hid_hw_open(struct hid_device *hdev);
1050void hid_hw_close(struct hid_device *hdev);
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062static inline int hid_hw_power(struct hid_device *hdev, int level)
1063{
1064 return hdev->ll_driver->power ? hdev->ll_driver->power(hdev, level) : 0;
1065}
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075static inline void hid_hw_request(struct hid_device *hdev,
1076 struct hid_report *report, int reqtype)
1077{
1078 if (hdev->ll_driver->request)
1079 return hdev->ll_driver->request(hdev, report, reqtype);
1080
1081 __hid_request(hdev, report, reqtype);
1082}
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098static inline int hid_hw_raw_request(struct hid_device *hdev,
1099 unsigned char reportnum, __u8 *buf,
1100 size_t len, unsigned char rtype, int reqtype)
1101{
1102 if (len < 1 || len > HID_MAX_BUFFER_SIZE || !buf)
1103 return -EINVAL;
1104
1105 return hdev->ll_driver->raw_request(hdev, reportnum, buf, len,
1106 rtype, reqtype);
1107}
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118static inline int hid_hw_output_report(struct hid_device *hdev, __u8 *buf,
1119 size_t len)
1120{
1121 if (len < 1 || len > HID_MAX_BUFFER_SIZE || !buf)
1122 return -EINVAL;
1123
1124 if (hdev->ll_driver->output_report)
1125 return hdev->ll_driver->output_report(hdev, buf, len);
1126
1127 return -ENOSYS;
1128}
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138static inline int hid_hw_idle(struct hid_device *hdev, int report, int idle,
1139 int reqtype)
1140{
1141 if (hdev->ll_driver->idle)
1142 return hdev->ll_driver->idle(hdev, report, idle, reqtype);
1143
1144 return 0;
1145}
1146
1147
1148
1149
1150
1151
1152static inline void hid_hw_wait(struct hid_device *hdev)
1153{
1154 if (hdev->ll_driver->wait)
1155 hdev->ll_driver->wait(hdev);
1156}
1157
1158
1159
1160
1161
1162
1163static inline u32 hid_report_len(struct hid_report *report)
1164{
1165
1166 return ((report->size - 1) >> 3) + 1 + (report->id > 0);
1167}
1168
1169int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
1170 int interrupt);
1171
1172
1173unsigned long hid_lookup_quirk(const struct hid_device *hdev);
1174int hid_quirks_init(char **quirks_param, __u16 bus, int count);
1175void hid_quirks_exit(__u16 bus);
1176
1177#ifdef CONFIG_HID_PID
1178int hid_pidff_init(struct hid_device *hid);
1179#else
1180#define hid_pidff_init NULL
1181#endif
1182
1183#define dbg_hid(fmt, ...) \
1184do { \
1185 if (hid_debug) \
1186 printk(KERN_DEBUG "%s: " fmt, __FILE__, ##__VA_ARGS__); \
1187} while (0)
1188
1189#define hid_err(hid, fmt, ...) \
1190 dev_err(&(hid)->dev, fmt, ##__VA_ARGS__)
1191#define hid_notice(hid, fmt, ...) \
1192 dev_notice(&(hid)->dev, fmt, ##__VA_ARGS__)
1193#define hid_warn(hid, fmt, ...) \
1194 dev_warn(&(hid)->dev, fmt, ##__VA_ARGS__)
1195#define hid_info(hid, fmt, ...) \
1196 dev_info(&(hid)->dev, fmt, ##__VA_ARGS__)
1197#define hid_dbg(hid, fmt, ...) \
1198 dev_dbg(&(hid)->dev, fmt, ##__VA_ARGS__)
1199
1200#define hid_err_once(hid, fmt, ...) \
1201 dev_err_once(&(hid)->dev, fmt, ##__VA_ARGS__)
1202#define hid_notice_once(hid, fmt, ...) \
1203 dev_notice_once(&(hid)->dev, fmt, ##__VA_ARGS__)
1204#define hid_warn_once(hid, fmt, ...) \
1205 dev_warn_once(&(hid)->dev, fmt, ##__VA_ARGS__)
1206#define hid_info_once(hid, fmt, ...) \
1207 dev_info_once(&(hid)->dev, fmt, ##__VA_ARGS__)
1208#define hid_dbg_once(hid, fmt, ...) \
1209 dev_dbg_once(&(hid)->dev, fmt, ##__VA_ARGS__)
1210
1211#endif
1212