[PATCH] fix semaphore handling in __unregister_chrdev_region
[linux/fpc-iii.git] / drivers / macintosh / adbhid.c
blobdb654e8bd67e2611733069ecfb1c3f03043b00cf
1 /*
2 * drivers/input/adbhid.c
4 * ADB HID driver for Power Macintosh computers.
6 * Adapted from drivers/macintosh/mac_keyb.c by Franz Sirl.
7 * drivers/macintosh/mac_keyb.c was Copyright (C) 1996 Paul Mackerras
8 * with considerable contributions from Ben Herrenschmidt and others.
10 * Copyright (C) 2000 Franz Sirl.
12 * Adapted to ADB changes and support for more devices by
13 * Benjamin Herrenschmidt. Adapted from code in MkLinux
14 * and reworked.
16 * Supported devices:
18 * - Standard 1 button mouse
19 * - All standard Apple Extended protocol (handler ID 4)
20 * - mouseman and trackman mice & trackballs
21 * - PowerBook Trackpad (default setup: enable tapping)
22 * - MicroSpeed mouse & trackball (needs testing)
23 * - CH Products Trackball Pro (needs testing)
24 * - Contour Design (Contour Mouse)
25 * - Hunter digital (NoHandsMouse)
26 * - Kensignton TurboMouse 5 (needs testing)
27 * - Mouse Systems A3 mice and trackballs <aidan@kublai.com>
28 * - MacAlly 2-buttons mouse (needs testing) <pochini@denise.shiny.it>
30 * To do:
32 * Improve Kensington support.
33 * Split mouse/kbd
34 * Move to syfs
37 #include <linux/config.h>
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>
44 #include <linux/adb.h>
45 #include <linux/cuda.h>
46 #include <linux/pmu.h>
48 #include <asm/machdep.h>
49 #ifdef CONFIG_PPC_PMAC
50 #include <asm/pmac_feature.h>
51 #endif
53 #ifdef CONFIG_PMAC_BACKLIGHT
54 #include <asm/backlight.h>
55 #endif
57 MODULE_AUTHOR("Franz Sirl <Franz.Sirl-kernel@lauterbach.com>");
59 #define KEYB_KEYREG 0 /* register # for key up/down data */
60 #define KEYB_LEDREG 2 /* register # for leds on ADB keyboard */
61 #define MOUSE_DATAREG 0 /* reg# for movement/button codes from mouse */
63 static int adb_message_handler(struct notifier_block *, unsigned long, void *);
64 static struct notifier_block adbhid_adb_notifier = {
65 .notifier_call = adb_message_handler,
68 /* Some special keys */
69 #define ADB_KEY_DEL 0x33
70 #define ADB_KEY_CMD 0x37
71 #define ADB_KEY_CAPSLOCK 0x39
72 #define ADB_KEY_FN 0x3f
73 #define ADB_KEY_FWDEL 0x75
74 #define ADB_KEY_POWER_OLD 0x7e
75 #define ADB_KEY_POWER 0x7f
77 u8 adb_to_linux_keycodes[128] = {
78 /* 0x00 */ KEY_A, /* 30 */
79 /* 0x01 */ KEY_S, /* 31 */
80 /* 0x02 */ KEY_D, /* 32 */
81 /* 0x03 */ KEY_F, /* 33 */
82 /* 0x04 */ KEY_H, /* 35 */
83 /* 0x05 */ KEY_G, /* 34 */
84 /* 0x06 */ KEY_Z, /* 44 */
85 /* 0x07 */ KEY_X, /* 45 */
86 /* 0x08 */ KEY_C, /* 46 */
87 /* 0x09 */ KEY_V, /* 47 */
88 /* 0x0a */ KEY_102ND, /* 86 */
89 /* 0x0b */ KEY_B, /* 48 */
90 /* 0x0c */ KEY_Q, /* 16 */
91 /* 0x0d */ KEY_W, /* 17 */
92 /* 0x0e */ KEY_E, /* 18 */
93 /* 0x0f */ KEY_R, /* 19 */
94 /* 0x10 */ KEY_Y, /* 21 */
95 /* 0x11 */ KEY_T, /* 20 */
96 /* 0x12 */ KEY_1, /* 2 */
97 /* 0x13 */ KEY_2, /* 3 */
98 /* 0x14 */ KEY_3, /* 4 */
99 /* 0x15 */ KEY_4, /* 5 */
100 /* 0x16 */ KEY_6, /* 7 */
101 /* 0x17 */ KEY_5, /* 6 */
102 /* 0x18 */ KEY_EQUAL, /* 13 */
103 /* 0x19 */ KEY_9, /* 10 */
104 /* 0x1a */ KEY_7, /* 8 */
105 /* 0x1b */ KEY_MINUS, /* 12 */
106 /* 0x1c */ KEY_8, /* 9 */
107 /* 0x1d */ KEY_0, /* 11 */
108 /* 0x1e */ KEY_RIGHTBRACE, /* 27 */
109 /* 0x1f */ KEY_O, /* 24 */
110 /* 0x20 */ KEY_U, /* 22 */
111 /* 0x21 */ KEY_LEFTBRACE, /* 26 */
112 /* 0x22 */ KEY_I, /* 23 */
113 /* 0x23 */ KEY_P, /* 25 */
114 /* 0x24 */ KEY_ENTER, /* 28 */
115 /* 0x25 */ KEY_L, /* 38 */
116 /* 0x26 */ KEY_J, /* 36 */
117 /* 0x27 */ KEY_APOSTROPHE, /* 40 */
118 /* 0x28 */ KEY_K, /* 37 */
119 /* 0x29 */ KEY_SEMICOLON, /* 39 */
120 /* 0x2a */ KEY_BACKSLASH, /* 43 */
121 /* 0x2b */ KEY_COMMA, /* 51 */
122 /* 0x2c */ KEY_SLASH, /* 53 */
123 /* 0x2d */ KEY_N, /* 49 */
124 /* 0x2e */ KEY_M, /* 50 */
125 /* 0x2f */ KEY_DOT, /* 52 */
126 /* 0x30 */ KEY_TAB, /* 15 */
127 /* 0x31 */ KEY_SPACE, /* 57 */
128 /* 0x32 */ KEY_GRAVE, /* 41 */
129 /* 0x33 */ KEY_BACKSPACE, /* 14 */
130 /* 0x34 */ KEY_KPENTER, /* 96 */
131 /* 0x35 */ KEY_ESC, /* 1 */
132 /* 0x36 */ KEY_LEFTCTRL, /* 29 */
133 /* 0x37 */ KEY_LEFTMETA, /* 125 */
134 /* 0x38 */ KEY_LEFTSHIFT, /* 42 */
135 /* 0x39 */ KEY_CAPSLOCK, /* 58 */
136 /* 0x3a */ KEY_LEFTALT, /* 56 */
137 /* 0x3b */ KEY_LEFT, /* 105 */
138 /* 0x3c */ KEY_RIGHT, /* 106 */
139 /* 0x3d */ KEY_DOWN, /* 108 */
140 /* 0x3e */ KEY_UP, /* 103 */
141 /* 0x3f */ 0,
142 /* 0x40 */ 0,
143 /* 0x41 */ KEY_KPDOT, /* 83 */
144 /* 0x42 */ 0,
145 /* 0x43 */ KEY_KPASTERISK, /* 55 */
146 /* 0x44 */ 0,
147 /* 0x45 */ KEY_KPPLUS, /* 78 */
148 /* 0x46 */ 0,
149 /* 0x47 */ KEY_NUMLOCK, /* 69 */
150 /* 0x48 */ 0,
151 /* 0x49 */ 0,
152 /* 0x4a */ 0,
153 /* 0x4b */ KEY_KPSLASH, /* 98 */
154 /* 0x4c */ KEY_KPENTER, /* 96 */
155 /* 0x4d */ 0,
156 /* 0x4e */ KEY_KPMINUS, /* 74 */
157 /* 0x4f */ 0,
158 /* 0x50 */ 0,
159 /* 0x51 */ KEY_KPEQUAL, /* 117 */
160 /* 0x52 */ KEY_KP0, /* 82 */
161 /* 0x53 */ KEY_KP1, /* 79 */
162 /* 0x54 */ KEY_KP2, /* 80 */
163 /* 0x55 */ KEY_KP3, /* 81 */
164 /* 0x56 */ KEY_KP4, /* 75 */
165 /* 0x57 */ KEY_KP5, /* 76 */
166 /* 0x58 */ KEY_KP6, /* 77 */
167 /* 0x59 */ KEY_KP7, /* 71 */
168 /* 0x5a */ 0,
169 /* 0x5b */ KEY_KP8, /* 72 */
170 /* 0x5c */ KEY_KP9, /* 73 */
171 /* 0x5d */ KEY_YEN, /* 124 */
172 /* 0x5e */ KEY_RO, /* 89 */
173 /* 0x5f */ KEY_KPCOMMA, /* 121 */
174 /* 0x60 */ KEY_F5, /* 63 */
175 /* 0x61 */ KEY_F6, /* 64 */
176 /* 0x62 */ KEY_F7, /* 65 */
177 /* 0x63 */ KEY_F3, /* 61 */
178 /* 0x64 */ KEY_F8, /* 66 */
179 /* 0x65 */ KEY_F9, /* 67 */
180 /* 0x66 */ KEY_HANJA, /* 123 */
181 /* 0x67 */ KEY_F11, /* 87 */
182 /* 0x68 */ KEY_HANGUEL, /* 122 */
183 /* 0x69 */ KEY_SYSRQ, /* 99 */
184 /* 0x6a */ 0,
185 /* 0x6b */ KEY_SCROLLLOCK, /* 70 */
186 /* 0x6c */ 0,
187 /* 0x6d */ KEY_F10, /* 68 */
188 /* 0x6e */ KEY_COMPOSE, /* 127 */
189 /* 0x6f */ KEY_F12, /* 88 */
190 /* 0x70 */ 0,
191 /* 0x71 */ KEY_PAUSE, /* 119 */
192 /* 0x72 */ KEY_INSERT, /* 110 */
193 /* 0x73 */ KEY_HOME, /* 102 */
194 /* 0x74 */ KEY_PAGEUP, /* 104 */
195 /* 0x75 */ KEY_DELETE, /* 111 */
196 /* 0x76 */ KEY_F4, /* 62 */
197 /* 0x77 */ KEY_END, /* 107 */
198 /* 0x78 */ KEY_F2, /* 60 */
199 /* 0x79 */ KEY_PAGEDOWN, /* 109 */
200 /* 0x7a */ KEY_F1, /* 59 */
201 /* 0x7b */ KEY_RIGHTSHIFT, /* 54 */
202 /* 0x7c */ KEY_RIGHTALT, /* 100 */
203 /* 0x7d */ KEY_RIGHTCTRL, /* 97 */
204 /* 0x7e */ KEY_RIGHTMETA, /* 126 */
205 /* 0x7f */ KEY_POWER, /* 116 */
208 struct adbhid {
209 struct input_dev input;
210 int id;
211 int default_id;
212 int original_handler_id;
213 int current_handler_id;
214 int mouse_kind;
215 unsigned char *keycode;
216 char name[64];
217 char phys[32];
218 int flags;
221 #define FLAG_FN_KEY_PRESSED 0x00000001
222 #define FLAG_POWER_FROM_FN 0x00000002
223 #define FLAG_EMU_FWDEL_DOWN 0x00000004
225 static struct adbhid *adbhid[16];
227 static void adbhid_probe(void);
229 static void adbhid_input_keycode(int, int, int, struct pt_regs *);
231 static void init_trackpad(int id);
232 static void init_trackball(int id);
233 static void init_turbomouse(int id);
234 static void init_microspeed(int id);
235 static void init_ms_a3(int id);
237 static struct adb_ids keyboard_ids;
238 static struct adb_ids mouse_ids;
239 static struct adb_ids buttons_ids;
241 #ifdef CONFIG_PMAC_BACKLIGHT
242 /* Exported to via-pmu.c */
243 int disable_kernel_backlight = 0;
244 #endif /* CONFIG_PMAC_BACKLIGHT */
246 /* Kind of keyboard, see Apple technote 1152 */
247 #define ADB_KEYBOARD_UNKNOWN 0
248 #define ADB_KEYBOARD_ANSI 0x0100
249 #define ADB_KEYBOARD_ISO 0x0200
250 #define ADB_KEYBOARD_JIS 0x0300
252 /* Kind of mouse */
253 #define ADBMOUSE_STANDARD_100 0 /* Standard 100cpi mouse (handler 1) */
254 #define ADBMOUSE_STANDARD_200 1 /* Standard 200cpi mouse (handler 2) */
255 #define ADBMOUSE_EXTENDED 2 /* Apple Extended mouse (handler 4) */
256 #define ADBMOUSE_TRACKBALL 3 /* TrackBall (handler 4) */
257 #define ADBMOUSE_TRACKPAD 4 /* Apple's PowerBook trackpad (handler 4) */
258 #define ADBMOUSE_TURBOMOUSE5 5 /* Turbomouse 5 (previously req. mousehack) */
259 #define ADBMOUSE_MICROSPEED 6 /* Microspeed mouse (&trackball ?), MacPoint */
260 #define ADBMOUSE_TRACKBALLPRO 7 /* Trackball Pro (special buttons) */
261 #define ADBMOUSE_MS_A3 8 /* Mouse systems A3 trackball (handler 3) */
262 #define ADBMOUSE_MACALLY2 9 /* MacAlly 2-button mouse */
264 static void
265 adbhid_keyboard_input(unsigned char *data, int nb, struct pt_regs *regs, int apoll)
267 int id = (data[0] >> 4) & 0x0f;
269 if (!adbhid[id]) {
270 printk(KERN_ERR "ADB HID on ID %d not yet registered, packet %#02x, %#02x, %#02x, %#02x\n",
271 id, data[0], data[1], data[2], data[3]);
272 return;
275 /* first check this is from register 0 */
276 if (nb != 3 || (data[0] & 3) != KEYB_KEYREG)
277 return; /* ignore it */
278 adbhid_input_keycode(id, data[1], 0, regs);
279 if (!(data[2] == 0xff || (data[2] == 0x7f && data[1] == 0x7f)))
280 adbhid_input_keycode(id, data[2], 0, regs);
283 static void
284 adbhid_input_keycode(int id, int keycode, int repeat, struct pt_regs *regs)
286 struct adbhid *ahid = adbhid[id];
287 int up_flag;
289 up_flag = (keycode & 0x80);
290 keycode &= 0x7f;
292 switch (keycode) {
293 case ADB_KEY_CAPSLOCK: /* Generate down/up events for CapsLock everytime. */
294 input_regs(&ahid->input, regs);
295 input_report_key(&ahid->input, KEY_CAPSLOCK, 1);
296 input_report_key(&ahid->input, KEY_CAPSLOCK, 0);
297 input_sync(&ahid->input);
298 return;
299 #ifdef CONFIG_PPC_PMAC
300 case ADB_KEY_POWER_OLD: /* Power key on PBook 3400 needs remapping */
301 switch(pmac_call_feature(PMAC_FTR_GET_MB_INFO,
302 NULL, PMAC_MB_INFO_MODEL, 0)) {
303 case PMAC_TYPE_COMET:
304 case PMAC_TYPE_HOOPER:
305 case PMAC_TYPE_KANGA:
306 keycode = ADB_KEY_POWER;
308 break;
309 case ADB_KEY_POWER:
310 /* Fn + Command will produce a bogus "power" keycode */
311 if (ahid->flags & FLAG_FN_KEY_PRESSED) {
312 keycode = ADB_KEY_CMD;
313 if (up_flag)
314 ahid->flags &= ~FLAG_POWER_FROM_FN;
315 else
316 ahid->flags |= FLAG_POWER_FROM_FN;
317 } else if (ahid->flags & FLAG_POWER_FROM_FN) {
318 keycode = ADB_KEY_CMD;
319 ahid->flags &= ~FLAG_POWER_FROM_FN;
321 break;
322 case ADB_KEY_FN:
323 /* Keep track of the Fn key state */
324 if (up_flag) {
325 ahid->flags &= ~FLAG_FN_KEY_PRESSED;
326 /* Emulate Fn+delete = forward delete */
327 if (ahid->flags & FLAG_EMU_FWDEL_DOWN) {
328 ahid->flags &= ~FLAG_EMU_FWDEL_DOWN;
329 keycode = ADB_KEY_FWDEL;
330 break;
332 } else
333 ahid->flags |= FLAG_FN_KEY_PRESSED;
334 /* Swallow the key press */
335 return;
336 case ADB_KEY_DEL:
337 /* Emulate Fn+delete = forward delete */
338 if (ahid->flags & FLAG_FN_KEY_PRESSED) {
339 keycode = ADB_KEY_FWDEL;
340 if (up_flag)
341 ahid->flags &= ~FLAG_EMU_FWDEL_DOWN;
342 else
343 ahid->flags |= FLAG_EMU_FWDEL_DOWN;
345 break;
346 #endif /* CONFIG_PPC_PMAC */
349 if (adbhid[id]->keycode[keycode]) {
350 input_regs(&adbhid[id]->input, regs);
351 input_report_key(&adbhid[id]->input,
352 adbhid[id]->keycode[keycode], !up_flag);
353 input_sync(&adbhid[id]->input);
354 } else
355 printk(KERN_INFO "Unhandled ADB key (scancode %#02x) %s.\n", keycode,
356 up_flag ? "released" : "pressed");
360 static void
361 adbhid_mouse_input(unsigned char *data, int nb, struct pt_regs *regs, int autopoll)
363 int id = (data[0] >> 4) & 0x0f;
365 if (!adbhid[id]) {
366 printk(KERN_ERR "ADB HID on ID %d not yet registered\n", id);
367 return;
371 Handler 1 -- 100cpi original Apple mouse protocol.
372 Handler 2 -- 200cpi original Apple mouse protocol.
374 For Apple's standard one-button mouse protocol the data array will
375 contain the following values:
377 BITS COMMENTS
378 data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
379 data[1] = bxxx xxxx First button and x-axis motion.
380 data[2] = byyy yyyy Second button and y-axis motion.
382 Handler 4 -- Apple Extended mouse protocol.
384 For Apple's 3-button mouse protocol the data array will contain the
385 following values:
387 BITS COMMENTS
388 data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
389 data[1] = bxxx xxxx Left button and x-axis motion.
390 data[2] = byyy yyyy Second button and y-axis motion.
391 data[3] = byyy bxxx Third button and fourth button. Y is additional
392 high bits of y-axis motion. XY is additional
393 high bits of x-axis motion.
395 MacAlly 2-button mouse protocol.
397 For MacAlly 2-button mouse protocol the data array will contain the
398 following values:
400 BITS COMMENTS
401 data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
402 data[1] = bxxx xxxx Left button and x-axis motion.
403 data[2] = byyy yyyy Right button and y-axis motion.
404 data[3] = ???? ???? unknown
405 data[4] = ???? ???? unknown
409 /* If it's a trackpad, we alias the second button to the first.
410 NOTE: Apple sends an ADB flush command to the trackpad when
411 the first (the real) button is released. We could do
412 this here using async flush requests.
414 switch (adbhid[id]->mouse_kind)
416 case ADBMOUSE_TRACKPAD:
417 data[1] = (data[1] & 0x7f) | ((data[1] & data[2]) & 0x80);
418 data[2] = data[2] | 0x80;
419 break;
420 case ADBMOUSE_MICROSPEED:
421 data[1] = (data[1] & 0x7f) | ((data[3] & 0x01) << 7);
422 data[2] = (data[2] & 0x7f) | ((data[3] & 0x02) << 6);
423 data[3] = (data[3] & 0x77) | ((data[3] & 0x04) << 5)
424 | (data[3] & 0x08);
425 break;
426 case ADBMOUSE_TRACKBALLPRO:
427 data[1] = (data[1] & 0x7f) | (((data[3] & 0x04) << 5)
428 & ((data[3] & 0x08) << 4));
429 data[2] = (data[2] & 0x7f) | ((data[3] & 0x01) << 7);
430 data[3] = (data[3] & 0x77) | ((data[3] & 0x02) << 6);
431 break;
432 case ADBMOUSE_MS_A3:
433 data[1] = (data[1] & 0x7f) | ((data[3] & 0x01) << 7);
434 data[2] = (data[2] & 0x7f) | ((data[3] & 0x02) << 6);
435 data[3] = ((data[3] & 0x04) << 5);
436 break;
437 case ADBMOUSE_MACALLY2:
438 data[3] = (data[2] & 0x80) ? 0x80 : 0x00;
439 data[2] |= 0x80; /* Right button is mapped as button 3 */
440 nb=4;
441 break;
444 input_regs(&adbhid[id]->input, regs);
446 input_report_key(&adbhid[id]->input, BTN_LEFT, !((data[1] >> 7) & 1));
447 input_report_key(&adbhid[id]->input, BTN_MIDDLE, !((data[2] >> 7) & 1));
449 if (nb >= 4 && adbhid[id]->mouse_kind != ADBMOUSE_TRACKPAD)
450 input_report_key(&adbhid[id]->input, BTN_RIGHT, !((data[3] >> 7) & 1));
452 input_report_rel(&adbhid[id]->input, REL_X,
453 ((data[2]&0x7f) < 64 ? (data[2]&0x7f) : (data[2]&0x7f)-128 ));
454 input_report_rel(&adbhid[id]->input, REL_Y,
455 ((data[1]&0x7f) < 64 ? (data[1]&0x7f) : (data[1]&0x7f)-128 ));
457 input_sync(&adbhid[id]->input);
460 static void
461 adbhid_buttons_input(unsigned char *data, int nb, struct pt_regs *regs, int autopoll)
463 int id = (data[0] >> 4) & 0x0f;
465 if (!adbhid[id]) {
466 printk(KERN_ERR "ADB HID on ID %d not yet registered\n", id);
467 return;
470 input_regs(&adbhid[id]->input, regs);
472 switch (adbhid[id]->original_handler_id) {
473 default:
474 case 0x02: /* Adjustable keyboard button device */
476 int down = (data[1] == (data[1] & 0xf));
478 switch (data[1] & 0x0f) {
479 case 0x0: /* microphone */
480 input_report_key(&adbhid[id]->input, KEY_SOUND, down);
481 break;
483 case 0x1: /* mute */
484 input_report_key(&adbhid[id]->input, KEY_MUTE, down);
485 break;
487 case 0x2: /* volume decrease */
488 input_report_key(&adbhid[id]->input, KEY_VOLUMEDOWN, down);
489 break;
491 case 0x3: /* volume increase */
492 input_report_key(&adbhid[id]->input, KEY_VOLUMEUP, down);
493 break;
495 default:
496 printk(KERN_INFO "Unhandled ADB_MISC event %02x, %02x, %02x, %02x\n",
497 data[0], data[1], data[2], data[3]);
498 break;
501 break;
503 case 0x1f: /* Powerbook button device */
505 int down = (data[1] == (data[1] & 0xf));
506 #ifdef CONFIG_PMAC_BACKLIGHT
507 int backlight = get_backlight_level();
508 #endif
510 * XXX: Where is the contrast control for the passive?
511 * -- Cort
514 switch (data[1] & 0x0f) {
515 case 0x8: /* mute */
516 input_report_key(&adbhid[id]->input, KEY_MUTE, down);
517 break;
519 case 0x7: /* volume decrease */
520 input_report_key(&adbhid[id]->input, KEY_VOLUMEDOWN, down);
521 break;
523 case 0x6: /* volume increase */
524 input_report_key(&adbhid[id]->input, KEY_VOLUMEUP, down);
525 break;
527 case 0xb: /* eject */
528 input_report_key(&adbhid[id]->input, KEY_EJECTCD, down);
529 break;
531 case 0xa: /* brightness decrease */
532 #ifdef CONFIG_PMAC_BACKLIGHT
533 if (!disable_kernel_backlight) {
534 if (down && backlight >= 0) {
535 if (backlight > BACKLIGHT_OFF)
536 set_backlight_level(backlight-1);
537 else
538 set_backlight_level(BACKLIGHT_OFF);
541 #endif /* CONFIG_PMAC_BACKLIGHT */
542 input_report_key(&adbhid[id]->input, KEY_BRIGHTNESSDOWN, down);
543 break;
545 case 0x9: /* brightness increase */
546 #ifdef CONFIG_PMAC_BACKLIGHT
547 if (!disable_kernel_backlight) {
548 if (down && backlight >= 0) {
549 if (backlight < BACKLIGHT_MAX)
550 set_backlight_level(backlight+1);
551 else
552 set_backlight_level(BACKLIGHT_MAX);
555 #endif /* CONFIG_PMAC_BACKLIGHT */
556 input_report_key(&adbhid[id]->input, KEY_BRIGHTNESSUP, down);
557 break;
559 case 0xc: /* videomode switch */
560 input_report_key(&adbhid[id]->input, KEY_SWITCHVIDEOMODE, down);
561 break;
563 case 0xd: /* keyboard illumination toggle */
564 input_report_key(&adbhid[id]->input, KEY_KBDILLUMTOGGLE, down);
565 break;
567 case 0xe: /* keyboard illumination decrease */
568 input_report_key(&adbhid[id]->input, KEY_KBDILLUMDOWN, down);
569 break;
571 case 0xf:
572 switch (data[1]) {
573 case 0x8f:
574 case 0x0f:
575 /* keyboard illumination increase */
576 input_report_key(&adbhid[id]->input, KEY_KBDILLUMUP, down);
577 break;
579 case 0x7f:
580 case 0xff:
581 /* keypad overlay toogle */
582 break;
584 default:
585 printk(KERN_INFO "Unhandled ADB_MISC event %02x, %02x, %02x, %02x\n",
586 data[0], data[1], data[2], data[3]);
587 break;
589 break;
590 default:
591 printk(KERN_INFO "Unhandled ADB_MISC event %02x, %02x, %02x, %02x\n",
592 data[0], data[1], data[2], data[3]);
593 break;
596 break;
599 input_sync(&adbhid[id]->input);
602 static struct adb_request led_request;
603 static int leds_pending[16];
604 static int leds_req_pending;
605 static int pending_devs[16];
606 static int pending_led_start=0;
607 static int pending_led_end=0;
608 static DEFINE_SPINLOCK(leds_lock);
610 static void leds_done(struct adb_request *req)
612 int leds = 0, device = 0, pending = 0;
613 unsigned long flags;
615 spin_lock_irqsave(&leds_lock, flags);
617 if (pending_led_start != pending_led_end) {
618 device = pending_devs[pending_led_start];
619 leds = leds_pending[device] & 0xff;
620 leds_pending[device] = 0;
621 pending_led_start++;
622 pending_led_start = (pending_led_start < 16) ? pending_led_start : 0;
623 pending = leds_req_pending;
624 } else
625 leds_req_pending = 0;
626 spin_unlock_irqrestore(&leds_lock, flags);
627 if (pending)
628 adb_request(&led_request, leds_done, 0, 3,
629 ADB_WRITEREG(device, KEYB_LEDREG), 0xff, ~leds);
632 static void real_leds(unsigned char leds, int device)
634 unsigned long flags;
636 spin_lock_irqsave(&leds_lock, flags);
637 if (!leds_req_pending) {
638 leds_req_pending = 1;
639 spin_unlock_irqrestore(&leds_lock, flags);
640 adb_request(&led_request, leds_done, 0, 3,
641 ADB_WRITEREG(device, KEYB_LEDREG), 0xff, ~leds);
642 return;
643 } else {
644 if (!(leds_pending[device] & 0x100)) {
645 pending_devs[pending_led_end] = device;
646 pending_led_end++;
647 pending_led_end = (pending_led_end < 16) ? pending_led_end : 0;
649 leds_pending[device] = leds | 0x100;
651 spin_unlock_irqrestore(&leds_lock, flags);
655 * Event callback from the input module. Events that change the state of
656 * the hardware are processed here.
658 static int adbhid_kbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
660 struct adbhid *adbhid = dev->private;
661 unsigned char leds;
663 switch (type) {
664 case EV_LED:
665 leds = (test_bit(LED_SCROLLL, dev->led) ? 4 : 0)
666 | (test_bit(LED_NUML, dev->led) ? 1 : 0)
667 | (test_bit(LED_CAPSL, dev->led) ? 2 : 0);
668 real_leds(leds, adbhid->id);
669 return 0;
672 return -1;
675 static int
676 adb_message_handler(struct notifier_block *this, unsigned long code, void *x)
678 switch (code) {
679 case ADB_MSG_PRE_RESET:
680 case ADB_MSG_POWERDOWN:
681 /* Stop the repeat timer. Autopoll is already off at this point */
683 int i;
684 for (i = 1; i < 16; i++) {
685 if (adbhid[i])
686 del_timer_sync(&adbhid[i]->input.timer);
690 /* Stop pending led requests */
691 while(leds_req_pending)
692 adb_poll();
693 break;
695 case ADB_MSG_POST_RESET:
696 adbhid_probe();
697 break;
699 return NOTIFY_DONE;
702 static void
703 adbhid_input_register(int id, int default_id, int original_handler_id,
704 int current_handler_id, int mouse_kind)
706 int i;
708 if (adbhid[id]) {
709 printk(KERN_ERR "Trying to reregister ADB HID on ID %d\n", id);
710 return;
713 if (!(adbhid[id] = kmalloc(sizeof(struct adbhid), GFP_KERNEL)))
714 return;
716 memset(adbhid[id], 0, sizeof(struct adbhid));
717 sprintf(adbhid[id]->phys, "adb%d:%d.%02x/input", id, default_id, original_handler_id);
719 init_input_dev(&adbhid[id]->input);
721 adbhid[id]->id = default_id;
722 adbhid[id]->original_handler_id = original_handler_id;
723 adbhid[id]->current_handler_id = current_handler_id;
724 adbhid[id]->mouse_kind = mouse_kind;
725 adbhid[id]->flags = 0;
726 adbhid[id]->input.private = adbhid[id];
727 adbhid[id]->input.name = adbhid[id]->name;
728 adbhid[id]->input.phys = adbhid[id]->phys;
729 adbhid[id]->input.id.bustype = BUS_ADB;
730 adbhid[id]->input.id.vendor = 0x0001;
731 adbhid[id]->input.id.product = (id << 12) | (default_id << 8) | original_handler_id;
732 adbhid[id]->input.id.version = 0x0100;
734 switch (default_id) {
735 case ADB_KEYBOARD:
736 if (!(adbhid[id]->keycode = kmalloc(sizeof(adb_to_linux_keycodes), GFP_KERNEL))) {
737 kfree(adbhid[id]);
738 return;
741 sprintf(adbhid[id]->name, "ADB keyboard");
743 memcpy(adbhid[id]->keycode, adb_to_linux_keycodes, sizeof(adb_to_linux_keycodes));
745 printk(KERN_INFO "Detected ADB keyboard, type ");
746 switch (original_handler_id) {
747 default:
748 printk("<unknown>.\n");
749 adbhid[id]->input.id.version = ADB_KEYBOARD_UNKNOWN;
750 break;
752 case 0x01: case 0x02: case 0x03: case 0x06: case 0x08:
753 case 0x0C: case 0x10: case 0x18: case 0x1B: case 0x1C:
754 case 0xC0: case 0xC3: case 0xC6:
755 printk("ANSI.\n");
756 adbhid[id]->input.id.version = ADB_KEYBOARD_ANSI;
757 break;
759 case 0x04: case 0x05: case 0x07: case 0x09: case 0x0D:
760 case 0x11: case 0x14: case 0x19: case 0x1D: case 0xC1:
761 case 0xC4: case 0xC7:
762 printk("ISO, swapping keys.\n");
763 adbhid[id]->input.id.version = ADB_KEYBOARD_ISO;
764 i = adbhid[id]->keycode[10];
765 adbhid[id]->keycode[10] = adbhid[id]->keycode[50];
766 adbhid[id]->keycode[50] = i;
767 break;
769 case 0x12: case 0x15: case 0x16: case 0x17: case 0x1A:
770 case 0x1E: case 0xC2: case 0xC5: case 0xC8: case 0xC9:
771 printk("JIS.\n");
772 adbhid[id]->input.id.version = ADB_KEYBOARD_JIS;
773 break;
776 for (i = 0; i < 128; i++)
777 if (adbhid[id]->keycode[i])
778 set_bit(adbhid[id]->keycode[i], adbhid[id]->input.keybit);
780 adbhid[id]->input.evbit[0] = BIT(EV_KEY) | BIT(EV_LED) | BIT(EV_REP);
781 adbhid[id]->input.ledbit[0] = BIT(LED_SCROLLL) | BIT(LED_CAPSL) | BIT(LED_NUML);
782 adbhid[id]->input.event = adbhid_kbd_event;
783 adbhid[id]->input.keycodemax = 127;
784 adbhid[id]->input.keycodesize = 1;
785 break;
787 case ADB_MOUSE:
788 sprintf(adbhid[id]->name, "ADB mouse");
790 adbhid[id]->input.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
791 adbhid[id]->input.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
792 adbhid[id]->input.relbit[0] = BIT(REL_X) | BIT(REL_Y);
793 break;
795 case ADB_MISC:
796 switch (original_handler_id) {
797 case 0x02: /* Adjustable keyboard button device */
798 sprintf(adbhid[id]->name, "ADB adjustable keyboard buttons");
799 adbhid[id]->input.evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
800 set_bit(KEY_SOUND, adbhid[id]->input.keybit);
801 set_bit(KEY_MUTE, adbhid[id]->input.keybit);
802 set_bit(KEY_VOLUMEUP, adbhid[id]->input.keybit);
803 set_bit(KEY_VOLUMEDOWN, adbhid[id]->input.keybit);
804 break;
805 case 0x1f: /* Powerbook button device */
806 sprintf(adbhid[id]->name, "ADB Powerbook buttons");
807 adbhid[id]->input.evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
808 set_bit(KEY_MUTE, adbhid[id]->input.keybit);
809 set_bit(KEY_VOLUMEUP, adbhid[id]->input.keybit);
810 set_bit(KEY_VOLUMEDOWN, adbhid[id]->input.keybit);
811 set_bit(KEY_BRIGHTNESSUP, adbhid[id]->input.keybit);
812 set_bit(KEY_BRIGHTNESSDOWN, adbhid[id]->input.keybit);
813 set_bit(KEY_EJECTCD, adbhid[id]->input.keybit);
814 set_bit(KEY_SWITCHVIDEOMODE, adbhid[id]->input.keybit);
815 set_bit(KEY_KBDILLUMTOGGLE, adbhid[id]->input.keybit);
816 set_bit(KEY_KBDILLUMDOWN, adbhid[id]->input.keybit);
817 set_bit(KEY_KBDILLUMUP, adbhid[id]->input.keybit);
818 break;
820 if (adbhid[id]->name[0])
821 break;
822 /* else fall through */
824 default:
825 printk(KERN_INFO "Trying to register unknown ADB device to input layer.\n");
826 kfree(adbhid[id]);
827 return;
830 adbhid[id]->input.keycode = adbhid[id]->keycode;
832 input_register_device(&adbhid[id]->input);
834 printk(KERN_INFO "input: %s on %s\n",
835 adbhid[id]->name, adbhid[id]->phys);
837 if (default_id == ADB_KEYBOARD) {
838 /* HACK WARNING!! This should go away as soon there is an utility
839 * to control that for event devices.
841 adbhid[id]->input.rep[REP_DELAY] = 500; /* input layer default: 250 */
842 adbhid[id]->input.rep[REP_PERIOD] = 66; /* input layer default: 33 */
846 static void adbhid_input_unregister(int id)
848 input_unregister_device(&adbhid[id]->input);
849 if (adbhid[id]->keycode)
850 kfree(adbhid[id]->keycode);
851 kfree(adbhid[id]);
852 adbhid[id] = NULL;
856 static u16
857 adbhid_input_reregister(int id, int default_id, int org_handler_id,
858 int cur_handler_id, int mk)
860 if (adbhid[id]) {
861 if (adbhid[id]->input.id.product !=
862 ((id << 12)|(default_id << 8)|org_handler_id)) {
863 adbhid_input_unregister(id);
864 adbhid_input_register(id, default_id, org_handler_id,
865 cur_handler_id, mk);
867 } else
868 adbhid_input_register(id, default_id, org_handler_id,
869 cur_handler_id, mk);
870 return 1<<id;
873 static void
874 adbhid_input_devcleanup(u16 exist)
876 int i;
877 for(i=1; i<16; i++)
878 if (adbhid[i] && !(exist&(1<<i)))
879 adbhid_input_unregister(i);
882 static void
883 adbhid_probe(void)
885 struct adb_request req;
886 int i, default_id, org_handler_id, cur_handler_id;
887 u16 reg = 0;
889 adb_register(ADB_MOUSE, 0, &mouse_ids, adbhid_mouse_input);
890 adb_register(ADB_KEYBOARD, 0, &keyboard_ids, adbhid_keyboard_input);
891 adb_register(ADB_MISC, 0, &buttons_ids, adbhid_buttons_input);
893 for (i = 0; i < keyboard_ids.nids; i++) {
894 int id = keyboard_ids.id[i];
896 adb_get_infos(id, &default_id, &org_handler_id);
898 /* turn off all leds */
899 adb_request(&req, NULL, ADBREQ_SYNC, 3,
900 ADB_WRITEREG(id, KEYB_LEDREG), 0xff, 0xff);
902 /* Enable full feature set of the keyboard
903 ->get it to send separate codes for left and right shift,
904 control, option keys */
905 #if 0 /* handler 5 doesn't send separate codes for R modifiers */
906 if (adb_try_handler_change(id, 5))
907 printk("ADB keyboard at %d, handler set to 5\n", id);
908 else
909 #endif
910 if (adb_try_handler_change(id, 3))
911 printk("ADB keyboard at %d, handler set to 3\n", id);
912 else
913 printk("ADB keyboard at %d, handler 1\n", id);
915 adb_get_infos(id, &default_id, &cur_handler_id);
916 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
917 cur_handler_id, 0);
920 for (i = 0; i < buttons_ids.nids; i++) {
921 int id = buttons_ids.id[i];
923 adb_get_infos(id, &default_id, &org_handler_id);
924 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
925 org_handler_id, 0);
928 /* Try to switch all mice to handler 4, or 2 for three-button
929 mode and full resolution. */
930 for (i = 0; i < mouse_ids.nids; i++) {
931 int id = mouse_ids.id[i];
932 int mouse_kind;
934 adb_get_infos(id, &default_id, &org_handler_id);
936 if (adb_try_handler_change(id, 4)) {
937 printk("ADB mouse at %d, handler set to 4", id);
938 mouse_kind = ADBMOUSE_EXTENDED;
940 else if (adb_try_handler_change(id, 0x2F)) {
941 printk("ADB mouse at %d, handler set to 0x2F", id);
942 mouse_kind = ADBMOUSE_MICROSPEED;
944 else if (adb_try_handler_change(id, 0x42)) {
945 printk("ADB mouse at %d, handler set to 0x42", id);
946 mouse_kind = ADBMOUSE_TRACKBALLPRO;
948 else if (adb_try_handler_change(id, 0x66)) {
949 printk("ADB mouse at %d, handler set to 0x66", id);
950 mouse_kind = ADBMOUSE_MICROSPEED;
952 else if (adb_try_handler_change(id, 0x5F)) {
953 printk("ADB mouse at %d, handler set to 0x5F", id);
954 mouse_kind = ADBMOUSE_MICROSPEED;
956 else if (adb_try_handler_change(id, 3)) {
957 printk("ADB mouse at %d, handler set to 3", id);
958 mouse_kind = ADBMOUSE_MS_A3;
960 else if (adb_try_handler_change(id, 2)) {
961 printk("ADB mouse at %d, handler set to 2", id);
962 mouse_kind = ADBMOUSE_STANDARD_200;
964 else {
965 printk("ADB mouse at %d, handler 1", id);
966 mouse_kind = ADBMOUSE_STANDARD_100;
969 if ((mouse_kind == ADBMOUSE_TRACKBALLPRO)
970 || (mouse_kind == ADBMOUSE_MICROSPEED)) {
971 init_microspeed(id);
972 } else if (mouse_kind == ADBMOUSE_MS_A3) {
973 init_ms_a3(id);
974 } else if (mouse_kind == ADBMOUSE_EXTENDED) {
976 * Register 1 is usually used for device
977 * identification. Here, we try to identify
978 * a known device and call the appropriate
979 * init function.
981 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
982 ADB_READREG(id, 1));
984 if ((req.reply_len) &&
985 (req.reply[1] == 0x9a) && ((req.reply[2] == 0x21)
986 || (req.reply[2] == 0x20))) {
987 mouse_kind = ADBMOUSE_TRACKBALL;
988 init_trackball(id);
990 else if ((req.reply_len >= 4) &&
991 (req.reply[1] == 0x74) && (req.reply[2] == 0x70) &&
992 (req.reply[3] == 0x61) && (req.reply[4] == 0x64)) {
993 mouse_kind = ADBMOUSE_TRACKPAD;
994 init_trackpad(id);
996 else if ((req.reply_len >= 4) &&
997 (req.reply[1] == 0x4b) && (req.reply[2] == 0x4d) &&
998 (req.reply[3] == 0x4c) && (req.reply[4] == 0x31)) {
999 mouse_kind = ADBMOUSE_TURBOMOUSE5;
1000 init_turbomouse(id);
1002 else if ((req.reply_len == 9) &&
1003 (req.reply[1] == 0x4b) && (req.reply[2] == 0x4f) &&
1004 (req.reply[3] == 0x49) && (req.reply[4] == 0x54)) {
1005 if (adb_try_handler_change(id, 0x42)) {
1006 printk("\nADB MacAlly 2-button mouse at %d, handler set to 0x42", id);
1007 mouse_kind = ADBMOUSE_MACALLY2;
1011 printk("\n");
1013 adb_get_infos(id, &default_id, &cur_handler_id);
1014 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
1015 cur_handler_id, mouse_kind);
1017 adbhid_input_devcleanup(reg);
1020 static void
1021 init_trackpad(int id)
1023 struct adb_request req;
1024 unsigned char r1_buffer[8];
1026 printk(" (trackpad)");
1028 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
1029 ADB_READREG(id,1));
1030 if (req.reply_len < 8)
1031 printk("bad length for reg. 1\n");
1032 else
1034 memcpy(r1_buffer, &req.reply[1], 8);
1036 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1037 ADB_WRITEREG(id,1),
1038 r1_buffer[0],
1039 r1_buffer[1],
1040 r1_buffer[2],
1041 r1_buffer[3],
1042 r1_buffer[4],
1043 r1_buffer[5],
1044 0x0d,
1045 r1_buffer[7]);
1047 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1048 ADB_WRITEREG(id,2),
1049 0x99,
1050 0x94,
1051 0x19,
1052 0xff,
1053 0xb2,
1054 0x8a,
1055 0x1b,
1056 0x50);
1058 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1059 ADB_WRITEREG(id,1),
1060 r1_buffer[0],
1061 r1_buffer[1],
1062 r1_buffer[2],
1063 r1_buffer[3],
1064 r1_buffer[4],
1065 r1_buffer[5],
1066 0x03, /*r1_buffer[6],*/
1067 r1_buffer[7]);
1069 /* Without this flush, the trackpad may be locked up */
1070 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1074 static void
1075 init_trackball(int id)
1077 struct adb_request req;
1079 printk(" (trackman/mouseman)");
1081 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1082 ADB_WRITEREG(id,1), 00,0x81);
1084 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1085 ADB_WRITEREG(id,1), 01,0x81);
1087 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1088 ADB_WRITEREG(id,1), 02,0x81);
1090 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1091 ADB_WRITEREG(id,1), 03,0x38);
1093 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1094 ADB_WRITEREG(id,1), 00,0x81);
1096 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1097 ADB_WRITEREG(id,1), 01,0x81);
1099 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1100 ADB_WRITEREG(id,1), 02,0x81);
1102 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1103 ADB_WRITEREG(id,1), 03,0x38);
1106 static void
1107 init_turbomouse(int id)
1109 struct adb_request req;
1111 printk(" (TurboMouse 5)");
1113 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1115 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
1117 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1118 ADB_WRITEREG(3,2),
1119 0xe7,
1120 0x8c,
1124 0xff,
1125 0xff,
1126 0x94);
1128 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
1130 adb_request(&req, NULL, ADBREQ_SYNC, 9,
1131 ADB_WRITEREG(3,2),
1132 0xa5,
1133 0x14,
1136 0x69,
1137 0xff,
1138 0xff,
1139 0x27);
1142 static void
1143 init_microspeed(int id)
1145 struct adb_request req;
1147 printk(" (Microspeed/MacPoint or compatible)");
1149 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1151 /* This will initialize mice using the Microspeed, MacPoint and
1152 other compatible firmware. Bit 12 enables extended protocol.
1154 Register 1 Listen (4 Bytes)
1155 0 - 3 Button is mouse (set also for double clicking!!!)
1156 4 - 7 Button is locking (affects change speed also)
1157 8 - 11 Button changes speed
1158 12 1 = Extended mouse mode, 0 = normal mouse mode
1159 13 - 15 unused 0
1160 16 - 23 normal speed
1161 24 - 31 changed speed
1163 Register 1 talk holds version and product identification information.
1164 Register 1 Talk (4 Bytes):
1165 0 - 7 Product code
1166 8 - 23 undefined, reserved
1167 24 - 31 Version number
1169 Speed 0 is max. 1 to 255 set speed in increments of 1/256 of max.
1171 adb_request(&req, NULL, ADBREQ_SYNC, 5,
1172 ADB_WRITEREG(id,1),
1173 0x20, /* alt speed = 0x20 (rather slow) */
1174 0x00, /* norm speed = 0x00 (fastest) */
1175 0x10, /* extended protocol, no speed change */
1176 0x07); /* all buttons enabled as mouse buttons, no locking */
1179 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1182 static void
1183 init_ms_a3(int id)
1185 struct adb_request req;
1187 printk(" (Mouse Systems A3 Mouse, or compatible)");
1188 adb_request(&req, NULL, ADBREQ_SYNC, 3,
1189 ADB_WRITEREG(id, 0x2),
1190 0x00,
1191 0x07);
1193 adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1196 static int __init adbhid_init(void)
1198 #ifndef CONFIG_MAC
1199 if ( (_machine != _MACH_chrp) && (_machine != _MACH_Pmac) )
1200 return 0;
1201 #endif
1203 led_request.complete = 1;
1205 adbhid_probe();
1207 notifier_chain_register(&adb_client_list, &adbhid_adb_notifier);
1209 return 0;
1212 static void __exit adbhid_exit(void)
1216 module_init(adbhid_init);
1217 module_exit(adbhid_exit);