This source file includes following definitions.
- adbhid_keyboard_input
- adbhid_input_keycode
- adbhid_mouse_input
- adbhid_buttons_input
- leds_done
- real_leds
- adbhid_kbd_event
- adbhid_kbd_capslock_remember
- adb_message_handler
- adbhid_input_register
- adbhid_input_unregister
- adbhid_input_reregister
- adbhid_input_devcleanup
- adbhid_probe
- init_trackpad
- init_trackball
- init_turbomouse
- init_microspeed
- init_ms_a3
- adbhid_init
- adbhid_exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38 #include <linux/module.h>
39 #include <linux/slab.h>
40 #include <linux/init.h>
41 #include <linux/notifier.h>
42 #include <linux/input.h>
43
44 #include <linux/adb.h>
45 #include <linux/cuda.h>
46 #include <linux/pmu.h>
47
48 #include <asm/machdep.h>
49 #ifdef CONFIG_PPC_PMAC
50 #include <asm/backlight.h>
51 #include <asm/pmac_feature.h>
52 #endif
53
54 MODULE_AUTHOR("Franz Sirl <Franz.Sirl-kernel@lauterbach.com>");
55
56 static int restore_capslock_events;
57 module_param(restore_capslock_events, int, 0644);
58 MODULE_PARM_DESC(restore_capslock_events,
59 "Produce keypress events for capslock on both keyup and keydown.");
60
61 #define KEYB_KEYREG 0
62 #define KEYB_LEDREG 2
63 #define MOUSE_DATAREG 0
64
65 static int adb_message_handler(struct notifier_block *, unsigned long, void *);
66 static struct notifier_block adbhid_adb_notifier = {
67 .notifier_call = adb_message_handler,
68 };
69
70
71 #define ADB_KEY_DEL 0x33
72 #define ADB_KEY_CMD 0x37
73 #define ADB_KEY_CAPSLOCK 0x39
74 #define ADB_KEY_FN 0x3f
75 #define ADB_KEY_FWDEL 0x75
76 #define ADB_KEY_POWER_OLD 0x7e
77 #define ADB_KEY_POWER 0x7f
78
79 static const u16 adb_to_linux_keycodes[128] = {
80 KEY_A,
81 KEY_S,
82 KEY_D,
83 KEY_F,
84 KEY_H,
85 KEY_G,
86 KEY_Z,
87 KEY_X,
88 KEY_C,
89 KEY_V,
90 KEY_102ND,
91 KEY_B,
92 KEY_Q,
93 KEY_W,
94 KEY_E,
95 KEY_R,
96 KEY_Y,
97 KEY_T,
98 KEY_1,
99 KEY_2,
100 KEY_3,
101 KEY_4,
102 KEY_6,
103 KEY_5,
104 KEY_EQUAL,
105 KEY_9,
106 KEY_7,
107 KEY_MINUS,
108 KEY_8,
109 KEY_0,
110 KEY_RIGHTBRACE,
111 KEY_O,
112 KEY_U,
113 KEY_LEFTBRACE,
114 KEY_I,
115 KEY_P,
116 KEY_ENTER,
117 KEY_L,
118 KEY_J,
119 KEY_APOSTROPHE,
120 KEY_K,
121 KEY_SEMICOLON,
122 KEY_BACKSLASH,
123 KEY_COMMA,
124 KEY_SLASH,
125 KEY_N,
126 KEY_M,
127 KEY_DOT,
128 KEY_TAB,
129 KEY_SPACE,
130 KEY_GRAVE,
131 KEY_BACKSPACE,
132 KEY_KPENTER,
133 KEY_ESC,
134 KEY_LEFTCTRL,
135 KEY_LEFTMETA,
136 KEY_LEFTSHIFT,
137 KEY_CAPSLOCK,
138 KEY_LEFTALT,
139 KEY_LEFT,
140 KEY_RIGHT,
141 KEY_DOWN,
142 KEY_UP,
143 KEY_FN,
144 0,
145 KEY_KPDOT,
146 0,
147 KEY_KPASTERISK,
148 0,
149 KEY_KPPLUS,
150 0,
151 KEY_NUMLOCK,
152 0,
153 0,
154 0,
155 KEY_KPSLASH,
156 KEY_KPENTER,
157 0,
158 KEY_KPMINUS,
159 0,
160 0,
161 KEY_KPEQUAL,
162 KEY_KP0,
163 KEY_KP1,
164 KEY_KP2,
165 KEY_KP3,
166 KEY_KP4,
167 KEY_KP5,
168 KEY_KP6,
169 KEY_KP7,
170 0,
171 KEY_KP8,
172 KEY_KP9,
173 KEY_YEN,
174 KEY_RO,
175 KEY_KPCOMMA,
176 KEY_F5,
177 KEY_F6,
178 KEY_F7,
179 KEY_F3,
180 KEY_F8,
181 KEY_F9,
182 KEY_HANJA,
183 KEY_F11,
184 KEY_HANGEUL,
185 KEY_SYSRQ,
186 0,
187 KEY_SCROLLLOCK,
188 0,
189 KEY_F10,
190 KEY_COMPOSE,
191 KEY_F12,
192 0,
193 KEY_PAUSE,
194 KEY_INSERT,
195 KEY_HOME,
196 KEY_PAGEUP,
197 KEY_DELETE,
198 KEY_F4,
199 KEY_END,
200 KEY_F2,
201 KEY_PAGEDOWN,
202 KEY_F1,
203 KEY_RIGHTSHIFT,
204 KEY_RIGHTALT,
205 KEY_RIGHTCTRL,
206 KEY_RIGHTMETA,
207 KEY_POWER,
208 };
209
210 struct adbhid {
211 struct input_dev *input;
212 int id;
213 int default_id;
214 int original_handler_id;
215 int current_handler_id;
216 int mouse_kind;
217 u16 *keycode;
218 char name[64];
219 char phys[32];
220 int flags;
221 };
222
223 #define FLAG_FN_KEY_PRESSED 0x00000001
224 #define FLAG_POWER_FROM_FN 0x00000002
225 #define FLAG_EMU_FWDEL_DOWN 0x00000004
226 #define FLAG_CAPSLOCK_TRANSLATE 0x00000008
227 #define FLAG_CAPSLOCK_DOWN 0x00000010
228 #define FLAG_CAPSLOCK_IGNORE_NEXT 0x00000020
229 #define FLAG_POWER_KEY_PRESSED 0x00000040
230
231 static struct adbhid *adbhid[16];
232
233 static void adbhid_probe(void);
234
235 static void adbhid_input_keycode(int, int, int);
236
237 static void init_trackpad(int id);
238 static void init_trackball(int id);
239 static void init_turbomouse(int id);
240 static void init_microspeed(int id);
241 static void init_ms_a3(int id);
242
243 static struct adb_ids keyboard_ids;
244 static struct adb_ids mouse_ids;
245 static struct adb_ids buttons_ids;
246
247
248 #define ADB_KEYBOARD_UNKNOWN 0
249 #define ADB_KEYBOARD_ANSI 0x0100
250 #define ADB_KEYBOARD_ISO 0x0200
251 #define ADB_KEYBOARD_JIS 0x0300
252
253
254 #define ADBMOUSE_STANDARD_100 0
255 #define ADBMOUSE_STANDARD_200 1
256 #define ADBMOUSE_EXTENDED 2
257 #define ADBMOUSE_TRACKBALL 3
258 #define ADBMOUSE_TRACKPAD 4
259 #define ADBMOUSE_TURBOMOUSE5 5
260 #define ADBMOUSE_MICROSPEED 6
261 #define ADBMOUSE_TRACKBALLPRO 7
262 #define ADBMOUSE_MS_A3 8
263 #define ADBMOUSE_MACALLY2 9
264
265 static void
266 adbhid_keyboard_input(unsigned char *data, int nb, int apoll)
267 {
268 int id = (data[0] >> 4) & 0x0f;
269
270 if (!adbhid[id]) {
271 pr_err("ADB HID on ID %d not yet registered, packet %#02x, %#02x, %#02x, %#02x\n",
272 id, data[0], data[1], data[2], data[3]);
273 return;
274 }
275
276
277 if (nb != 3 || (data[0] & 3) != KEYB_KEYREG)
278 return;
279 adbhid_input_keycode(id, data[1], 0);
280 if (!(data[2] == 0xff || (data[2] == 0x7f && data[1] == 0x7f)))
281 adbhid_input_keycode(id, data[2], 0);
282 }
283
284 static void
285 adbhid_input_keycode(int id, int scancode, int repeat)
286 {
287 struct adbhid *ahid = adbhid[id];
288 int keycode, up_flag, key;
289
290 keycode = scancode & 0x7f;
291 up_flag = scancode & 0x80;
292
293 if (restore_capslock_events) {
294 if (keycode == ADB_KEY_CAPSLOCK && !up_flag) {
295
296
297 if (ahid->flags & FLAG_CAPSLOCK_IGNORE_NEXT) {
298
299
300 ahid->flags &= ~FLAG_CAPSLOCK_IGNORE_NEXT;
301 return;
302 } else {
303 ahid->flags |= FLAG_CAPSLOCK_TRANSLATE
304 | FLAG_CAPSLOCK_DOWN;
305 }
306 } else if (scancode == 0xff &&
307 !(ahid->flags & FLAG_POWER_KEY_PRESSED)) {
308
309
310
311 if (ahid->flags & FLAG_CAPSLOCK_TRANSLATE) {
312 keycode = ADB_KEY_CAPSLOCK;
313 if (ahid->flags & FLAG_CAPSLOCK_DOWN) {
314
315 up_flag = 1;
316 ahid->flags &= ~FLAG_CAPSLOCK_DOWN;
317 } else {
318
319 up_flag = 0;
320 ahid->flags &= ~FLAG_CAPSLOCK_TRANSLATE;
321 }
322 } else {
323 pr_info("Spurious caps lock event (scancode 0xff).\n");
324 }
325 }
326 }
327
328 switch (keycode) {
329 case ADB_KEY_CAPSLOCK:
330 if (!restore_capslock_events) {
331
332 input_report_key(ahid->input, KEY_CAPSLOCK, 1);
333 input_sync(ahid->input);
334 input_report_key(ahid->input, KEY_CAPSLOCK, 0);
335 input_sync(ahid->input);
336 return;
337 }
338 break;
339 #ifdef CONFIG_PPC_PMAC
340 case ADB_KEY_POWER_OLD:
341 switch(pmac_call_feature(PMAC_FTR_GET_MB_INFO,
342 NULL, PMAC_MB_INFO_MODEL, 0)) {
343 case PMAC_TYPE_COMET:
344 case PMAC_TYPE_HOOPER:
345 case PMAC_TYPE_KANGA:
346 keycode = ADB_KEY_POWER;
347 }
348 break;
349 case ADB_KEY_POWER:
350
351 if (up_flag)
352 ahid->flags &= ~FLAG_POWER_KEY_PRESSED;
353 else
354 ahid->flags |= FLAG_POWER_KEY_PRESSED;
355
356
357 if (ahid->flags & FLAG_FN_KEY_PRESSED) {
358 keycode = ADB_KEY_CMD;
359 if (up_flag)
360 ahid->flags &= ~FLAG_POWER_FROM_FN;
361 else
362 ahid->flags |= FLAG_POWER_FROM_FN;
363 } else if (ahid->flags & FLAG_POWER_FROM_FN) {
364 keycode = ADB_KEY_CMD;
365 ahid->flags &= ~FLAG_POWER_FROM_FN;
366 }
367 break;
368 case ADB_KEY_FN:
369
370 if (up_flag) {
371 ahid->flags &= ~FLAG_FN_KEY_PRESSED;
372
373 if (ahid->flags & FLAG_EMU_FWDEL_DOWN) {
374 ahid->flags &= ~FLAG_EMU_FWDEL_DOWN;
375 keycode = ADB_KEY_FWDEL;
376 break;
377 }
378 } else
379 ahid->flags |= FLAG_FN_KEY_PRESSED;
380 break;
381 case ADB_KEY_DEL:
382
383 if (ahid->flags & FLAG_FN_KEY_PRESSED) {
384 keycode = ADB_KEY_FWDEL;
385 if (up_flag)
386 ahid->flags &= ~FLAG_EMU_FWDEL_DOWN;
387 else
388 ahid->flags |= FLAG_EMU_FWDEL_DOWN;
389 }
390 break;
391 #endif
392 }
393
394 key = adbhid[id]->keycode[keycode];
395 if (key) {
396 input_report_key(adbhid[id]->input, key, !up_flag);
397 input_sync(adbhid[id]->input);
398 } else
399 pr_info("Unhandled ADB key (scancode %#02x) %s.\n", keycode,
400 up_flag ? "released" : "pressed");
401
402 }
403
404 static void
405 adbhid_mouse_input(unsigned char *data, int nb, int autopoll)
406 {
407 int id = (data[0] >> 4) & 0x0f;
408
409 if (!adbhid[id]) {
410 pr_err("ADB HID on ID %d not yet registered\n", id);
411 return;
412 }
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458 switch (adbhid[id]->mouse_kind)
459 {
460 case ADBMOUSE_TRACKPAD:
461 data[1] = (data[1] & 0x7f) | ((data[1] & data[2]) & 0x80);
462 data[2] = data[2] | 0x80;
463 break;
464 case ADBMOUSE_MICROSPEED:
465 data[1] = (data[1] & 0x7f) | ((data[3] & 0x01) << 7);
466 data[2] = (data[2] & 0x7f) | ((data[3] & 0x02) << 6);
467 data[3] = (data[3] & 0x77) | ((data[3] & 0x04) << 5)
468 | (data[3] & 0x08);
469 break;
470 case ADBMOUSE_TRACKBALLPRO:
471 data[1] = (data[1] & 0x7f) | (((data[3] & 0x04) << 5)
472 & ((data[3] & 0x08) << 4));
473 data[2] = (data[2] & 0x7f) | ((data[3] & 0x01) << 7);
474 data[3] = (data[3] & 0x77) | ((data[3] & 0x02) << 6);
475 break;
476 case ADBMOUSE_MS_A3:
477 data[1] = (data[1] & 0x7f) | ((data[3] & 0x01) << 7);
478 data[2] = (data[2] & 0x7f) | ((data[3] & 0x02) << 6);
479 data[3] = ((data[3] & 0x04) << 5);
480 break;
481 case ADBMOUSE_MACALLY2:
482 data[3] = (data[2] & 0x80) ? 0x80 : 0x00;
483 data[2] |= 0x80;
484 nb=4;
485 break;
486 }
487
488 input_report_key(adbhid[id]->input, BTN_LEFT, !((data[1] >> 7) & 1));
489 input_report_key(adbhid[id]->input, BTN_MIDDLE, !((data[2] >> 7) & 1));
490
491 if (nb >= 4 && adbhid[id]->mouse_kind != ADBMOUSE_TRACKPAD)
492 input_report_key(adbhid[id]->input, BTN_RIGHT, !((data[3] >> 7) & 1));
493
494 input_report_rel(adbhid[id]->input, REL_X,
495 ((data[2]&0x7f) < 64 ? (data[2]&0x7f) : (data[2]&0x7f)-128 ));
496 input_report_rel(adbhid[id]->input, REL_Y,
497 ((data[1]&0x7f) < 64 ? (data[1]&0x7f) : (data[1]&0x7f)-128 ));
498
499 input_sync(adbhid[id]->input);
500 }
501
502 static void
503 adbhid_buttons_input(unsigned char *data, int nb, int autopoll)
504 {
505 int id = (data[0] >> 4) & 0x0f;
506
507 if (!adbhid[id]) {
508 pr_err("ADB HID on ID %d not yet registered\n", id);
509 return;
510 }
511
512 switch (adbhid[id]->original_handler_id) {
513 default:
514 case 0x02:
515 {
516 int down = (data[1] == (data[1] & 0xf));
517
518 switch (data[1] & 0x0f) {
519 case 0x0:
520 input_report_key(adbhid[id]->input, KEY_SOUND, down);
521 break;
522
523 case 0x1:
524 input_report_key(adbhid[id]->input, KEY_MUTE, down);
525 break;
526
527 case 0x2:
528 input_report_key(adbhid[id]->input, KEY_VOLUMEDOWN, down);
529 break;
530
531 case 0x3:
532 input_report_key(adbhid[id]->input, KEY_VOLUMEUP, down);
533 break;
534
535 default:
536 pr_info("Unhandled ADB_MISC event %02x, %02x, %02x, %02x\n",
537 data[0], data[1], data[2], data[3]);
538 break;
539 }
540 }
541 break;
542
543 case 0x1f:
544 {
545 int down = (data[1] == (data[1] & 0xf));
546
547
548
549
550
551
552 switch (data[1] & 0x0f) {
553 case 0x8:
554 input_report_key(adbhid[id]->input, KEY_MUTE, down);
555 break;
556
557 case 0x7:
558 input_report_key(adbhid[id]->input, KEY_VOLUMEDOWN, down);
559 break;
560
561 case 0x6:
562 input_report_key(adbhid[id]->input, KEY_VOLUMEUP, down);
563 break;
564
565 case 0xb:
566 input_report_key(adbhid[id]->input, KEY_EJECTCD, down);
567 break;
568
569 case 0xa:
570 #ifdef CONFIG_PMAC_BACKLIGHT
571 if (down)
572 pmac_backlight_key_down();
573 #endif
574 input_report_key(adbhid[id]->input, KEY_BRIGHTNESSDOWN, down);
575 break;
576
577 case 0x9:
578 #ifdef CONFIG_PMAC_BACKLIGHT
579 if (down)
580 pmac_backlight_key_up();
581 #endif
582 input_report_key(adbhid[id]->input, KEY_BRIGHTNESSUP, down);
583 break;
584
585 case 0xc:
586 input_report_key(adbhid[id]->input, KEY_SWITCHVIDEOMODE, down);
587 break;
588
589 case 0xd:
590 input_report_key(adbhid[id]->input, KEY_KBDILLUMTOGGLE, down);
591 break;
592
593 case 0xe:
594 input_report_key(adbhid[id]->input, KEY_KBDILLUMDOWN, down);
595 break;
596
597 case 0xf:
598 switch (data[1]) {
599 case 0x8f:
600 case 0x0f:
601
602 input_report_key(adbhid[id]->input, KEY_KBDILLUMUP, down);
603 break;
604
605 case 0x7f:
606 case 0xff:
607
608 break;
609
610 default:
611 pr_info("Unhandled ADB_MISC event %02x, %02x, %02x, %02x\n",
612 data[0], data[1], data[2], data[3]);
613 break;
614 }
615 break;
616 default:
617 pr_info("Unhandled ADB_MISC event %02x, %02x, %02x, %02x\n",
618 data[0], data[1], data[2], data[3]);
619 break;
620 }
621 }
622 break;
623 }
624
625 input_sync(adbhid[id]->input);
626 }
627
628 static struct adb_request led_request;
629 static int leds_pending[16];
630 static int leds_req_pending;
631 static int pending_devs[16];
632 static int pending_led_start;
633 static int pending_led_end;
634 static DEFINE_SPINLOCK(leds_lock);
635
636 static void leds_done(struct adb_request *req)
637 {
638 int leds = 0, device = 0, pending = 0;
639 unsigned long flags;
640
641 spin_lock_irqsave(&leds_lock, flags);
642
643 if (pending_led_start != pending_led_end) {
644 device = pending_devs[pending_led_start];
645 leds = leds_pending[device] & 0xff;
646 leds_pending[device] = 0;
647 pending_led_start++;
648 pending_led_start = (pending_led_start < 16) ? pending_led_start : 0;
649 pending = leds_req_pending;
650 } else
651 leds_req_pending = 0;
652 spin_unlock_irqrestore(&leds_lock, flags);
653 if (pending)
654 adb_request(&led_request, leds_done, 0, 3,
655 ADB_WRITEREG(device, KEYB_LEDREG), 0xff, ~leds);
656 }
657
658 static void real_leds(unsigned char leds, int device)
659 {
660 unsigned long flags;
661
662 spin_lock_irqsave(&leds_lock, flags);
663 if (!leds_req_pending) {
664 leds_req_pending = 1;
665 spin_unlock_irqrestore(&leds_lock, flags);
666 adb_request(&led_request, leds_done, 0, 3,
667 ADB_WRITEREG(device, KEYB_LEDREG), 0xff, ~leds);
668 return;
669 } else {
670 if (!(leds_pending[device] & 0x100)) {
671 pending_devs[pending_led_end] = device;
672 pending_led_end++;
673 pending_led_end = (pending_led_end < 16) ? pending_led_end : 0;
674 }
675 leds_pending[device] = leds | 0x100;
676 }
677 spin_unlock_irqrestore(&leds_lock, flags);
678 }
679
680
681
682
683
684 static int adbhid_kbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
685 {
686 struct adbhid *adbhid = input_get_drvdata(dev);
687 unsigned char leds;
688
689 switch (type) {
690 case EV_LED:
691 leds = (test_bit(LED_SCROLLL, dev->led) ? 4 : 0) |
692 (test_bit(LED_NUML, dev->led) ? 1 : 0) |
693 (test_bit(LED_CAPSL, dev->led) ? 2 : 0);
694 real_leds(leds, adbhid->id);
695 return 0;
696 }
697
698 return -1;
699 }
700
701 static void
702 adbhid_kbd_capslock_remember(void)
703 {
704 struct adbhid *ahid;
705 int i;
706
707 for (i = 1; i < 16; i++) {
708 ahid = adbhid[i];
709
710 if (ahid && ahid->id == ADB_KEYBOARD)
711 if (ahid->flags & FLAG_CAPSLOCK_TRANSLATE)
712 ahid->flags |= FLAG_CAPSLOCK_IGNORE_NEXT;
713 }
714 }
715
716 static int
717 adb_message_handler(struct notifier_block *this, unsigned long code, void *x)
718 {
719 switch (code) {
720 case ADB_MSG_PRE_RESET:
721 case ADB_MSG_POWERDOWN:
722
723 {
724 int i;
725 for (i = 1; i < 16; i++) {
726 if (adbhid[i])
727 del_timer_sync(&adbhid[i]->input->timer);
728 }
729 }
730
731
732 while (leds_req_pending)
733 adb_poll();
734
735
736
737
738
739
740 if (restore_capslock_events)
741 adbhid_kbd_capslock_remember();
742
743 break;
744
745 case ADB_MSG_POST_RESET:
746 adbhid_probe();
747 break;
748 }
749 return NOTIFY_DONE;
750 }
751
752 static int
753 adbhid_input_register(int id, int default_id, int original_handler_id,
754 int current_handler_id, int mouse_kind)
755 {
756 struct adbhid *hid;
757 struct input_dev *input_dev;
758 int err;
759 int i;
760 char *keyboard_type;
761
762 if (adbhid[id]) {
763 pr_err("Trying to reregister ADB HID on ID %d\n", id);
764 return -EEXIST;
765 }
766
767 adbhid[id] = hid = kzalloc(sizeof(struct adbhid), GFP_KERNEL);
768 input_dev = input_allocate_device();
769 if (!hid || !input_dev) {
770 err = -ENOMEM;
771 goto fail;
772 }
773
774 sprintf(hid->phys, "adb%d:%d.%02x/input", id, default_id, original_handler_id);
775
776 hid->input = input_dev;
777 hid->id = default_id;
778 hid->original_handler_id = original_handler_id;
779 hid->current_handler_id = current_handler_id;
780 hid->mouse_kind = mouse_kind;
781 hid->flags = 0;
782 input_set_drvdata(input_dev, hid);
783 input_dev->name = hid->name;
784 input_dev->phys = hid->phys;
785 input_dev->id.bustype = BUS_ADB;
786 input_dev->id.vendor = 0x0001;
787 input_dev->id.product = (id << 12) | (default_id << 8) | original_handler_id;
788 input_dev->id.version = 0x0100;
789
790 switch (default_id) {
791 case ADB_KEYBOARD:
792 hid->keycode = kmalloc(sizeof(adb_to_linux_keycodes), GFP_KERNEL);
793 if (!hid->keycode) {
794 err = -ENOMEM;
795 goto fail;
796 }
797
798 sprintf(hid->name, "ADB keyboard");
799
800 memcpy(hid->keycode, adb_to_linux_keycodes, sizeof(adb_to_linux_keycodes));
801
802 switch (original_handler_id) {
803 default:
804 keyboard_type = "<unknown>";
805 input_dev->id.version = ADB_KEYBOARD_UNKNOWN;
806 break;
807
808 case 0x01: case 0x02: case 0x03: case 0x06: case 0x08:
809 case 0x0C: case 0x10: case 0x18: case 0x1B: case 0x1C:
810 case 0xC0: case 0xC3: case 0xC6:
811 keyboard_type = "ANSI";
812 input_dev->id.version = ADB_KEYBOARD_ANSI;
813 break;
814
815 case 0x04: case 0x05: case 0x07: case 0x09: case 0x0D:
816 case 0x11: case 0x14: case 0x19: case 0x1D: case 0xC1:
817 case 0xC4: case 0xC7:
818 keyboard_type = "ISO, swapping keys";
819 input_dev->id.version = ADB_KEYBOARD_ISO;
820 i = hid->keycode[10];
821 hid->keycode[10] = hid->keycode[50];
822 hid->keycode[50] = i;
823 break;
824
825 case 0x12: case 0x15: case 0x16: case 0x17: case 0x1A:
826 case 0x1E: case 0xC2: case 0xC5: case 0xC8: case 0xC9:
827 keyboard_type = "JIS";
828 input_dev->id.version = ADB_KEYBOARD_JIS;
829 break;
830 }
831 pr_info("Detected ADB keyboard, type %s.\n", keyboard_type);
832
833 for (i = 0; i < 128; i++)
834 if (hid->keycode[i])
835 set_bit(hid->keycode[i], input_dev->keybit);
836
837 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) |
838 BIT_MASK(EV_REP);
839 input_dev->ledbit[0] = BIT_MASK(LED_SCROLLL) |
840 BIT_MASK(LED_CAPSL) | BIT_MASK(LED_NUML);
841 input_dev->event = adbhid_kbd_event;
842 input_dev->keycodemax = KEY_FN;
843 input_dev->keycodesize = sizeof(hid->keycode[0]);
844 break;
845
846 case ADB_MOUSE:
847 sprintf(hid->name, "ADB mouse");
848
849 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
850 input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
851 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
852 input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
853 break;
854
855 case ADB_MISC:
856 switch (original_handler_id) {
857 case 0x02:
858 sprintf(hid->name, "ADB adjustable keyboard buttons");
859 input_dev->evbit[0] = BIT_MASK(EV_KEY) |
860 BIT_MASK(EV_REP);
861 set_bit(KEY_SOUND, input_dev->keybit);
862 set_bit(KEY_MUTE, input_dev->keybit);
863 set_bit(KEY_VOLUMEUP, input_dev->keybit);
864 set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
865 break;
866 case 0x1f:
867 sprintf(hid->name, "ADB Powerbook buttons");
868 input_dev->evbit[0] = BIT_MASK(EV_KEY) |
869 BIT_MASK(EV_REP);
870 set_bit(KEY_MUTE, input_dev->keybit);
871 set_bit(KEY_VOLUMEUP, input_dev->keybit);
872 set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
873 set_bit(KEY_BRIGHTNESSUP, input_dev->keybit);
874 set_bit(KEY_BRIGHTNESSDOWN, input_dev->keybit);
875 set_bit(KEY_EJECTCD, input_dev->keybit);
876 set_bit(KEY_SWITCHVIDEOMODE, input_dev->keybit);
877 set_bit(KEY_KBDILLUMTOGGLE, input_dev->keybit);
878 set_bit(KEY_KBDILLUMDOWN, input_dev->keybit);
879 set_bit(KEY_KBDILLUMUP, input_dev->keybit);
880 break;
881 }
882 if (hid->name[0])
883 break;
884
885
886 default:
887 pr_info("Trying to register unknown ADB device to input layer.\n");
888 err = -ENODEV;
889 goto fail;
890 }
891
892 input_dev->keycode = hid->keycode;
893
894 err = input_register_device(input_dev);
895 if (err)
896 goto fail;
897
898 if (default_id == ADB_KEYBOARD) {
899
900
901
902 input_dev->rep[REP_DELAY] = 500;
903 input_dev->rep[REP_PERIOD] = 66;
904 }
905
906 return 0;
907
908 fail: input_free_device(input_dev);
909 if (hid) {
910 kfree(hid->keycode);
911 kfree(hid);
912 }
913 adbhid[id] = NULL;
914 return err;
915 }
916
917 static void adbhid_input_unregister(int id)
918 {
919 input_unregister_device(adbhid[id]->input);
920 kfree(adbhid[id]->keycode);
921 kfree(adbhid[id]);
922 adbhid[id] = NULL;
923 }
924
925
926 static u16
927 adbhid_input_reregister(int id, int default_id, int org_handler_id,
928 int cur_handler_id, int mk)
929 {
930 if (adbhid[id]) {
931 if (adbhid[id]->input->id.product !=
932 ((id << 12)|(default_id << 8)|org_handler_id)) {
933 adbhid_input_unregister(id);
934 adbhid_input_register(id, default_id, org_handler_id,
935 cur_handler_id, mk);
936 }
937 } else
938 adbhid_input_register(id, default_id, org_handler_id,
939 cur_handler_id, mk);
940 return 1<<id;
941 }
942
943 static void
944 adbhid_input_devcleanup(u16 exist)
945 {
946 int i;
947 for(i=1; i<16; i++)
948 if (adbhid[i] && !(exist&(1<<i)))
949 adbhid_input_unregister(i);
950 }
951
952 static void
953 adbhid_probe(void)
954 {
955 struct adb_request req;
956 int i, default_id, org_handler_id, cur_handler_id;
957 u16 reg = 0;
958
959 adb_register(ADB_MOUSE, 0, &mouse_ids, adbhid_mouse_input);
960 adb_register(ADB_KEYBOARD, 0, &keyboard_ids, adbhid_keyboard_input);
961 adb_register(ADB_MISC, 0, &buttons_ids, adbhid_buttons_input);
962
963 for (i = 0; i < keyboard_ids.nids; i++) {
964 int id = keyboard_ids.id[i];
965
966 adb_get_infos(id, &default_id, &org_handler_id);
967
968
969 adb_request(&req, NULL, ADBREQ_SYNC, 3,
970 ADB_WRITEREG(id, KEYB_LEDREG), 0xff, 0xff);
971
972
973
974
975 #if 0
976 if (!adb_try_handler_change(id, 5))
977 #endif
978 adb_try_handler_change(id, 3);
979
980 adb_get_infos(id, &default_id, &cur_handler_id);
981 printk(KERN_DEBUG "ADB keyboard at %d has handler 0x%X\n",
982 id, cur_handler_id);
983 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
984 cur_handler_id, 0);
985 }
986
987 for (i = 0; i < buttons_ids.nids; i++) {
988 int id = buttons_ids.id[i];
989
990 adb_get_infos(id, &default_id, &org_handler_id);
991 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
992 org_handler_id, 0);
993 }
994
995
996
997 for (i = 0; i < mouse_ids.nids; i++) {
998 int id = mouse_ids.id[i];
999 int mouse_kind;
1000 char *desc = "standard";
1001
1002 adb_get_infos(id, &default_id, &org_handler_id);
1003
1004 if (adb_try_handler_change(id, 4)) {
1005 mouse_kind = ADBMOUSE_EXTENDED;
1006 }
1007 else if (adb_try_handler_change(id, 0x2F)) {
1008 mouse_kind = ADBMOUSE_MICROSPEED;
1009 }
1010 else if (adb_try_handler_change(id, 0x42)) {
1011 mouse_kind = ADBMOUSE_TRACKBALLPRO;
1012 }
1013 else if (adb_try_handler_change(id, 0x66)) {
1014 mouse_kind = ADBMOUSE_MICROSPEED;
1015 }
1016 else if (adb_try_handler_change(id, 0x5F)) {
1017 mouse_kind = ADBMOUSE_MICROSPEED;
1018 }
1019 else if (adb_try_handler_change(id, 3)) {
1020 mouse_kind = ADBMOUSE_MS_A3;
1021 }
1022 else if (adb_try_handler_change(id, 2)) {
1023 mouse_kind = ADBMOUSE_STANDARD_200;
1024 }
1025 else {
1026 mouse_kind = ADBMOUSE_STANDARD_100;
1027 }
1028
1029 if ((mouse_kind == ADBMOUSE_TRACKBALLPRO)
1030 || (mouse_kind == ADBMOUSE_MICROSPEED)) {
1031 desc = "Microspeed/MacPoint or compatible";
1032 init_microspeed(id);
1033 } else if (mouse_kind == ADBMOUSE_MS_A3) {
1034 desc = "Mouse Systems A3 Mouse or compatible";
1035 init_ms_a3(id);
1036 } else if (mouse_kind == ADBMOUSE_EXTENDED) {
1037 desc = "extended";
1038
1039
1040
1041
1042
1043
1044 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
1045 ADB_READREG(id, 1));
1046
1047 if ((req.reply_len) &&
1048 (req.reply[1] == 0x9a) && ((req.reply[2] == 0x21)
1049 || (req.reply[2] == 0x20))) {
1050 mouse_kind = ADBMOUSE_TRACKBALL;
1051 desc = "trackman/mouseman";
1052 init_trackball(id);
1053 }
1054 else if ((req.reply_len >= 4) &&
1055 (req.reply[1] == 0x74) && (req.reply[2] == 0x70) &&
1056 (req.reply[3] == 0x61) && (req.reply[4] == 0x64)) {
1057 mouse_kind = ADBMOUSE_TRACKPAD;
1058 desc = "trackpad";
1059 init_trackpad(id);
1060 }
1061 else if ((req.reply_len >= 4) &&
1062 (req.reply[1] == 0x4b) && (req.reply[2] == 0x4d) &&
1063 (req.reply[3] == 0x4c) && (req.reply[4] == 0x31)) {
1064 mouse_kind = ADBMOUSE_TURBOMOUSE5;
1065 desc = "TurboMouse 5";
1066 init_turbomouse(id);
1067 }
1068 else if ((req.reply_len == 9) &&
1069 (req.reply[1] == 0x4b) && (req.reply[2] == 0x4f) &&
1070 (req.reply[3] == 0x49) && (req.reply[4] == 0x54)) {
1071 if (adb_try_handler_change(id, 0x42)) {
1072 mouse_kind = ADBMOUSE_MACALLY2;
1073 desc = "MacAlly 2-button";
1074 }
1075 }
1076 }
1077
1078 adb_get_infos(id, &default_id, &cur_handler_id);
1079 printk(KERN_DEBUG "ADB mouse (%s) at %d has handler 0x%X\n",
1080 desc, id, cur_handler_id);
1081 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
1082 cur_handler_id, mouse_kind);
1083 }
1084 adbhid_input_devcleanup(reg);
1085 }
1086
1087 static void
1088 init_trackpad(int id)
1089 {
1090 struct adb_request req;
1091 unsigned char r1_buffer[8];
1092
1093 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
1094 ADB_READREG(id,1));
1095 if (req.reply_len < 8)
1096 pr_err("%s: bad length for reg. 1\n", __func__);
1097 else
1098 {
1099 memcpy(r1_buffer, &req.reply[1], 8);
1100
1101 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1102 ADB_WRITEREG(id,1),
1103 r1_buffer[0],
1104 r1_buffer[1],
1105 r1_buffer[2],
1106 r1_buffer[3],
1107 r1_buffer[4],
1108 r1_buffer[5],
1109 0x0d,
1110 r1_buffer[7]);
1111
1112 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1113 ADB_WRITEREG(id,2),
1114 0x99,
1115 0x94,
1116 0x19,
1117 0xff,
1118 0xb2,
1119 0x8a,
1120 0x1b,
1121 0x50);
1122
1123 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1124 ADB_WRITEREG(id,1),
1125 r1_buffer[0],
1126 r1_buffer[1],
1127 r1_buffer[2],
1128 r1_buffer[3],
1129 r1_buffer[4],
1130 r1_buffer[5],
1131 0x03,
1132 r1_buffer[7]);
1133
1134
1135 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1136 }
1137 }
1138
1139 static void
1140 init_trackball(int id)
1141 {
1142 struct adb_request req;
1143
1144 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1145 ADB_WRITEREG(id,1), 00,0x81);
1146
1147 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1148 ADB_WRITEREG(id,1), 01,0x81);
1149
1150 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1151 ADB_WRITEREG(id,1), 02,0x81);
1152
1153 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1154 ADB_WRITEREG(id,1), 03,0x38);
1155
1156 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1157 ADB_WRITEREG(id,1), 00,0x81);
1158
1159 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1160 ADB_WRITEREG(id,1), 01,0x81);
1161
1162 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1163 ADB_WRITEREG(id,1), 02,0x81);
1164
1165 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1166 ADB_WRITEREG(id,1), 03,0x38);
1167 }
1168
1169 static void
1170 init_turbomouse(int id)
1171 {
1172 struct adb_request req;
1173
1174 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1175
1176 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
1177
1178 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1179 ADB_WRITEREG(3,2),
1180 0xe7,
1181 0x8c,
1182 0,
1183 0,
1184 0,
1185 0xff,
1186 0xff,
1187 0x94);
1188
1189 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
1190
1191 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1192 ADB_WRITEREG(3,2),
1193 0xa5,
1194 0x14,
1195 0,
1196 0,
1197 0x69,
1198 0xff,
1199 0xff,
1200 0x27);
1201 }
1202
1203 static void
1204 init_microspeed(int id)
1205 {
1206 struct adb_request req;
1207
1208 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230 adb_request(&req, NULL, ADBREQ_SYNC, 5,
1231 ADB_WRITEREG(id,1),
1232 0x20,
1233 0x00,
1234 0x10,
1235 0x07);
1236
1237
1238 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1239 }
1240
1241 static void
1242 init_ms_a3(int id)
1243 {
1244 struct adb_request req;
1245
1246 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1247 ADB_WRITEREG(id, 0x2),
1248 0x00,
1249 0x07);
1250
1251 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1252 }
1253
1254 static int __init adbhid_init(void)
1255 {
1256 #ifndef CONFIG_MAC
1257 if (!machine_is(chrp) && !machine_is(powermac))
1258 return 0;
1259 #endif
1260
1261 led_request.complete = 1;
1262
1263 adbhid_probe();
1264
1265 blocking_notifier_chain_register(&adb_client_list,
1266 &adbhid_adb_notifier);
1267
1268 return 0;
1269 }
1270
1271 static void __exit adbhid_exit(void)
1272 {
1273 }
1274
1275 module_init(adbhid_init);
1276 module_exit(adbhid_exit);