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