Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
846 | giacomo | 1 | #ifndef __HID_H |
2 | #define __HID_H |
||
3 | |||
4 | /* |
||
5 | * $Id: hid.h,v 1.1 2004-09-13 15:04:47 giacomo Exp $ |
||
6 | * |
||
7 | * Copyright (c) 1999 Andreas Gal |
||
8 | * Copyright (c) 2000-2001 Vojtech Pavlik |
||
9 | */ |
||
10 | |||
11 | /* |
||
12 | * This program is free software; you can redistribute it and/or modify |
||
13 | * it under the terms of the GNU General Public License as published by |
||
14 | * the Free Software Foundation; either version 2 of the License, or |
||
15 | * (at your option) any later version. |
||
16 | * |
||
17 | * This program is distributed in the hope that it will be useful, |
||
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
20 | * GNU General Public License for more details. |
||
21 | * |
||
22 | * You should have received a copy of the GNU General Public License |
||
23 | * along with this program; if not, write to the Free Software |
||
24 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
||
25 | * |
||
26 | * Should you need to contact me, the author, you can do so either by |
||
27 | * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail: |
||
28 | * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic |
||
29 | */ |
||
30 | |||
31 | #include <linux/types.h> |
||
32 | #include <linux/slab.h> |
||
33 | #include <linux/list.h> |
||
34 | |||
35 | /* |
||
36 | * USB HID (Human Interface Device) interface class code |
||
37 | */ |
||
38 | |||
39 | #define USB_INTERFACE_CLASS_HID 3 |
||
40 | |||
41 | /* |
||
42 | * HID class requests |
||
43 | */ |
||
44 | |||
45 | #define HID_REQ_GET_REPORT 0x01 |
||
46 | #define HID_REQ_GET_IDLE 0x02 |
||
47 | #define HID_REQ_GET_PROTOCOL 0x03 |
||
48 | #define HID_REQ_SET_REPORT 0x09 |
||
49 | #define HID_REQ_SET_IDLE 0x0A |
||
50 | #define HID_REQ_SET_PROTOCOL 0x0B |
||
51 | |||
52 | /* |
||
53 | * HID class descriptor types |
||
54 | */ |
||
55 | |||
56 | #define HID_DT_HID (USB_TYPE_CLASS | 0x01) |
||
57 | #define HID_DT_REPORT (USB_TYPE_CLASS | 0x02) |
||
58 | #define HID_DT_PHYSICAL (USB_TYPE_CLASS | 0x03) |
||
59 | |||
60 | /* |
||
61 | * We parse each description item into this structure. Short items data |
||
62 | * values are expanded to 32-bit signed int, long items contain a pointer |
||
63 | * into the data area. |
||
64 | */ |
||
65 | |||
66 | struct hid_item { |
||
67 | unsigned format; |
||
68 | __u8 size; |
||
69 | __u8 type; |
||
70 | __u8 tag; |
||
71 | union { |
||
72 | __u8 u8; |
||
73 | __s8 s8; |
||
74 | __u16 u16; |
||
75 | __s16 s16; |
||
76 | __u32 u32; |
||
77 | __s32 s32; |
||
78 | __u8 *longdata; |
||
79 | } data; |
||
80 | }; |
||
81 | |||
82 | /* |
||
83 | * HID report item format |
||
84 | */ |
||
85 | |||
86 | #define HID_ITEM_FORMAT_SHORT 0 |
||
87 | #define HID_ITEM_FORMAT_LONG 1 |
||
88 | |||
89 | /* |
||
90 | * Special tag indicating long items |
||
91 | */ |
||
92 | |||
93 | #define HID_ITEM_TAG_LONG 15 |
||
94 | |||
95 | /* |
||
96 | * HID report descriptor item type (prefix bit 2,3) |
||
97 | */ |
||
98 | |||
99 | #define HID_ITEM_TYPE_MAIN 0 |
||
100 | #define HID_ITEM_TYPE_GLOBAL 1 |
||
101 | #define HID_ITEM_TYPE_LOCAL 2 |
||
102 | #define HID_ITEM_TYPE_RESERVED 3 |
||
103 | |||
104 | /* |
||
105 | * HID report descriptor main item tags |
||
106 | */ |
||
107 | |||
108 | #define HID_MAIN_ITEM_TAG_INPUT 8 |
||
109 | #define HID_MAIN_ITEM_TAG_OUTPUT 9 |
||
110 | #define HID_MAIN_ITEM_TAG_FEATURE 11 |
||
111 | #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION 10 |
||
112 | #define HID_MAIN_ITEM_TAG_END_COLLECTION 12 |
||
113 | |||
114 | /* |
||
115 | * HID report descriptor main item contents |
||
116 | */ |
||
117 | |||
118 | #define HID_MAIN_ITEM_CONSTANT 0x001 |
||
119 | #define HID_MAIN_ITEM_VARIABLE 0x002 |
||
120 | #define HID_MAIN_ITEM_RELATIVE 0x004 |
||
121 | #define HID_MAIN_ITEM_WRAP 0x008 |
||
122 | #define HID_MAIN_ITEM_NONLINEAR 0x010 |
||
123 | #define HID_MAIN_ITEM_NO_PREFERRED 0x020 |
||
124 | #define HID_MAIN_ITEM_NULL_STATE 0x040 |
||
125 | #define HID_MAIN_ITEM_VOLATILE 0x080 |
||
126 | #define HID_MAIN_ITEM_BUFFERED_BYTE 0x100 |
||
127 | |||
128 | /* |
||
129 | * HID report descriptor collection item types |
||
130 | */ |
||
131 | |||
132 | #define HID_COLLECTION_PHYSICAL 0 |
||
133 | #define HID_COLLECTION_APPLICATION 1 |
||
134 | #define HID_COLLECTION_LOGICAL 2 |
||
135 | |||
136 | /* |
||
137 | * HID report descriptor global item tags |
||
138 | */ |
||
139 | |||
140 | #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE 0 |
||
141 | #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM 1 |
||
142 | #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM 2 |
||
143 | #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM 3 |
||
144 | #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM 4 |
||
145 | #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT 5 |
||
146 | #define HID_GLOBAL_ITEM_TAG_UNIT 6 |
||
147 | #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE 7 |
||
148 | #define HID_GLOBAL_ITEM_TAG_REPORT_ID 8 |
||
149 | #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT 9 |
||
150 | #define HID_GLOBAL_ITEM_TAG_PUSH 10 |
||
151 | #define HID_GLOBAL_ITEM_TAG_POP 11 |
||
152 | |||
153 | /* |
||
154 | * HID report descriptor local item tags |
||
155 | */ |
||
156 | |||
157 | #define HID_LOCAL_ITEM_TAG_USAGE 0 |
||
158 | #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM 1 |
||
159 | #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM 2 |
||
160 | #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX 3 |
||
161 | #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM 4 |
||
162 | #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM 5 |
||
163 | #define HID_LOCAL_ITEM_TAG_STRING_INDEX 7 |
||
164 | #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM 8 |
||
165 | #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM 9 |
||
166 | #define HID_LOCAL_ITEM_TAG_DELIMITER 10 |
||
167 | |||
168 | /* |
||
169 | * HID usage tables |
||
170 | */ |
||
171 | |||
172 | #define HID_USAGE_PAGE 0xffff0000 |
||
173 | |||
174 | #define HID_UP_GENDESK 0x00010000 |
||
175 | #define HID_UP_KEYBOARD 0x00070000 |
||
176 | #define HID_UP_LED 0x00080000 |
||
177 | #define HID_UP_BUTTON 0x00090000 |
||
178 | #define HID_UP_ORDINAL 0x000a0000 |
||
179 | #define HID_UP_CONSUMER 0x000c0000 |
||
180 | #define HID_UP_DIGITIZER 0x000d0000 |
||
181 | #define HID_UP_PID 0x000f0000 |
||
182 | #define HID_UP_HPVENDOR 0xff7f0000 |
||
183 | |||
184 | #define HID_USAGE 0x0000ffff |
||
185 | |||
186 | #define HID_GD_POINTER 0x00010001 |
||
187 | #define HID_GD_MOUSE 0x00010002 |
||
188 | #define HID_GD_JOYSTICK 0x00010004 |
||
189 | #define HID_GD_GAMEPAD 0x00010005 |
||
190 | #define HID_GD_HATSWITCH 0x00010039 |
||
191 | |||
192 | /* |
||
193 | * HID report types --- Ouch! HID spec says 1 2 3! |
||
194 | */ |
||
195 | |||
196 | #define HID_INPUT_REPORT 0 |
||
197 | #define HID_OUTPUT_REPORT 1 |
||
198 | #define HID_FEATURE_REPORT 2 |
||
199 | |||
200 | /* |
||
201 | * HID device quirks. |
||
202 | */ |
||
203 | |||
204 | #define HID_QUIRK_INVERT 0x001 |
||
205 | #define HID_QUIRK_NOTOUCH 0x002 |
||
206 | #define HID_QUIRK_IGNORE 0x004 |
||
207 | #define HID_QUIRK_NOGET 0x008 |
||
208 | #define HID_QUIRK_HIDDEV 0x010 |
||
209 | #define HID_QUIRK_BADPAD 0x020 |
||
210 | #define HID_QUIRK_MULTI_INPUT 0x040 |
||
211 | #define HID_QUIRK_2WHEEL_MOUSE_HACK 0x080 |
||
212 | #define HID_QUIRK_2WHEEL_MOUSE_HACK_ON 0x100 |
||
213 | |||
214 | /* |
||
215 | * This is the global environment of the parser. This information is |
||
216 | * persistent for main-items. The global environment can be saved and |
||
217 | * restored with PUSH/POP statements. |
||
218 | */ |
||
219 | |||
220 | struct hid_global { |
||
221 | unsigned usage_page; |
||
222 | __s32 logical_minimum; |
||
223 | __s32 logical_maximum; |
||
224 | __s32 physical_minimum; |
||
225 | __s32 physical_maximum; |
||
226 | __s32 unit_exponent; |
||
227 | unsigned unit; |
||
228 | unsigned report_id; |
||
229 | unsigned report_size; |
||
230 | unsigned report_count; |
||
231 | }; |
||
232 | |||
233 | /* |
||
234 | * This is the local environment. It is persistent up the next main-item. |
||
235 | */ |
||
236 | |||
237 | #define HID_MAX_DESCRIPTOR_SIZE 4096 |
||
238 | #define HID_MAX_USAGES 1024 |
||
239 | #define HID_DEFAULT_NUM_COLLECTIONS 16 |
||
240 | |||
241 | struct hid_local { |
||
242 | unsigned usage[HID_MAX_USAGES]; /* usage array */ |
||
243 | unsigned collection_index[HID_MAX_USAGES]; /* collection index array */ |
||
244 | unsigned usage_index; |
||
245 | unsigned usage_minimum; |
||
246 | unsigned delimiter_depth; |
||
247 | unsigned delimiter_branch; |
||
248 | }; |
||
249 | |||
250 | /* |
||
251 | * This is the collection stack. We climb up the stack to determine |
||
252 | * application and function of each field. |
||
253 | */ |
||
254 | |||
255 | struct hid_collection { |
||
256 | unsigned type; |
||
257 | unsigned usage; |
||
258 | unsigned level; |
||
259 | }; |
||
260 | |||
261 | struct hid_usage { |
||
262 | unsigned hid; /* hid usage code */ |
||
263 | unsigned collection_index; /* index into collection array */ |
||
264 | __u16 code; /* input driver code */ |
||
265 | __u8 type; /* input driver type */ |
||
266 | __s8 hat_min; /* hat switch fun */ |
||
267 | __s8 hat_max; /* ditto */ |
||
268 | }; |
||
269 | |||
270 | struct hid_field { |
||
271 | unsigned physical; /* physical usage for this field */ |
||
272 | unsigned logical; /* logical usage for this field */ |
||
273 | unsigned application; /* application usage for this field */ |
||
274 | struct hid_usage *usage; /* usage table for this function */ |
||
275 | unsigned maxusage; /* maximum usage index */ |
||
276 | unsigned flags; /* main-item flags (i.e. volatile,array,constant) */ |
||
277 | unsigned report_offset; /* bit offset in the report */ |
||
278 | unsigned report_size; /* size of this field in the report */ |
||
279 | unsigned report_count; /* number of this field in the report */ |
||
280 | unsigned report_type; /* (input,output,feature) */ |
||
281 | __s32 *value; /* last known value(s) */ |
||
282 | __s32 logical_minimum; |
||
283 | __s32 logical_maximum; |
||
284 | __s32 physical_minimum; |
||
285 | __s32 physical_maximum; |
||
286 | __s32 unit_exponent; |
||
287 | unsigned unit; |
||
288 | struct hid_report *report; /* associated report */ |
||
289 | unsigned index; /* index into report->field[] */ |
||
290 | }; |
||
291 | |||
292 | #define HID_MAX_FIELDS 64 |
||
293 | |||
294 | struct hid_report { |
||
295 | struct list_head list; |
||
296 | unsigned id; /* id of this report */ |
||
297 | unsigned type; /* report type */ |
||
298 | struct hid_field *field[HID_MAX_FIELDS]; /* fields of the report */ |
||
299 | unsigned maxfield; /* maximum valid field index */ |
||
300 | unsigned size; /* size of the report (bits) */ |
||
301 | struct hid_device *device; /* associated device */ |
||
302 | }; |
||
303 | |||
304 | struct hid_report_enum { |
||
305 | unsigned numbered; |
||
306 | struct list_head report_list; |
||
307 | struct hid_report *report_id_hash[256]; |
||
308 | }; |
||
309 | |||
310 | #define HID_REPORT_TYPES 3 |
||
311 | |||
312 | #define HID_BUFFER_SIZE 32 |
||
313 | #define HID_CONTROL_FIFO_SIZE 256 /* to init devices with >100 reports */ |
||
314 | #define HID_OUTPUT_FIFO_SIZE 64 |
||
315 | |||
316 | struct hid_control_fifo { |
||
317 | unsigned char dir; |
||
318 | struct hid_report *report; |
||
319 | }; |
||
320 | |||
321 | #define HID_CLAIMED_INPUT 1 |
||
322 | #define HID_CLAIMED_HIDDEV 2 |
||
323 | |||
324 | #define HID_CTRL_RUNNING 1 |
||
325 | #define HID_OUT_RUNNING 2 |
||
326 | |||
327 | struct hid_input { |
||
328 | struct list_head list; |
||
329 | struct hid_report *report; |
||
330 | struct input_dev input; |
||
331 | }; |
||
332 | |||
333 | struct hid_device { /* device report descriptor */ |
||
334 | __u8 *rdesc; |
||
335 | unsigned rsize; |
||
336 | struct hid_collection *collection; /* List of HID collections */ |
||
337 | unsigned collection_size; /* Number of allocated hid_collections */ |
||
338 | unsigned maxcollection; /* Number of parsed collections */ |
||
339 | unsigned maxapplication; /* Number of applications */ |
||
340 | unsigned version; /* HID version */ |
||
341 | unsigned country; /* HID country */ |
||
342 | struct hid_report_enum report_enum[HID_REPORT_TYPES]; |
||
343 | |||
344 | struct usb_device *dev; /* USB device */ |
||
345 | int ifnum; /* USB interface number */ |
||
346 | |||
347 | unsigned long iofl; /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */ |
||
348 | |||
349 | struct urb *urbin; /* Input URB */ |
||
350 | char *inbuf; /* Input buffer */ |
||
351 | dma_addr_t inbuf_dma; /* Input buffer dma */ |
||
352 | |||
353 | struct urb *urbctrl; /* Control URB */ |
||
354 | struct usb_ctrlrequest *cr; /* Control request struct */ |
||
355 | dma_addr_t cr_dma; /* Control request struct dma */ |
||
356 | struct hid_control_fifo ctrl[HID_CONTROL_FIFO_SIZE]; /* Control fifo */ |
||
357 | unsigned char ctrlhead, ctrltail; /* Control fifo head & tail */ |
||
358 | char *ctrlbuf; /* Control buffer */ |
||
359 | dma_addr_t ctrlbuf_dma; /* Control buffer dma */ |
||
360 | spinlock_t ctrllock; /* Control fifo spinlock */ |
||
361 | |||
362 | struct urb *urbout; /* Output URB */ |
||
363 | struct hid_report *out[HID_CONTROL_FIFO_SIZE]; /* Output pipe fifo */ |
||
364 | unsigned char outhead, outtail; /* Output pipe fifo head & tail */ |
||
365 | char *outbuf; /* Output buffer */ |
||
366 | dma_addr_t outbuf_dma; /* Output buffer dma */ |
||
367 | spinlock_t outlock; /* Output fifo spinlock */ |
||
368 | |||
369 | unsigned claimed; /* Claimed by hidinput, hiddev? */ |
||
370 | unsigned quirks; /* Various quirks the device can pull on us */ |
||
371 | |||
372 | struct list_head inputs; /* The list of inputs */ |
||
373 | void *hiddev; /* The hiddev structure */ |
||
374 | int minor; /* Hiddev minor number */ |
||
375 | |||
376 | wait_queue_head_t wait; /* For sleeping */ |
||
377 | |||
378 | int open; /* is the device open by anyone? */ |
||
379 | char name[128]; /* Device name */ |
||
380 | char phys[64]; /* Device physical location */ |
||
381 | char uniq[64]; /* Device unique identifier (serial #) */ |
||
382 | |||
383 | void *ff_private; /* Private data for the force-feedback driver */ |
||
384 | void (*ff_exit)(struct hid_device*); /* Called by hid_exit_ff(hid) */ |
||
385 | int (*ff_event)(struct hid_device *hid, struct input_dev *input, |
||
386 | unsigned int type, unsigned int code, int value); |
||
387 | }; |
||
388 | |||
389 | #define HID_GLOBAL_STACK_SIZE 4 |
||
390 | #define HID_COLLECTION_STACK_SIZE 4 |
||
391 | |||
392 | struct hid_parser { |
||
393 | struct hid_global global; |
||
394 | struct hid_global global_stack[HID_GLOBAL_STACK_SIZE]; |
||
395 | unsigned global_stack_ptr; |
||
396 | struct hid_local local; |
||
397 | unsigned collection_stack[HID_COLLECTION_STACK_SIZE]; |
||
398 | unsigned collection_stack_ptr; |
||
399 | struct hid_device *device; |
||
400 | }; |
||
401 | |||
402 | struct hid_class_descriptor { |
||
403 | __u8 bDescriptorType; |
||
404 | __u16 wDescriptorLength; |
||
405 | } __attribute__ ((packed)); |
||
406 | |||
407 | struct hid_descriptor { |
||
408 | __u8 bLength; |
||
409 | __u8 bDescriptorType; |
||
410 | __u16 bcdHID; |
||
411 | __u8 bCountryCode; |
||
412 | __u8 bNumDescriptors; |
||
413 | |||
414 | struct hid_class_descriptor desc[1]; |
||
415 | } __attribute__ ((packed)); |
||
416 | |||
417 | #ifdef DEBUG |
||
418 | #include "hid-debug.h" |
||
419 | #else |
||
420 | #define hid_dump_input(a,b) do { } while (0) |
||
421 | #define hid_dump_device(c) do { } while (0) |
||
422 | #define hid_dump_field(a,b) do { } while (0) |
||
423 | #define resolv_usage(a) do { } while (0) |
||
424 | #endif |
||
425 | |||
426 | #endif |
||
427 | |||
428 | #ifdef CONFIG_USB_HIDINPUT |
||
429 | /* Applications from HID Usage Tables 4/8/99 Version 1.1 */ |
||
430 | /* We ignore a few input applications that are not widely used */ |
||
431 | #define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || ( a == 0x00010080) || ( a == 0x000c0001)) |
||
432 | extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32, struct pt_regs *regs); |
||
433 | extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report); |
||
434 | extern int hidinput_connect(struct hid_device *); |
||
435 | extern void hidinput_disconnect(struct hid_device *); |
||
436 | #else |
||
437 | #define IS_INPUT_APPLICATION(a) (0) |
||
438 | static inline void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, struct pt_regs *regs) { } |
||
439 | static inline void hidinput_report_event(struct hid_device *hid, struct hid_report *report) { } |
||
440 | static inline int hidinput_connect(struct hid_device *hid) { return -ENODEV; } |
||
441 | static inline void hidinput_disconnect(struct hid_device *hid) { } |
||
442 | #endif |
||
443 | |||
444 | int hid_open(struct hid_device *); |
||
445 | void hid_close(struct hid_device *); |
||
446 | int hid_find_field(struct hid_device *, unsigned int, unsigned int, struct hid_field **); |
||
447 | int hid_set_field(struct hid_field *, unsigned, __s32); |
||
448 | void hid_submit_report(struct hid_device *, struct hid_report *, unsigned char dir); |
||
449 | void hid_init_reports(struct hid_device *hid); |
||
450 | int hid_find_report_by_usage(struct hid_device *hid, __u32 wanted_usage, struct hid_report **report, int type); |
||
451 | |||
452 | |||
453 | #ifdef CONFIG_HID_FF |
||
454 | int hid_ff_init(struct hid_device *hid); |
||
455 | #else |
||
456 | static inline int hid_ff_init(struct hid_device *hid) { return -1; } |
||
457 | #endif |
||
458 | static inline void hid_ff_exit(struct hid_device *hid) |
||
459 | { |
||
460 | if (hid->ff_exit) |
||
461 | hid->ff_exit(hid); |
||
462 | } |
||
463 | static inline int hid_ff_event(struct hid_device *hid, struct input_dev *input, |
||
464 | unsigned int type, unsigned int code, int value) |
||
465 | { |
||
466 | if (hid->ff_event) |
||
467 | return hid->ff_event(hid, input, type, code, value); |
||
468 | return -ENOSYS; |
||
469 | } |