2 * Copyright (c) 2000-2001 Vojtech Pavlik
3 * Copyright (c) 2006-2007 Jiri Kosina
5 * HID to Linux Input mapping
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 * Should you need to contact me, the author, you can do so either by
24 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
25 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
28 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <linux/kernel.h>
32 #include <linux/hid.h>
33 #include <linux/hid-debug.h>
35 static int hid_apple_fnmode
= 1;
36 module_param_named(pb_fnmode
, hid_apple_fnmode
, int, 0644);
37 MODULE_PARM_DESC(pb_fnmode
,
38 "Mode of fn key on Apple keyboards (0 = disabled, 1 = fkeyslast, 2 = fkeysfirst)");
40 #define unk KEY_UNKNOWN
42 static const unsigned char hid_keyboard
[256] = {
43 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
44 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44, 2, 3,
45 4, 5, 6, 7, 8, 9, 10, 11, 28, 1, 14, 15, 57, 12, 13, 26,
46 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
47 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
48 105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
49 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
50 191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
51 115,114,unk
,unk
,unk
,121,unk
, 89, 93,124, 92, 94, 95,unk
,unk
,unk
,
52 122,123, 90, 91, 85,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,
53 unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,
54 unk
,unk
,unk
,unk
,unk
,unk
,179,180,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
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,unk
,
57 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
58 150,158,159,128,136,177,178,176,142,152,173,140,unk
,unk
,unk
,unk
61 /* extended mapping for certain Logitech hardware (Logitech cordless desktop LX500) */
62 #define LOGITECH_EXPANDED_KEYMAP_SIZE 80
63 static int logitech_expanded_keymap
[LOGITECH_EXPANDED_KEYMAP_SIZE
] = {
64 0,216, 0,213,175,156, 0, 0, 0, 0,
65 144, 0, 0, 0, 0, 0, 0, 0, 0,212,
66 174,167,152,161,112, 0, 0, 0,154, 0,
67 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
68 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
69 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
70 0, 0, 0, 0, 0,183,184,185,186,187,
71 188,189,190,191,192,193,194, 0, 0, 0
77 } hid_hat_to_axis
[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
79 #define map_abs(c) hid_map_usage(hidinput, usage, &bit, &max, EV_ABS, (c))
80 #define map_rel(c) hid_map_usage(hidinput, usage, &bit, &max, EV_REL, (c))
81 #define map_key(c) hid_map_usage(hidinput, usage, &bit, &max, EV_KEY, (c))
82 #define map_led(c) hid_map_usage(hidinput, usage, &bit, &max, EV_LED, (c))
84 #define map_abs_clear(c) hid_map_usage_clear(hidinput, usage, &bit, \
86 #define map_key_clear(c) hid_map_usage_clear(hidinput, usage, &bit, \
89 #ifdef CONFIG_USB_HIDINPUT_POWERBOOK
91 struct hidinput_key_translation
{
97 #define APPLE_FLAG_FKEY 0x01
99 static struct hidinput_key_translation apple_fn_keys
[] = {
100 { KEY_BACKSPACE
, KEY_DELETE
},
101 { KEY_F1
, KEY_BRIGHTNESSDOWN
, APPLE_FLAG_FKEY
},
102 { KEY_F2
, KEY_BRIGHTNESSUP
, APPLE_FLAG_FKEY
},
103 { KEY_F3
, KEY_FN_F5
, APPLE_FLAG_FKEY
}, /* Exposé */
104 { KEY_F4
, KEY_FN_F4
, APPLE_FLAG_FKEY
}, /* Dashboard */
105 { KEY_F5
, KEY_KBDILLUMDOWN
, APPLE_FLAG_FKEY
},
106 { KEY_F6
, KEY_KBDILLUMUP
, APPLE_FLAG_FKEY
},
107 { KEY_F7
, KEY_PREVIOUSSONG
, APPLE_FLAG_FKEY
},
108 { KEY_F8
, KEY_PLAYPAUSE
, APPLE_FLAG_FKEY
},
109 { KEY_F9
, KEY_NEXTSONG
, APPLE_FLAG_FKEY
},
110 { KEY_F10
, KEY_MUTE
, APPLE_FLAG_FKEY
},
111 { KEY_F11
, KEY_VOLUMEDOWN
, APPLE_FLAG_FKEY
},
112 { KEY_F12
, KEY_VOLUMEUP
, APPLE_FLAG_FKEY
},
113 { KEY_UP
, KEY_PAGEUP
},
114 { KEY_DOWN
, KEY_PAGEDOWN
},
115 { KEY_LEFT
, KEY_HOME
},
116 { KEY_RIGHT
, KEY_END
},
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 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 (hid
->quirks
& HID_QUIRK_APPLE_NUMLOCK_EMULATION
&& (
224 test_bit(usage
->code
, hid
->pb_pressed_numlock
) ||
225 test_bit(LED_NUML
, input
->led
))) {
226 trans
= find_translation(powerbook_numlock_keys
, usage
->code
);
230 set_bit(usage
->code
, hid
->pb_pressed_numlock
);
232 clear_bit(usage
->code
, hid
->pb_pressed_numlock
);
234 input_event(input
, usage
->type
, trans
->to
, value
);
241 if (hid
->quirks
& HID_QUIRK_APPLE_ISO_KEYBOARD
) {
242 trans
= find_translation(apple_iso_keyboard
, usage
->code
);
244 input_event(input
, usage
->type
, trans
->to
, value
);
252 static void hidinput_apple_setup(struct input_dev
*input
)
254 struct hidinput_key_translation
*trans
;
256 set_bit(KEY_NUMLOCK
, input
->keybit
);
258 /* Enable all needed keys */
259 for (trans
= apple_fn_keys
; trans
->from
; trans
++)
260 set_bit(trans
->to
, input
->keybit
);
262 for (trans
= powerbook_fn_keys
; trans
->from
; trans
++)
263 set_bit(trans
->to
, input
->keybit
);
265 for (trans
= powerbook_numlock_keys
; trans
->from
; trans
++)
266 set_bit(trans
->to
, input
->keybit
);
268 for (trans
= apple_iso_keyboard
; trans
->from
; trans
++)
269 set_bit(trans
->to
, input
->keybit
);
273 inline int hidinput_apple_event(struct hid_device
*hid
,
274 struct input_dev
*input
,
275 struct hid_usage
*usage
, __s32 value
)
280 static inline void hidinput_apple_setup(struct input_dev
*input
)
285 static inline int match_scancode(int code
, int scancode
)
289 return ((code
& (HID_USAGE_PAGE
| HID_USAGE
)) == scancode
);
292 static inline int match_keycode(int code
, int keycode
)
296 return (code
== keycode
);
299 static struct hid_usage
*hidinput_find_key(struct hid_device
*hid
,
300 int scancode
, int keycode
)
303 struct hid_report
*report
;
304 struct hid_usage
*usage
;
306 for (k
= HID_INPUT_REPORT
; k
<= HID_OUTPUT_REPORT
; k
++) {
307 list_for_each_entry(report
, &hid
->report_enum
[k
].report_list
, list
) {
308 for (i
= 0; i
< report
->maxfield
; i
++) {
309 for ( j
= 0; j
< report
->field
[i
]->maxusage
; j
++) {
310 usage
= report
->field
[i
]->usage
+ j
;
311 if (usage
->type
== EV_KEY
&&
312 match_scancode(usage
->hid
, scancode
) &&
313 match_keycode(usage
->code
, keycode
))
322 static int hidinput_getkeycode(struct input_dev
*dev
, int scancode
,
325 struct hid_device
*hid
= input_get_drvdata(dev
);
326 struct hid_usage
*usage
;
328 usage
= hidinput_find_key(hid
, scancode
, 0);
330 *keycode
= usage
->code
;
336 static int hidinput_setkeycode(struct input_dev
*dev
, int scancode
,
339 struct hid_device
*hid
= input_get_drvdata(dev
);
340 struct hid_usage
*usage
;
343 if (keycode
< 0 || keycode
> KEY_MAX
)
346 usage
= hidinput_find_key(hid
, scancode
, 0);
348 old_keycode
= usage
->code
;
349 usage
->code
= keycode
;
351 clear_bit(old_keycode
, dev
->keybit
);
352 set_bit(usage
->code
, dev
->keybit
);
353 dbg_hid(KERN_DEBUG
"Assigned keycode %d to HID usage code %x\n", keycode
, scancode
);
354 /* Set the keybit for the old keycode if the old keycode is used
356 if (hidinput_find_key (hid
, 0, old_keycode
))
357 set_bit(old_keycode
, dev
->keybit
);
366 static void hidinput_configure_usage(struct hid_input
*hidinput
, struct hid_field
*field
,
367 struct hid_usage
*usage
)
369 struct input_dev
*input
= hidinput
->input
;
370 struct hid_device
*device
= input_get_drvdata(input
);
371 int max
= 0, code
, ret
;
372 unsigned long *bit
= NULL
;
374 field
->hidinput
= hidinput
;
376 dbg_hid("Mapping: ");
377 hid_resolv_usage(usage
->hid
);
378 dbg_hid_line(" ---> ");
380 if (field
->flags
& HID_MAIN_ITEM_CONSTANT
)
383 /* only LED usages are supported in output fields */
384 if (field
->report_type
== HID_OUTPUT_REPORT
&&
385 (usage
->hid
& HID_USAGE_PAGE
) != HID_UP_LED
) {
386 dbg_hid_line(" [non-LED output field] ");
390 /* handle input mappings for quirky devices */
391 ret
= hidinput_mapping_quirks(usage
, hidinput
, &bit
, &max
);
395 if (device
->driver
->input_mapping
) {
396 int ret
= device
->driver
->input_mapping(device
, hidinput
, field
,
404 switch (usage
->hid
& HID_USAGE_PAGE
) {
406 case HID_UP_UNDEFINED
:
409 case HID_UP_KEYBOARD
:
411 set_bit(EV_REP
, input
->evbit
);
413 if ((usage
->hid
& HID_USAGE
) < 256) {
414 if (!hid_keyboard
[usage
->hid
& HID_USAGE
]) goto ignore
;
415 map_key_clear(hid_keyboard
[usage
->hid
& HID_USAGE
]);
417 map_key(KEY_UNKNOWN
);
423 code
= ((usage
->hid
- 1) & 0xf);
425 switch (field
->application
) {
427 case HID_GD_POINTER
: code
+= 0x110; break;
428 case HID_GD_JOYSTICK
: code
+= 0x120; break;
429 case HID_GD_GAMEPAD
: code
+= 0x130; break;
431 switch (field
->physical
) {
433 case HID_GD_POINTER
: code
+= 0x110; break;
434 case HID_GD_JOYSTICK
: code
+= 0x120; break;
435 case HID_GD_GAMEPAD
: code
+= 0x130; break;
436 default: code
+= 0x100;
440 /* Special handling for Logitech Cordless Desktop */
441 if (field
->application
!= HID_GD_MOUSE
) {
442 if (device
->quirks
& HID_QUIRK_LOGITECH_EXPANDED_KEYMAP
) {
443 int hid
= usage
->hid
& HID_USAGE
;
444 if (hid
< LOGITECH_EXPANDED_KEYMAP_SIZE
&& logitech_expanded_keymap
[hid
] != 0)
445 code
= logitech_expanded_keymap
[hid
];
448 if (device
->quirks
& HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL
) {
449 int hid
= usage
->hid
& HID_USAGE
;
450 if (hid
== 7 || hid
== 8)
459 case HID_UP_SIMULATION
:
461 switch (usage
->hid
& 0xffff) {
462 case 0xba: map_abs(ABS_RUDDER
); break;
463 case 0xbb: map_abs(ABS_THROTTLE
); break;
464 case 0xc4: map_abs(ABS_GAS
); break;
465 case 0xc5: map_abs(ABS_BRAKE
); break;
466 case 0xc8: map_abs(ABS_WHEEL
); break;
467 default: goto ignore
;
473 if ((usage
->hid
& 0xf0) == 0x80) { /* SystemControl */
474 switch (usage
->hid
& 0xf) {
475 case 0x1: map_key_clear(KEY_POWER
); break;
476 case 0x2: map_key_clear(KEY_SLEEP
); break;
477 case 0x3: map_key_clear(KEY_WAKEUP
); break;
478 default: goto unknown
;
483 if ((usage
->hid
& 0xf0) == 0x90) { /* D-pad */
484 switch (usage
->hid
) {
485 case HID_GD_UP
: usage
->hat_dir
= 1; break;
486 case HID_GD_DOWN
: usage
->hat_dir
= 5; break;
487 case HID_GD_RIGHT
: usage
->hat_dir
= 3; break;
488 case HID_GD_LEFT
: usage
->hat_dir
= 7; break;
489 default: goto unknown
;
492 map_abs(field
->dpad
);
499 switch (usage
->hid
) {
501 /* These usage IDs map directly to the usage codes. */
502 case HID_GD_X
: case HID_GD_Y
: case HID_GD_Z
:
503 case HID_GD_RX
: case HID_GD_RY
: case HID_GD_RZ
:
504 case HID_GD_SLIDER
: case HID_GD_DIAL
: case HID_GD_WHEEL
:
505 if (field
->flags
& HID_MAIN_ITEM_RELATIVE
)
506 map_rel(usage
->hid
& 0xf);
508 map_abs(usage
->hid
& 0xf);
511 case HID_GD_HATSWITCH
:
512 usage
->hat_min
= field
->logical_minimum
;
513 usage
->hat_max
= field
->logical_maximum
;
517 case HID_GD_START
: map_key_clear(BTN_START
); break;
518 case HID_GD_SELECT
: map_key_clear(BTN_SELECT
); break;
520 default: goto unknown
;
527 switch (usage
->hid
& 0xffff) { /* HID-Value: */
528 case 0x01: map_led (LED_NUML
); break; /* "Num Lock" */
529 case 0x02: map_led (LED_CAPSL
); break; /* "Caps Lock" */
530 case 0x03: map_led (LED_SCROLLL
); break; /* "Scroll Lock" */
531 case 0x04: map_led (LED_COMPOSE
); break; /* "Compose" */
532 case 0x05: map_led (LED_KANA
); break; /* "Kana" */
533 case 0x27: map_led (LED_SLEEP
); break; /* "Stand-By" */
534 case 0x4c: map_led (LED_SUSPEND
); break; /* "System Suspend" */
535 case 0x09: map_led (LED_MUTE
); break; /* "Mute" */
536 case 0x4b: map_led (LED_MISC
); break; /* "Generic Indicator" */
537 case 0x19: map_led (LED_MAIL
); break; /* "Message Waiting" */
538 case 0x4d: map_led (LED_CHARGING
); break; /* "External Power Connected" */
540 default: goto ignore
;
544 case HID_UP_DIGITIZER
:
546 switch (usage
->hid
& 0xff) {
548 case 0x30: /* TipPressure */
549 if (!test_bit(BTN_TOUCH
, input
->keybit
)) {
550 device
->quirks
|= HID_QUIRK_NOTOUCH
;
551 set_bit(EV_KEY
, input
->evbit
);
552 set_bit(BTN_TOUCH
, input
->keybit
);
555 map_abs_clear(ABS_PRESSURE
);
558 case 0x32: /* InRange */
559 switch (field
->physical
& 0xff) {
560 case 0x21: map_key(BTN_TOOL_MOUSE
); break;
561 case 0x22: map_key(BTN_TOOL_FINGER
); break;
562 default: map_key(BTN_TOOL_PEN
); break;
566 case 0x3c: /* Invert */
567 map_key_clear(BTN_TOOL_RUBBER
);
570 case 0x33: /* Touch */
571 case 0x42: /* TipSwitch */
572 case 0x43: /* TipSwitch2 */
573 device
->quirks
&= ~HID_QUIRK_NOTOUCH
;
574 map_key_clear(BTN_TOUCH
);
577 case 0x44: /* BarrelSwitch */
578 map_key_clear(BTN_STYLUS
);
581 default: goto unknown
;
585 case HID_UP_CONSUMER
: /* USB HUT v1.1, pages 56-62 */
587 switch (usage
->hid
& HID_USAGE
) {
588 case 0x000: goto ignore
;
589 case 0x034: map_key_clear(KEY_SLEEP
); break;
590 case 0x036: map_key_clear(BTN_MISC
); break;
592 case 0x040: map_key_clear(KEY_MENU
); break;
593 case 0x045: map_key_clear(KEY_RADIO
); break;
595 case 0x083: map_key_clear(KEY_LAST
); break;
596 case 0x088: map_key_clear(KEY_PC
); break;
597 case 0x089: map_key_clear(KEY_TV
); break;
598 case 0x08a: map_key_clear(KEY_WWW
); break;
599 case 0x08b: map_key_clear(KEY_DVD
); break;
600 case 0x08c: map_key_clear(KEY_PHONE
); break;
601 case 0x08d: map_key_clear(KEY_PROGRAM
); break;
602 case 0x08e: map_key_clear(KEY_VIDEOPHONE
); break;
603 case 0x08f: map_key_clear(KEY_GAMES
); break;
604 case 0x090: map_key_clear(KEY_MEMO
); break;
605 case 0x091: map_key_clear(KEY_CD
); break;
606 case 0x092: map_key_clear(KEY_VCR
); break;
607 case 0x093: map_key_clear(KEY_TUNER
); break;
608 case 0x094: map_key_clear(KEY_EXIT
); break;
609 case 0x095: map_key_clear(KEY_HELP
); break;
610 case 0x096: map_key_clear(KEY_TAPE
); break;
611 case 0x097: map_key_clear(KEY_TV2
); break;
612 case 0x098: map_key_clear(KEY_SAT
); break;
613 case 0x09a: map_key_clear(KEY_PVR
); break;
615 case 0x09c: map_key_clear(KEY_CHANNELUP
); break;
616 case 0x09d: map_key_clear(KEY_CHANNELDOWN
); break;
617 case 0x0a0: map_key_clear(KEY_VCR2
); break;
619 case 0x0b0: map_key_clear(KEY_PLAY
); break;
620 case 0x0b1: map_key_clear(KEY_PAUSE
); break;
621 case 0x0b2: map_key_clear(KEY_RECORD
); break;
622 case 0x0b3: map_key_clear(KEY_FASTFORWARD
); break;
623 case 0x0b4: map_key_clear(KEY_REWIND
); break;
624 case 0x0b5: map_key_clear(KEY_NEXTSONG
); break;
625 case 0x0b6: map_key_clear(KEY_PREVIOUSSONG
); break;
626 case 0x0b7: map_key_clear(KEY_STOPCD
); break;
627 case 0x0b8: map_key_clear(KEY_EJECTCD
); break;
628 case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT
); break;
630 case 0x0cd: map_key_clear(KEY_PLAYPAUSE
); break;
631 case 0x0e0: map_abs_clear(ABS_VOLUME
); break;
632 case 0x0e2: map_key_clear(KEY_MUTE
); break;
633 case 0x0e5: map_key_clear(KEY_BASSBOOST
); break;
634 case 0x0e9: map_key_clear(KEY_VOLUMEUP
); break;
635 case 0x0ea: map_key_clear(KEY_VOLUMEDOWN
); break;
637 case 0x182: map_key_clear(KEY_BOOKMARKS
); break;
638 case 0x183: map_key_clear(KEY_CONFIG
); break;
639 case 0x184: map_key_clear(KEY_WORDPROCESSOR
); break;
640 case 0x185: map_key_clear(KEY_EDITOR
); break;
641 case 0x186: map_key_clear(KEY_SPREADSHEET
); break;
642 case 0x187: map_key_clear(KEY_GRAPHICSEDITOR
); break;
643 case 0x188: map_key_clear(KEY_PRESENTATION
); break;
644 case 0x189: map_key_clear(KEY_DATABASE
); break;
645 case 0x18a: map_key_clear(KEY_MAIL
); break;
646 case 0x18b: map_key_clear(KEY_NEWS
); break;
647 case 0x18c: map_key_clear(KEY_VOICEMAIL
); break;
648 case 0x18d: map_key_clear(KEY_ADDRESSBOOK
); break;
649 case 0x18e: map_key_clear(KEY_CALENDAR
); break;
650 case 0x191: map_key_clear(KEY_FINANCE
); break;
651 case 0x192: map_key_clear(KEY_CALC
); break;
652 case 0x194: map_key_clear(KEY_FILE
); break;
653 case 0x196: map_key_clear(KEY_WWW
); break;
654 case 0x19c: map_key_clear(KEY_LOGOFF
); break;
655 case 0x19e: map_key_clear(KEY_COFFEE
); break;
656 case 0x1a6: map_key_clear(KEY_HELP
); break;
657 case 0x1a7: map_key_clear(KEY_DOCUMENTS
); break;
658 case 0x1ab: map_key_clear(KEY_SPELLCHECK
); break;
659 case 0x1b6: map_key_clear(KEY_MEDIA
); break;
660 case 0x1b7: map_key_clear(KEY_SOUND
); break;
661 case 0x1bc: map_key_clear(KEY_MESSENGER
); break;
662 case 0x1bd: map_key_clear(KEY_INFO
); break;
663 case 0x201: map_key_clear(KEY_NEW
); break;
664 case 0x202: map_key_clear(KEY_OPEN
); break;
665 case 0x203: map_key_clear(KEY_CLOSE
); break;
666 case 0x204: map_key_clear(KEY_EXIT
); break;
667 case 0x207: map_key_clear(KEY_SAVE
); break;
668 case 0x208: map_key_clear(KEY_PRINT
); break;
669 case 0x209: map_key_clear(KEY_PROPS
); break;
670 case 0x21a: map_key_clear(KEY_UNDO
); break;
671 case 0x21b: map_key_clear(KEY_COPY
); break;
672 case 0x21c: map_key_clear(KEY_CUT
); break;
673 case 0x21d: map_key_clear(KEY_PASTE
); break;
674 case 0x21f: map_key_clear(KEY_FIND
); break;
675 case 0x221: map_key_clear(KEY_SEARCH
); break;
676 case 0x222: map_key_clear(KEY_GOTO
); break;
677 case 0x223: map_key_clear(KEY_HOMEPAGE
); break;
678 case 0x224: map_key_clear(KEY_BACK
); break;
679 case 0x225: map_key_clear(KEY_FORWARD
); break;
680 case 0x226: map_key_clear(KEY_STOP
); break;
681 case 0x227: map_key_clear(KEY_REFRESH
); break;
682 case 0x22a: map_key_clear(KEY_BOOKMARKS
); break;
683 case 0x22d: map_key_clear(KEY_ZOOMIN
); break;
684 case 0x22e: map_key_clear(KEY_ZOOMOUT
); break;
685 case 0x22f: map_key_clear(KEY_ZOOMRESET
); break;
686 case 0x233: map_key_clear(KEY_SCROLLUP
); break;
687 case 0x234: map_key_clear(KEY_SCROLLDOWN
); break;
688 case 0x238: map_rel(REL_HWHEEL
); break;
689 case 0x25f: map_key_clear(KEY_CANCEL
); break;
690 case 0x279: map_key_clear(KEY_REDO
); break;
692 case 0x289: map_key_clear(KEY_REPLY
); break;
693 case 0x28b: map_key_clear(KEY_FORWARDMAIL
); break;
694 case 0x28c: map_key_clear(KEY_SEND
); break;
696 default: goto ignore
;
700 case HID_UP_HPVENDOR
: /* Reported on a Dutch layout HP5308 */
702 set_bit(EV_REP
, input
->evbit
);
703 switch (usage
->hid
& HID_USAGE
) {
704 case 0x021: map_key_clear(KEY_PRINT
); break;
705 case 0x070: map_key_clear(KEY_HP
); break;
706 case 0x071: map_key_clear(KEY_CAMERA
); break;
707 case 0x072: map_key_clear(KEY_SOUND
); break;
708 case 0x073: map_key_clear(KEY_QUESTION
); break;
709 case 0x080: map_key_clear(KEY_EMAIL
); break;
710 case 0x081: map_key_clear(KEY_CHAT
); break;
711 case 0x082: map_key_clear(KEY_SEARCH
); break;
712 case 0x083: map_key_clear(KEY_CONNECT
); break;
713 case 0x084: map_key_clear(KEY_FINANCE
); break;
714 case 0x085: map_key_clear(KEY_SPORT
); break;
715 case 0x086: map_key_clear(KEY_SHOP
); break;
716 default: goto ignore
;
720 case HID_UP_MSVENDOR
:
724 case HID_UP_CUSTOM
: /* Reported on Logitech and Apple USB keyboards */
726 set_bit(EV_REP
, input
->evbit
);
727 switch(usage
->hid
& HID_USAGE
) {
729 /* The fn key on Apple USB keyboards */
730 map_key_clear(KEY_FN
);
731 hidinput_apple_setup(input
);
734 default: goto ignore
;
738 case HID_UP_LOGIVENDOR
:
744 switch(usage
->hid
& HID_USAGE
) {
745 case 0xa4: map_key_clear(BTN_DEAD
); break;
746 default: goto ignore
;
752 if (field
->report_size
== 1) {
753 if (field
->report
->type
== HID_OUTPUT_REPORT
) {
760 if (field
->flags
& HID_MAIN_ITEM_RELATIVE
) {
769 if (device
->driver
->input_mapped
&& device
->driver
->input_mapped(device
,
770 hidinput
, field
, usage
, &bit
, &max
) < 0)
773 if (device
->quirks
& HID_QUIRK_MIGHTYMOUSE
) {
774 if (usage
->hid
== HID_GD_Z
)
776 else if (usage
->code
== BTN_1
)
778 else if (usage
->code
== BTN_2
)
782 if ((device
->quirks
& (HID_QUIRK_2WHEEL_MOUSE_HACK_7
| HID_QUIRK_2WHEEL_MOUSE_HACK_5
|
783 HID_QUIRK_2WHEEL_MOUSE_HACK_B8
)) && (usage
->type
== EV_REL
) &&
784 (usage
->code
== REL_WHEEL
))
785 set_bit(REL_HWHEEL
, bit
);
787 if (((device
->quirks
& HID_QUIRK_2WHEEL_MOUSE_HACK_5
) && (usage
->hid
== 0x00090005))
788 || ((device
->quirks
& HID_QUIRK_2WHEEL_MOUSE_HACK_7
) && (usage
->hid
== 0x00090007)))
791 if ((device
->quirks
& HID_QUIRK_BAD_RELATIVE_KEYS
) &&
792 usage
->type
== EV_KEY
&& (field
->flags
& HID_MAIN_ITEM_RELATIVE
))
793 field
->flags
&= ~HID_MAIN_ITEM_RELATIVE
;
795 set_bit(usage
->type
, input
->evbit
);
797 if (device
->quirks
& HID_QUIRK_DUPLICATE_USAGES
&&
798 (usage
->type
== EV_KEY
||
799 usage
->type
== EV_REL
||
800 usage
->type
== EV_ABS
))
801 clear_bit(usage
->code
, bit
);
803 while (usage
->code
<= max
&& test_and_set_bit(usage
->code
, bit
))
804 usage
->code
= find_next_zero_bit(bit
, max
+ 1, usage
->code
);
806 if (usage
->code
> max
)
810 if (usage
->type
== EV_ABS
) {
812 int a
= field
->logical_minimum
;
813 int b
= field
->logical_maximum
;
815 if ((device
->quirks
& HID_QUIRK_BADPAD
) && (usage
->code
== ABS_X
|| usage
->code
== ABS_Y
)) {
816 a
= field
->logical_minimum
= 0;
817 b
= field
->logical_maximum
= 255;
820 if (field
->application
== HID_GD_GAMEPAD
|| field
->application
== HID_GD_JOYSTICK
)
821 input_set_abs_params(input
, usage
->code
, a
, b
, (b
- a
) >> 8, (b
- a
) >> 4);
822 else input_set_abs_params(input
, usage
->code
, a
, b
, 0, 0);
826 if (usage
->type
== EV_ABS
&&
827 (usage
->hat_min
< usage
->hat_max
|| usage
->hat_dir
)) {
829 for (i
= usage
->code
; i
< usage
->code
+ 2 && i
<= max
; i
++) {
830 input_set_abs_params(input
, i
, -1, 1, 0, 0);
831 set_bit(i
, input
->absbit
);
833 if (usage
->hat_dir
&& !field
->dpad
)
834 field
->dpad
= usage
->code
;
837 /* for those devices which produce Consumer volume usage as relative,
838 * we emulate pressing volumeup/volumedown appropriate number of times
839 * in hidinput_hid_event()
841 if ((usage
->type
== EV_ABS
) && (field
->flags
& HID_MAIN_ITEM_RELATIVE
) &&
842 (usage
->code
== ABS_VOLUME
)) {
843 set_bit(KEY_VOLUMEUP
, input
->keybit
);
844 set_bit(KEY_VOLUMEDOWN
, input
->keybit
);
847 if (usage
->type
== EV_KEY
) {
848 set_bit(EV_MSC
, input
->evbit
);
849 set_bit(MSC_SCAN
, input
->mscbit
);
852 hid_resolv_event(usage
->type
, usage
->code
);
859 dbg_hid_line("IGNORED\n");
863 void hidinput_hid_event(struct hid_device
*hid
, struct hid_field
*field
, struct hid_usage
*usage
, __s32 value
)
865 struct input_dev
*input
;
866 unsigned *quirks
= &hid
->quirks
;
868 if (!field
->hidinput
)
871 input
= field
->hidinput
->input
;
876 /* handle input events for quirky devices */
877 if (hidinput_event_quirks(hid
, field
, usage
, value
))
880 if (usage
->hat_min
< usage
->hat_max
|| usage
->hat_dir
) {
881 int hat_dir
= usage
->hat_dir
;
883 hat_dir
= (value
- usage
->hat_min
) * 8 / (usage
->hat_max
- usage
->hat_min
+ 1) + 1;
884 if (hat_dir
< 0 || hat_dir
> 8) hat_dir
= 0;
885 input_event(input
, usage
->type
, usage
->code
, hid_hat_to_axis
[hat_dir
].x
);
886 input_event(input
, usage
->type
, usage
->code
+ 1, hid_hat_to_axis
[hat_dir
].y
);
890 if (usage
->hid
== (HID_UP_DIGITIZER
| 0x003c)) { /* Invert */
891 *quirks
= value
? (*quirks
| HID_QUIRK_INVERT
) : (*quirks
& ~HID_QUIRK_INVERT
);
895 if (usage
->hid
== (HID_UP_DIGITIZER
| 0x0032)) { /* InRange */
897 input_event(input
, usage
->type
, (*quirks
& HID_QUIRK_INVERT
) ? BTN_TOOL_RUBBER
: usage
->code
, 1);
900 input_event(input
, usage
->type
, usage
->code
, 0);
901 input_event(input
, usage
->type
, BTN_TOOL_RUBBER
, 0);
905 if (usage
->hid
== (HID_UP_DIGITIZER
| 0x0030) && (*quirks
& HID_QUIRK_NOTOUCH
)) { /* Pressure */
906 int a
= field
->logical_minimum
;
907 int b
= field
->logical_maximum
;
908 input_event(input
, EV_KEY
, BTN_TOUCH
, value
> a
+ ((b
- a
) >> 3));
911 if (usage
->hid
== (HID_UP_PID
| 0x83UL
)) { /* Simultaneous Effects Max */
912 dbg_hid("Maximum Effects - %d\n",value
);
916 if (usage
->hid
== (HID_UP_PID
| 0x7fUL
)) {
917 dbg_hid("PID Pool Report\n");
921 if ((usage
->type
== EV_KEY
) && (usage
->code
== 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
924 if ((usage
->type
== EV_ABS
) && (field
->flags
& HID_MAIN_ITEM_RELATIVE
) &&
925 (usage
->code
== ABS_VOLUME
)) {
926 int count
= abs(value
);
927 int direction
= value
> 0 ? KEY_VOLUMEUP
: KEY_VOLUMEDOWN
;
930 for (i
= 0; i
< count
; i
++) {
931 input_event(input
, EV_KEY
, direction
, 1);
933 input_event(input
, EV_KEY
, direction
, 0);
939 /* report the usage code as scancode if the key status has changed */
940 if (usage
->type
== EV_KEY
&& !!test_bit(usage
->code
, input
->key
) != value
)
941 input_event(input
, EV_MSC
, MSC_SCAN
, usage
->hid
);
943 input_event(input
, usage
->type
, usage
->code
, value
);
945 if ((field
->flags
& HID_MAIN_ITEM_RELATIVE
) && (usage
->type
== EV_KEY
))
946 input_event(input
, usage
->type
, usage
->code
, 0);
949 void hidinput_report_event(struct hid_device
*hid
, struct hid_report
*report
)
951 struct hid_input
*hidinput
;
953 list_for_each_entry(hidinput
, &hid
->inputs
, list
)
954 input_sync(hidinput
->input
);
956 EXPORT_SYMBOL_GPL(hidinput_report_event
);
958 int hidinput_find_field(struct hid_device
*hid
, unsigned int type
, unsigned int code
, struct hid_field
**field
)
960 struct hid_report
*report
;
963 list_for_each_entry(report
, &hid
->report_enum
[HID_OUTPUT_REPORT
].report_list
, list
) {
964 for (i
= 0; i
< report
->maxfield
; i
++) {
965 *field
= report
->field
[i
];
966 for (j
= 0; j
< (*field
)->maxusage
; j
++)
967 if ((*field
)->usage
[j
].type
== type
&& (*field
)->usage
[j
].code
== code
)
973 EXPORT_SYMBOL_GPL(hidinput_find_field
);
975 static int hidinput_open(struct input_dev
*dev
)
977 struct hid_device
*hid
= input_get_drvdata(dev
);
979 return hid
->ll_driver
->open(hid
);
982 static void hidinput_close(struct input_dev
*dev
)
984 struct hid_device
*hid
= input_get_drvdata(dev
);
986 hid
->ll_driver
->close(hid
);
990 * Register the input device; print a message.
991 * Configure the input layer interface
992 * Read all reports and initialize the absolute field values.
995 int hidinput_connect(struct hid_device
*hid
)
997 struct hid_report
*report
;
998 struct hid_input
*hidinput
= NULL
;
999 struct input_dev
*input_dev
;
1001 int max_report_type
= HID_OUTPUT_REPORT
;
1003 if (hid
->quirks
& HID_QUIRK_IGNORE_HIDINPUT
)
1006 INIT_LIST_HEAD(&hid
->inputs
);
1008 for (i
= 0; i
< hid
->maxcollection
; i
++)
1009 if (hid
->collection
[i
].type
== HID_COLLECTION_APPLICATION
||
1010 hid
->collection
[i
].type
== HID_COLLECTION_PHYSICAL
)
1011 if (IS_INPUT_APPLICATION(hid
->collection
[i
].usage
))
1014 if (i
== hid
->maxcollection
&& (hid
->quirks
& HID_QUIRK_HIDINPUT
) == 0)
1017 if (hid
->quirks
& HID_QUIRK_SKIP_OUTPUT_REPORTS
)
1018 max_report_type
= HID_INPUT_REPORT
;
1020 for (k
= HID_INPUT_REPORT
; k
<= max_report_type
; k
++)
1021 list_for_each_entry(report
, &hid
->report_enum
[k
].report_list
, list
) {
1023 if (!report
->maxfield
)
1027 hidinput
= kzalloc(sizeof(*hidinput
), GFP_KERNEL
);
1028 input_dev
= input_allocate_device();
1029 if (!hidinput
|| !input_dev
) {
1031 input_free_device(input_dev
);
1032 err_hid("Out of memory during hid input probe");
1036 input_set_drvdata(input_dev
, hid
);
1038 hid
->ll_driver
->hidinput_input_event
;
1039 input_dev
->open
= hidinput_open
;
1040 input_dev
->close
= hidinput_close
;
1041 input_dev
->setkeycode
= hidinput_setkeycode
;
1042 input_dev
->getkeycode
= hidinput_getkeycode
;
1044 input_dev
->name
= hid
->name
;
1045 input_dev
->phys
= hid
->phys
;
1046 input_dev
->uniq
= hid
->uniq
;
1047 input_dev
->id
.bustype
= hid
->bus
;
1048 input_dev
->id
.vendor
= hid
->vendor
;
1049 input_dev
->id
.product
= hid
->product
;
1050 input_dev
->id
.version
= hid
->version
;
1051 input_dev
->dev
.parent
= hid
->dev
.parent
;
1052 hidinput
->input
= input_dev
;
1053 list_add_tail(&hidinput
->list
, &hid
->inputs
);
1056 for (i
= 0; i
< report
->maxfield
; i
++)
1057 for (j
= 0; j
< report
->field
[i
]->maxusage
; j
++)
1058 hidinput_configure_usage(hidinput
, report
->field
[i
],
1059 report
->field
[i
]->usage
+ j
);
1061 if (hid
->quirks
& HID_QUIRK_MULTI_INPUT
) {
1062 /* This will leave hidinput NULL, so that it
1063 * allocates another one if we have more inputs on
1064 * the same interface. Some devices (e.g. Happ's
1065 * UGCI) cram a lot of unrelated inputs into the
1066 * same interface. */
1067 hidinput
->report
= report
;
1068 if (input_register_device(hidinput
->input
))
1074 if (hidinput
&& input_register_device(hidinput
->input
))
1080 input_free_device(hidinput
->input
);
1083 /* unwind the ones we already registered */
1084 hidinput_disconnect(hid
);
1088 EXPORT_SYMBOL_GPL(hidinput_connect
);
1090 void hidinput_disconnect(struct hid_device
*hid
)
1092 struct hid_input
*hidinput
, *next
;
1094 list_for_each_entry_safe(hidinput
, next
, &hid
->inputs
, list
) {
1095 list_del(&hidinput
->list
);
1096 input_unregister_device(hidinput
->input
);
1100 EXPORT_SYMBOL_GPL(hidinput_disconnect
);