Kernel

Kernel Git Source Tree

Root/drivers/macintosh/adbhid.c

1	/*
2	* drivers/macintosh/adbhid.c
3	*
4	* ADB HID driver for Power Macintosh computers.
5	*
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.
9	*
10	* Copyright (C) 2000 Franz Sirl.
11	*
12	* Adapted to ADB changes and support for more devices by
13	* Benjamin Herrenschmidt. Adapted from code in MkLinux
14	* and reworked.
15	*
16	* Supported devices:
17	*
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>
29	*
30	* To do:
31	*
32	* Improve Kensington support.
33	* Split mouse/kbd
34	* Move to syfs
35	*/
36
37	#include <linux/module.h>
38	#include <linux/slab.h>
39	#include <linux/init.h>
40	#include <linux/notifier.h>
41	#include <linux/input.h>
42
43	#include <linux/adb.h>
44	#include <linux/cuda.h>
45	#include <linux/pmu.h>
46
47	#include <asm/machdep.h>
48	#ifdef CONFIG_PPC_PMAC
49	#include <asm/backlight.h>
50	#include <asm/pmac_feature.h>
51	#endif
52
53	MODULE_AUTHOR("Franz Sirl <Franz.Sirl-kernel@lauterbach.com>");
54
55	static int restore_capslock_events;
56	module_param(restore_capslock_events, int, 0644);
57	MODULE_PARM_DESC(restore_capslock_events,
58	"Produce keypress events for capslock on both keyup and keydown.");
59
60	#define KEYB_KEYREG 0 /* register # for key up/down data */
61	#define KEYB_LEDREG 2 /* register # for leds on ADB keyboard */
62	#define MOUSE_DATAREG 0 /* reg# for movement/button codes from mouse */
63
64	static int adb_message_handler(struct notifier_block , unsigned long, void );
65	static struct notifier_block adbhid_adb_notifier = {
66	.notifier_call = adb_message_handler,
67	};
68
69	/* Some special keys */
70	#define ADB_KEY_DEL 0x33
71	#define ADB_KEY_CMD 0x37
72	#define ADB_KEY_CAPSLOCK 0x39
73	#define ADB_KEY_FN 0x3f
74	#define ADB_KEY_FWDEL 0x75
75	#define ADB_KEY_POWER_OLD 0x7e
76	#define ADB_KEY_POWER 0x7f
77
78	static const u16 adb_to_linux_keycodes[128] = {
79	/* 0x00 / KEY_A, / 30 */
80	/* 0x01 / KEY_S, / 31 */
81	/* 0x02 / KEY_D, / 32 */
82	/* 0x03 / KEY_F, / 33 */
83	/* 0x04 / KEY_H, / 35 */
84	/* 0x05 / KEY_G, / 34 */
85	/* 0x06 / KEY_Z, / 44 */
86	/* 0x07 / KEY_X, / 45 */
87	/* 0x08 / KEY_C, / 46 */
88	/* 0x09 / KEY_V, / 47 */
89	/* 0x0a / KEY_102ND, / 86 */
90	/* 0x0b / KEY_B, / 48 */
91	/* 0x0c / KEY_Q, / 16 */
92	/* 0x0d / KEY_W, / 17 */
93	/* 0x0e / KEY_E, / 18 */
94	/* 0x0f / KEY_R, / 19 */
95	/* 0x10 / KEY_Y, / 21 */
96	/* 0x11 / KEY_T, / 20 */
97	/* 0x12 / KEY_1, / 2 */
98	/* 0x13 / KEY_2, / 3 */
99	/* 0x14 / KEY_3, / 4 */
100	/* 0x15 / KEY_4, / 5 */
101	/* 0x16 / KEY_6, / 7 */
102	/* 0x17 / KEY_5, / 6 */
103	/* 0x18 / KEY_EQUAL, / 13 */
104	/* 0x19 / KEY_9, / 10 */
105	/* 0x1a / KEY_7, / 8 */
106	/* 0x1b / KEY_MINUS, / 12 */
107	/* 0x1c / KEY_8, / 9 */
108	/* 0x1d / KEY_0, / 11 */
109	/* 0x1e / KEY_RIGHTBRACE, / 27 */
110	/* 0x1f / KEY_O, / 24 */
111	/* 0x20 / KEY_U, / 22 */
112	/* 0x21 / KEY_LEFTBRACE, / 26 */
113	/* 0x22 / KEY_I, / 23 */
114	/* 0x23 / KEY_P, / 25 */
115	/* 0x24 / KEY_ENTER, / 28 */
116	/* 0x25 / KEY_L, / 38 */
117	/* 0x26 / KEY_J, / 36 */
118	/* 0x27 / KEY_APOSTROPHE, / 40 */
119	/* 0x28 / KEY_K, / 37 */
120	/* 0x29 / KEY_SEMICOLON, / 39 */
121	/* 0x2a / KEY_BACKSLASH, / 43 */
122	/* 0x2b / KEY_COMMA, / 51 */
123	/* 0x2c / KEY_SLASH, / 53 */
124	/* 0x2d / KEY_N, / 49 */
125	/* 0x2e / KEY_M, / 50 */
126	/* 0x2f / KEY_DOT, / 52 */
127	/* 0x30 / KEY_TAB, / 15 */
128	/* 0x31 / KEY_SPACE, / 57 */
129	/* 0x32 / KEY_GRAVE, / 41 */
130	/* 0x33 / KEY_BACKSPACE, / 14 */
131	/* 0x34 / KEY_KPENTER, / 96 */
132	/* 0x35 / KEY_ESC, / 1 */
133	/* 0x36 / KEY_LEFTCTRL, / 29 */
134	/* 0x37 / KEY_LEFTMETA, / 125 */
135	/* 0x38 / KEY_LEFTSHIFT, / 42 */
136	/* 0x39 / KEY_CAPSLOCK, / 58 */
137	/* 0x3a / KEY_LEFTALT, / 56 */
138	/* 0x3b / KEY_LEFT, / 105 */
139	/* 0x3c / KEY_RIGHT, / 106 */
140	/* 0x3d / KEY_DOWN, / 108 */
141	/* 0x3e / KEY_UP, / 103 */
142	/* 0x3f / KEY_FN, / 0x1d0 */
143	/* 0x40 */ 0,
144	/* 0x41 / KEY_KPDOT, / 83 */
145	/* 0x42 */ 0,
146	/* 0x43 / KEY_KPASTERISK, / 55 */
147	/* 0x44 */ 0,
148	/* 0x45 / KEY_KPPLUS, / 78 */
149	/* 0x46 */ 0,
150	/* 0x47 / KEY_NUMLOCK, / 69 */
151	/* 0x48 */ 0,
152	/* 0x49 */ 0,
153	/* 0x4a */ 0,
154	/* 0x4b / KEY_KPSLASH, / 98 */
155	/* 0x4c / KEY_KPENTER, / 96 */
156	/* 0x4d */ 0,
157	/* 0x4e / KEY_KPMINUS, / 74 */
158	/* 0x4f */ 0,
159	/* 0x50 */ 0,
160	/* 0x51 / KEY_KPEQUAL, / 117 */
161	/* 0x52 / KEY_KP0, / 82 */
162	/* 0x53 / KEY_KP1, / 79 */
163	/* 0x54 / KEY_KP2, / 80 */
164	/* 0x55 / KEY_KP3, / 81 */
165	/* 0x56 / KEY_KP4, / 75 */
166	/* 0x57 / KEY_KP5, / 76 */
167	/* 0x58 / KEY_KP6, / 77 */
168	/* 0x59 / KEY_KP7, / 71 */
169	/* 0x5a */ 0,
170	/* 0x5b / KEY_KP8, / 72 */
171	/* 0x5c / KEY_KP9, / 73 */
172	/* 0x5d / KEY_YEN, / 124 */
173	/* 0x5e / KEY_RO, / 89 */
174	/* 0x5f / KEY_KPCOMMA, / 121 */
175	/* 0x60 / KEY_F5, / 63 */
176	/* 0x61 / KEY_F6, / 64 */
177	/* 0x62 / KEY_F7, / 65 */
178	/* 0x63 / KEY_F3, / 61 */
179	/* 0x64 / KEY_F8, / 66 */
180	/* 0x65 / KEY_F9, / 67 */
181	/* 0x66 / KEY_HANJA, / 123 */
182	/* 0x67 / KEY_F11, / 87 */
183	/* 0x68 / KEY_HANGEUL, / 122 */
184	/* 0x69 / KEY_SYSRQ, / 99 */
185	/* 0x6a */ 0,
186	/* 0x6b / KEY_SCROLLLOCK, / 70 */
187	/* 0x6c */ 0,
188	/* 0x6d / KEY_F10, / 68 */
189	/* 0x6e / KEY_COMPOSE, / 127 */
190	/* 0x6f / KEY_F12, / 88 */
191	/* 0x70 */ 0,
192	/* 0x71 / KEY_PAUSE, / 119 */
193	/* 0x72 / KEY_INSERT, / 110 */
194	/* 0x73 / KEY_HOME, / 102 */
195	/* 0x74 / KEY_PAGEUP, / 104 */
196	/* 0x75 / KEY_DELETE, / 111 */
197	/* 0x76 / KEY_F4, / 62 */
198	/* 0x77 / KEY_END, / 107 */
199	/* 0x78 / KEY_F2, / 60 */
200	/* 0x79 / KEY_PAGEDOWN, / 109 */
201	/* 0x7a / KEY_F1, / 59 */
202	/* 0x7b / KEY_RIGHTSHIFT, / 54 */
203	/* 0x7c / KEY_RIGHTALT, / 100 */
204	/* 0x7d / KEY_RIGHTCTRL, / 97 */
205	/* 0x7e / KEY_RIGHTMETA, / 126 */
206	/* 0x7f / KEY_POWER, / 116 */
207	};
208
209	struct adbhid {
210	struct input_dev *input;
211	int id;
212	int default_id;
213	int original_handler_id;
214	int current_handler_id;
215	int mouse_kind;
216	u16 *keycode;
217	char name[64];
218	char phys[32];
219	int flags;
220	};
221
222	#define FLAG_FN_KEY_PRESSED 0x00000001
223	#define FLAG_POWER_FROM_FN 0x00000002
224	#define FLAG_EMU_FWDEL_DOWN 0x00000004
225	#define FLAG_CAPSLOCK_TRANSLATE 0x00000008
226	#define FLAG_CAPSLOCK_DOWN 0x00000010
227	#define FLAG_CAPSLOCK_IGNORE_NEXT 0x00000020
228	#define FLAG_POWER_KEY_PRESSED 0x00000040
229
230	static struct adbhid *adbhid[16];
231
232	static void adbhid_probe(void);
233
234	static void adbhid_input_keycode(int, int, int);
235
236	static void init_trackpad(int id);
237	static void init_trackball(int id);
238	static void init_turbomouse(int id);
239	static void init_microspeed(int id);
240	static void init_ms_a3(int id);
241
242	static struct adb_ids keyboard_ids;
243	static struct adb_ids mouse_ids;
244	static struct adb_ids buttons_ids;
245
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
251
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 */
263
264	static void
265	adbhid_keyboard_input(unsigned char *data, int nb, int apoll)
266	{
267	int id = (data[0] >> 4) & 0x0f;
268
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;
273	}
274
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);
279	if (!(data[2] == 0xff \|\| (data[2] == 0x7f && data[1] == 0x7f)))
280	adbhid_input_keycode(id, data[2], 0);
281	}
282
283	static void
284	adbhid_input_keycode(int id, int scancode, int repeat)
285	{
286	struct adbhid *ahid = adbhid[id];
287	int keycode, up_flag, key;
288
289	keycode = scancode & 0x7f;
290	up_flag = scancode & 0x80;
291
292	if (restore_capslock_events) {
293	if (keycode == ADB_KEY_CAPSLOCK && !up_flag) {
294	/* Key pressed, turning on the CapsLock LED.
295	* The next 0xff will be interpreted as a release. */
296	if (ahid->flags & FLAG_CAPSLOCK_IGNORE_NEXT) {
297	/* Throw away this key event if it happens
298	* just after resume. */
299	ahid->flags &= ~FLAG_CAPSLOCK_IGNORE_NEXT;
300	return;
301	} else {
302	ahid->flags \|= FLAG_CAPSLOCK_TRANSLATE
303	\| FLAG_CAPSLOCK_DOWN;
304	}
305	} else if (scancode == 0xff &&
306	!(ahid->flags & FLAG_POWER_KEY_PRESSED)) {
307	/* Scancode 0xff usually signifies that the capslock
308	* key was either pressed or released, or that the
309	* power button was released. */
310	if (ahid->flags & FLAG_CAPSLOCK_TRANSLATE) {
311	keycode = ADB_KEY_CAPSLOCK;
312	if (ahid->flags & FLAG_CAPSLOCK_DOWN) {
313	/* Key released */
314	up_flag = 1;
315	ahid->flags &= ~FLAG_CAPSLOCK_DOWN;
316	} else {
317	/* Key pressed */
318	up_flag = 0;
319	ahid->flags &= ~FLAG_CAPSLOCK_TRANSLATE;
320	}
321	} else {
322	printk(KERN_INFO "Spurious caps lock event "
323	"(scancode 0xff).\n");
324	}
325	}
326	}
327
328	switch (keycode) {
329	case ADB_KEY_CAPSLOCK:
330	if (!restore_capslock_events) {
331	/* Generate down/up events for CapsLock every time. */
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: /* Power key on PBook 3400 needs remapping */
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	/* Keep track of the power key state */
351	if (up_flag)
352	ahid->flags &= ~FLAG_POWER_KEY_PRESSED;
353	else
354	ahid->flags \|= FLAG_POWER_KEY_PRESSED;
355
356	/* Fn + Command will produce a bogus "power" keycode */
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	/* Keep track of the Fn key state */
370	if (up_flag) {
371	ahid->flags &= ~FLAG_FN_KEY_PRESSED;
372	/* Emulate Fn+delete = forward delete */
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	/* Emulate Fn+delete = forward delete */
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 /* CONFIG_PPC_PMAC */
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	printk(KERN_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	printk(KERN_ERR "ADB HID on ID %d not yet registered\n", id);
411	return;
412	}
413
414	/*
415	Handler 1 -- 100cpi original Apple mouse protocol.
416	Handler 2 -- 200cpi original Apple mouse protocol.
417
418	For Apple's standard one-button mouse protocol the data array will
419	contain the following values:
420
421	BITS COMMENTS
422	data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
423	data[1] = bxxx xxxx First button and x-axis motion.
424	data[2] = byyy yyyy Second button and y-axis motion.
425
426	Handler 4 -- Apple Extended mouse protocol.
427
428	For Apple's 3-button mouse protocol the data array will contain the
429	following values:
430
431	BITS COMMENTS
432	data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
433	data[1] = bxxx xxxx Left button and x-axis motion.
434	data[2] = byyy yyyy Second button and y-axis motion.
435	data[3] = byyy bxxx Third button and fourth button. Y is additional
436	high bits of y-axis motion. XY is additional
437	high bits of x-axis motion.
438
439	MacAlly 2-button mouse protocol.
440
441	For MacAlly 2-button mouse protocol the data array will contain the
442	following values:
443
444	BITS COMMENTS
445	data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
446	data[1] = bxxx xxxx Left button and x-axis motion.
447	data[2] = byyy yyyy Right button and y-axis motion.
448	data[3] = ???? ???? unknown
449	data[4] = ???? ???? unknown
450
451	*/
452
453	/* If it's a trackpad, we alias the second button to the first.
454	NOTE: Apple sends an ADB flush command to the trackpad when
455	the first (the real) button is released. We could do
456	this here using async flush requests.
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; /* Right button is mapped as button 3 */
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	printk(KERN_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: /* Adjustable keyboard button device */
515	{
516	int down = (data[1] == (data[1] & 0xf));
517
518	switch (data[1] & 0x0f) {
519	case 0x0: /* microphone */
520	input_report_key(adbhid[id]->input, KEY_SOUND, down);
521	break;
522
523	case 0x1: /* mute */
524	input_report_key(adbhid[id]->input, KEY_MUTE, down);
525	break;
526
527	case 0x2: /* volume decrease */
528	input_report_key(adbhid[id]->input, KEY_VOLUMEDOWN, down);
529	break;
530
531	case 0x3: /* volume increase */
532	input_report_key(adbhid[id]->input, KEY_VOLUMEUP, down);
533	break;
534
535	default:
536	printk(KERN_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: /* Powerbook button device */
544	{
545	int down = (data[1] == (data[1] & 0xf));
546
547	/*
548	* XXX: Where is the contrast control for the passive?
549	* -- Cort
550	*/
551
552	switch (data[1] & 0x0f) {
553	case 0x8: /* mute */
554	input_report_key(adbhid[id]->input, KEY_MUTE, down);
555	break;
556
557	case 0x7: /* volume decrease */
558	input_report_key(adbhid[id]->input, KEY_VOLUMEDOWN, down);
559	break;
560
561	case 0x6: /* volume increase */
562	input_report_key(adbhid[id]->input, KEY_VOLUMEUP, down);
563	break;
564
565	case 0xb: /* eject */
566	input_report_key(adbhid[id]->input, KEY_EJECTCD, down);
567	break;
568
569	case 0xa: /* brightness decrease */
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: /* brightness increase */
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: /* videomode switch */
586	input_report_key(adbhid[id]->input, KEY_SWITCHVIDEOMODE, down);
587	break;
588
589	case 0xd: /* keyboard illumination toggle */
590	input_report_key(adbhid[id]->input, KEY_KBDILLUMTOGGLE, down);
591	break;
592
593	case 0xe: /* keyboard illumination decrease */
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	/* keyboard illumination increase */
602	input_report_key(adbhid[id]->input, KEY_KBDILLUMUP, down);
603	break;
604
605	case 0x7f:
606	case 0xff:
607	/* keypad overlay toogle */
608	break;
609
610	default:
611	printk(KERN_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	printk(KERN_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	* Event callback from the input module. Events that change the state of
682	* the hardware are processed here.
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	/* Stop the repeat timer. Autopoll is already off at this point */
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	/* Stop pending led requests */
732	while (leds_req_pending)
733	adb_poll();
734
735	/* After resume, and if the capslock LED is on, the PMU will
736	* send a "capslock down" key event. This confuses the
737	* restore_capslock_events logic. Remember if the capslock
738	* LED was on before suspend so the unwanted key event can
739	* be ignored after resume. */
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
761	if (adbhid[id]) {
762	printk(KERN_ERR "Trying to reregister ADB HID on ID %d\n", id);
763	return -EEXIST;
764	}
765
766	adbhid[id] = hid = kzalloc(sizeof(struct adbhid), GFP_KERNEL);
767	input_dev = input_allocate_device();
768	if (!hid \|\| !input_dev) {
769	err = -ENOMEM;
770	goto fail;
771	}
772
773	sprintf(hid->phys, "adb%d:%d.%02x/input", id, default_id, original_handler_id);
774
775	hid->input = input_dev;
776	hid->id = default_id;
777	hid->original_handler_id = original_handler_id;
778	hid->current_handler_id = current_handler_id;
779	hid->mouse_kind = mouse_kind;
780	hid->flags = 0;
781	input_set_drvdata(input_dev, hid);
782	input_dev->name = hid->name;
783	input_dev->phys = hid->phys;
784	input_dev->id.bustype = BUS_ADB;
785	input_dev->id.vendor = 0x0001;
786	input_dev->id.product = (id << 12) \| (default_id << 8) \| original_handler_id;
787	input_dev->id.version = 0x0100;
788
789	switch (default_id) {
790	case ADB_KEYBOARD:
791	hid->keycode = kmalloc(sizeof(adb_to_linux_keycodes), GFP_KERNEL);
792	if (!hid->keycode) {
793	err = -ENOMEM;
794	goto fail;
795	}
796
797	sprintf(hid->name, "ADB keyboard");
798
799	memcpy(hid->keycode, adb_to_linux_keycodes, sizeof(adb_to_linux_keycodes));
800
801	printk(KERN_INFO "Detected ADB keyboard, type ");
802	switch (original_handler_id) {
803	default:
804	printk("<unknown>.\n");
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	printk("ANSI.\n");
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	printk("ISO, swapping keys.\n");
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	printk("JIS.\n");
828	input_dev->id.version = ADB_KEYBOARD_JIS;
829	break;
830	}
831
832	for (i = 0; i < 128; i++)
833	if (hid->keycode[i])
834	set_bit(hid->keycode[i], input_dev->keybit);
835
836	input_dev->evbit[0] = BIT_MASK(EV_KEY) \| BIT_MASK(EV_LED) \|
837	BIT_MASK(EV_REP);
838	input_dev->ledbit[0] = BIT_MASK(LED_SCROLLL) \|
839	BIT_MASK(LED_CAPSL) \| BIT_MASK(LED_NUML);
840	input_dev->event = adbhid_kbd_event;
841	input_dev->keycodemax = KEY_FN;
842	input_dev->keycodesize = sizeof(hid->keycode[0]);
843	break;
844
845	case ADB_MOUSE:
846	sprintf(hid->name, "ADB mouse");
847
848	input_dev->evbit[0] = BIT_MASK(EV_KEY) \| BIT_MASK(EV_REL);
849	input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) \|
850	BIT_MASK(BTN_MIDDLE) \| BIT_MASK(BTN_RIGHT);
851	input_dev->relbit[0] = BIT_MASK(REL_X) \| BIT_MASK(REL_Y);
852	break;
853
854	case ADB_MISC:
855	switch (original_handler_id) {
856	case 0x02: /* Adjustable keyboard button device */
857	sprintf(hid->name, "ADB adjustable keyboard buttons");
858	input_dev->evbit[0] = BIT_MASK(EV_KEY) \|
859	BIT_MASK(EV_REP);
860	set_bit(KEY_SOUND, input_dev->keybit);
861	set_bit(KEY_MUTE, input_dev->keybit);
862	set_bit(KEY_VOLUMEUP, input_dev->keybit);
863	set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
864	break;
865	case 0x1f: /* Powerbook button device */
866	sprintf(hid->name, "ADB Powerbook buttons");
867	input_dev->evbit[0] = BIT_MASK(EV_KEY) \|
868	BIT_MASK(EV_REP);
869	set_bit(KEY_MUTE, input_dev->keybit);
870	set_bit(KEY_VOLUMEUP, input_dev->keybit);
871	set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
872	set_bit(KEY_BRIGHTNESSUP, input_dev->keybit);
873	set_bit(KEY_BRIGHTNESSDOWN, input_dev->keybit);
874	set_bit(KEY_EJECTCD, input_dev->keybit);
875	set_bit(KEY_SWITCHVIDEOMODE, input_dev->keybit);
876	set_bit(KEY_KBDILLUMTOGGLE, input_dev->keybit);
877	set_bit(KEY_KBDILLUMDOWN, input_dev->keybit);
878	set_bit(KEY_KBDILLUMUP, input_dev->keybit);
879	break;
880	}
881	if (hid->name[0])
882	break;
883	/* else fall through */
884
885	default:
886	printk(KERN_INFO "Trying to register unknown ADB device to input layer.\n");
887	err = -ENODEV;
888	goto fail;
889	}
890
891	input_dev->keycode = hid->keycode;
892
893	err = input_register_device(input_dev);
894	if (err)
895	goto fail;
896
897	if (default_id == ADB_KEYBOARD) {
898	/* HACK WARNING!! This should go away as soon there is an utility
899	* to control that for event devices.
900	*/
901	input_dev->rep[REP_DELAY] = 500; /* input layer default: 250 */
902	input_dev->rep[REP_PERIOD] = 66; /* input layer default: 33 */
903	}
904
905	return 0;
906
907	fail: input_free_device(input_dev);
908	if (hid) {
909	kfree(hid->keycode);
910	kfree(hid);
911	}
912	adbhid[id] = NULL;
913	return err;
914	}
915
916	static void adbhid_input_unregister(int id)
917	{
918	input_unregister_device(adbhid[id]->input);
919	kfree(adbhid[id]->keycode);
920	kfree(adbhid[id]);
921	adbhid[id] = NULL;
922	}
923
924
925	static u16
926	adbhid_input_reregister(int id, int default_id, int org_handler_id,
927	int cur_handler_id, int mk)
928	{
929	if (adbhid[id]) {
930	if (adbhid[id]->input->id.product !=
931	((id << 12)\|(default_id << 8)\|org_handler_id)) {
932	adbhid_input_unregister(id);
933	adbhid_input_register(id, default_id, org_handler_id,
934	cur_handler_id, mk);
935	}
936	} else
937	adbhid_input_register(id, default_id, org_handler_id,
938	cur_handler_id, mk);
939	return 1<<id;
940	}
941
942	static void
943	adbhid_input_devcleanup(u16 exist)
944	{
945	int i;
946	for(i=1; i<16; i++)
947	if (adbhid[i] && !(exist&(1<<i)))
948	adbhid_input_unregister(i);
949	}
950
951	static void
952	adbhid_probe(void)
953	{
954	struct adb_request req;
955	int i, default_id, org_handler_id, cur_handler_id;
956	u16 reg = 0;
957
958	adb_register(ADB_MOUSE, 0, &mouse_ids, adbhid_mouse_input);
959	adb_register(ADB_KEYBOARD, 0, &keyboard_ids, adbhid_keyboard_input);
960	adb_register(ADB_MISC, 0, &buttons_ids, adbhid_buttons_input);
961
962	for (i = 0; i < keyboard_ids.nids; i++) {
963	int id = keyboard_ids.id[i];
964
965	adb_get_infos(id, &default_id, &org_handler_id);
966
967	/* turn off all leds */
968	adb_request(&req, NULL, ADBREQ_SYNC, 3,
969	ADB_WRITEREG(id, KEYB_LEDREG), 0xff, 0xff);
970
971	/* Enable full feature set of the keyboard
972	->get it to send separate codes for left and right shift,
973	control, option keys */
974	#if 0 /* handler 5 doesn't send separate codes for R modifiers */
975	if (adb_try_handler_change(id, 5))
976	printk("ADB keyboard at %d, handler set to 5\n", id);
977	else
978	#endif
979	if (adb_try_handler_change(id, 3))
980	printk("ADB keyboard at %d, handler set to 3\n", id);
981	else
982	printk("ADB keyboard at %d, handler 1\n", id);
983
984	adb_get_infos(id, &default_id, &cur_handler_id);
985	reg \|= adbhid_input_reregister(id, default_id, org_handler_id,
986	cur_handler_id, 0);
987	}
988
989	for (i = 0; i < buttons_ids.nids; i++) {
990	int id = buttons_ids.id[i];
991
992	adb_get_infos(id, &default_id, &org_handler_id);
993	reg \|= adbhid_input_reregister(id, default_id, org_handler_id,
994	org_handler_id, 0);
995	}
996
997	/* Try to switch all mice to handler 4, or 2 for three-button
998	mode and full resolution. */
999	for (i = 0; i < mouse_ids.nids; i++) {
1000	int id = mouse_ids.id[i];
1001	int mouse_kind;
1002
1003	adb_get_infos(id, &default_id, &org_handler_id);
1004
1005	if (adb_try_handler_change(id, 4)) {
1006	printk("ADB mouse at %d, handler set to 4", id);
1007	mouse_kind = ADBMOUSE_EXTENDED;
1008	}
1009	else if (adb_try_handler_change(id, 0x2F)) {
1010	printk("ADB mouse at %d, handler set to 0x2F", id);
1011	mouse_kind = ADBMOUSE_MICROSPEED;
1012	}
1013	else if (adb_try_handler_change(id, 0x42)) {
1014	printk("ADB mouse at %d, handler set to 0x42", id);
1015	mouse_kind = ADBMOUSE_TRACKBALLPRO;
1016	}
1017	else if (adb_try_handler_change(id, 0x66)) {
1018	printk("ADB mouse at %d, handler set to 0x66", id);
1019	mouse_kind = ADBMOUSE_MICROSPEED;
1020	}
1021	else if (adb_try_handler_change(id, 0x5F)) {
1022	printk("ADB mouse at %d, handler set to 0x5F", id);
1023	mouse_kind = ADBMOUSE_MICROSPEED;
1024	}
1025	else if (adb_try_handler_change(id, 3)) {
1026	printk("ADB mouse at %d, handler set to 3", id);
1027	mouse_kind = ADBMOUSE_MS_A3;
1028	}
1029	else if (adb_try_handler_change(id, 2)) {
1030	printk("ADB mouse at %d, handler set to 2", id);
1031	mouse_kind = ADBMOUSE_STANDARD_200;
1032	}
1033	else {
1034	printk("ADB mouse at %d, handler 1", id);
1035	mouse_kind = ADBMOUSE_STANDARD_100;
1036	}
1037
1038	if ((mouse_kind == ADBMOUSE_TRACKBALLPRO)
1039	\|\| (mouse_kind == ADBMOUSE_MICROSPEED)) {
1040	init_microspeed(id);
1041	} else if (mouse_kind == ADBMOUSE_MS_A3) {
1042	init_ms_a3(id);
1043	} else if (mouse_kind == ADBMOUSE_EXTENDED) {
1044	/*
1045	* Register 1 is usually used for device
1046	* identification. Here, we try to identify
1047	* a known device and call the appropriate
1048	* init function.
1049	*/
1050	adb_request(&req, NULL, ADBREQ_SYNC \| ADBREQ_REPLY, 1,
1051	ADB_READREG(id, 1));
1052
1053	if ((req.reply_len) &&
1054	(req.reply[1] == 0x9a) && ((req.reply[2] == 0x21)
1055	\|\| (req.reply[2] == 0x20))) {
1056	mouse_kind = ADBMOUSE_TRACKBALL;
1057	init_trackball(id);
1058	}
1059	else if ((req.reply_len >= 4) &&
1060	(req.reply[1] == 0x74) && (req.reply[2] == 0x70) &&
1061	(req.reply[3] == 0x61) && (req.reply[4] == 0x64)) {
1062	mouse_kind = ADBMOUSE_TRACKPAD;
1063	init_trackpad(id);
1064	}
1065	else if ((req.reply_len >= 4) &&
1066	(req.reply[1] == 0x4b) && (req.reply[2] == 0x4d) &&
1067	(req.reply[3] == 0x4c) && (req.reply[4] == 0x31)) {
1068	mouse_kind = ADBMOUSE_TURBOMOUSE5;
1069	init_turbomouse(id);
1070	}
1071	else if ((req.reply_len == 9) &&
1072	(req.reply[1] == 0x4b) && (req.reply[2] == 0x4f) &&
1073	(req.reply[3] == 0x49) && (req.reply[4] == 0x54)) {
1074	if (adb_try_handler_change(id, 0x42)) {
1075	printk("\nADB MacAlly 2-button mouse at %d, handler set to 0x42", id);
1076	mouse_kind = ADBMOUSE_MACALLY2;
1077	}
1078	}
1079	}
1080	printk("\n");
1081
1082	adb_get_infos(id, &default_id, &cur_handler_id);
1083	reg \|= adbhid_input_reregister(id, default_id, org_handler_id,
1084	cur_handler_id, mouse_kind);
1085	}
1086	adbhid_input_devcleanup(reg);
1087	}
1088
1089	static void
1090	init_trackpad(int id)
1091	{
1092	struct adb_request req;
1093	unsigned char r1_buffer[8];
1094
1095	printk(" (trackpad)");
1096
1097	adb_request(&req, NULL, ADBREQ_SYNC \| ADBREQ_REPLY, 1,
1098	ADB_READREG(id,1));
1099	if (req.reply_len < 8)
1100	printk("bad length for reg. 1\n");
1101	else
1102	{
1103	memcpy(r1_buffer, &req.reply[1], 8);
1104
1105	adb_request(&req, NULL, ADBREQ_SYNC, 9,
1106	ADB_WRITEREG(id,1),
1107	r1_buffer[0],
1108	r1_buffer[1],
1109	r1_buffer[2],
1110	r1_buffer[3],
1111	r1_buffer[4],
1112	r1_buffer[5],
1113	0x0d,
1114	r1_buffer[7]);
1115
1116	adb_request(&req, NULL, ADBREQ_SYNC, 9,
1117	ADB_WRITEREG(id,2),
1118	0x99,
1119	0x94,
1120	0x19,
1121	0xff,
1122	0xb2,
1123	0x8a,
1124	0x1b,
1125	0x50);
1126
1127	adb_request(&req, NULL, ADBREQ_SYNC, 9,
1128	ADB_WRITEREG(id,1),
1129	r1_buffer[0],
1130	r1_buffer[1],
1131	r1_buffer[2],
1132	r1_buffer[3],
1133	r1_buffer[4],
1134	r1_buffer[5],
1135	0x03, /r1_buffer[6],/
1136	r1_buffer[7]);
1137
1138	/* Without this flush, the trackpad may be locked up */
1139	adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1140	}
1141	}
1142
1143	static void
1144	init_trackball(int id)
1145	{
1146	struct adb_request req;
1147
1148	printk(" (trackman/mouseman)");
1149
1150	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1151	ADB_WRITEREG(id,1), 00,0x81);
1152
1153	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1154	ADB_WRITEREG(id,1), 01,0x81);
1155
1156	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1157	ADB_WRITEREG(id,1), 02,0x81);
1158
1159	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1160	ADB_WRITEREG(id,1), 03,0x38);
1161
1162	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1163	ADB_WRITEREG(id,1), 00,0x81);
1164
1165	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1166	ADB_WRITEREG(id,1), 01,0x81);
1167
1168	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1169	ADB_WRITEREG(id,1), 02,0x81);
1170
1171	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1172	ADB_WRITEREG(id,1), 03,0x38);
1173	}
1174
1175	static void
1176	init_turbomouse(int id)
1177	{
1178	struct adb_request req;
1179
1180	printk(" (TurboMouse 5)");
1181
1182	adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1183
1184	adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
1185
1186	adb_request(&req, NULL, ADBREQ_SYNC, 9,
1187	ADB_WRITEREG(3,2),
1188	0xe7,
1189	0x8c,
1190	0,
1191	0,
1192	0,
1193	0xff,
1194	0xff,
1195	0x94);
1196
1197	adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
1198
1199	adb_request(&req, NULL, ADBREQ_SYNC, 9,
1200	ADB_WRITEREG(3,2),
1201	0xa5,
1202	0x14,
1203	0,
1204	0,
1205	0x69,
1206	0xff,
1207	0xff,
1208	0x27);
1209	}
1210
1211	static void
1212	init_microspeed(int id)
1213	{
1214	struct adb_request req;
1215
1216	printk(" (Microspeed/MacPoint or compatible)");
1217
1218	adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1219
1220	/* This will initialize mice using the Microspeed, MacPoint and
1221	other compatible firmware. Bit 12 enables extended protocol.
1222
1223	Register 1 Listen (4 Bytes)
1224	0 - 3 Button is mouse (set also for double clicking!!!)
1225	4 - 7 Button is locking (affects change speed also)
1226	8 - 11 Button changes speed
1227	12 1 = Extended mouse mode, 0 = normal mouse mode
1228	13 - 15 unused 0
1229	16 - 23 normal speed
1230	24 - 31 changed speed
1231
1232	Register 1 talk holds version and product identification information.
1233	Register 1 Talk (4 Bytes):
1234	0 - 7 Product code
1235	8 - 23 undefined, reserved
1236	24 - 31 Version number
1237
1238	Speed 0 is max. 1 to 255 set speed in increments of 1/256 of max.
1239	*/
1240	adb_request(&req, NULL, ADBREQ_SYNC, 5,
1241	ADB_WRITEREG(id,1),
1242	0x20, /* alt speed = 0x20 (rather slow) */
1243	0x00, /* norm speed = 0x00 (fastest) */
1244	0x10, /* extended protocol, no speed change */
1245	0x07); /* all buttons enabled as mouse buttons, no locking */
1246
1247
1248	adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1249	}
1250
1251	static void
1252	init_ms_a3(int id)
1253	{
1254	struct adb_request req;
1255
1256	printk(" (Mouse Systems A3 Mouse, or compatible)");
1257	adb_request(&req, NULL, ADBREQ_SYNC, 3,
1258	ADB_WRITEREG(id, 0x2),
1259	0x00,
1260	0x07);
1261
1262	adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1263	}
1264
1265	static int __init adbhid_init(void)
1266	{
1267	#ifndef CONFIG_MAC
1268	if (!machine_is(chrp) && !machine_is(powermac))
1269	return 0;
1270	#endif
1271
1272	led_request.complete = 1;
1273
1274	adbhid_probe();
1275
1276	blocking_notifier_chain_register(&adb_client_list,
1277	&adbhid_adb_notifier);
1278
1279	return 0;
1280	}
1281
1282	static void __exit adbhid_exit(void)
1283	{
1284	}
1285
1286	module_init(adbhid_init);
1287	module_exit(adbhid_exit);
1288

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/macintosh/adbhid.c

interactive