1#ifndef __HID_H
2#define __HID_H
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34#define USB_INTERFACE_CLASS_HID 3
35
36
37
38
39
40#define USB_INTERFACE_SUBCLASS_BOOT 1
41#define USB_INTERFACE_PROTOCOL_KEYBOARD 1
42#define USB_INTERFACE_PROTOCOL_MOUSE 2
43
44
45
46
47
48#define HID_REQ_GET_REPORT 0x01
49#define HID_REQ_GET_IDLE 0x02
50#define HID_REQ_GET_PROTOCOL 0x03
51#define HID_REQ_SET_REPORT 0x09
52#define HID_REQ_SET_IDLE 0x0A
53#define HID_REQ_SET_PROTOCOL 0x0B
54
55
56
57
58
59#define HID_DT_HID (USB_TYPE_CLASS | 0x01)
60#define HID_DT_REPORT (USB_TYPE_CLASS | 0x02)
61#define HID_DT_PHYSICAL (USB_TYPE_CLASS | 0x03)
62
63#define HID_MAX_DESCRIPTOR_SIZE 4096
64
65#ifdef __KERNEL__
66
67#include <linux/types.h>
68#include <linux/slab.h>
69#include <linux/list.h>
70#include <linux/mod_devicetable.h>
71#include <linux/timer.h>
72#include <linux/workqueue.h>
73#include <linux/input.h>
74
75
76
77
78
79
80
81struct hid_item {
82 unsigned format;
83 __u8 size;
84 __u8 type;
85 __u8 tag;
86 union {
87 __u8 u8;
88 __s8 s8;
89 __u16 u16;
90 __s16 s16;
91 __u32 u32;
92 __s32 s32;
93 __u8 *longdata;
94 } data;
95};
96
97
98
99
100
101#define HID_ITEM_FORMAT_SHORT 0
102#define HID_ITEM_FORMAT_LONG 1
103
104
105
106
107
108#define HID_ITEM_TAG_LONG 15
109
110
111
112
113
114#define HID_ITEM_TYPE_MAIN 0
115#define HID_ITEM_TYPE_GLOBAL 1
116#define HID_ITEM_TYPE_LOCAL 2
117#define HID_ITEM_TYPE_RESERVED 3
118
119
120
121
122
123#define HID_MAIN_ITEM_TAG_INPUT 8
124#define HID_MAIN_ITEM_TAG_OUTPUT 9
125#define HID_MAIN_ITEM_TAG_FEATURE 11
126#define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION 10
127#define HID_MAIN_ITEM_TAG_END_COLLECTION 12
128
129
130
131
132
133#define HID_MAIN_ITEM_CONSTANT 0x001
134#define HID_MAIN_ITEM_VARIABLE 0x002
135#define HID_MAIN_ITEM_RELATIVE 0x004
136#define HID_MAIN_ITEM_WRAP 0x008
137#define HID_MAIN_ITEM_NONLINEAR 0x010
138#define HID_MAIN_ITEM_NO_PREFERRED 0x020
139#define HID_MAIN_ITEM_NULL_STATE 0x040
140#define HID_MAIN_ITEM_VOLATILE 0x080
141#define HID_MAIN_ITEM_BUFFERED_BYTE 0x100
142
143
144
145
146
147#define HID_COLLECTION_PHYSICAL 0
148#define HID_COLLECTION_APPLICATION 1
149#define HID_COLLECTION_LOGICAL 2
150
151
152
153
154
155#define HID_GLOBAL_ITEM_TAG_USAGE_PAGE 0
156#define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM 1
157#define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM 2
158#define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM 3
159#define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM 4
160#define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT 5
161#define HID_GLOBAL_ITEM_TAG_UNIT 6
162#define HID_GLOBAL_ITEM_TAG_REPORT_SIZE 7
163#define HID_GLOBAL_ITEM_TAG_REPORT_ID 8
164#define HID_GLOBAL_ITEM_TAG_REPORT_COUNT 9
165#define HID_GLOBAL_ITEM_TAG_PUSH 10
166#define HID_GLOBAL_ITEM_TAG_POP 11
167
168
169
170
171
172#define HID_LOCAL_ITEM_TAG_USAGE 0
173#define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM 1
174#define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM 2
175#define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX 3
176#define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM 4
177#define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM 5
178#define HID_LOCAL_ITEM_TAG_STRING_INDEX 7
179#define HID_LOCAL_ITEM_TAG_STRING_MINIMUM 8
180#define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM 9
181#define HID_LOCAL_ITEM_TAG_DELIMITER 10
182
183
184
185
186
187#define HID_USAGE_PAGE 0xffff0000
188
189#define HID_UP_UNDEFINED 0x00000000
190#define HID_UP_GENDESK 0x00010000
191#define HID_UP_SIMULATION 0x00020000
192#define HID_UP_KEYBOARD 0x00070000
193#define HID_UP_LED 0x00080000
194#define HID_UP_BUTTON 0x00090000
195#define HID_UP_ORDINAL 0x000a0000
196#define HID_UP_CONSUMER 0x000c0000
197#define HID_UP_DIGITIZER 0x000d0000
198#define HID_UP_PID 0x000f0000
199#define HID_UP_HPVENDOR 0xff7f0000
200#define HID_UP_MSVENDOR 0xff000000
201#define HID_UP_CUSTOM 0x00ff0000
202#define HID_UP_LOGIVENDOR 0xffbc0000
203
204#define HID_USAGE 0x0000ffff
205
206#define HID_GD_POINTER 0x00010001
207#define HID_GD_MOUSE 0x00010002
208#define HID_GD_JOYSTICK 0x00010004
209#define HID_GD_GAMEPAD 0x00010005
210#define HID_GD_KEYBOARD 0x00010006
211#define HID_GD_KEYPAD 0x00010007
212#define HID_GD_MULTIAXIS 0x00010008
213#define HID_GD_X 0x00010030
214#define HID_GD_Y 0x00010031
215#define HID_GD_Z 0x00010032
216#define HID_GD_RX 0x00010033
217#define HID_GD_RY 0x00010034
218#define HID_GD_RZ 0x00010035
219#define HID_GD_SLIDER 0x00010036
220#define HID_GD_DIAL 0x00010037
221#define HID_GD_WHEEL 0x00010038
222#define HID_GD_HATSWITCH 0x00010039
223#define HID_GD_BUFFER 0x0001003a
224#define HID_GD_BYTECOUNT 0x0001003b
225#define HID_GD_MOTION 0x0001003c
226#define HID_GD_START 0x0001003d
227#define HID_GD_SELECT 0x0001003e
228#define HID_GD_VX 0x00010040
229#define HID_GD_VY 0x00010041
230#define HID_GD_VZ 0x00010042
231#define HID_GD_VBRX 0x00010043
232#define HID_GD_VBRY 0x00010044
233#define HID_GD_VBRZ 0x00010045
234#define HID_GD_VNO 0x00010046
235#define HID_GD_FEATURE 0x00010047
236#define HID_GD_UP 0x00010090
237#define HID_GD_DOWN 0x00010091
238#define HID_GD_RIGHT 0x00010092
239#define HID_GD_LEFT 0x00010093
240
241#define HID_DG_DIGITIZER 0x000d0001
242#define HID_DG_PEN 0x000d0002
243#define HID_DG_LIGHTPEN 0x000d0003
244#define HID_DG_TOUCHSCREEN 0x000d0004
245#define HID_DG_TOUCHPAD 0x000d0005
246#define HID_DG_STYLUS 0x000d0020
247#define HID_DG_PUCK 0x000d0021
248#define HID_DG_FINGER 0x000d0022
249#define HID_DG_TIPPRESSURE 0x000d0030
250#define HID_DG_BARRELPRESSURE 0x000d0031
251#define HID_DG_INRANGE 0x000d0032
252#define HID_DG_TOUCH 0x000d0033
253#define HID_DG_UNTOUCH 0x000d0034
254#define HID_DG_TAP 0x000d0035
255#define HID_DG_TABLETFUNCTIONKEY 0x000d0039
256#define HID_DG_PROGRAMCHANGEKEY 0x000d003a
257#define HID_DG_INVERT 0x000d003c
258#define HID_DG_TIPSWITCH 0x000d0042
259#define HID_DG_TIPSWITCH2 0x000d0043
260#define HID_DG_BARRELSWITCH 0x000d0044
261#define HID_DG_ERASER 0x000d0045
262#define HID_DG_TABLETPICK 0x000d0046
263
264
265
266
267
268#define HID_DG_CONFIDENCE 0x000d0047
269#define HID_DG_WIDTH 0x000d0048
270#define HID_DG_HEIGHT 0x000d0049
271#define HID_DG_CONTACTID 0x000d0051
272#define HID_DG_INPUTMODE 0x000d0052
273#define HID_DG_DEVICEINDEX 0x000d0053
274#define HID_DG_CONTACTCOUNT 0x000d0054
275#define HID_DG_CONTACTMAX 0x000d0055
276
277
278
279
280
281#define HID_INPUT_REPORT 0
282#define HID_OUTPUT_REPORT 1
283#define HID_FEATURE_REPORT 2
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_DEFAULT (HID_CONNECT_HIDINPUT|HID_CONNECT_HIDRAW| \
296 HID_CONNECT_HIDDEV|HID_CONNECT_FF)
297
298
299
300
301
302
303
304
305#define MAX_USBHID_BOOT_QUIRKS 4
306
307#define HID_QUIRK_INVERT 0x00000001
308#define HID_QUIRK_NOTOUCH 0x00000002
309#define HID_QUIRK_IGNORE 0x00000004
310#define HID_QUIRK_NOGET 0x00000008
311#define HID_QUIRK_HIDDEV_FORCE 0x00000010
312#define HID_QUIRK_BADPAD 0x00000020
313#define HID_QUIRK_MULTI_INPUT 0x00000040
314#define HID_QUIRK_HIDINPUT_FORCE 0x00000080
315#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000
316#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000
317#define HID_QUIRK_NO_INIT_REPORTS 0x20000000
318#define HID_QUIRK_NO_IGNORE 0x40000000
319#define HID_QUIRK_NO_INPUT_SYNC 0x80000000
320
321
322
323
324
325
326
327struct hid_global {
328 unsigned usage_page;
329 __s32 logical_minimum;
330 __s32 logical_maximum;
331 __s32 physical_minimum;
332 __s32 physical_maximum;
333 __s32 unit_exponent;
334 unsigned unit;
335 unsigned report_id;
336 unsigned report_size;
337 unsigned report_count;
338};
339
340
341
342
343
344#define HID_MAX_USAGES 12288
345#define HID_DEFAULT_NUM_COLLECTIONS 16
346
347struct hid_local {
348 unsigned usage[HID_MAX_USAGES];
349 unsigned collection_index[HID_MAX_USAGES];
350 unsigned usage_index;
351 unsigned usage_minimum;
352 unsigned delimiter_depth;
353 unsigned delimiter_branch;
354};
355
356
357
358
359
360
361struct hid_collection {
362 unsigned type;
363 unsigned usage;
364 unsigned level;
365};
366
367struct hid_usage {
368 unsigned hid;
369 unsigned collection_index;
370
371 __u16 code;
372 __u8 type;
373 __s8 hat_min;
374 __s8 hat_max;
375 __s8 hat_dir;
376};
377
378struct hid_input;
379
380struct hid_field {
381 unsigned physical;
382 unsigned logical;
383 unsigned application;
384 struct hid_usage *usage;
385 unsigned maxusage;
386 unsigned flags;
387 unsigned report_offset;
388 unsigned report_size;
389 unsigned report_count;
390 unsigned report_type;
391 __s32 *value;
392 __s32 logical_minimum;
393 __s32 logical_maximum;
394 __s32 physical_minimum;
395 __s32 physical_maximum;
396 __s32 unit_exponent;
397 unsigned unit;
398 struct hid_report *report;
399 unsigned index;
400
401 struct hid_input *hidinput;
402 __u16 dpad;
403};
404
405#define HID_MAX_FIELDS 128
406
407struct hid_report {
408 struct list_head list;
409 unsigned id;
410 unsigned type;
411 struct hid_field *field[HID_MAX_FIELDS];
412 unsigned maxfield;
413 unsigned size;
414 struct hid_device *device;
415};
416
417struct hid_report_enum {
418 unsigned numbered;
419 struct list_head report_list;
420 struct hid_report *report_id_hash[256];
421};
422
423#define HID_REPORT_TYPES 3
424
425#define HID_MIN_BUFFER_SIZE 64
426#define HID_MAX_BUFFER_SIZE 4096
427#define HID_CONTROL_FIFO_SIZE 256
428#define HID_OUTPUT_FIFO_SIZE 64
429
430struct hid_control_fifo {
431 unsigned char dir;
432 struct hid_report *report;
433 char *raw_report;
434};
435
436struct hid_output_fifo {
437 struct hid_report *report;
438 char *raw_report;
439};
440
441#define HID_CLAIMED_INPUT 1
442#define HID_CLAIMED_HIDDEV 2
443#define HID_CLAIMED_HIDRAW 4
444
445#define HID_STAT_ADDED 1
446#define HID_STAT_PARSED 2
447
448struct hid_input {
449 struct list_head list;
450 struct hid_report *report;
451 struct input_dev *input;
452};
453
454enum hid_type {
455 HID_TYPE_OTHER = 0,
456 HID_TYPE_USBMOUSE
457};
458
459struct hid_driver;
460struct hid_ll_driver;
461
462struct hid_device {
463 __u8 *rdesc;
464 unsigned rsize;
465 struct hid_collection *collection;
466 unsigned collection_size;
467 unsigned maxcollection;
468 unsigned maxapplication;
469 __u16 bus;
470 __u32 vendor;
471 __u32 product;
472 __u32 version;
473 enum hid_type type;
474 unsigned country;
475 struct hid_report_enum report_enum[HID_REPORT_TYPES];
476
477 struct device dev;
478 struct hid_driver *driver;
479 struct hid_ll_driver *ll_driver;
480
481 unsigned int status;
482 unsigned claimed;
483 unsigned quirks;
484
485 struct list_head inputs;
486 void *hiddev;
487 void *hidraw;
488 int minor;
489
490 int open;
491 char name[128];
492 char phys[64];
493 char uniq[64];
494
495 void *driver_data;
496
497
498 int (*ff_init)(struct hid_device *);
499
500
501 int (*hiddev_connect)(struct hid_device *, unsigned int);
502 void (*hiddev_disconnect)(struct hid_device *);
503 void (*hiddev_hid_event) (struct hid_device *, struct hid_field *field,
504 struct hid_usage *, __s32);
505 void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
506
507
508 int (*hid_output_raw_report) (struct hid_device *, __u8 *, size_t, unsigned char);
509
510
511 unsigned short debug;
512 struct dentry *debug_dir;
513 struct dentry *debug_rdesc;
514 struct dentry *debug_events;
515 struct list_head debug_list;
516 wait_queue_head_t debug_wait;
517};
518
519static inline void *hid_get_drvdata(struct hid_device *hdev)
520{
521 return dev_get_drvdata(&hdev->dev);
522}
523
524static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
525{
526 dev_set_drvdata(&hdev->dev, data);
527}
528
529#define HID_GLOBAL_STACK_SIZE 4
530#define HID_COLLECTION_STACK_SIZE 4
531
532struct hid_parser {
533 struct hid_global global;
534 struct hid_global global_stack[HID_GLOBAL_STACK_SIZE];
535 unsigned global_stack_ptr;
536 struct hid_local local;
537 unsigned collection_stack[HID_COLLECTION_STACK_SIZE];
538 unsigned collection_stack_ptr;
539 struct hid_device *device;
540};
541
542struct hid_class_descriptor {
543 __u8 bDescriptorType;
544 __le16 wDescriptorLength;
545} __attribute__ ((packed));
546
547struct hid_descriptor {
548 __u8 bLength;
549 __u8 bDescriptorType;
550 __le16 bcdHID;
551 __u8 bCountryCode;
552 __u8 bNumDescriptors;
553
554 struct hid_class_descriptor desc[1];
555} __attribute__ ((packed));
556
557#define HID_DEVICE(b, ven, prod) \
558 .bus = (b), \
559 .vendor = (ven), .product = (prod)
560
561#define HID_USB_DEVICE(ven, prod) HID_DEVICE(BUS_USB, ven, prod)
562#define HID_BLUETOOTH_DEVICE(ven, prod) HID_DEVICE(BUS_BLUETOOTH, ven, prod)
563
564#define HID_REPORT_ID(rep) \
565 .report_type = (rep)
566#define HID_USAGE_ID(uhid, utype, ucode) \
567 .usage_hid = (uhid), .usage_type = (utype), .usage_code = (ucode)
568
569#define HID_TERMINATOR (HID_ANY_ID - 1)
570
571struct hid_report_id {
572 __u32 report_type;
573};
574struct hid_usage_id {
575 __u32 usage_hid;
576 __u32 usage_type;
577 __u32 usage_code;
578};
579
580
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
614struct hid_driver {
615 char *name;
616 const struct hid_device_id *id_table;
617
618 struct list_head dyn_list;
619 spinlock_t dyn_lock;
620
621 int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
622 void (*remove)(struct hid_device *dev);
623
624 const struct hid_report_id *report_table;
625 int (*raw_event)(struct hid_device *hdev, struct hid_report *report,
626 u8 *data, int size);
627 const struct hid_usage_id *usage_table;
628 int (*event)(struct hid_device *hdev, struct hid_field *field,
629 struct hid_usage *usage, __s32 value);
630
631 __u8 *(*report_fixup)(struct hid_device *hdev, __u8 *buf,
632 unsigned int *size);
633
634 int (*input_mapping)(struct hid_device *hdev,
635 struct hid_input *hidinput, struct hid_field *field,
636 struct hid_usage *usage, unsigned long **bit, int *max);
637 int (*input_mapped)(struct hid_device *hdev,
638 struct hid_input *hidinput, struct hid_field *field,
639 struct hid_usage *usage, unsigned long **bit, int *max);
640 void (*feature_mapping)(struct hid_device *hdev,
641 struct hid_input *hidinput, struct hid_field *field,
642 struct hid_usage *usage);
643#ifdef CONFIG_PM
644 int (*suspend)(struct hid_device *hdev, pm_message_t message);
645 int (*resume)(struct hid_device *hdev);
646 int (*reset_resume)(struct hid_device *hdev);
647#endif
648
649 struct device_driver driver;
650};
651
652
653
654
655
656
657
658
659
660
661
662struct hid_ll_driver {
663 int (*start)(struct hid_device *hdev);
664 void (*stop)(struct hid_device *hdev);
665
666 int (*open)(struct hid_device *hdev);
667 void (*close)(struct hid_device *hdev);
668
669 int (*power)(struct hid_device *hdev, int level);
670
671 int (*hidinput_input_event) (struct input_dev *idev, unsigned int type,
672 unsigned int code, int value);
673
674 int (*parse)(struct hid_device *hdev);
675};
676
677#define PM_HINT_FULLON 1<<5
678#define PM_HINT_NORMAL 1<<1
679
680
681
682#define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || ((a >= 0x000d0002) && (a <= 0x000d0006)))
683
684
685
686extern int hid_debug;
687
688extern int hid_add_device(struct hid_device *);
689extern void hid_destroy_device(struct hid_device *);
690
691extern int __must_check __hid_register_driver(struct hid_driver *,
692 struct module *, const char *mod_name);
693static inline int __must_check hid_register_driver(struct hid_driver *driver)
694{
695 return __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
696}
697extern void hid_unregister_driver(struct hid_driver *);
698
699extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
700extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
701extern int hidinput_connect(struct hid_device *hid, unsigned int force);
702extern void hidinput_disconnect(struct hid_device *);
703
704int hid_set_field(struct hid_field *, unsigned, __s32);
705int hid_input_report(struct hid_device *, int type, u8 *, int, int);
706int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
707void hid_output_report(struct hid_report *report, __u8 *data);
708struct hid_device *hid_allocate_device(void);
709struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id);
710int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
711int hid_check_keys_pressed(struct hid_device *hid);
712int hid_connect(struct hid_device *hid, unsigned int connect_mask);
713void hid_disconnect(struct hid_device *hid);
714
715
716
717
718
719
720
721
722
723
724
725static inline void hid_map_usage(struct hid_input *hidinput,
726 struct hid_usage *usage, unsigned long **bit, int *max,
727 __u8 type, __u16 c)
728{
729 struct input_dev *input = hidinput->input;
730
731 usage->type = type;
732 usage->code = c;
733
734 switch (type) {
735 case EV_ABS:
736 *bit = input->absbit;
737 *max = ABS_MAX;
738 break;
739 case EV_REL:
740 *bit = input->relbit;
741 *max = REL_MAX;
742 break;
743 case EV_KEY:
744 *bit = input->keybit;
745 *max = KEY_MAX;
746 break;
747 case EV_LED:
748 *bit = input->ledbit;
749 *max = LED_MAX;
750 break;
751 }
752}
753
754
755
756
757
758
759
760static inline void hid_map_usage_clear(struct hid_input *hidinput,
761 struct hid_usage *usage, unsigned long **bit, int *max,
762 __u8 type, __u16 c)
763{
764 hid_map_usage(hidinput, usage, bit, max, type, c);
765 clear_bit(c, *bit);
766}
767
768
769
770
771
772
773
774
775
776
777static inline int __must_check hid_parse(struct hid_device *hdev)
778{
779 int ret;
780
781 if (hdev->status & HID_STAT_PARSED)
782 return 0;
783
784 ret = hdev->ll_driver->parse(hdev);
785 if (!ret)
786 hdev->status |= HID_STAT_PARSED;
787
788 return ret;
789}
790
791
792
793
794
795
796
797
798
799
800
801static inline int __must_check hid_hw_start(struct hid_device *hdev,
802 unsigned int connect_mask)
803{
804 int ret = hdev->ll_driver->start(hdev);
805 if (ret || !connect_mask)
806 return ret;
807 ret = hid_connect(hdev, connect_mask);
808 if (ret)
809 hdev->ll_driver->stop(hdev);
810 return ret;
811}
812
813
814
815
816
817
818
819
820
821static inline void hid_hw_stop(struct hid_device *hdev)
822{
823 hid_disconnect(hdev);
824 hdev->ll_driver->stop(hdev);
825}
826
827
828
829
830
831
832
833
834
835
836static inline int __must_check hid_hw_open(struct hid_device *hdev)
837{
838 return hdev->ll_driver->open(hdev);
839}
840
841
842
843
844
845
846
847
848
849
850static inline void hid_hw_close(struct hid_device *hdev)
851{
852 hdev->ll_driver->close(hdev);
853}
854
855
856
857
858
859
860
861
862
863
864
865static inline int hid_hw_power(struct hid_device *hdev, int level)
866{
867 return hdev->ll_driver->power ? hdev->ll_driver->power(hdev, level) : 0;
868}
869
870void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
871 int interrupt);
872
873extern int hid_generic_init(void);
874extern void hid_generic_exit(void);
875
876
877u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct);
878int usbhid_quirks_init(char **quirks_param);
879void usbhid_quirks_exit(void);
880void usbhid_set_leds(struct hid_device *hid);
881
882#ifdef CONFIG_HID_PID
883int hid_pidff_init(struct hid_device *hid);
884#else
885#define hid_pidff_init NULL
886#endif
887
888#define dbg_hid(format, arg...) \
889do { \
890 if (hid_debug) \
891 printk(KERN_DEBUG "%s: " format, __FILE__, ##arg); \
892} while (0)
893
894#define hid_printk(level, hid, fmt, arg...) \
895 dev_printk(level, &(hid)->dev, fmt, ##arg)
896#define hid_emerg(hid, fmt, arg...) \
897 dev_emerg(&(hid)->dev, fmt, ##arg)
898#define hid_crit(hid, fmt, arg...) \
899 dev_crit(&(hid)->dev, fmt, ##arg)
900#define hid_alert(hid, fmt, arg...) \
901 dev_alert(&(hid)->dev, fmt, ##arg)
902#define hid_err(hid, fmt, arg...) \
903 dev_err(&(hid)->dev, fmt, ##arg)
904#define hid_notice(hid, fmt, arg...) \
905 dev_notice(&(hid)->dev, fmt, ##arg)
906#define hid_warn(hid, fmt, arg...) \
907 dev_warn(&(hid)->dev, fmt, ##arg)
908#define hid_info(hid, fmt, arg...) \
909 dev_info(&(hid)->dev, fmt, ##arg)
910#define hid_dbg(hid, fmt, arg...) \
911 dev_dbg(&(hid)->dev, fmt, ##arg)
912
913#endif
914
915#endif
916
917