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