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