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