]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - drivers/usb/input/hid-input.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'devel' of master.kernel.org:/home/rmk/linux-2.6-serial
[mirror_ubuntu-hirsute-kernel.git] / drivers / usb / input / hid-input.c
CommitLineData
1da177e4
LT		 1/*
2 * $Id: hid-input.c,v 1.2 2002/04/23 00:59:25 rdamazio Exp $
3 *
4 * Copyright (c) 2000-2001 Vojtech Pavlik
5 *
6 * USB HID to Linux Input mapping
7 */
8
9/*
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 * Should you need to contact me, the author, you can do so either by
25 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
26 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
27 */
28
29#include <linux/module.h>
30#include <linux/slab.h>
31#include <linux/kernel.h>
ae0dadcf 32#include <linux/usb/input.h>
1da177e4
LT		 33
34#undef DEBUG
35
36#include "hid.h"
37
38#define unk KEY_UNKNOWN
39
4c4c9432 40static const unsigned char hid_keyboard[256] = {
1da177e4
LT		 41 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
42 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44, 2, 3,
43 4, 5, 6, 7, 8, 9, 10, 11, 28, 1, 14, 15, 57, 12, 13, 26,
44 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
45 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
46 105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
47 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
48 191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
49 115,114,unk,unk,unk,121,unk, 89, 93,124, 92, 94, 95,unk,unk,unk,
50 122,123, 90, 91, 85,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
51 unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
52 unk,unk,unk,unk,unk,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,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
55 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
56 150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
57};
58
4c4c9432 59static const struct {
1da177e4
LT		 60 __s32 x;
61 __s32 y;
62} hid_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
63
64#define map_abs(c) do { usage->code = c; usage->type = EV_ABS; bit = input->absbit; max = ABS_MAX; } while (0)
65#define map_rel(c) do { usage->code = c; usage->type = EV_REL; bit = input->relbit; max = REL_MAX; } while (0)
66#define map_key(c) do { usage->code = c; usage->type = EV_KEY; bit = input->keybit; max = KEY_MAX; } while (0)
67#define map_led(c) do { usage->code = c; usage->type = EV_LED; bit = input->ledbit; max = LED_MAX; } while (0)
1da177e4
LT		 68
69#define map_abs_clear(c) do { map_abs(c); clear_bit(c, bit); } while (0)
70#define map_key_clear(c) do { map_key(c); clear_bit(c, bit); } while (0)
1da177e4 71
eab9edd2
MH		 72#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
73
74struct hidinput_key_translation {
75 u16 from;
76 u16 to;
77 u8 flags;
78};
79
80#define POWERBOOK_FLAG_FKEY 0x01
81
82static struct hidinput_key_translation powerbook_fn_keys[] = {
83 { KEY_BACKSPACE, KEY_DELETE },
84 { KEY_F1, KEY_BRIGHTNESSDOWN, POWERBOOK_FLAG_FKEY },
85 { KEY_F2, KEY_BRIGHTNESSUP, POWERBOOK_FLAG_FKEY },
86 { KEY_F3, KEY_MUTE, POWERBOOK_FLAG_FKEY },
87 { KEY_F4, KEY_VOLUMEDOWN, POWERBOOK_FLAG_FKEY },
88 { KEY_F5, KEY_VOLUMEUP, POWERBOOK_FLAG_FKEY },
89 { KEY_F6, KEY_NUMLOCK, POWERBOOK_FLAG_FKEY },
90 { KEY_F7, KEY_SWITCHVIDEOMODE, POWERBOOK_FLAG_FKEY },
91 { KEY_F8, KEY_KBDILLUMTOGGLE, POWERBOOK_FLAG_FKEY },
92 { KEY_F9, KEY_KBDILLUMDOWN, POWERBOOK_FLAG_FKEY },
93 { KEY_F10, KEY_KBDILLUMUP, POWERBOOK_FLAG_FKEY },
94 { KEY_UP, KEY_PAGEUP },
95 { KEY_DOWN, KEY_PAGEDOWN },
96 { KEY_LEFT, KEY_HOME },
97 { KEY_RIGHT, KEY_END },
98 { }
99};
100
101static struct hidinput_key_translation powerbook_numlock_keys[] = {
102 { KEY_J, KEY_KP1 },
103 { KEY_K, KEY_KP2 },
104 { KEY_L, KEY_KP3 },
105 { KEY_U, KEY_KP4 },
106 { KEY_I, KEY_KP5 },
107 { KEY_O, KEY_KP6 },
108 { KEY_7, KEY_KP7 },
109 { KEY_8, KEY_KP8 },
110 { KEY_9, KEY_KP9 },
111 { KEY_M, KEY_KP0 },
112 { KEY_DOT, KEY_KPDOT },
113 { KEY_SLASH, KEY_KPPLUS },
114 { KEY_SEMICOLON, KEY_KPMINUS },
115 { KEY_P, KEY_KPASTERISK },
116 { KEY_MINUS, KEY_KPEQUAL },
117 { KEY_0, KEY_KPSLASH },
118 { KEY_F6, KEY_NUMLOCK },
119 { KEY_KPENTER, KEY_KPENTER },
120 { KEY_BACKSPACE, KEY_BACKSPACE },
121 { }
122};
123
124static int usbhid_pb_fnmode = 1;
125module_param_named(pb_fnmode, usbhid_pb_fnmode, int, 0644);
126MODULE_PARM_DESC(pb_fnmode,
127 "Mode of fn key on PowerBooks (0 = disabled, 1 = fkeyslast, 2 = fkeysfirst)");
128
129static struct hidinput_key_translation *find_translation(struct hidinput_key_translation *table, u16 from)
130{
131 struct hidinput_key_translation *trans;
132
133 /* Look for the translation */
134 for (trans = table; trans->from; trans++)
135 if (trans->from == from)
136 return trans;
137
138 return NULL;
139}
140
141static int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
142 struct hid_usage *usage, __s32 value)
143{
144 struct hidinput_key_translation *trans;
145
146 if (usage->code == KEY_FN) {
147 if (value) hid->quirks |= HID_QUIRK_POWERBOOK_FN_ON;
148 else hid->quirks &= ~HID_QUIRK_POWERBOOK_FN_ON;
149
150 input_event(input, usage->type, usage->code, value);
151
152 return 1;
153 }
154
155 if (usbhid_pb_fnmode) {
156 int do_translate;
157
158 trans = find_translation(powerbook_fn_keys, usage->code);
159 if (trans) {
160 if (test_bit(usage->code, hid->pb_pressed_fn))
161 do_translate = 1;
162 else if (trans->flags & POWERBOOK_FLAG_FKEY)
163 do_translate =
164 (usbhid_pb_fnmode == 2 && (hid->quirks & HID_QUIRK_POWERBOOK_FN_ON)) ||
165 (usbhid_pb_fnmode == 1 && !(hid->quirks & HID_QUIRK_POWERBOOK_FN_ON));
166 else
167 do_translate = (hid->quirks & HID_QUIRK_POWERBOOK_FN_ON);
168
169 if (do_translate) {
170 if (value)
171 set_bit(usage->code, hid->pb_pressed_fn);
172 else
173 clear_bit(usage->code, hid->pb_pressed_fn);
174
175 input_event(input, usage->type, trans->to, value);
176
177 return 1;
178 }
179 }
180
181 if (test_bit(usage->code, hid->pb_pressed_numlock) ||
182 test_bit(LED_NUML, input->led)) {
183 trans = find_translation(powerbook_numlock_keys, usage->code);
184
185 if (trans) {
186 if (value)
187 set_bit(usage->code, hid->pb_pressed_numlock);
188 else
189 clear_bit(usage->code, hid->pb_pressed_numlock);
190
191 input_event(input, usage->type, trans->to, value);
192 }
193
194 return 1;
195 }
196 }
197
198 return 0;
199}
200
201static void hidinput_pb_setup(struct input_dev *input)
202{
203 struct hidinput_key_translation *trans;
204
205 set_bit(KEY_NUMLOCK, input->keybit);
206
207 /* Enable all needed keys */
208 for (trans = powerbook_fn_keys; trans->from; trans++)
209 set_bit(trans->to, input->keybit);
210
211 for (trans = powerbook_numlock_keys; trans->from; trans++)
212 set_bit(trans->to, input->keybit);
213}
214#else
215static inline int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
216 struct hid_usage *usage, __s32 value)
217{
218 return 0;
219}
220
221static inline void hidinput_pb_setup(struct input_dev *input)
222{
223}
224#endif
225
1da177e4
LT		 226static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,
227 struct hid_usage *usage)
228{
c5b7c7c3
DT		 229 struct input_dev *input = hidinput->input;
230 struct hid_device *device = input->private;
8a409b01
VP		 231 int max = 0, code;
232 unsigned long *bit = NULL;
1da177e4
LT		 233
234 field->hidinput = hidinput;
235
236#ifdef DEBUG
237 printk(KERN_DEBUG "Mapping: ");
238 resolv_usage(usage->hid);
239 printk(" ---> ");
240#endif
241
242 if (field->flags & HID_MAIN_ITEM_CONSTANT)
243 goto ignore;
244
245 switch (usage->hid & HID_USAGE_PAGE) {
246
247 case HID_UP_UNDEFINED:
248 goto ignore;
249
250 case HID_UP_KEYBOARD:
251
252 set_bit(EV_REP, input->evbit);
253
254 if ((usage->hid & HID_USAGE) < 256) {
255 if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
256 map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
257 } else
258 map_key(KEY_UNKNOWN);
259
260 break;
261
262 case HID_UP_BUTTON:
263
264 code = ((usage->hid - 1) & 0xf);
265
266 switch (field->application) {
267 case HID_GD_MOUSE:
268 case HID_GD_POINTER: code += 0x110; break;
269 case HID_GD_JOYSTICK: code += 0x120; break;
270 case HID_GD_GAMEPAD: code += 0x130; break;
271 default:
272 switch (field->physical) {
273 case HID_GD_MOUSE:
274 case HID_GD_POINTER: code += 0x110; break;
275 case HID_GD_JOYSTICK: code += 0x120; break;
276 case HID_GD_GAMEPAD: code += 0x130; break;
277 default: code += 0x100;
278 }
279 }
280
281 map_key(code);
282 break;
283
0aebfdac
VP		 284
285 case HID_UP_SIMULATION:
286
287 switch (usage->hid & 0xffff) {
5fce9d7b 288 case 0xba: map_abs(ABS_RUDDER); break;
0aebfdac 289 case 0xbb: map_abs(ABS_THROTTLE); break;
5fce9d7b
DT		 290 case 0xc4: map_abs(ABS_GAS); break;
291 case 0xc5: map_abs(ABS_BRAKE); break;
292 case 0xc8: map_abs(ABS_WHEEL); break;
ff60dde9 293 default: goto ignore;
0aebfdac
VP		 294 }
295 break;
296
1da177e4
LT		 297 case HID_UP_GENDESK:
298
299 if ((usage->hid & 0xf0) == 0x80) { /* SystemControl */
300 switch (usage->hid & 0xf) {
301 case 0x1: map_key_clear(KEY_POWER); break;
302 case 0x2: map_key_clear(KEY_SLEEP); break;
303 case 0x3: map_key_clear(KEY_WAKEUP); break;
304 default: goto unknown;
305 }
306 break;
307 }
308
309 if ((usage->hid & 0xf0) == 0x90) { /* D-pad */
310 switch (usage->hid) {
311 case HID_GD_UP: usage->hat_dir = 1; break;
312 case HID_GD_DOWN: usage->hat_dir = 5; break;
313 case HID_GD_RIGHT: usage->hat_dir = 3; break;
314 case HID_GD_LEFT: usage->hat_dir = 7; break;
315 default: goto unknown;
316 }
317 if (field->dpad) {
318 map_abs(field->dpad);
319 goto ignore;
320 }
321 map_abs(ABS_HAT0X);
322 break;
323 }
324
325 switch (usage->hid) {
326
327 /* These usage IDs map directly to the usage codes. */
328 case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
329 case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
330 case HID_GD_SLIDER: case HID_GD_DIAL: case HID_GD_WHEEL:
05f091ab 331 if (field->flags & HID_MAIN_ITEM_RELATIVE)
1da177e4
LT		 332 map_rel(usage->hid & 0xf);
333 else
334 map_abs(usage->hid & 0xf);
335 break;
336
337 case HID_GD_HATSWITCH:
338 usage->hat_min = field->logical_minimum;
339 usage->hat_max = field->logical_maximum;
340 map_abs(ABS_HAT0X);
341 break;
342
343 case HID_GD_START: map_key_clear(BTN_START); break;
344 case HID_GD_SELECT: map_key_clear(BTN_SELECT); break;
345
346 default: goto unknown;
347 }
348
349 break;
350
351 case HID_UP_LED:
352 if (((usage->hid - 1) & 0xffff) >= LED_MAX)
353 goto ignore;
354 map_led((usage->hid - 1) & 0xffff);
355 break;
356
357 case HID_UP_DIGITIZER:
358
359 switch (usage->hid & 0xff) {
360
361 case 0x30: /* TipPressure */
362 if (!test_bit(BTN_TOUCH, input->keybit)) {
363 device->quirks |= HID_QUIRK_NOTOUCH;
364 set_bit(EV_KEY, input->evbit);
365 set_bit(BTN_TOUCH, input->keybit);
366 }
367
368 map_abs_clear(ABS_PRESSURE);
369 break;
370
371 case 0x32: /* InRange */
372 switch (field->physical & 0xff) {
373 case 0x21: map_key(BTN_TOOL_MOUSE); break;
374 case 0x22: map_key(BTN_TOOL_FINGER); break;
375 default: map_key(BTN_TOOL_PEN); break;
376 }
377 break;
378
379 case 0x3c: /* Invert */
380 map_key_clear(BTN_TOOL_RUBBER);
381 break;
382
383 case 0x33: /* Touch */
384 case 0x42: /* TipSwitch */
385 case 0x43: /* TipSwitch2 */
386 device->quirks &= ~HID_QUIRK_NOTOUCH;
387 map_key_clear(BTN_TOUCH);
388 break;
389
390 case 0x44: /* BarrelSwitch */
391 map_key_clear(BTN_STYLUS);
392 break;
393
394 default: goto unknown;
395 }
396 break;
397
398 case HID_UP_CONSUMER: /* USB HUT v1.1, pages 56-62 */
399
400 switch (usage->hid & HID_USAGE) {
401 case 0x000: goto ignore;
402 case 0x034: map_key_clear(KEY_SLEEP); break;
403 case 0x036: map_key_clear(BTN_MISC); break;
39fd748f 404 case 0x045: map_key_clear(KEY_RADIO); break;
1da177e4 405 case 0x08a: map_key_clear(KEY_WWW); break;
8a409b01 406 case 0x08d: map_key_clear(KEY_PROGRAM); break;
1da177e4 407 case 0x095: map_key_clear(KEY_HELP); break;
8a409b01
VP		 408 case 0x09c: map_key_clear(KEY_CHANNELUP); break;
409 case 0x09d: map_key_clear(KEY_CHANNELDOWN); break;
1da177e4
LT		 410 case 0x0b0: map_key_clear(KEY_PLAY); break;
411 case 0x0b1: map_key_clear(KEY_PAUSE); break;
412 case 0x0b2: map_key_clear(KEY_RECORD); break;
413 case 0x0b3: map_key_clear(KEY_FASTFORWARD); break;
414 case 0x0b4: map_key_clear(KEY_REWIND); break;
415 case 0x0b5: map_key_clear(KEY_NEXTSONG); break;
416 case 0x0b6: map_key_clear(KEY_PREVIOUSSONG); break;
417 case 0x0b7: map_key_clear(KEY_STOPCD); break;
418 case 0x0b8: map_key_clear(KEY_EJECTCD); break;
419 case 0x0cd: map_key_clear(KEY_PLAYPAUSE); break;
420 case 0x0e0: map_abs_clear(ABS_VOLUME); break;
421 case 0x0e2: map_key_clear(KEY_MUTE); break;
422 case 0x0e5: map_key_clear(KEY_BASSBOOST); break;
423 case 0x0e9: map_key_clear(KEY_VOLUMEUP); break;
424 case 0x0ea: map_key_clear(KEY_VOLUMEDOWN); break;
425 case 0x183: map_key_clear(KEY_CONFIG); break;
426 case 0x18a: map_key_clear(KEY_MAIL); break;
427 case 0x192: map_key_clear(KEY_CALC); break;
428 case 0x194: map_key_clear(KEY_FILE); break;
8a409b01
VP		 429 case 0x1a7: map_key_clear(KEY_DOCUMENTS); break;
430 case 0x201: map_key_clear(KEY_NEW); break;
431 case 0x207: map_key_clear(KEY_SAVE); break;
432 case 0x208: map_key_clear(KEY_PRINT); break;
433 case 0x209: map_key_clear(KEY_PROPS); break;
1da177e4
LT		 434 case 0x21a: map_key_clear(KEY_UNDO); break;
435 case 0x21b: map_key_clear(KEY_COPY); break;
436 case 0x21c: map_key_clear(KEY_CUT); break;
437 case 0x21d: map_key_clear(KEY_PASTE); break;
438 case 0x221: map_key_clear(KEY_FIND); break;
439 case 0x223: map_key_clear(KEY_HOMEPAGE); break;
440 case 0x224: map_key_clear(KEY_BACK); break;
441 case 0x225: map_key_clear(KEY_FORWARD); break;
442 case 0x226: map_key_clear(KEY_STOP); break;
443 case 0x227: map_key_clear(KEY_REFRESH); break;
444 case 0x22a: map_key_clear(KEY_BOOKMARKS); break;
940824b0
VP		 445 case 0x233: map_key_clear(KEY_SCROLLUP); break;
446 case 0x234: map_key_clear(KEY_SCROLLDOWN); break;
1da177e4 447 case 0x238: map_rel(REL_HWHEEL); break;
8a409b01
VP		 448 case 0x279: map_key_clear(KEY_REDO); break;
449 case 0x289: map_key_clear(KEY_REPLY); break;
450 case 0x28b: map_key_clear(KEY_FORWARDMAIL); break;
451 case 0x28c: map_key_clear(KEY_SEND); break;
940824b0
VP		 452
453 /* Reported on a Cherry Cymotion keyboard */
454 case 0x301: map_key_clear(KEY_PROG1); break;
455 case 0x302: map_key_clear(KEY_PROG2); break;
456 case 0x303: map_key_clear(KEY_PROG3); break;
457
8a409b01 458 default: goto ignore;
1da177e4
LT		 459 }
460 break;
461
462 case HID_UP_HPVENDOR: /* Reported on a Dutch layout HP5308 */
463
464 set_bit(EV_REP, input->evbit);
465 switch (usage->hid & HID_USAGE) {
466 case 0x021: map_key_clear(KEY_PRINT); break;
467 case 0x070: map_key_clear(KEY_HP); break;
468 case 0x071: map_key_clear(KEY_CAMERA); break;
469 case 0x072: map_key_clear(KEY_SOUND); break;
470 case 0x073: map_key_clear(KEY_QUESTION); break;
471 case 0x080: map_key_clear(KEY_EMAIL); break;
472 case 0x081: map_key_clear(KEY_CHAT); break;
473 case 0x082: map_key_clear(KEY_SEARCH); break;
474 case 0x083: map_key_clear(KEY_CONNECT); break;
475 case 0x084: map_key_clear(KEY_FINANCE); break;
476 case 0x085: map_key_clear(KEY_SPORT); break;
477 case 0x086: map_key_clear(KEY_SHOP); break;
478 default: goto ignore;
479 }
480 break;
481
482 case HID_UP_MSVENDOR:
1da177e4 483 goto ignore;
05f091ab 484
e875ce37
SP		 485 case HID_UP_CUSTOM: /* Reported on Logitech and Powerbook USB keyboards */
486
487 set_bit(EV_REP, input->evbit);
488 switch(usage->hid & HID_USAGE) {
eab9edd2
MH		 489 case 0x003:
490 /* The fn key on Apple PowerBooks */
491 map_key_clear(KEY_FN);
492 hidinput_pb_setup(input);
493 break;
494
e875ce37
SP		 495 default: goto ignore;
496 }
497 break;
498
499 case HID_UP_LOGIVENDOR: /* Reported on Logitech Ultra X Media Remote */
39fd748f
MG		 500
501 set_bit(EV_REP, input->evbit);
502 switch(usage->hid & HID_USAGE) {
503 case 0x004: map_key_clear(KEY_AGAIN); break;
504 case 0x00d: map_key_clear(KEY_HOME); break;
505 case 0x024: map_key_clear(KEY_SHUFFLE); break;
506 case 0x025: map_key_clear(KEY_TV); break;
507 case 0x026: map_key_clear(KEY_MENU); break;
508 case 0x031: map_key_clear(KEY_AUDIO); break;
50a598de 509 case 0x032: map_key_clear(KEY_TEXT); break;
39fd748f
MG		 510 case 0x033: map_key_clear(KEY_LAST); break;
511 case 0x047: map_key_clear(KEY_MP3); break;
512 case 0x048: map_key_clear(KEY_DVD); break;
513 case 0x049: map_key_clear(KEY_MEDIA); break;
514 case 0x04a: map_key_clear(KEY_VIDEO); break;
515 case 0x04b: map_key_clear(KEY_ANGLE); break;
516 case 0x04c: map_key_clear(KEY_LANGUAGE); break;
517 case 0x04d: map_key_clear(KEY_SUBTITLE); break;
518 case 0x051: map_key_clear(KEY_RED); break;
519 case 0x052: map_key_clear(KEY_CLOSE); break;
520 default: goto ignore;
521 }
522 break;
523
1da177e4
LT		 524 case HID_UP_PID:
525
1da177e4 526 switch(usage->hid & HID_USAGE) {
1da177e4
LT		 527 case 0xa4: map_key_clear(BTN_DEAD); break;
528 default: goto ignore;
529 }
530 break;
531
532 default:
533 unknown:
534 if (field->report_size == 1) {
535 if (field->report->type == HID_OUTPUT_REPORT) {
536 map_led(LED_MISC);
537 break;
538 }
539 map_key(BTN_MISC);
540 break;
541 }
542 if (field->flags & HID_MAIN_ITEM_RELATIVE) {
543 map_rel(REL_MISC);
544 break;
545 }
546 map_abs(ABS_MISC);
547 break;
548 }
549
a82e49b8
BM		 550 if (device->quirks & HID_QUIRK_MIGHTYMOUSE) {
551 if (usage->hid == HID_GD_Z)
552 map_rel(REL_HWHEEL);
553 else if (usage->code == BTN_1)
554 map_key(BTN_2);
555 else if (usage->code == BTN_2)
556 map_key(BTN_1);
557 }
c58de6d9 558
1da177e4 559 if ((device->quirks & (HID_QUIRK_2WHEEL_MOUSE_HACK_7 | HID_QUIRK_2WHEEL_MOUSE_HACK_5)) &&
05f091ab 560 (usage->type == EV_REL) && (usage->code == REL_WHEEL))
1da177e4
LT		 561 set_bit(REL_HWHEEL, bit);
562
563 if (((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
564 || ((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007)))
565 goto ignore;
566
a82e49b8
BM		 567 set_bit(usage->type, input->evbit);
568
569 while (usage->code <= max && test_and_set_bit(usage->code, bit))
570 usage->code = find_next_zero_bit(bit, max + 1, usage->code);
571
572 if (usage->code > max)
573 goto ignore;
574
575
1da177e4
LT		 576 if (usage->type == EV_ABS) {
577
578 int a = field->logical_minimum;
579 int b = field->logical_maximum;
580
581 if ((device->quirks & HID_QUIRK_BADPAD) && (usage->code == ABS_X || usage->code == ABS_Y)) {
582 a = field->logical_minimum = 0;
583 b = field->logical_maximum = 255;
584 }
05f091ab 585
1da177e4
LT		 586 if (field->application == HID_GD_GAMEPAD || field->application == HID_GD_JOYSTICK)
587 input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);
588 else input_set_abs_params(input, usage->code, a, b, 0, 0);
05f091ab 589
1da177e4
LT		 590 }
591
cb786235
DT		 592 if (usage->type == EV_ABS &&
593 (usage->hat_min < usage->hat_max || usage->hat_dir)) {
1da177e4
LT		 594 int i;
595 for (i = usage->code; i < usage->code + 2 && i <= max; i++) {
596 input_set_abs_params(input, i, -1, 1, 0, 0);
597 set_bit(i, input->absbit);
598 }
599 if (usage->hat_dir && !field->dpad)
600 field->dpad = usage->code;
601 }
602
603#ifdef DEBUG
604 resolv_event(usage->type, usage->code);
605 printk("\n");
606#endif
607 return;
608
609ignore:
610#ifdef DEBUG
611 printk("IGNORED\n");
612#endif
613 return;
614}
615
616void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, struct pt_regs *regs)
617{
a9b2e917 618 struct input_dev *input;
1da177e4
LT		 619 int *quirks = &hid->quirks;
620
a9b2e917 621 if (!field->hidinput)
1da177e4 622 return;
c5b7c7c3
DT		 623
624 input = field->hidinput->input;
1da177e4
LT		 625
626 input_regs(input, regs);
627
628 if (!usage->type)
629 return;
630
631 if (((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
632 || ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007))) {
633 if (value) hid->quirks |= HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
634 else hid->quirks &= ~HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
635 return;
636 }
637
a82e49b8
BM		 638 if ((hid->quirks & HID_QUIRK_INVERT_HWHEEL) && (usage->code == REL_HWHEEL)) {
639 input_event(input, usage->type, usage->code, -value);
640 return;
641 }
642
1da177e4
LT		 643 if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_ON) && (usage->code == REL_WHEEL)) {
644 input_event(input, usage->type, REL_HWHEEL, value);
645 return;
646 }
647
eab9edd2
MH		 648 if ((hid->quirks & HID_QUIRK_POWERBOOK_HAS_FN) && hidinput_pb_event(hid, input, usage, value))
649 return;
650
05f091ab 651 if (usage->hat_min < usage->hat_max || usage->hat_dir) {
1da177e4
LT		 652 int hat_dir = usage->hat_dir;
653 if (!hat_dir)
654 hat_dir = (value - usage->hat_min) * 8 / (usage->hat_max - usage->hat_min + 1) + 1;
655 if (hat_dir < 0 || hat_dir > 8) hat_dir = 0;
656 input_event(input, usage->type, usage->code , hid_hat_to_axis[hat_dir].x);
657 input_event(input, usage->type, usage->code + 1, hid_hat_to_axis[hat_dir].y);
658 return;
659 }
660
661 if (usage->hid == (HID_UP_DIGITIZER | 0x003c)) { /* Invert */
662 *quirks = value ? (*quirks | HID_QUIRK_INVERT) : (*quirks & ~HID_QUIRK_INVERT);
663 return;
664 }
665
666 if (usage->hid == (HID_UP_DIGITIZER | 0x0032)) { /* InRange */
667 if (value) {
668 input_event(input, usage->type, (*quirks & HID_QUIRK_INVERT) ? BTN_TOOL_RUBBER : usage->code, 1);
669 return;
670 }
671 input_event(input, usage->type, usage->code, 0);
672 input_event(input, usage->type, BTN_TOOL_RUBBER, 0);
673 return;
674 }
675
676 if (usage->hid == (HID_UP_DIGITIZER | 0x0030) && (*quirks & HID_QUIRK_NOTOUCH)) { /* Pressure */
677 int a = field->logical_minimum;
678 int b = field->logical_maximum;
679 input_event(input, EV_KEY, BTN_TOUCH, value > a + ((b - a) >> 3));
680 }
681
682 if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
224ee88f 683 dbg("Maximum Effects - %d",value);
1da177e4
LT		 684 return;
685 }
686
687 if (usage->hid == (HID_UP_PID | 0x7fUL)) {
688 dbg("PID Pool Report\n");
689 return;
690 }
691
eab9edd2 692 if ((usage->type == EV_KEY) && (usage->code == 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
1da177e4
LT		 693 return;
694
695 input_event(input, usage->type, usage->code, value);
696
697 if ((field->flags & HID_MAIN_ITEM_RELATIVE) && (usage->type == EV_KEY))
698 input_event(input, usage->type, usage->code, 0);
699}
700
701void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
702{
1da177e4
LT		 703 struct hid_input *hidinput;
704
c5b7c7c3
DT		 705 list_for_each_entry(hidinput, &hid->inputs, list)
706 input_sync(hidinput->input);
1da177e4
LT		 707}
708
709static int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field)
710{
711 struct hid_report *report;
712 int i, j;
713
714 list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
715 for (i = 0; i < report->maxfield; i++) {
716 *field = report->field[i];
717 for (j = 0; j < (*field)->maxusage; j++)
718 if ((*field)->usage[j].type == type && (*field)->usage[j].code == code)
719 return j;
720 }
721 }
722 return -1;
723}
724
725static int hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
726{
727 struct hid_device *hid = dev->private;
728 struct hid_field *field;
729 int offset;
730
731 if (type == EV_FF)
dc76c912 732 return input_ff_event(dev, type, code, value);
1da177e4
LT		 733
734 if (type != EV_LED)
735 return -1;
736
737 if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
738 warn("event field not found");
739 return -1;
740 }
741
742 hid_set_field(field, offset, value);
743 hid_submit_report(hid, field->report, USB_DIR_OUT);
744
745 return 0;
746}
747
748static int hidinput_open(struct input_dev *dev)
749{
750 struct hid_device *hid = dev->private;
751 return hid_open(hid);
752}
753
754static void hidinput_close(struct input_dev *dev)
755{
756 struct hid_device *hid = dev->private;
757 hid_close(hid);
758}
759
760/*
761 * Register the input device; print a message.
762 * Configure the input layer interface
763 * Read all reports and initialize the absolute field values.
764 */
765
766int hidinput_connect(struct hid_device *hid)
767{
768 struct usb_device *dev = hid->dev;
769 struct hid_report *report;
770 struct hid_input *hidinput = NULL;
c5b7c7c3 771 struct input_dev *input_dev;
1da177e4
LT		 772 int i, j, k;
773
774 INIT_LIST_HEAD(&hid->inputs);
775
776 for (i = 0; i < hid->maxcollection; i++)
777 if (hid->collection[i].type == HID_COLLECTION_APPLICATION ||
778 hid->collection[i].type == HID_COLLECTION_PHYSICAL)
05f091ab 779 if (IS_INPUT_APPLICATION(hid->collection[i].usage))
1da177e4
LT		 780 break;
781
782 if (i == hid->maxcollection)
783 return -1;
784
785 for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++)
786 list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
787
788 if (!report->maxfield)
789 continue;
790
791 if (!hidinput) {
c5b7c7c3
DT		 792 hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
793 input_dev = input_allocate_device();
794 if (!hidinput || !input_dev) {
795 kfree(hidinput);
796 input_free_device(input_dev);
1da177e4
LT		 797 err("Out of memory during hid input probe");
798 return -1;
799 }
1da177e4 800
c5b7c7c3
DT		 801 input_dev->private = hid;
802 input_dev->event = hidinput_input_event;
803 input_dev->open = hidinput_open;
804 input_dev->close = hidinput_close;
1da177e4 805
c5b7c7c3
DT		 806 input_dev->name = hid->name;
807 input_dev->phys = hid->phys;
808 input_dev->uniq = hid->uniq;
809 usb_to_input_id(dev, &input_dev->id);
810 input_dev->cdev.dev = &hid->intf->dev;
1da177e4 811
c5b7c7c3
DT		 812 hidinput->input = input_dev;
813 list_add_tail(&hidinput->list, &hid->inputs);
1da177e4
LT		 814 }
815
816 for (i = 0; i < report->maxfield; i++)
817 for (j = 0; j < report->field[i]->maxusage; j++)
818 hidinput_configure_usage(hidinput, report->field[i],
819 report->field[i]->usage + j);
05f091ab 820
1da177e4
LT		 821 if (hid->quirks & HID_QUIRK_MULTI_INPUT) {
822 /* This will leave hidinput NULL, so that it
823 * allocates another one if we have more inputs on
824 * the same interface. Some devices (e.g. Happ's
825 * UGCI) cram a lot of unrelated inputs into the
826 * same interface. */
827 hidinput->report = report;
c5b7c7c3 828 input_register_device(hidinput->input);
1da177e4
LT		 829 hidinput = NULL;
830 }
831 }
832
833 /* This only gets called when we are a single-input (most of the
834 * time). IOW, not a HID_QUIRK_MULTI_INPUT. The hid_ff_init() is
835 * only useful in this case, and not for multi-input quirks. */
836 if (hidinput) {
837 hid_ff_init(hid);
c5b7c7c3 838 input_register_device(hidinput->input);
1da177e4
LT		 839 }
840
841 return 0;
842}
843
844void hidinput_disconnect(struct hid_device *hid)
845{
c5b7c7c3 846 struct hid_input *hidinput, *next;
1da177e4 847
c5b7c7c3 848 list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
1da177e4 849 list_del(&hidinput->list);
c5b7c7c3 850 input_unregister_device(hidinput->input);
1da177e4
LT		 851 kfree(hidinput);
852 }
853}
Ubuntu Hirsute Linux kernel mirror