2 * $Id: hid-input.c,v 1.2 2002/04/23 00:59:25 rdamazio Exp $
4 * Copyright (c) 2000-2001 Vojtech Pavlik
5 * Copyright (c) 2006-2007 Jiri Kosina
7 * HID to Linux Input mapping
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 * Should you need to contact me, the author, you can do so either by
26 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
27 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
30 #include <linux/module.h>
31 #include <linux/slab.h>
32 #include <linux/kernel.h>
34 #include <linux/hid.h>
35 #include <linux/hid-debug.h>
37 static int hid_apple_fnmode
= 1;
38 module_param_named(pb_fnmode
, hid_apple_fnmode
, int, 0644);
39 MODULE_PARM_DESC(pb_fnmode
,
40 "Mode of fn key on Apple keyboards (0 = disabled, 1 = fkeyslast, 2 = fkeysfirst)");
42 #define unk KEY_UNKNOWN
44 static const unsigned char hid_keyboard
[256] = {
45 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
46 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44, 2, 3,
47 4, 5, 6, 7, 8, 9, 10, 11, 28, 1, 14, 15, 57, 12, 13, 26,
48 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
49 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
50 105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
51 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
52 191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
53 115,114,unk
,unk
,unk
,121,unk
, 89, 93,124, 92, 94, 95,unk
,unk
,unk
,
54 122,123, 90, 91, 85,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,
55 unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,
56 unk
,unk
,unk
,unk
,unk
,unk
,179,180,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,
57 unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,
58 unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,
59 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
60 150,158,159,128,136,177,178,176,142,152,173,140,unk
,unk
,unk
,unk
63 /* extended mapping for certain Logitech hardware (Logitech cordless desktop LX500) */
64 #define LOGITECH_EXPANDED_KEYMAP_SIZE 80
65 static int logitech_expanded_keymap
[LOGITECH_EXPANDED_KEYMAP_SIZE
] = {
66 0,216, 0,213,175,156, 0, 0, 0, 0,
67 144, 0, 0, 0, 0, 0, 0, 0, 0,212,
68 174,167,152,161,112, 0, 0, 0,154, 0,
69 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
70 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
71 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72 0, 0, 0, 0, 0,183,184,185,186,187,
73 188,189,190,191,192,193,194, 0, 0, 0
79 } hid_hat_to_axis
[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
81 #define map_abs(c) do { usage->code = c; usage->type = EV_ABS; bit = input->absbit; max = ABS_MAX; } while (0)
82 #define map_rel(c) do { usage->code = c; usage->type = EV_REL; bit = input->relbit; max = REL_MAX; } while (0)
83 #define map_key(c) do { usage->code = c; usage->type = EV_KEY; bit = input->keybit; max = KEY_MAX; } while (0)
84 #define map_led(c) do { usage->code = c; usage->type = EV_LED; bit = input->ledbit; max = LED_MAX; } while (0)
86 #define map_abs_clear(c) do { map_abs(c); clear_bit(c, bit); } while (0)
87 #define map_key_clear(c) do { map_key(c); clear_bit(c, bit); } while (0)
89 /* hardware needing special handling due to colliding MSVENDOR page usages */
90 #define IS_CHICONY_TACTICAL_PAD(x) (x->vendor == 0x04f2 && device->product == 0x0418)
91 #define IS_MS_KB(x) (x->vendor == 0x045e && (x->product == 0x00db || x->product == 0x00f9))
92 #define IS_MS_PRESENTER_8000(x) (x->vendor == 0x045e && x->product == 0x0713)
94 #ifdef CONFIG_USB_HIDINPUT_POWERBOOK
96 struct hidinput_key_translation
{
102 #define APPLE_FLAG_FKEY 0x01
104 static struct hidinput_key_translation apple_fn_keys
[] = {
105 { KEY_F1
, KEY_BRIGHTNESSDOWN
, APPLE_FLAG_FKEY
},
106 { KEY_F2
, KEY_BRIGHTNESSUP
, APPLE_FLAG_FKEY
},
107 { KEY_F3
, KEY_CYCLEWINDOWS
, APPLE_FLAG_FKEY
}, /* Exposé */
108 { KEY_F4
, KEY_FN_F4
, APPLE_FLAG_FKEY
}, /* Dashboard */
109 { KEY_F5
, KEY_FN_F5
},
110 { KEY_F6
, KEY_FN_F6
},
111 { KEY_F7
, KEY_BACK
, APPLE_FLAG_FKEY
},
112 { KEY_F8
, KEY_PLAYPAUSE
, APPLE_FLAG_FKEY
},
113 { KEY_F9
, KEY_FORWARD
, APPLE_FLAG_FKEY
},
114 { KEY_F10
, KEY_MUTE
, APPLE_FLAG_FKEY
},
115 { KEY_F11
, KEY_VOLUMEDOWN
, APPLE_FLAG_FKEY
},
116 { KEY_F12
, KEY_VOLUMEUP
, APPLE_FLAG_FKEY
},
120 static struct hidinput_key_translation powerbook_fn_keys
[] = {
121 { KEY_BACKSPACE
, KEY_DELETE
},
122 { KEY_F1
, KEY_BRIGHTNESSDOWN
, APPLE_FLAG_FKEY
},
123 { KEY_F2
, KEY_BRIGHTNESSUP
, APPLE_FLAG_FKEY
},
124 { KEY_F3
, KEY_MUTE
, APPLE_FLAG_FKEY
},
125 { KEY_F4
, KEY_VOLUMEDOWN
, APPLE_FLAG_FKEY
},
126 { KEY_F5
, KEY_VOLUMEUP
, APPLE_FLAG_FKEY
},
127 { KEY_F6
, KEY_NUMLOCK
, APPLE_FLAG_FKEY
},
128 { KEY_F7
, KEY_SWITCHVIDEOMODE
, APPLE_FLAG_FKEY
},
129 { KEY_F8
, KEY_KBDILLUMTOGGLE
, APPLE_FLAG_FKEY
},
130 { KEY_F9
, KEY_KBDILLUMDOWN
, APPLE_FLAG_FKEY
},
131 { KEY_F10
, KEY_KBDILLUMUP
, APPLE_FLAG_FKEY
},
132 { KEY_UP
, KEY_PAGEUP
},
133 { KEY_DOWN
, KEY_PAGEDOWN
},
134 { KEY_LEFT
, KEY_HOME
},
135 { KEY_RIGHT
, KEY_END
},
139 static struct hidinput_key_translation powerbook_numlock_keys
[] = {
150 { KEY_DOT
, KEY_KPDOT
},
151 { KEY_SLASH
, KEY_KPPLUS
},
152 { KEY_SEMICOLON
, KEY_KPMINUS
},
153 { KEY_P
, KEY_KPASTERISK
},
154 { KEY_MINUS
, KEY_KPEQUAL
},
155 { KEY_0
, KEY_KPSLASH
},
156 { KEY_F6
, KEY_NUMLOCK
},
157 { KEY_KPENTER
, KEY_KPENTER
},
158 { KEY_BACKSPACE
, KEY_BACKSPACE
},
162 static struct hidinput_key_translation apple_iso_keyboard
[] = {
163 { KEY_GRAVE
, KEY_102ND
},
164 { KEY_102ND
, KEY_GRAVE
},
168 static struct hidinput_key_translation
*find_translation(struct hidinput_key_translation
*table
, u16 from
)
170 struct hidinput_key_translation
*trans
;
172 /* Look for the translation */
173 for (trans
= table
; trans
->from
; trans
++)
174 if (trans
->from
== from
)
180 static int hidinput_apple_event(struct hid_device
*hid
, struct input_dev
*input
,
181 struct hid_usage
*usage
, __s32 value
)
183 struct hidinput_key_translation
*trans
;
185 if (usage
->code
== KEY_FN
) {
186 if (value
) hid
->quirks
|= HID_QUIRK_APPLE_FN_ON
;
187 else hid
->quirks
&= ~HID_QUIRK_APPLE_FN_ON
;
189 input_event(input
, usage
->type
, usage
->code
, value
);
194 if (hid_apple_fnmode
) {
197 trans
= find_translation((hid
->product
< 0x220 ||
198 hid
->product
>= 0x300) ?
199 powerbook_fn_keys
: apple_fn_keys
,
202 if (test_bit(usage
->code
, hid
->apple_pressed_fn
))
204 else if (trans
->flags
& APPLE_FLAG_FKEY
)
206 (hid_apple_fnmode
== 2 && (hid
->quirks
& HID_QUIRK_APPLE_FN_ON
)) ||
207 (hid_apple_fnmode
== 1 && !(hid
->quirks
& HID_QUIRK_APPLE_FN_ON
));
209 do_translate
= (hid
->quirks
& HID_QUIRK_APPLE_FN_ON
);
213 set_bit(usage
->code
, hid
->apple_pressed_fn
);
215 clear_bit(usage
->code
, hid
->apple_pressed_fn
);
217 input_event(input
, usage
->type
, trans
->to
, value
);
223 if (test_bit(usage
->code
, hid
->pb_pressed_numlock
) ||
224 test_bit(LED_NUML
, input
->led
)) {
225 trans
= find_translation(powerbook_numlock_keys
, usage
->code
);
229 set_bit(usage
->code
, hid
->pb_pressed_numlock
);
231 clear_bit(usage
->code
, hid
->pb_pressed_numlock
);
233 input_event(input
, usage
->type
, trans
->to
, value
);
240 if (hid
->quirks
& HID_QUIRK_APPLE_ISO_KEYBOARD
) {
241 trans
= find_translation(apple_iso_keyboard
, usage
->code
);
243 input_event(input
, usage
->type
, trans
->to
, value
);
251 static void hidinput_apple_setup(struct input_dev
*input
)
253 struct hidinput_key_translation
*trans
;
255 set_bit(KEY_NUMLOCK
, input
->keybit
);
257 /* Enable all needed keys */
258 for (trans
= apple_fn_keys
; trans
->from
; trans
++)
259 set_bit(trans
->to
, input
->keybit
);
261 for (trans
= powerbook_fn_keys
; trans
->from
; trans
++)
262 set_bit(trans
->to
, input
->keybit
);
264 for (trans
= powerbook_numlock_keys
; trans
->from
; trans
++)
265 set_bit(trans
->to
, input
->keybit
);
267 for (trans
= apple_iso_keyboard
; trans
->from
; trans
++)
268 set_bit(trans
->to
, input
->keybit
);
272 static inline int hidinput_apple_event(struct hid_device
*hid
,
273 struct input_dev
*input
,
274 struct hid_usage
*usage
, __s32 value
)
279 static inline void hidinput_apple_setup(struct input_dev
*input
)
284 static inline int match_scancode(int code
, int scancode
)
288 return ((code
& (HID_USAGE_PAGE
| HID_USAGE
)) == scancode
);
291 static inline int match_keycode(int code
, int keycode
)
295 return (code
== keycode
);
298 static struct hid_usage
*hidinput_find_key(struct hid_device
*hid
,
299 int scancode
, int keycode
)
302 struct hid_report
*report
;
303 struct hid_usage
*usage
;
305 for (k
= HID_INPUT_REPORT
; k
<= HID_OUTPUT_REPORT
; k
++) {
306 list_for_each_entry(report
, &hid
->report_enum
[k
].report_list
, list
) {
307 for (i
= 0; i
< report
->maxfield
; i
++) {
308 for ( j
= 0; j
< report
->field
[i
]->maxusage
; j
++) {
309 usage
= report
->field
[i
]->usage
+ j
;
310 if (usage
->type
== EV_KEY
&&
311 match_scancode(usage
->hid
, scancode
) &&
312 match_keycode(usage
->code
, keycode
))
321 static int hidinput_getkeycode(struct input_dev
*dev
, int scancode
,
324 struct hid_device
*hid
= input_get_drvdata(dev
);
325 struct hid_usage
*usage
;
327 usage
= hidinput_find_key(hid
, scancode
, 0);
329 *keycode
= usage
->code
;
335 static int hidinput_setkeycode(struct input_dev
*dev
, int scancode
,
338 struct hid_device
*hid
= input_get_drvdata(dev
);
339 struct hid_usage
*usage
;
342 if (keycode
< 0 || keycode
> KEY_MAX
)
345 usage
= hidinput_find_key(hid
, scancode
, 0);
347 old_keycode
= usage
->code
;
348 usage
->code
= keycode
;
350 clear_bit(old_keycode
, dev
->keybit
);
351 set_bit(usage
->code
, dev
->keybit
);
352 dbg_hid(KERN_DEBUG
"Assigned keycode %d to HID usage code %x\n", keycode
, scancode
);
353 /* Set the keybit for the old keycode if the old keycode is used
355 if (hidinput_find_key (hid
, 0, old_keycode
))
356 set_bit(old_keycode
, dev
->keybit
);
365 static void hidinput_configure_usage(struct hid_input
*hidinput
, struct hid_field
*field
,
366 struct hid_usage
*usage
)
368 struct input_dev
*input
= hidinput
->input
;
369 struct hid_device
*device
= input_get_drvdata(input
);
371 unsigned long *bit
= NULL
;
373 field
->hidinput
= hidinput
;
375 dbg_hid("Mapping: ");
376 hid_resolv_usage(usage
->hid
);
377 dbg_hid_line(" ---> ");
379 if (field
->flags
& HID_MAIN_ITEM_CONSTANT
)
382 /* only LED usages are supported in output fields */
383 if (field
->report_type
== HID_OUTPUT_REPORT
&&
384 (usage
->hid
& HID_USAGE_PAGE
) != HID_UP_LED
) {
385 dbg_hid_line(" [non-LED output field] ");
389 switch (usage
->hid
& HID_USAGE_PAGE
) {
391 case HID_UP_UNDEFINED
:
394 case HID_UP_KEYBOARD
:
396 set_bit(EV_REP
, input
->evbit
);
398 if ((usage
->hid
& HID_USAGE
) < 256) {
399 if (!hid_keyboard
[usage
->hid
& HID_USAGE
]) goto ignore
;
400 map_key_clear(hid_keyboard
[usage
->hid
& HID_USAGE
]);
402 map_key(KEY_UNKNOWN
);
408 code
= ((usage
->hid
- 1) & 0xf);
410 switch (field
->application
) {
412 case HID_GD_POINTER
: code
+= 0x110; break;
413 case HID_GD_JOYSTICK
: code
+= 0x120; break;
414 case HID_GD_GAMEPAD
: code
+= 0x130; break;
416 switch (field
->physical
) {
418 case HID_GD_POINTER
: code
+= 0x110; break;
419 case HID_GD_JOYSTICK
: code
+= 0x120; break;
420 case HID_GD_GAMEPAD
: code
+= 0x130; break;
421 default: code
+= 0x100;
425 /* Special handling for Logitech Cordless Desktop */
426 if (field
->application
!= HID_GD_MOUSE
) {
427 if (device
->quirks
& HID_QUIRK_LOGITECH_EXPANDED_KEYMAP
) {
428 int hid
= usage
->hid
& HID_USAGE
;
429 if (hid
< LOGITECH_EXPANDED_KEYMAP_SIZE
&& logitech_expanded_keymap
[hid
] != 0)
430 code
= logitech_expanded_keymap
[hid
];
433 if (device
->quirks
& HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL
) {
434 int hid
= usage
->hid
& HID_USAGE
;
435 if (hid
== 7 || hid
== 8)
444 case HID_UP_SIMULATION
:
446 switch (usage
->hid
& 0xffff) {
447 case 0xba: map_abs(ABS_RUDDER
); break;
448 case 0xbb: map_abs(ABS_THROTTLE
); break;
449 case 0xc4: map_abs(ABS_GAS
); break;
450 case 0xc5: map_abs(ABS_BRAKE
); break;
451 case 0xc8: map_abs(ABS_WHEEL
); break;
452 default: goto ignore
;
458 if ((usage
->hid
& 0xf0) == 0x80) { /* SystemControl */
459 switch (usage
->hid
& 0xf) {
460 case 0x1: map_key_clear(KEY_POWER
); break;
461 case 0x2: map_key_clear(KEY_SLEEP
); break;
462 case 0x3: map_key_clear(KEY_WAKEUP
); break;
463 default: goto unknown
;
468 if ((usage
->hid
& 0xf0) == 0x90) { /* D-pad */
469 switch (usage
->hid
) {
470 case HID_GD_UP
: usage
->hat_dir
= 1; break;
471 case HID_GD_DOWN
: usage
->hat_dir
= 5; break;
472 case HID_GD_RIGHT
: usage
->hat_dir
= 3; break;
473 case HID_GD_LEFT
: usage
->hat_dir
= 7; break;
474 default: goto unknown
;
477 map_abs(field
->dpad
);
484 switch (usage
->hid
) {
486 /* These usage IDs map directly to the usage codes. */
487 case HID_GD_X
: case HID_GD_Y
: case HID_GD_Z
:
488 case HID_GD_RX
: case HID_GD_RY
: case HID_GD_RZ
:
489 case HID_GD_SLIDER
: case HID_GD_DIAL
: case HID_GD_WHEEL
:
490 if (field
->flags
& HID_MAIN_ITEM_RELATIVE
)
491 map_rel(usage
->hid
& 0xf);
493 map_abs(usage
->hid
& 0xf);
496 case HID_GD_HATSWITCH
:
497 usage
->hat_min
= field
->logical_minimum
;
498 usage
->hat_max
= field
->logical_maximum
;
502 case HID_GD_START
: map_key_clear(BTN_START
); break;
503 case HID_GD_SELECT
: map_key_clear(BTN_SELECT
); break;
505 default: goto unknown
;
512 switch (usage
->hid
& 0xffff) { /* HID-Value: */
513 case 0x01: map_led (LED_NUML
); break; /* "Num Lock" */
514 case 0x02: map_led (LED_CAPSL
); break; /* "Caps Lock" */
515 case 0x03: map_led (LED_SCROLLL
); break; /* "Scroll Lock" */
516 case 0x04: map_led (LED_COMPOSE
); break; /* "Compose" */
517 case 0x05: map_led (LED_KANA
); break; /* "Kana" */
518 case 0x27: map_led (LED_SLEEP
); break; /* "Stand-By" */
519 case 0x4c: map_led (LED_SUSPEND
); break; /* "System Suspend" */
520 case 0x09: map_led (LED_MUTE
); break; /* "Mute" */
521 case 0x4b: map_led (LED_MISC
); break; /* "Generic Indicator" */
522 case 0x19: map_led (LED_MAIL
); break; /* "Message Waiting" */
523 case 0x4d: map_led (LED_CHARGING
); break; /* "External Power Connected" */
525 default: goto ignore
;
529 case HID_UP_DIGITIZER
:
531 switch (usage
->hid
& 0xff) {
533 case 0x30: /* TipPressure */
534 if (!test_bit(BTN_TOUCH
, input
->keybit
)) {
535 device
->quirks
|= HID_QUIRK_NOTOUCH
;
536 set_bit(EV_KEY
, input
->evbit
);
537 set_bit(BTN_TOUCH
, input
->keybit
);
540 map_abs_clear(ABS_PRESSURE
);
543 case 0x32: /* InRange */
544 switch (field
->physical
& 0xff) {
545 case 0x21: map_key(BTN_TOOL_MOUSE
); break;
546 case 0x22: map_key(BTN_TOOL_FINGER
); break;
547 default: map_key(BTN_TOOL_PEN
); break;
551 case 0x3c: /* Invert */
552 map_key_clear(BTN_TOOL_RUBBER
);
555 case 0x33: /* Touch */
556 case 0x42: /* TipSwitch */
557 case 0x43: /* TipSwitch2 */
558 device
->quirks
&= ~HID_QUIRK_NOTOUCH
;
559 map_key_clear(BTN_TOUCH
);
562 case 0x44: /* BarrelSwitch */
563 map_key_clear(BTN_STYLUS
);
566 default: goto unknown
;
570 case HID_UP_CONSUMER
: /* USB HUT v1.1, pages 56-62 */
572 switch (usage
->hid
& HID_USAGE
) {
573 case 0x000: goto ignore
;
574 case 0x034: map_key_clear(KEY_SLEEP
); break;
575 case 0x036: map_key_clear(BTN_MISC
); break;
577 * The next three are reported by Belkin wireless
578 * keyboard (1020:0006). These values are "reserved"
581 case 0x03a: map_key_clear(KEY_SOUND
); break;
582 case 0x03b: map_key_clear(KEY_CAMERA
); break;
583 case 0x03c: map_key_clear(KEY_DOCUMENTS
); break;
585 case 0x040: map_key_clear(KEY_MENU
); break;
586 case 0x045: map_key_clear(KEY_RADIO
); break;
588 case 0x083: map_key_clear(KEY_LAST
); break;
589 case 0x088: map_key_clear(KEY_PC
); break;
590 case 0x089: map_key_clear(KEY_TV
); break;
591 case 0x08a: map_key_clear(KEY_WWW
); break;
592 case 0x08b: map_key_clear(KEY_DVD
); break;
593 case 0x08c: map_key_clear(KEY_PHONE
); break;
594 case 0x08d: map_key_clear(KEY_PROGRAM
); break;
595 case 0x08e: map_key_clear(KEY_VIDEOPHONE
); break;
596 case 0x08f: map_key_clear(KEY_GAMES
); break;
597 case 0x090: map_key_clear(KEY_MEMO
); break;
598 case 0x091: map_key_clear(KEY_CD
); break;
599 case 0x092: map_key_clear(KEY_VCR
); break;
600 case 0x093: map_key_clear(KEY_TUNER
); break;
601 case 0x094: map_key_clear(KEY_EXIT
); break;
602 case 0x095: map_key_clear(KEY_HELP
); break;
603 case 0x096: map_key_clear(KEY_TAPE
); break;
604 case 0x097: map_key_clear(KEY_TV2
); break;
605 case 0x098: map_key_clear(KEY_SAT
); break;
606 case 0x09a: map_key_clear(KEY_PVR
); break;
608 case 0x09c: map_key_clear(KEY_CHANNELUP
); break;
609 case 0x09d: map_key_clear(KEY_CHANNELDOWN
); break;
610 case 0x0a0: map_key_clear(KEY_VCR2
); break;
612 case 0x0b0: map_key_clear(KEY_PLAY
); break;
613 case 0x0b1: map_key_clear(KEY_PAUSE
); break;
614 case 0x0b2: map_key_clear(KEY_RECORD
); break;
615 case 0x0b3: map_key_clear(KEY_FASTFORWARD
); break;
616 case 0x0b4: map_key_clear(KEY_REWIND
); break;
617 case 0x0b5: map_key_clear(KEY_NEXTSONG
); break;
618 case 0x0b6: map_key_clear(KEY_PREVIOUSSONG
); break;
619 case 0x0b7: map_key_clear(KEY_STOPCD
); break;
620 case 0x0b8: map_key_clear(KEY_EJECTCD
); break;
622 case 0x0cd: map_key_clear(KEY_PLAYPAUSE
); break;
623 case 0x0e0: map_abs_clear(ABS_VOLUME
); break;
624 case 0x0e2: map_key_clear(KEY_MUTE
); break;
625 case 0x0e5: map_key_clear(KEY_BASSBOOST
); break;
626 case 0x0e9: map_key_clear(KEY_VOLUMEUP
); break;
627 case 0x0ea: map_key_clear(KEY_VOLUMEDOWN
); break;
629 /* reserved in HUT 1.12. Reported on Petalynx remote */
630 case 0x0f6: map_key_clear(KEY_NEXT
); break;
631 case 0x0fa: map_key_clear(KEY_BACK
); break;
633 case 0x182: map_key_clear(KEY_BOOKMARKS
); break;
634 case 0x183: map_key_clear(KEY_CONFIG
); break;
635 case 0x184: map_key_clear(KEY_WORDPROCESSOR
); break;
636 case 0x185: map_key_clear(KEY_EDITOR
); break;
637 case 0x186: map_key_clear(KEY_SPREADSHEET
); break;
638 case 0x187: map_key_clear(KEY_GRAPHICSEDITOR
); break;
639 case 0x188: map_key_clear(KEY_PRESENTATION
); break;
640 case 0x189: map_key_clear(KEY_DATABASE
); break;
641 case 0x18a: map_key_clear(KEY_MAIL
); break;
642 case 0x18b: map_key_clear(KEY_NEWS
); break;
643 case 0x18c: map_key_clear(KEY_VOICEMAIL
); break;
644 case 0x18d: map_key_clear(KEY_ADDRESSBOOK
); break;
645 case 0x18e: map_key_clear(KEY_CALENDAR
); break;
646 case 0x191: map_key_clear(KEY_FINANCE
); break;
647 case 0x192: map_key_clear(KEY_CALC
); break;
648 case 0x194: map_key_clear(KEY_FILE
); break;
649 case 0x196: map_key_clear(KEY_WWW
); break;
650 case 0x19c: map_key_clear(KEY_LOGOFF
); break;
651 case 0x19e: map_key_clear(KEY_COFFEE
); break;
652 case 0x1a6: map_key_clear(KEY_HELP
); break;
653 case 0x1a7: map_key_clear(KEY_DOCUMENTS
); break;
654 case 0x1ab: map_key_clear(KEY_SPELLCHECK
); break;
655 case 0x1b6: map_key_clear(KEY_MEDIA
); break;
656 case 0x1b7: map_key_clear(KEY_SOUND
); break;
657 case 0x1bc: map_key_clear(KEY_MESSENGER
); break;
658 case 0x1bd: map_key_clear(KEY_INFO
); break;
659 case 0x201: map_key_clear(KEY_NEW
); break;
660 case 0x202: map_key_clear(KEY_OPEN
); break;
661 case 0x203: map_key_clear(KEY_CLOSE
); break;
662 case 0x204: map_key_clear(KEY_EXIT
); break;
663 case 0x207: map_key_clear(KEY_SAVE
); break;
664 case 0x208: map_key_clear(KEY_PRINT
); break;
665 case 0x209: map_key_clear(KEY_PROPS
); break;
666 case 0x21a: map_key_clear(KEY_UNDO
); break;
667 case 0x21b: map_key_clear(KEY_COPY
); break;
668 case 0x21c: map_key_clear(KEY_CUT
); break;
669 case 0x21d: map_key_clear(KEY_PASTE
); break;
670 case 0x21f: map_key_clear(KEY_FIND
); break;
671 case 0x221: map_key_clear(KEY_SEARCH
); break;
672 case 0x222: map_key_clear(KEY_GOTO
); break;
673 case 0x223: map_key_clear(KEY_HOMEPAGE
); break;
674 case 0x224: map_key_clear(KEY_BACK
); break;
675 case 0x225: map_key_clear(KEY_FORWARD
); break;
676 case 0x226: map_key_clear(KEY_STOP
); break;
677 case 0x227: map_key_clear(KEY_REFRESH
); break;
678 case 0x22a: map_key_clear(KEY_BOOKMARKS
); break;
679 case 0x22d: map_key_clear(KEY_ZOOMIN
); break;
680 case 0x22e: map_key_clear(KEY_ZOOMOUT
); break;
681 case 0x22f: map_key_clear(KEY_ZOOMRESET
); break;
682 case 0x233: map_key_clear(KEY_SCROLLUP
); break;
683 case 0x234: map_key_clear(KEY_SCROLLDOWN
); break;
684 case 0x238: map_rel(REL_HWHEEL
); break;
685 case 0x25f: map_key_clear(KEY_CANCEL
); break;
686 case 0x279: map_key_clear(KEY_REDO
); break;
688 case 0x289: map_key_clear(KEY_REPLY
); break;
689 case 0x28b: map_key_clear(KEY_FORWARDMAIL
); break;
690 case 0x28c: map_key_clear(KEY_SEND
); break;
692 /* Reported on a Cherry Cymotion keyboard */
693 case 0x301: map_key_clear(KEY_PROG1
); break;
694 case 0x302: map_key_clear(KEY_PROG2
); break;
695 case 0x303: map_key_clear(KEY_PROG3
); break;
697 /* Reported on certain Logitech wireless keyboards */
698 case 0x1001: map_key_clear(KEY_MESSENGER
); break;
699 case 0x1003: map_key_clear(KEY_SOUND
); break;
700 case 0x1004: map_key_clear(KEY_VIDEO
); break;
701 case 0x1005: map_key_clear(KEY_AUDIO
); break;
702 case 0x100a: map_key_clear(KEY_DOCUMENTS
); break;
703 case 0x1011: map_key_clear(KEY_PREVIOUSSONG
); break;
704 case 0x1012: map_key_clear(KEY_NEXTSONG
); break;
705 case 0x1013: map_key_clear(KEY_CAMERA
); break;
706 case 0x1014: map_key_clear(KEY_MESSENGER
); break;
707 case 0x1015: map_key_clear(KEY_RECORD
); break;
708 case 0x1016: map_key_clear(KEY_PLAYER
); break;
709 case 0x1017: map_key_clear(KEY_EJECTCD
); break;
710 case 0x1018: map_key_clear(KEY_MEDIA
); break;
711 case 0x1019: map_key_clear(KEY_PROG1
); break;
712 case 0x101a: map_key_clear(KEY_PROG2
); break;
713 case 0x101b: map_key_clear(KEY_PROG3
); break;
714 case 0x101f: map_key_clear(KEY_ZOOMIN
); break;
715 case 0x1020: map_key_clear(KEY_ZOOMOUT
); break;
716 case 0x1021: map_key_clear(KEY_ZOOMRESET
); break;
717 case 0x1023: map_key_clear(KEY_CLOSE
); break;
718 case 0x1027: map_key_clear(KEY_MENU
); break;
719 /* this one is marked as 'Rotate' */
720 case 0x1028: map_key_clear(KEY_ANGLE
); break;
721 case 0x1029: map_key_clear(KEY_SHUFFLE
); break;
722 case 0x102a: map_key_clear(KEY_BACK
); break;
723 case 0x102b: map_key_clear(KEY_CYCLEWINDOWS
); break;
724 case 0x1041: map_key_clear(KEY_BATTERY
); break;
725 case 0x1042: map_key_clear(KEY_WORDPROCESSOR
); break;
726 case 0x1043: map_key_clear(KEY_SPREADSHEET
); break;
727 case 0x1044: map_key_clear(KEY_PRESENTATION
); break;
728 case 0x1045: map_key_clear(KEY_UNDO
); break;
729 case 0x1046: map_key_clear(KEY_REDO
); break;
730 case 0x1047: map_key_clear(KEY_PRINT
); break;
731 case 0x1048: map_key_clear(KEY_SAVE
); break;
732 case 0x1049: map_key_clear(KEY_PROG1
); break;
733 case 0x104a: map_key_clear(KEY_PROG2
); break;
734 case 0x104b: map_key_clear(KEY_PROG3
); break;
735 case 0x104c: map_key_clear(KEY_PROG4
); break;
737 default: goto ignore
;
741 case HID_UP_HPVENDOR
: /* Reported on a Dutch layout HP5308 */
743 set_bit(EV_REP
, input
->evbit
);
744 switch (usage
->hid
& HID_USAGE
) {
745 case 0x021: map_key_clear(KEY_PRINT
); break;
746 case 0x070: map_key_clear(KEY_HP
); break;
747 case 0x071: map_key_clear(KEY_CAMERA
); break;
748 case 0x072: map_key_clear(KEY_SOUND
); break;
749 case 0x073: map_key_clear(KEY_QUESTION
); break;
750 case 0x080: map_key_clear(KEY_EMAIL
); break;
751 case 0x081: map_key_clear(KEY_CHAT
); break;
752 case 0x082: map_key_clear(KEY_SEARCH
); break;
753 case 0x083: map_key_clear(KEY_CONNECT
); break;
754 case 0x084: map_key_clear(KEY_FINANCE
); break;
755 case 0x085: map_key_clear(KEY_SPORT
); break;
756 case 0x086: map_key_clear(KEY_SHOP
); break;
757 default: goto ignore
;
761 case HID_UP_MSVENDOR
:
763 /* Unfortunately, there are multiple devices which
764 * emit usages from MSVENDOR page that require different
765 * handling. If this list grows too much in the future,
766 * more general handling will have to be introduced here
767 * (i.e. another blacklist).
770 /* Chicony Chicony KU-0418 tactical pad */
771 if (IS_CHICONY_TACTICAL_PAD(device
)) {
772 set_bit(EV_REP
, input
->evbit
);
773 switch(usage
->hid
& HID_USAGE
) {
774 case 0xff01: map_key_clear(BTN_1
); break;
775 case 0xff02: map_key_clear(BTN_2
); break;
776 case 0xff03: map_key_clear(BTN_3
); break;
777 case 0xff04: map_key_clear(BTN_4
); break;
778 case 0xff05: map_key_clear(BTN_5
); break;
779 case 0xff06: map_key_clear(BTN_6
); break;
780 case 0xff07: map_key_clear(BTN_7
); break;
781 case 0xff08: map_key_clear(BTN_8
); break;
782 case 0xff09: map_key_clear(BTN_9
); break;
783 case 0xff0a: map_key_clear(BTN_A
); break;
784 case 0xff0b: map_key_clear(BTN_B
); break;
785 default: goto ignore
;
788 /* Microsoft Natural Ergonomic Keyboard 4000 */
789 } else if (IS_MS_KB(device
)) {
790 switch(usage
->hid
& HID_USAGE
) {
792 map_key_clear(KEY_CHAT
);
795 map_key_clear(KEY_PHONE
);
798 set_bit(EV_REP
, input
->evbit
);
799 map_key_clear(KEY_F13
);
800 set_bit(KEY_F14
, input
->keybit
);
801 set_bit(KEY_F15
, input
->keybit
);
802 set_bit(KEY_F16
, input
->keybit
);
803 set_bit(KEY_F17
, input
->keybit
);
804 set_bit(KEY_F18
, input
->keybit
);
805 default: goto ignore
;
808 /* Microsoft Wireless Notebook Presenter Mouse 8000 */
809 } else if (IS_MS_PRESENTER_8000(device
)) {
810 set_bit(EV_REP
, input
->evbit
);
811 switch(usage
->hid
& HID_USAGE
) {
812 /* Useful mappings of bottom-side keys for presentations */
813 case 0xfd08: map_key_clear(KEY_RIGHT
); break;
814 case 0xfd09: map_key_clear(KEY_LEFT
); break;
815 case 0xfd0b: map_key_clear(KEY_PAUSE
); break;
816 case 0xfd0f: map_key_clear(KEY_F5
); break;
817 default: goto ignore
;
823 case HID_UP_CUSTOM
: /* Reported on Logitech and Apple USB keyboards */
825 set_bit(EV_REP
, input
->evbit
);
826 switch(usage
->hid
& HID_USAGE
) {
828 /* The fn key on Apple USB keyboards */
829 map_key_clear(KEY_FN
);
830 hidinput_apple_setup(input
);
833 default: goto ignore
;
837 case HID_UP_LOGIVENDOR
:
838 set_bit(EV_REP
, input
->evbit
);
839 switch(usage
->hid
& HID_USAGE
) {
840 /* Reported on Logitech Ultra X Media Remote */
841 case 0x004: map_key_clear(KEY_AGAIN
); break;
842 case 0x00d: map_key_clear(KEY_HOME
); break;
843 case 0x024: map_key_clear(KEY_SHUFFLE
); break;
844 case 0x025: map_key_clear(KEY_TV
); break;
845 case 0x026: map_key_clear(KEY_MENU
); break;
846 case 0x031: map_key_clear(KEY_AUDIO
); break;
847 case 0x032: map_key_clear(KEY_TEXT
); break;
848 case 0x033: map_key_clear(KEY_LAST
); break;
849 case 0x047: map_key_clear(KEY_MP3
); break;
850 case 0x048: map_key_clear(KEY_DVD
); break;
851 case 0x049: map_key_clear(KEY_MEDIA
); break;
852 case 0x04a: map_key_clear(KEY_VIDEO
); break;
853 case 0x04b: map_key_clear(KEY_ANGLE
); break;
854 case 0x04c: map_key_clear(KEY_LANGUAGE
); break;
855 case 0x04d: map_key_clear(KEY_SUBTITLE
); break;
856 case 0x051: map_key_clear(KEY_RED
); break;
857 case 0x052: map_key_clear(KEY_CLOSE
); break;
859 /* Reported on Petalynx Maxter remote */
860 case 0x05a: map_key_clear(KEY_TEXT
); break;
861 case 0x05b: map_key_clear(KEY_RED
); break;
862 case 0x05c: map_key_clear(KEY_GREEN
); break;
863 case 0x05d: map_key_clear(KEY_YELLOW
); break;
864 case 0x05e: map_key_clear(KEY_BLUE
); break;
866 default: goto ignore
;
872 switch(usage
->hid
& HID_USAGE
) {
873 case 0xa4: map_key_clear(BTN_DEAD
); break;
874 default: goto ignore
;
880 if (field
->report_size
== 1) {
881 if (field
->report
->type
== HID_OUTPUT_REPORT
) {
888 if (field
->flags
& HID_MAIN_ITEM_RELATIVE
) {
896 if (device
->quirks
& HID_QUIRK_MIGHTYMOUSE
) {
897 if (usage
->hid
== HID_GD_Z
)
899 else if (usage
->code
== BTN_1
)
901 else if (usage
->code
== BTN_2
)
905 if ((device
->quirks
& (HID_QUIRK_2WHEEL_MOUSE_HACK_7
| HID_QUIRK_2WHEEL_MOUSE_HACK_5
)) &&
906 (usage
->type
== EV_REL
) && (usage
->code
== REL_WHEEL
))
907 set_bit(REL_HWHEEL
, bit
);
909 if (((device
->quirks
& HID_QUIRK_2WHEEL_MOUSE_HACK_5
) && (usage
->hid
== 0x00090005))
910 || ((device
->quirks
& HID_QUIRK_2WHEEL_MOUSE_HACK_7
) && (usage
->hid
== 0x00090007)))
913 if ((device
->quirks
& HID_QUIRK_BAD_RELATIVE_KEYS
) &&
914 usage
->type
== EV_KEY
&& (field
->flags
& HID_MAIN_ITEM_RELATIVE
))
915 field
->flags
&= ~HID_MAIN_ITEM_RELATIVE
;
917 set_bit(usage
->type
, input
->evbit
);
919 if (device
->quirks
& HID_QUIRK_DUPLICATE_USAGES
&&
920 (usage
->type
== EV_KEY
||
921 usage
->type
== EV_REL
||
922 usage
->type
== EV_ABS
))
923 clear_bit(usage
->code
, bit
);
925 while (usage
->code
<= max
&& test_and_set_bit(usage
->code
, bit
))
926 usage
->code
= find_next_zero_bit(bit
, max
+ 1, usage
->code
);
928 if (usage
->code
> max
)
932 if (usage
->type
== EV_ABS
) {
934 int a
= field
->logical_minimum
;
935 int b
= field
->logical_maximum
;
937 if ((device
->quirks
& HID_QUIRK_BADPAD
) && (usage
->code
== ABS_X
|| usage
->code
== ABS_Y
)) {
938 a
= field
->logical_minimum
= 0;
939 b
= field
->logical_maximum
= 255;
942 if (field
->application
== HID_GD_GAMEPAD
|| field
->application
== HID_GD_JOYSTICK
)
943 input_set_abs_params(input
, usage
->code
, a
, b
, (b
- a
) >> 8, (b
- a
) >> 4);
944 else input_set_abs_params(input
, usage
->code
, a
, b
, 0, 0);
948 if (usage
->type
== EV_ABS
&&
949 (usage
->hat_min
< usage
->hat_max
|| usage
->hat_dir
)) {
951 for (i
= usage
->code
; i
< usage
->code
+ 2 && i
<= max
; i
++) {
952 input_set_abs_params(input
, i
, -1, 1, 0, 0);
953 set_bit(i
, input
->absbit
);
955 if (usage
->hat_dir
&& !field
->dpad
)
956 field
->dpad
= usage
->code
;
959 /* for those devices which produce Consumer volume usage as relative,
960 * we emulate pressing volumeup/volumedown appropriate number of times
961 * in hidinput_hid_event()
963 if ((usage
->type
== EV_ABS
) && (field
->flags
& HID_MAIN_ITEM_RELATIVE
) &&
964 (usage
->code
== ABS_VOLUME
)) {
965 set_bit(KEY_VOLUMEUP
, input
->keybit
);
966 set_bit(KEY_VOLUMEDOWN
, input
->keybit
);
969 if (usage
->type
== EV_KEY
) {
970 set_bit(EV_MSC
, input
->evbit
);
971 set_bit(MSC_SCAN
, input
->mscbit
);
974 hid_resolv_event(usage
->type
, usage
->code
);
981 dbg_hid_line("IGNORED\n");
985 void hidinput_hid_event(struct hid_device
*hid
, struct hid_field
*field
, struct hid_usage
*usage
, __s32 value
)
987 struct input_dev
*input
;
988 unsigned *quirks
= &hid
->quirks
;
990 if (!field
->hidinput
)
993 input
= field
->hidinput
->input
;
998 if (((hid
->quirks
& HID_QUIRK_2WHEEL_MOUSE_HACK_5
) && (usage
->hid
== 0x00090005))
999 || ((hid
->quirks
& HID_QUIRK_2WHEEL_MOUSE_HACK_7
) && (usage
->hid
== 0x00090007))) {
1000 if (value
) hid
->quirks
|= HID_QUIRK_2WHEEL_MOUSE_HACK_ON
;
1001 else hid
->quirks
&= ~HID_QUIRK_2WHEEL_MOUSE_HACK_ON
;
1005 if ((hid
->quirks
& HID_QUIRK_INVERT_HWHEEL
) && (usage
->code
== REL_HWHEEL
)) {
1006 input_event(input
, usage
->type
, usage
->code
, -value
);
1010 if ((hid
->quirks
& HID_QUIRK_2WHEEL_MOUSE_HACK_ON
) && (usage
->code
== REL_WHEEL
)) {
1011 input_event(input
, usage
->type
, REL_HWHEEL
, value
);
1015 if ((hid
->quirks
& HID_QUIRK_APPLE_HAS_FN
) && hidinput_apple_event(hid
, input
, usage
, value
))
1018 if (usage
->hat_min
< usage
->hat_max
|| usage
->hat_dir
) {
1019 int hat_dir
= usage
->hat_dir
;
1021 hat_dir
= (value
- usage
->hat_min
) * 8 / (usage
->hat_max
- usage
->hat_min
+ 1) + 1;
1022 if (hat_dir
< 0 || hat_dir
> 8) hat_dir
= 0;
1023 input_event(input
, usage
->type
, usage
->code
, hid_hat_to_axis
[hat_dir
].x
);
1024 input_event(input
, usage
->type
, usage
->code
+ 1, hid_hat_to_axis
[hat_dir
].y
);
1028 if (usage
->hid
== (HID_UP_DIGITIZER
| 0x003c)) { /* Invert */
1029 *quirks
= value
? (*quirks
| HID_QUIRK_INVERT
) : (*quirks
& ~HID_QUIRK_INVERT
);
1033 if (usage
->hid
== (HID_UP_DIGITIZER
| 0x0032)) { /* InRange */
1035 input_event(input
, usage
->type
, (*quirks
& HID_QUIRK_INVERT
) ? BTN_TOOL_RUBBER
: usage
->code
, 1);
1038 input_event(input
, usage
->type
, usage
->code
, 0);
1039 input_event(input
, usage
->type
, BTN_TOOL_RUBBER
, 0);
1043 if (usage
->hid
== (HID_UP_DIGITIZER
| 0x0030) && (*quirks
& HID_QUIRK_NOTOUCH
)) { /* Pressure */
1044 int a
= field
->logical_minimum
;
1045 int b
= field
->logical_maximum
;
1046 input_event(input
, EV_KEY
, BTN_TOUCH
, value
> a
+ ((b
- a
) >> 3));
1049 if (usage
->hid
== (HID_UP_PID
| 0x83UL
)) { /* Simultaneous Effects Max */
1050 dbg_hid("Maximum Effects - %d\n",value
);
1054 if (usage
->hid
== (HID_UP_PID
| 0x7fUL
)) {
1055 dbg_hid("PID Pool Report\n");
1059 if ((usage
->type
== EV_KEY
) && (usage
->code
== 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
1062 if ((usage
->type
== EV_ABS
) && (field
->flags
& HID_MAIN_ITEM_RELATIVE
) &&
1063 (usage
->code
== ABS_VOLUME
)) {
1064 int count
= abs(value
);
1065 int direction
= value
> 0 ? KEY_VOLUMEUP
: KEY_VOLUMEDOWN
;
1068 for (i
= 0; i
< count
; i
++) {
1069 input_event(input
, EV_KEY
, direction
, 1);
1071 input_event(input
, EV_KEY
, direction
, 0);
1077 /* Handling MS keyboards special buttons */
1078 if (IS_MS_KB(hid
) && usage
->hid
== (HID_UP_MSVENDOR
| 0xff05)) {
1080 static int last_key
= 0;
1082 case 0x01: key
= KEY_F14
; break;
1083 case 0x02: key
= KEY_F15
; break;
1084 case 0x04: key
= KEY_F16
; break;
1085 case 0x08: key
= KEY_F17
; break;
1086 case 0x10: key
= KEY_F18
; break;
1090 input_event(input
, usage
->type
, key
, 1);
1093 input_event(input
, usage
->type
, last_key
, 0);
1096 /* report the usage code as scancode if the key status has changed */
1097 if (usage
->type
== EV_KEY
&& !!test_bit(usage
->code
, input
->key
) != value
)
1098 input_event(input
, EV_MSC
, MSC_SCAN
, usage
->hid
);
1100 input_event(input
, usage
->type
, usage
->code
, value
);
1102 if ((field
->flags
& HID_MAIN_ITEM_RELATIVE
) && (usage
->type
== EV_KEY
))
1103 input_event(input
, usage
->type
, usage
->code
, 0);
1106 void hidinput_report_event(struct hid_device
*hid
, struct hid_report
*report
)
1108 struct hid_input
*hidinput
;
1110 list_for_each_entry(hidinput
, &hid
->inputs
, list
)
1111 input_sync(hidinput
->input
);
1113 EXPORT_SYMBOL_GPL(hidinput_report_event
);
1115 int hidinput_find_field(struct hid_device
*hid
, unsigned int type
, unsigned int code
, struct hid_field
**field
)
1117 struct hid_report
*report
;
1120 list_for_each_entry(report
, &hid
->report_enum
[HID_OUTPUT_REPORT
].report_list
, list
) {
1121 for (i
= 0; i
< report
->maxfield
; i
++) {
1122 *field
= report
->field
[i
];
1123 for (j
= 0; j
< (*field
)->maxusage
; j
++)
1124 if ((*field
)->usage
[j
].type
== type
&& (*field
)->usage
[j
].code
== code
)
1130 EXPORT_SYMBOL_GPL(hidinput_find_field
);
1132 static int hidinput_open(struct input_dev
*dev
)
1134 struct hid_device
*hid
= input_get_drvdata(dev
);
1136 return hid
->hid_open(hid
);
1139 static void hidinput_close(struct input_dev
*dev
)
1141 struct hid_device
*hid
= input_get_drvdata(dev
);
1143 hid
->hid_close(hid
);
1147 * Register the input device; print a message.
1148 * Configure the input layer interface
1149 * Read all reports and initialize the absolute field values.
1152 int hidinput_connect(struct hid_device
*hid
)
1154 struct hid_report
*report
;
1155 struct hid_input
*hidinput
= NULL
;
1156 struct input_dev
*input_dev
;
1158 int max_report_type
= HID_OUTPUT_REPORT
;
1160 if (hid
->quirks
& HID_QUIRK_IGNORE_HIDINPUT
)
1163 INIT_LIST_HEAD(&hid
->inputs
);
1165 for (i
= 0; i
< hid
->maxcollection
; i
++)
1166 if (hid
->collection
[i
].type
== HID_COLLECTION_APPLICATION
||
1167 hid
->collection
[i
].type
== HID_COLLECTION_PHYSICAL
)
1168 if (IS_INPUT_APPLICATION(hid
->collection
[i
].usage
))
1171 if (i
== hid
->maxcollection
&& (hid
->quirks
& HID_QUIRK_HIDINPUT
) == 0)
1174 if (hid
->quirks
& HID_QUIRK_SKIP_OUTPUT_REPORTS
)
1175 max_report_type
= HID_INPUT_REPORT
;
1177 for (k
= HID_INPUT_REPORT
; k
<= max_report_type
; k
++)
1178 list_for_each_entry(report
, &hid
->report_enum
[k
].report_list
, list
) {
1180 if (!report
->maxfield
)
1184 hidinput
= kzalloc(sizeof(*hidinput
), GFP_KERNEL
);
1185 input_dev
= input_allocate_device();
1186 if (!hidinput
|| !input_dev
) {
1188 input_free_device(input_dev
);
1189 err_hid("Out of memory during hid input probe");
1193 input_set_drvdata(input_dev
, hid
);
1194 input_dev
->event
= hid
->hidinput_input_event
;
1195 input_dev
->open
= hidinput_open
;
1196 input_dev
->close
= hidinput_close
;
1197 input_dev
->setkeycode
= hidinput_setkeycode
;
1198 input_dev
->getkeycode
= hidinput_getkeycode
;
1200 input_dev
->name
= hid
->name
;
1201 input_dev
->phys
= hid
->phys
;
1202 input_dev
->uniq
= hid
->uniq
;
1203 input_dev
->id
.bustype
= hid
->bus
;
1204 input_dev
->id
.vendor
= hid
->vendor
;
1205 input_dev
->id
.product
= hid
->product
;
1206 input_dev
->id
.version
= hid
->version
;
1207 input_dev
->dev
.parent
= hid
->dev
;
1208 hidinput
->input
= input_dev
;
1209 list_add_tail(&hidinput
->list
, &hid
->inputs
);
1212 for (i
= 0; i
< report
->maxfield
; i
++)
1213 for (j
= 0; j
< report
->field
[i
]->maxusage
; j
++)
1214 hidinput_configure_usage(hidinput
, report
->field
[i
],
1215 report
->field
[i
]->usage
+ j
);
1217 if (hid
->quirks
& HID_QUIRK_MULTI_INPUT
) {
1218 /* This will leave hidinput NULL, so that it
1219 * allocates another one if we have more inputs on
1220 * the same interface. Some devices (e.g. Happ's
1221 * UGCI) cram a lot of unrelated inputs into the
1222 * same interface. */
1223 hidinput
->report
= report
;
1224 if (input_register_device(hidinput
->input
))
1230 if (hidinput
&& input_register_device(hidinput
->input
))
1236 input_free_device(hidinput
->input
);
1239 /* unwind the ones we already registered */
1240 hidinput_disconnect(hid
);
1244 EXPORT_SYMBOL_GPL(hidinput_connect
);
1246 void hidinput_disconnect(struct hid_device
*hid
)
1248 struct hid_input
*hidinput
, *next
;
1250 list_for_each_entry_safe(hidinput
, next
, &hid
->inputs
, list
) {
1251 list_del(&hidinput
->list
);
1252 input_unregister_device(hidinput
->input
);
1256 EXPORT_SYMBOL_GPL(hidinput_disconnect
);