Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1029 | serge | 1 | #ifndef __HID_H |
2 | #define __HID_H |
||
3 | |||
4 | /* |
||
5 | * $Id: hid.h,v 1.24 2001/12/27 10:37:41 vojtech Exp $ |
||
6 | * |
||
7 | * Copyright (c) 1999 Andreas Gal |
||
8 | * Copyright (c) 2000-2001 Vojtech Pavlik |
||
9 | * Copyright (c) 2006-2007 Jiri Kosina |
||
10 | */ |
||
11 | |||
12 | /* |
||
13 | * This program is free software; you can redistribute it and/or modify |
||
14 | * it under the terms of the GNU General Public License as published by |
||
15 | * the Free Software Foundation; either version 2 of the License, or |
||
16 | * (at your option) any later version. |
||
17 | * |
||
18 | * This program is distributed in the hope that it will be useful, |
||
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
21 | * GNU General Public License for more details. |
||
22 | * |
||
23 | * You should have received a copy of the GNU General Public License |
||
24 | * along with this program; if not, write to the Free Software |
||
25 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
||
26 | * |
||
27 | * Should you need to contact me, the author, you can do so either by |
||
28 | * e-mail - mail your message to |
||
29 | * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic |
||
30 | */ |
||
31 | |||
32 | #include |
||
33 | #include |
||
34 | #include |
||
35 | #include |
||
36 | #include |
||
37 | #include |
||
38 | |||
39 | /* |
||
40 | * USB HID (Human Interface Device) interface class code |
||
41 | */ |
||
42 | |||
43 | #define USB_INTERFACE_CLASS_HID 3 |
||
44 | |||
45 | /* |
||
46 | * USB HID interface subclass and protocol codes |
||
47 | */ |
||
48 | |||
49 | #define USB_INTERFACE_SUBCLASS_BOOT 1 |
||
50 | #define USB_INTERFACE_PROTOCOL_KEYBOARD 1 |
||
51 | #define USB_INTERFACE_PROTOCOL_MOUSE 2 |
||
52 | |||
53 | /* |
||
54 | * HID class requests |
||
55 | */ |
||
56 | |||
57 | #define HID_REQ_GET_REPORT 0x01 |
||
58 | #define HID_REQ_GET_IDLE 0x02 |
||
59 | #define HID_REQ_GET_PROTOCOL 0x03 |
||
60 | #define HID_REQ_SET_REPORT 0x09 |
||
61 | #define HID_REQ_SET_IDLE 0x0A |
||
62 | #define HID_REQ_SET_PROTOCOL 0x0B |
||
63 | |||
64 | /* |
||
65 | * HID class descriptor types |
||
66 | */ |
||
67 | |||
68 | #define HID_DT_HID (USB_TYPE_CLASS | 0x01) |
||
69 | #define HID_DT_REPORT (USB_TYPE_CLASS | 0x02) |
||
70 | #define HID_DT_PHYSICAL (USB_TYPE_CLASS | 0x03) |
||
71 | |||
72 | /* |
||
73 | * We parse each description item into this structure. Short items data |
||
74 | * values are expanded to 32-bit signed int, long items contain a pointer |
||
75 | * into the data area. |
||
76 | */ |
||
77 | |||
78 | struct hid_item { |
||
79 | unsigned format; |
||
80 | __u8 size; |
||
81 | __u8 type; |
||
82 | __u8 tag; |
||
83 | union { |
||
84 | __u8 u8; |
||
85 | __s8 s8; |
||
86 | __u16 u16; |
||
87 | __s16 s16; |
||
88 | __u32 u32; |
||
89 | __s32 s32; |
||
90 | __u8 *longdata; |
||
91 | } data; |
||
92 | }; |
||
93 | |||
94 | /* |
||
95 | * HID report item format |
||
96 | */ |
||
97 | |||
98 | #define HID_ITEM_FORMAT_SHORT 0 |
||
99 | #define HID_ITEM_FORMAT_LONG 1 |
||
100 | |||
101 | /* |
||
102 | * Special tag indicating long items |
||
103 | */ |
||
104 | |||
105 | #define HID_ITEM_TAG_LONG 15 |
||
106 | |||
107 | /* |
||
108 | * HID report descriptor item type (prefix bit 2,3) |
||
109 | */ |
||
110 | |||
111 | #define HID_ITEM_TYPE_MAIN 0 |
||
112 | #define HID_ITEM_TYPE_GLOBAL 1 |
||
113 | #define HID_ITEM_TYPE_LOCAL 2 |
||
114 | #define HID_ITEM_TYPE_RESERVED 3 |
||
115 | |||
116 | /* |
||
117 | * HID report descriptor main item tags |
||
118 | */ |
||
119 | |||
120 | #define HID_MAIN_ITEM_TAG_INPUT 8 |
||
121 | #define HID_MAIN_ITEM_TAG_OUTPUT 9 |
||
122 | #define HID_MAIN_ITEM_TAG_FEATURE 11 |
||
123 | #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION 10 |
||
124 | #define HID_MAIN_ITEM_TAG_END_COLLECTION 12 |
||
125 | |||
126 | /* |
||
127 | * HID report descriptor main item contents |
||
128 | */ |
||
129 | |||
130 | #define HID_MAIN_ITEM_CONSTANT 0x001 |
||
131 | #define HID_MAIN_ITEM_VARIABLE 0x002 |
||
132 | #define HID_MAIN_ITEM_RELATIVE 0x004 |
||
133 | #define HID_MAIN_ITEM_WRAP 0x008 |
||
134 | #define HID_MAIN_ITEM_NONLINEAR 0x010 |
||
135 | #define HID_MAIN_ITEM_NO_PREFERRED 0x020 |
||
136 | #define HID_MAIN_ITEM_NULL_STATE 0x040 |
||
137 | #define HID_MAIN_ITEM_VOLATILE 0x080 |
||
138 | #define HID_MAIN_ITEM_BUFFERED_BYTE 0x100 |
||
139 | |||
140 | /* |
||
141 | * HID report descriptor collection item types |
||
142 | */ |
||
143 | |||
144 | #define HID_COLLECTION_PHYSICAL 0 |
||
145 | #define HID_COLLECTION_APPLICATION 1 |
||
146 | #define HID_COLLECTION_LOGICAL 2 |
||
147 | |||
148 | /* |
||
149 | * HID report descriptor global item tags |
||
150 | */ |
||
151 | |||
152 | #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE 0 |
||
153 | #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM 1 |
||
154 | #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM 2 |
||
155 | #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM 3 |
||
156 | #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM 4 |
||
157 | #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT 5 |
||
158 | #define HID_GLOBAL_ITEM_TAG_UNIT 6 |
||
159 | #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE 7 |
||
160 | #define HID_GLOBAL_ITEM_TAG_REPORT_ID 8 |
||
161 | #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT 9 |
||
162 | #define HID_GLOBAL_ITEM_TAG_PUSH 10 |
||
163 | #define HID_GLOBAL_ITEM_TAG_POP 11 |
||
164 | |||
165 | /* |
||
166 | * HID report descriptor local item tags |
||
167 | */ |
||
168 | |||
169 | #define HID_LOCAL_ITEM_TAG_USAGE 0 |
||
170 | #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM 1 |
||
171 | #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM 2 |
||
172 | #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX 3 |
||
173 | #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM 4 |
||
174 | #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM 5 |
||
175 | #define HID_LOCAL_ITEM_TAG_STRING_INDEX 7 |
||
176 | #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM 8 |
||
177 | #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM 9 |
||
178 | #define HID_LOCAL_ITEM_TAG_DELIMITER 10 |
||
179 | |||
180 | /* |
||
181 | * HID usage tables |
||
182 | */ |
||
183 | |||
184 | #define HID_USAGE_PAGE 0xffff0000 |
||
185 | |||
186 | #define HID_UP_UNDEFINED 0x00000000 |
||
187 | #define HID_UP_GENDESK 0x00010000 |
||
188 | #define HID_UP_SIMULATION 0x00020000 |
||
189 | #define HID_UP_KEYBOARD 0x00070000 |
||
190 | #define HID_UP_LED 0x00080000 |
||
191 | #define HID_UP_BUTTON 0x00090000 |
||
192 | #define HID_UP_ORDINAL 0x000a0000 |
||
193 | #define HID_UP_CONSUMER 0x000c0000 |
||
194 | #define HID_UP_DIGITIZER 0x000d0000 |
||
195 | #define HID_UP_PID 0x000f0000 |
||
196 | #define HID_UP_HPVENDOR 0xff7f0000 |
||
197 | #define HID_UP_MSVENDOR 0xff000000 |
||
198 | #define HID_UP_CUSTOM 0x00ff0000 |
||
199 | #define HID_UP_LOGIVENDOR 0xffbc0000 |
||
200 | |||
201 | #define HID_USAGE 0x0000ffff |
||
202 | |||
203 | #define HID_GD_POINTER 0x00010001 |
||
204 | #define HID_GD_MOUSE 0x00010002 |
||
205 | #define HID_GD_JOYSTICK 0x00010004 |
||
206 | #define HID_GD_GAMEPAD 0x00010005 |
||
207 | #define HID_GD_KEYBOARD 0x00010006 |
||
208 | #define HID_GD_KEYPAD 0x00010007 |
||
209 | #define HID_GD_MULTIAXIS 0x00010008 |
||
210 | #define HID_GD_X 0x00010030 |
||
211 | #define HID_GD_Y 0x00010031 |
||
212 | #define HID_GD_Z 0x00010032 |
||
213 | #define HID_GD_RX 0x00010033 |
||
214 | #define HID_GD_RY 0x00010034 |
||
215 | #define HID_GD_RZ 0x00010035 |
||
216 | #define HID_GD_SLIDER 0x00010036 |
||
217 | #define HID_GD_DIAL 0x00010037 |
||
218 | #define HID_GD_WHEEL 0x00010038 |
||
219 | #define HID_GD_HATSWITCH 0x00010039 |
||
220 | #define HID_GD_BUFFER 0x0001003a |
||
221 | #define HID_GD_BYTECOUNT 0x0001003b |
||
222 | #define HID_GD_MOTION 0x0001003c |
||
223 | #define HID_GD_START 0x0001003d |
||
224 | #define HID_GD_SELECT 0x0001003e |
||
225 | #define HID_GD_VX 0x00010040 |
||
226 | #define HID_GD_VY 0x00010041 |
||
227 | #define HID_GD_VZ 0x00010042 |
||
228 | #define HID_GD_VBRX 0x00010043 |
||
229 | #define HID_GD_VBRY 0x00010044 |
||
230 | #define HID_GD_VBRZ 0x00010045 |
||
231 | #define HID_GD_VNO 0x00010046 |
||
232 | #define HID_GD_FEATURE 0x00010047 |
||
233 | #define HID_GD_UP 0x00010090 |
||
234 | #define HID_GD_DOWN 0x00010091 |
||
235 | #define HID_GD_RIGHT 0x00010092 |
||
236 | #define HID_GD_LEFT 0x00010093 |
||
237 | |||
238 | /* |
||
239 | * HID report types --- Ouch! HID spec says 1 2 3! |
||
240 | */ |
||
241 | |||
242 | #define HID_INPUT_REPORT 0 |
||
243 | #define HID_OUTPUT_REPORT 1 |
||
244 | #define HID_FEATURE_REPORT 2 |
||
245 | |||
246 | /* |
||
247 | * HID device quirks. |
||
248 | */ |
||
249 | |||
250 | #define HID_QUIRK_INVERT 0x00000001 |
||
251 | #define HID_QUIRK_NOTOUCH 0x00000002 |
||
252 | #define HID_QUIRK_IGNORE 0x00000004 |
||
253 | #define HID_QUIRK_NOGET 0x00000008 |
||
254 | #define HID_QUIRK_HIDDEV 0x00000010 |
||
255 | #define HID_QUIRK_BADPAD 0x00000020 |
||
256 | #define HID_QUIRK_MULTI_INPUT 0x00000040 |
||
257 | #define HID_QUIRK_2WHEEL_MOUSE_HACK_7 0x00000080 |
||
258 | #define HID_QUIRK_2WHEEL_MOUSE_HACK_5 0x00000100 |
||
259 | #define HID_QUIRK_2WHEEL_MOUSE_HACK_ON 0x00000200 |
||
260 | #define HID_QUIRK_MIGHTYMOUSE 0x00000400 |
||
261 | #define HID_QUIRK_CYMOTION 0x00000800 |
||
262 | #define HID_QUIRK_POWERBOOK_HAS_FN 0x00001000 |
||
263 | #define HID_QUIRK_POWERBOOK_FN_ON 0x00002000 |
||
264 | #define HID_QUIRK_INVERT_HWHEEL 0x00004000 |
||
265 | #define HID_QUIRK_POWERBOOK_ISO_KEYBOARD 0x00008000 |
||
266 | #define HID_QUIRK_BAD_RELATIVE_KEYS 0x00010000 |
||
267 | #define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00020000 |
||
268 | #define HID_QUIRK_IGNORE_MOUSE 0x00040000 |
||
269 | #define HID_QUIRK_SONY_PS3_CONTROLLER 0x00080000 |
||
270 | #define HID_QUIRK_LOGITECH_S510_DESCRIPTOR 0x00100000 |
||
271 | #define HID_QUIRK_DUPLICATE_USAGES 0x00200000 |
||
272 | |||
273 | /* |
||
274 | * This is the global environment of the parser. This information is |
||
275 | * persistent for main-items. The global environment can be saved and |
||
276 | * restored with PUSH/POP statements. |
||
277 | */ |
||
278 | |||
279 | struct hid_global { |
||
280 | unsigned usage_page; |
||
281 | __s32 logical_minimum; |
||
282 | __s32 logical_maximum; |
||
283 | __s32 physical_minimum; |
||
284 | __s32 physical_maximum; |
||
285 | __s32 unit_exponent; |
||
286 | unsigned unit; |
||
287 | unsigned report_id; |
||
288 | unsigned report_size; |
||
289 | unsigned report_count; |
||
290 | }; |
||
291 | |||
292 | /* |
||
293 | * This is the local environment. It is persistent up the next main-item. |
||
294 | */ |
||
295 | |||
296 | #define HID_MAX_DESCRIPTOR_SIZE 4096 |
||
297 | #define HID_MAX_USAGES 8192 |
||
298 | #define HID_DEFAULT_NUM_COLLECTIONS 16 |
||
299 | |||
300 | struct hid_local { |
||
301 | unsigned usage[HID_MAX_USAGES]; /* usage array */ |
||
302 | unsigned collection_index[HID_MAX_USAGES]; /* collection index array */ |
||
303 | unsigned usage_index; |
||
304 | unsigned usage_minimum; |
||
305 | unsigned delimiter_depth; |
||
306 | unsigned delimiter_branch; |
||
307 | }; |
||
308 | |||
309 | /* |
||
310 | * This is the collection stack. We climb up the stack to determine |
||
311 | * application and function of each field. |
||
312 | */ |
||
313 | |||
314 | struct hid_collection { |
||
315 | unsigned type; |
||
316 | unsigned usage; |
||
317 | unsigned level; |
||
318 | }; |
||
319 | |||
320 | struct hid_usage { |
||
321 | unsigned hid; /* hid usage code */ |
||
322 | unsigned collection_index; /* index into collection array */ |
||
323 | /* hidinput data */ |
||
324 | __u16 code; /* input driver code */ |
||
325 | __u8 type; /* input driver type */ |
||
326 | __s8 hat_min; /* hat switch fun */ |
||
327 | __s8 hat_max; /* ditto */ |
||
328 | __s8 hat_dir; /* ditto */ |
||
329 | }; |
||
330 | |||
331 | struct hid_input; |
||
332 | |||
333 | struct hid_field { |
||
334 | unsigned physical; /* physical usage for this field */ |
||
335 | unsigned logical; /* logical usage for this field */ |
||
336 | unsigned application; /* application usage for this field */ |
||
337 | struct hid_usage *usage; /* usage table for this function */ |
||
338 | unsigned maxusage; /* maximum usage index */ |
||
339 | unsigned flags; /* main-item flags (i.e. volatile,array,constant) */ |
||
340 | unsigned report_offset; /* bit offset in the report */ |
||
341 | unsigned report_size; /* size of this field in the report */ |
||
342 | unsigned report_count; /* number of this field in the report */ |
||
343 | unsigned report_type; /* (input,output,feature) */ |
||
344 | __s32 *value; /* last known value(s) */ |
||
345 | __s32 logical_minimum; |
||
346 | __s32 logical_maximum; |
||
347 | __s32 physical_minimum; |
||
348 | __s32 physical_maximum; |
||
349 | __s32 unit_exponent; |
||
350 | unsigned unit; |
||
351 | struct hid_report *report; /* associated report */ |
||
352 | unsigned index; /* index into report->field[] */ |
||
353 | /* hidinput data */ |
||
354 | struct hid_input *hidinput; /* associated input structure */ |
||
355 | __u16 dpad; /* dpad input code */ |
||
356 | }; |
||
357 | |||
358 | #define HID_MAX_FIELDS 64 |
||
359 | |||
360 | struct hid_report { |
||
361 | struct list_head list; |
||
362 | unsigned id; /* id of this report */ |
||
363 | unsigned type; /* report type */ |
||
364 | struct hid_field *field[HID_MAX_FIELDS]; /* fields of the report */ |
||
365 | unsigned maxfield; /* maximum valid field index */ |
||
366 | unsigned size; /* size of the report (bits) */ |
||
367 | struct hid_device *device; /* associated device */ |
||
368 | }; |
||
369 | |||
370 | struct hid_report_enum { |
||
371 | unsigned numbered; |
||
372 | struct list_head report_list; |
||
373 | struct hid_report *report_id_hash[256]; |
||
374 | }; |
||
375 | |||
376 | #define HID_REPORT_TYPES 3 |
||
377 | |||
378 | #define HID_MIN_BUFFER_SIZE 64 /* make sure there is at least a packet size of space */ |
||
379 | #define HID_MAX_BUFFER_SIZE 4096 /* 4kb */ |
||
380 | #define HID_CONTROL_FIFO_SIZE 256 /* to init devices with >100 reports */ |
||
381 | #define HID_OUTPUT_FIFO_SIZE 64 |
||
382 | |||
383 | struct hid_control_fifo { |
||
384 | unsigned char dir; |
||
385 | struct hid_report *report; |
||
386 | }; |
||
387 | |||
388 | #define HID_CLAIMED_INPUT 1 |
||
389 | #define HID_CLAIMED_HIDDEV 2 |
||
390 | |||
391 | #define HID_CTRL_RUNNING 1 |
||
392 | #define HID_OUT_RUNNING 2 |
||
393 | #define HID_IN_RUNNING 3 |
||
394 | #define HID_RESET_PENDING 4 |
||
395 | #define HID_SUSPENDED 5 |
||
396 | #define HID_CLEAR_HALT 6 |
||
397 | |||
398 | struct hid_input { |
||
399 | struct list_head list; |
||
400 | struct hid_report *report; |
||
401 | struct input_dev *input; |
||
402 | }; |
||
403 | |||
404 | struct hid_device { /* device report descriptor */ |
||
405 | __u8 *rdesc; |
||
406 | unsigned rsize; |
||
407 | struct hid_collection *collection; /* List of HID collections */ |
||
408 | unsigned collection_size; /* Number of allocated hid_collections */ |
||
409 | unsigned maxcollection; /* Number of parsed collections */ |
||
410 | unsigned maxapplication; /* Number of applications */ |
||
411 | unsigned short bus; /* BUS ID */ |
||
412 | unsigned short vendor; /* Vendor ID */ |
||
413 | unsigned short product; /* Product ID */ |
||
414 | unsigned version; /* HID version */ |
||
415 | unsigned country; /* HID country */ |
||
416 | struct hid_report_enum report_enum[HID_REPORT_TYPES]; |
||
417 | |||
418 | struct device *dev; /* device */ |
||
419 | |||
420 | unsigned claimed; /* Claimed by hidinput, hiddev? */ |
||
421 | unsigned quirks; /* Various quirks the device can pull on us */ |
||
422 | |||
423 | struct list_head inputs; /* The list of inputs */ |
||
424 | void *hiddev; /* The hiddev structure */ |
||
425 | int minor; /* Hiddev minor number */ |
||
426 | |||
427 | wait_queue_head_t wait; /* For sleeping */ |
||
428 | |||
429 | int open; /* is the device open by anyone? */ |
||
430 | char name[128]; /* Device name */ |
||
431 | char phys[64]; /* Device physical location */ |
||
432 | char uniq[64]; /* Device unique identifier (serial #) */ |
||
433 | |||
434 | void *driver_data; |
||
435 | |||
436 | /* device-specific function pointers */ |
||
437 | int (*hidinput_input_event) (struct input_dev *, unsigned int, unsigned int, int); |
||
438 | int (*hid_open) (struct hid_device *); |
||
439 | void (*hid_close) (struct hid_device *); |
||
440 | |||
441 | /* hiddev event handler */ |
||
442 | void (*hiddev_hid_event) (struct hid_device *, struct hid_field *field, |
||
443 | struct hid_usage *, __s32); |
||
444 | void (*hiddev_report_event) (struct hid_device *, struct hid_report *); |
||
445 | #ifdef CONFIG_USB_HIDINPUT_POWERBOOK |
||
446 | unsigned long pb_pressed_fn[NBITS(KEY_MAX)]; |
||
447 | unsigned long pb_pressed_numlock[NBITS(KEY_MAX)]; |
||
448 | #endif |
||
449 | }; |
||
450 | |||
451 | #define HID_GLOBAL_STACK_SIZE 4 |
||
452 | #define HID_COLLECTION_STACK_SIZE 4 |
||
453 | |||
454 | struct hid_parser { |
||
455 | struct hid_global global; |
||
456 | struct hid_global global_stack[HID_GLOBAL_STACK_SIZE]; |
||
457 | unsigned global_stack_ptr; |
||
458 | struct hid_local local; |
||
459 | unsigned collection_stack[HID_COLLECTION_STACK_SIZE]; |
||
460 | unsigned collection_stack_ptr; |
||
461 | struct hid_device *device; |
||
462 | }; |
||
463 | |||
464 | struct hid_class_descriptor { |
||
465 | __u8 bDescriptorType; |
||
466 | __u16 wDescriptorLength; |
||
467 | } __attribute__ ((packed)); |
||
468 | |||
469 | struct hid_descriptor { |
||
470 | __u8 bLength; |
||
471 | __u8 bDescriptorType; |
||
472 | __u16 bcdHID; |
||
473 | __u8 bCountryCode; |
||
474 | __u8 bNumDescriptors; |
||
475 | |||
476 | struct hid_class_descriptor desc[1]; |
||
477 | } __attribute__ ((packed)); |
||
478 | |||
479 | /* Applications from HID Usage Tables 4/8/99 Version 1.1 */ |
||
480 | /* We ignore a few input applications that are not widely used */ |
||
481 | #define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001)) |
||
482 | |||
483 | /* HID core API */ |
||
484 | extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32); |
||
485 | extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report); |
||
486 | extern int hidinput_connect(struct hid_device *); |
||
487 | extern void hidinput_disconnect(struct hid_device *); |
||
488 | |||
489 | int hid_set_field(struct hid_field *, unsigned, __s32); |
||
490 | int hid_input_report(struct hid_device *, int type, u8 *, int, int); |
||
491 | int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field); |
||
492 | void hid_input_field(struct hid_device *hid, struct hid_field *field, __u8 *data, int interrupt); |
||
493 | void hid_output_report(struct hid_report *report, __u8 *data); |
||
494 | void hid_free_device(struct hid_device *device); |
||
495 | struct hid_device *hid_parse_report(__u8 *start, unsigned size); |
||
496 | |||
497 | #ifdef CONFIG_HID_FF |
||
498 | int hid_ff_init(struct hid_device *hid); |
||
499 | |||
500 | int hid_lgff_init(struct hid_device *hid); |
||
501 | int hid_plff_init(struct hid_device *hid); |
||
502 | int hid_tmff_init(struct hid_device *hid); |
||
503 | int hid_zpff_init(struct hid_device *hid); |
||
504 | #ifdef CONFIG_HID_PID |
||
505 | int hid_pidff_init(struct hid_device *hid); |
||
506 | #else |
||
507 | static inline int hid_pidff_init(struct hid_device *hid) { return -ENODEV; } |
||
508 | #endif |
||
509 | |||
510 | #else |
||
511 | static inline int hid_ff_init(struct hid_device *hid) { return -1; } |
||
512 | #endif |
||
513 | #ifdef DEBUG |
||
514 | #define dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \ |
||
515 | __FILE__ , ## arg) |
||
516 | #else |
||
517 | #define dbg(format, arg...) do {} while (0) |
||
518 | #endif |
||
519 | |||
520 | #define err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \ |
||
521 | __FILE__ , ## arg) |
||
522 | #endif=> |
||
523 |