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