OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [macintosh/] [mac_keyb.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1275 phoenix 
/*
2 
 * drivers/char/mac_keyb.c
3 
 *
4 
 * Keyboard driver for Power Macintosh computers.
5 
 *
6 
 * Adapted from drivers/char/keyboard.c by Paul Mackerras
7 
 * (see that file for its authors and contributors).
8 
 *
9 
 * Copyright (C) 1996 Paul Mackerras.
10 
 *
11 
 * Adapted to ADB changes and support for more devices by
12 
 * Benjamin Herrenschmidt. Adapted from code in MkLinux
13 
 * and reworked.
14 
 *
15 
 * Supported devices:
16 
 *
17 
 * - Standard 1 button mouse
18 
 * - All standard Apple Extended protocol (handler ID 4)
19 
 * - mouseman and trackman mice & trackballs
20 
 * - PowerBook Trackpad (default setup: enable tapping)
21 
 * - MicroSpeed mouse & trackball (needs testing)
22 
 * - CH Products Trackball Pro (needs testing)
23 
 * - Contour Design (Contour Mouse)
24 
 * - Hunter digital (NoHandsMouse)
25 
 * - Kensignton TurboMouse 5 (needs testing)
26 
 * - Mouse Systems A3 mice and trackballs <aidan@kublai.com>
27 
 * - MacAlly 2-buttons mouse (needs testing) <pochini@denise.shiny.it>
28 
 *
29 
 * To do:
30 
 *
31 
 * Improve Kensignton support, add MacX support as a dynamic
32 
 * option (not a compile-time option).
33 
 */
34 
 
35 
#include <linux/sched.h>
36 
#include <linux/interrupt.h>
37 
#include <linux/tty.h>
38 
#include <linux/mm.h>
39 
#include <linux/signal.h>
40 
#include <linux/ioport.h>
41 
#include <linux/init.h>
42 
#include <linux/tty_flip.h>
43 
#include <linux/config.h>
44 
#include <linux/notifier.h>
45 
 
46 
#include <asm/bitops.h>
47 
 
48 
#include <linux/adb.h>
49 
#include <linux/cuda.h>
50 
#include <linux/pmu.h>
51 
#include <linux/kbd_kern.h>
52 
#include <linux/kbd_ll.h>
53 
 
54 
#ifdef CONFIG_PMAC_BACKLIGHT
55 
#include <asm/backlight.h>
56 
#endif
57 
 
58 
#define KEYB_KEYREG     0        /* register # for key up/down data */
59 
#define KEYB_LEDREG     2       /* register # for leds on ADB keyboard */
60 
#define MOUSE_DATAREG   0        /* reg# for movement/button codes from mouse */
61 
 
62 
static int adb_message_handler(struct notifier_block *, unsigned long, void *);
63 
static struct notifier_block mackeyb_adb_notifier = {
64 
        adb_message_handler,
65 
        NULL,
66 
 
67 
};
68 
 
69 
/* this map indicates which keys shouldn't autorepeat. */
70 
static unsigned char dont_repeat[128] = {
71 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
73 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
74 
        0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,   /* esc...option */
75 
        0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, /* fn, num lock */
76 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
77 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, /* scroll lock */
78 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, /* R modifiers */
79 
};
80 
 
81 
/* Simple translation table for the SysRq keys */
82 
 
83 
#ifdef CONFIG_MAGIC_SYSRQ
84 
unsigned char mackbd_sysrq_xlate[128] =
85 
        "asdfhgzxcv\000bqwer"                           /* 0x00 - 0x0f */
86 
        "yt123465=97-80o]"                              /* 0x10 - 0x1f */
87 
        "u[ip\rlj'k;\\,/nm."                            /* 0x20 - 0x2f */
88 
        "\t `\177\000\033\000\000\000\000\000\000\000\000\000\000"
89 
                                                        /* 0x30 - 0x3f */
90 
        "\000\000\000*\000+\000\000\000\000\000/\r\000-\000"
91 
                                                        /* 0x40 - 0x4f */
92 
        "\000\0000123456789\000\000\000"                /* 0x50 - 0x5f */
93 
        "\205\206\207\203\210\211\000\213\000\215\000\000\000\000\000\212\000\214";
94 
                                                        /* 0x60 - 0x6f */
95 
#endif
96 
 
97 
static u_short macplain_map[NR_KEYS] __initdata = {
98 
        0xfb61, 0xfb73, 0xfb64, 0xfb66, 0xfb68, 0xfb67, 0xfb7a, 0xfb78,
99 
        0xfb63, 0xfb76, 0xf200, 0xfb62, 0xfb71, 0xfb77, 0xfb65, 0xfb72,
100 
        0xfb79, 0xfb74, 0xf031, 0xf032, 0xf033, 0xf034, 0xf036, 0xf035,
101 
        0xf03d, 0xf039, 0xf037, 0xf02d, 0xf038, 0xf030, 0xf05d, 0xfb6f,
102 
        0xfb75, 0xf05b, 0xfb69, 0xfb70, 0xf201, 0xfb6c, 0xfb6a, 0xf027,
103 
        0xfb6b, 0xf03b, 0xf05c, 0xf02c, 0xf02f, 0xfb6e, 0xfb6d, 0xf02e,
104 
        0xf009, 0xf020, 0xf060, 0xf07f, 0xf200, 0xf01b, 0xf702, 0xf703,
105 
        0xf700, 0xf207, 0xf701, 0xf601, 0xf602, 0xf600, 0xf603, 0xf200,
106 
        0xf200, 0xf310, 0xf200, 0xf30c, 0xf200, 0xf30a, 0xf200, 0xf208,
107 
        0xf200, 0xf200, 0xf200, 0xf30d, 0xf30e, 0xf200, 0xf30b, 0xf200,
108 
        0xf200, 0xf200, 0xf300, 0xf301, 0xf302, 0xf303, 0xf304, 0xf305,
109 
        0xf306, 0xf307, 0xf200, 0xf308, 0xf309, 0xf200, 0xf200, 0xf200,
110 
        0xf104, 0xf105, 0xf106, 0xf102, 0xf107, 0xf108, 0xf200, 0xf10a,
111 
        0xf200, 0xf10c, 0xf200, 0xf209, 0xf200, 0xf109, 0xf200, 0xf10b,
112 
        0xf200, 0xf11d, 0xf115, 0xf114, 0xf118, 0xf116, 0xf103, 0xf117,
113 
        0xf101, 0xf119, 0xf100, 0xf700, 0xf701, 0xf702, 0xf200, 0xf200,
114 
};
115 
 
116 
static u_short macshift_map[NR_KEYS] __initdata = {
117 
        0xfb41, 0xfb53, 0xfb44, 0xfb46, 0xfb48, 0xfb47, 0xfb5a, 0xfb58,
118 
        0xfb43, 0xfb56, 0xf200, 0xfb42, 0xfb51, 0xfb57, 0xfb45, 0xfb52,
119 
        0xfb59, 0xfb54, 0xf021, 0xf040, 0xf023, 0xf024, 0xf05e, 0xf025,
120 
        0xf02b, 0xf028, 0xf026, 0xf05f, 0xf02a, 0xf029, 0xf07d, 0xfb4f,
121 
        0xfb55, 0xf07b, 0xfb49, 0xfb50, 0xf201, 0xfb4c, 0xfb4a, 0xf022,
122 
        0xfb4b, 0xf03a, 0xf07c, 0xf03c, 0xf03f, 0xfb4e, 0xfb4d, 0xf03e,
123 
        0xf009, 0xf020, 0xf07e, 0xf07f, 0xf200, 0xf01b, 0xf702, 0xf703,
124 
        0xf700, 0xf207, 0xf701, 0xf601, 0xf602, 0xf600, 0xf603, 0xf200,
125 
        0xf200, 0xf310, 0xf200, 0xf30c, 0xf200, 0xf30a, 0xf200, 0xf208,
126 
        0xf200, 0xf200, 0xf200, 0xf30d, 0xf30e, 0xf200, 0xf30b, 0xf200,
127 
        0xf200, 0xf200, 0xf300, 0xf301, 0xf302, 0xf303, 0xf304, 0xf305,
128 
        0xf306, 0xf307, 0xf200, 0xf308, 0xf309, 0xf200, 0xf200, 0xf200,
129 
        0xf10e, 0xf10f, 0xf110, 0xf10c, 0xf111, 0xf112, 0xf200, 0xf10a,
130 
        0xf200, 0xf10c, 0xf200, 0xf203, 0xf200, 0xf113, 0xf200, 0xf10b,
131 
        0xf200, 0xf11d, 0xf115, 0xf114, 0xf20b, 0xf116, 0xf10d, 0xf117,
132 
        0xf10b, 0xf20a, 0xf10a, 0xf700, 0xf701, 0xf702, 0xf200, 0xf200,
133 
};
134 
 
135 
static u_short macaltgr_map[NR_KEYS] __initdata = {
136 
        0xf914, 0xfb73, 0xf917, 0xf919, 0xfb68, 0xfb67, 0xfb7a, 0xfb78,
137 
        0xf916, 0xfb76, 0xf200, 0xf915, 0xfb71, 0xfb77, 0xf918, 0xfb72,
138 
        0xfb79, 0xfb74, 0xf200, 0xf040, 0xf200, 0xf024, 0xf200, 0xf200,
139 
        0xf200, 0xf05d, 0xf07b, 0xf05c, 0xf05b, 0xf07d, 0xf07e, 0xfb6f,
140 
        0xfb75, 0xf200, 0xfb69, 0xfb70, 0xf201, 0xfb6c, 0xfb6a, 0xf200,
141 
        0xfb6b, 0xf200, 0xf200, 0xf200, 0xf200, 0xfb6e, 0xfb6d, 0xf200,
142 
        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf702, 0xf703,
143 
        0xf700, 0xf207, 0xf701, 0xf601, 0xf602, 0xf600, 0xf603, 0xf200,
144 
        0xf200, 0xf310, 0xf200, 0xf30c, 0xf200, 0xf30a, 0xf200, 0xf208,
145 
        0xf200, 0xf200, 0xf200, 0xf30d, 0xf30e, 0xf200, 0xf30b, 0xf200,
146 
        0xf200, 0xf200, 0xf90a, 0xf90b, 0xf90c, 0xf90d, 0xf90e, 0xf90f,
147 
        0xf910, 0xf911, 0xf200, 0xf912, 0xf913, 0xf200, 0xf200, 0xf200,
148 
        0xf510, 0xf511, 0xf512, 0xf50e, 0xf513, 0xf514, 0xf200, 0xf516,
149 
        0xf200, 0xf10c, 0xf200, 0xf202, 0xf200, 0xf515, 0xf200, 0xf517,
150 
        0xf200, 0xf11d, 0xf115, 0xf114, 0xf118, 0xf116, 0xf50f, 0xf117,
151 
        0xf50d, 0xf119, 0xf50c, 0xf700, 0xf701, 0xf702, 0xf200, 0xf200,
152 
};
153 
 
154 
static u_short macctrl_map[NR_KEYS] __initdata = {
155 
        0xf001, 0xf013, 0xf004, 0xf006, 0xf008, 0xf007, 0xf01a, 0xf018,
156 
        0xf003, 0xf016, 0xf200, 0xf002, 0xf011, 0xf017, 0xf005, 0xf012,
157 
        0xf019, 0xf014, 0xf200, 0xf000, 0xf01b, 0xf01c, 0xf01e, 0xf01d,
158 
        0xf200, 0xf200, 0xf01f, 0xf01f, 0xf07f, 0xf200, 0xf01d, 0xf00f,
159 
        0xf015, 0xf01b, 0xf009, 0xf010, 0xf201, 0xf00c, 0xf00a, 0xf007,
160 
        0xf00b, 0xf200, 0xf01c, 0xf200, 0xf07f, 0xf00e, 0xf00d, 0xf20e,
161 
        0xf200, 0xf000, 0xf000, 0xf008, 0xf200, 0xf200, 0xf702, 0xf703,
162 
        0xf700, 0xf207, 0xf701, 0xf601, 0xf602, 0xf600, 0xf603, 0xf200,
163 
        0xf200, 0xf310, 0xf200, 0xf30c, 0xf200, 0xf30a, 0xf200, 0xf208,
164 
        0xf200, 0xf200, 0xf200, 0xf30d, 0xf30e, 0xf200, 0xf30b, 0xf200,
165 
        0xf200, 0xf200, 0xf300, 0xf301, 0xf302, 0xf303, 0xf304, 0xf305,
166 
        0xf306, 0xf307, 0xf200, 0xf308, 0xf309, 0xf200, 0xf200, 0xf200,
167 
        0xf104, 0xf105, 0xf106, 0xf102, 0xf107, 0xf108, 0xf200, 0xf10a,
168 
        0xf200, 0xf10c, 0xf200, 0xf204, 0xf200, 0xf109, 0xf200, 0xf10b,
169 
        0xf200, 0xf11d, 0xf115, 0xf114, 0xf118, 0xf116, 0xf103, 0xf117,
170 
        0xf101, 0xf119, 0xf100, 0xf700, 0xf701, 0xf702, 0xf200, 0xf200,
171 
};
172 
 
173 
static u_short macshift_ctrl_map[NR_KEYS] __initdata = {
174 
        0xf001, 0xf013, 0xf004, 0xf006, 0xf008, 0xf007, 0xf01a, 0xf018,
175 
        0xf003, 0xf016, 0xf200, 0xf002, 0xf011, 0xf017, 0xf005, 0xf012,
176 
        0xf019, 0xf014, 0xf200, 0xf000, 0xf200, 0xf200, 0xf200, 0xf200,
177 
        0xf200, 0xf200, 0xf200, 0xf01f, 0xf200, 0xf200, 0xf200, 0xf00f,
178 
        0xf015, 0xf200, 0xf009, 0xf010, 0xf201, 0xf00c, 0xf00a, 0xf200,
179 
        0xf00b, 0xf200, 0xf200, 0xf200, 0xf200, 0xf00e, 0xf00d, 0xf200,
180 
        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf702, 0xf703,
181 
        0xf700, 0xf207, 0xf701, 0xf601, 0xf602, 0xf600, 0xf603, 0xf200,
182 
        0xf200, 0xf310, 0xf200, 0xf30c, 0xf200, 0xf30a, 0xf200, 0xf208,
183 
        0xf200, 0xf200, 0xf200, 0xf30d, 0xf30e, 0xf200, 0xf30b, 0xf200,
184 
        0xf200, 0xf200, 0xf300, 0xf301, 0xf302, 0xf303, 0xf304, 0xf305,
185 
        0xf306, 0xf307, 0xf200, 0xf308, 0xf309, 0xf200, 0xf200, 0xf200,
186 
        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
187 
        0xf200, 0xf10c, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
188 
        0xf200, 0xf11d, 0xf115, 0xf114, 0xf118, 0xf116, 0xf200, 0xf117,
189 
        0xf200, 0xf119, 0xf200, 0xf700, 0xf701, 0xf702, 0xf200, 0xf20c,
190 
};
191 
 
192 
static u_short macalt_map[NR_KEYS] __initdata = {
193 
        0xf861, 0xf873, 0xf864, 0xf866, 0xf868, 0xf867, 0xf87a, 0xf878,
194 
        0xf863, 0xf876, 0xf200, 0xf862, 0xf871, 0xf877, 0xf865, 0xf872,
195 
        0xf879, 0xf874, 0xf831, 0xf832, 0xf833, 0xf834, 0xf836, 0xf835,
196 
        0xf83d, 0xf839, 0xf837, 0xf82d, 0xf838, 0xf830, 0xf85d, 0xf86f,
197 
        0xf875, 0xf85b, 0xf869, 0xf870, 0xf80d, 0xf86c, 0xf86a, 0xf827,
198 
        0xf86b, 0xf83b, 0xf85c, 0xf82c, 0xf82f, 0xf86e, 0xf86d, 0xf82e,
199 
        0xf809, 0xf820, 0xf860, 0xf87f, 0xf200, 0xf81b, 0xf702, 0xf703,
200 
        0xf700, 0xf207, 0xf701, 0xf210, 0xf211, 0xf600, 0xf603, 0xf200,
201 
        0xf200, 0xf310, 0xf200, 0xf30c, 0xf200, 0xf30a, 0xf200, 0xf208,
202 
        0xf200, 0xf200, 0xf200, 0xf30d, 0xf30e, 0xf200, 0xf30b, 0xf200,
203 
        0xf200, 0xf200, 0xf900, 0xf901, 0xf902, 0xf903, 0xf904, 0xf905,
204 
        0xf906, 0xf907, 0xf200, 0xf908, 0xf909, 0xf200, 0xf200, 0xf200,
205 
        0xf504, 0xf505, 0xf506, 0xf502, 0xf507, 0xf508, 0xf200, 0xf50a,
206 
        0xf200, 0xf10c, 0xf200, 0xf209, 0xf200, 0xf509, 0xf200, 0xf50b,
207 
        0xf200, 0xf11d, 0xf115, 0xf114, 0xf118, 0xf116, 0xf503, 0xf117,
208 
        0xf501, 0xf119, 0xf500, 0xf700, 0xf701, 0xf702, 0xf200, 0xf200,
209 
};
210 
 
211 
static u_short macctrl_alt_map[NR_KEYS] __initdata = {
212 
        0xf801, 0xf813, 0xf804, 0xf806, 0xf808, 0xf807, 0xf81a, 0xf818,
213 
        0xf803, 0xf816, 0xf200, 0xf802, 0xf811, 0xf817, 0xf805, 0xf812,
214 
        0xf819, 0xf814, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
215 
        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf80f,
216 
        0xf815, 0xf200, 0xf809, 0xf810, 0xf201, 0xf80c, 0xf80a, 0xf200,
217 
        0xf80b, 0xf200, 0xf200, 0xf200, 0xf200, 0xf80e, 0xf80d, 0xf200,
218 
        0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf702, 0xf703,
219 
        0xf700, 0xf207, 0xf701, 0xf601, 0xf602, 0xf600, 0xf603, 0xf200,
220 
        0xf200, 0xf310, 0xf200, 0xf30c, 0xf200, 0xf30a, 0xf200, 0xf208,
221 
        0xf200, 0xf200, 0xf200, 0xf30d, 0xf30e, 0xf200, 0xf30b, 0xf200,
222 
        0xf200, 0xf200, 0xf300, 0xf301, 0xf302, 0xf303, 0xf304, 0xf305,
223 
        0xf306, 0xf307, 0xf200, 0xf308, 0xf309, 0xf200, 0xf200, 0xf200,
224 
        0xf504, 0xf505, 0xf506, 0xf502, 0xf507, 0xf508, 0xf200, 0xf50a,
225 
        0xf200, 0xf10c, 0xf200, 0xf200, 0xf200, 0xf509, 0xf200, 0xf50b,
226 
        0xf200, 0xf11d, 0xf115, 0xf114, 0xf118, 0xf116, 0xf503, 0xf117,
227 
        0xf501, 0xf119, 0xf500, 0xf700, 0xf701, 0xf702, 0xf200, 0xf200,
228 
};
229 
 
230 
 
231 
static void kbd_repeat(unsigned long);
232 
static struct timer_list repeat_timer = { function: kbd_repeat };
233 
static int last_keycode;
234 
 
235 
static void mackeyb_probe(void);
236 
 
237 
static void keyboard_input(unsigned char *, int, struct pt_regs *, int);
238 
static void input_keycode(int, int);
239 
static void leds_done(struct adb_request *);
240 
static void mac_put_queue(int);
241 
 
242 
static void buttons_input(unsigned char *, int, struct pt_regs *, int);
243 
 
244 
static void init_trackpad(int id);
245 
static void init_trackball(int id);
246 
static void init_turbomouse(int id);
247 
static void init_microspeed(int id);
248 
static void init_ms_a3(int id);
249 
 
250 
#ifdef CONFIG_ADBMOUSE
251 
/* XXX: Hook for mouse driver */
252 
void (*adb_mouse_interrupt_hook)(unsigned char *, int);
253 
int adb_emulate_buttons = 0;
254 
int adb_button2_keycode = 0x7d; /* right control key */
255 
int adb_button3_keycode = 0x7c; /* right option key */
256 
#endif
257 
 
258 
extern struct kbd_struct kbd_table[];
259 
 
260 
extern void handle_scancode(unsigned char, int);
261 
 
262 
static struct adb_ids keyboard_ids;
263 
static struct adb_ids mouse_ids;
264 
static struct adb_ids buttons_ids;
265 
 
266 
/* Kind of mouse  */
267 
#define ADBMOUSE_STANDARD_100   0        /* Standard 100cpi mouse (handler 1) */
268 
#define ADBMOUSE_STANDARD_200   1       /* Standard 200cpi mouse (handler 2) */
269 
#define ADBMOUSE_EXTENDED       2       /* Apple Extended mouse (handler 4) */
270 
#define ADBMOUSE_TRACKBALL      3       /* TrackBall (handler 4) */
271 
#define ADBMOUSE_TRACKPAD       4       /* Apple's PowerBook trackpad (handler 4) */
272 
#define ADBMOUSE_TURBOMOUSE5    5       /* Turbomouse 5 (previously req. mousehack) */
273 
#define ADBMOUSE_MICROSPEED     6       /* Microspeed mouse (&trackball ?), MacPoint */
274 
#define ADBMOUSE_TRACKBALLPRO   7       /* Trackball Pro (special buttons) */
275 
#define ADBMOUSE_MS_A3          8       /* Mouse systems A3 trackball (handler 3) */
276 
#define ADBMOUSE_MACALLY2       9       /* MacAlly 2-button mouse */
277 
 
278 
static int adb_mouse_kinds[16];
279 
 
280 
int mackbd_setkeycode(unsigned int scancode, unsigned int keycode)
281 
{
282 
        return -EINVAL;
283 
}
284 
 
285 
int mackbd_getkeycode(unsigned int scancode)
286 
{
287 
        return -EINVAL;
288 
}
289 
 
290 
int mackbd_translate(unsigned char keycode, unsigned char *keycodep,
291 
                     char raw_mode)
292 
{
293 
        if (!raw_mode) {
294 
                /*
295 
                 * Convert R-shift/control/option to L version.
296 
                 */
297 
                switch (keycode) {
298 
                case 0x7b: keycode = 0x38; break; /* R-shift */
299 
                case 0x7c: keycode = 0x3a; break; /* R-option */
300 
                case 0x7d: keycode = 0x36; break; /* R-control */
301 
                }
302 
        }
303 
        *keycodep = keycode;
304 
        return 1;
305 
}
306 
 
307 
char mackbd_unexpected_up(unsigned char keycode)
308 
{
309 
        return 0x80;
310 
}
311 
 
312 
static void
313 
keyboard_input(unsigned char *data, int nb, struct pt_regs *regs, int apoll)
314 
{
315 
        /* first check this is from register 0 */
316 
        if (nb != 3 || (data[0] & 3) != KEYB_KEYREG)
317 
                return;         /* ignore it */
318 
        kbd_pt_regs = regs;
319 
        input_keycode(data[1], 0);
320 
        if (!(data[2] == 0xff || (data[2] == 0x7f && data[1] == 0x7f)))
321 
                input_keycode(data[2], 0);
322 
}
323 
 
324 
static void
325 
input_keycode(int keycode, int repeat)
326 
{
327 
        struct kbd_struct *kbd;
328 
        int up_flag;
329 
 
330 
        kbd = kbd_table + fg_console;
331 
        up_flag = (keycode & 0x80);
332 
        keycode &= 0x7f;
333 
 
334 
        /* on the powerbook 3400, the power key gives code 0x7e */
335 
        if (keycode == 0x7e)
336 
                keycode = 0x7f;
337 
        /* remap the "Fn" key of the PowerBook G3 Series to 0x48
338 
           to avoid conflict with button emulation */
339 
        if (keycode == 0x3f)
340 
                keycode = 0x48;
341 
 
342 
        if (!repeat)
343 
                del_timer(&repeat_timer);
344 
 
345 
#ifdef CONFIG_ADBMOUSE
346 
        /*
347 
         * XXX: Add mouse button 2+3 fake codes here if mouse open.
348 
         *      Keep track of 'button' states here as we only send
349 
         *      single up/down events!
350 
         *      Really messy; might need to check if keyboard is in
351 
         *      VC_RAW mode.
352 
         *      Might also want to know how many buttons need to be emulated.
353 
         *      -> hide this as function in arch/m68k/mac ?
354 
         */
355 
        if (adb_emulate_buttons
356 
            && (keycode == adb_button2_keycode
357 
                || keycode == adb_button3_keycode)
358 
            && (adb_mouse_interrupt_hook || console_loglevel == 10)) {
359 
                int button;
360 
                /* faked ADB packet */
361 
                static unsigned char data[4] = { 0, 0x80, 0x80, 0x80 };
362 
 
363 
                button = keycode == adb_button2_keycode? 2: 3;
364 
                if (data[button] != up_flag) {
365 
                        /* send a fake mouse packet */
366 
                        data[button] = up_flag;
367 
                        if (console_loglevel >= 8)
368 
                                printk("fake mouse event: %x %x %x\n",
369 
                                       data[1], data[2], data[3]);
370 
                        if (adb_mouse_interrupt_hook)
371 
                                adb_mouse_interrupt_hook(data, 4);
372 
                }
373 
                return;
374 
        }
375 
#endif /* CONFIG_ADBMOUSE */
376 
 
377 
        if (kbd->kbdmode != VC_RAW) {
378 
                if (!up_flag && !dont_repeat[keycode]) {
379 
                        last_keycode = keycode;
380 
                        repeat_timer.expires = jiffies + (repeat? HZ/15: HZ/2);
381 
                        add_timer(&repeat_timer);
382 
                }
383 
 
384 
                /*
385 
                 * adb kludge!! Imitate pc caps lock behaviour by
386 
                 * generating an up/down event for each time caps
387 
                 * is pressed/released. Also, makes sure that the
388 
                 * LED are handled.  atong@uiuc.edu
389 
                 */
390 
                 switch (keycode) {
391 
                 /*case 0xb9:*/
392 
                 case 0x39:
393 
                        handle_scancode(0x39, 1);
394 
                        handle_scancode(0x39, 0);
395 
                        tasklet_schedule(&keyboard_tasklet);
396 
                        return;
397 
                 case 0x47:
398 
                 /*case 0xc7:*/
399 
                        tasklet_schedule(&keyboard_tasklet);
400 
                        break;
401 
                 }
402 
        }
403 
 
404 
        handle_scancode(keycode, !up_flag);
405 
        tasklet_schedule(&keyboard_tasklet);
406 
}
407 
 
408 
static void
409 
kbd_repeat(unsigned long xxx)
410 
{
411 
        unsigned long flags;
412 
 
413 
        save_flags(flags);
414 
        cli();
415 
        input_keycode(last_keycode, 1);
416 
        restore_flags(flags);
417 
}
418 
 
419 
static void mac_put_queue(int ch)
420 
{
421 
        extern struct tty_driver console_driver;
422 
        struct tty_struct *tty;
423 
 
424 
        tty = console_driver.table? console_driver.table[fg_console]: NULL;
425 
        if (tty) {
426 
                tty_insert_flip_char(tty, ch, 0);
427 
                con_schedule_flip(tty);
428 
        }
429 
}
430 
 
431 
#ifdef CONFIG_ADBMOUSE
432 
static void
433 
mouse_input(unsigned char *data, int nb, struct pt_regs *regs, int autopoll)
434 
{
435 
  /* [ACA:23-Mar-97] Three button mouse support.  This is designed to
436 
     function with MkLinux DR-2.1 style X servers.  It only works with
437 
     three-button mice that conform to Apple's multi-button mouse
438 
     protocol. */
439 
 
440 
  /*
441 
    The X server for MkLinux DR2.1 uses the following unused keycodes to
442 
    read the mouse:
443 
 
444 
    0x7e  This indicates that the next two keycodes should be interpreted
445 
          as mouse information.  The first following byte's high bit
446 
          represents the state of the left button.  The lower seven bits
447 
          represent the x-axis acceleration.  The lower seven bits of the
448 
          second byte represent y-axis acceleration.
449 
 
450 
    0x3f  The x server interprets this keycode as a middle button
451 
          release.
452 
 
453 
    0xbf  The x server interprets this keycode as a middle button
454 
          depress.
455 
 
456 
    0x40  The x server interprets this keycode as a right button
457 
          release.
458 
 
459 
    0xc0  The x server interprets this keycode as a right button
460 
          depress.
461 
 
462 
    NOTES: There should be a better way of handling mice in the X server.
463 
    The MOUSE_ESCAPE code (0x7e) should be followed by three bytes instead
464 
    of two.  The three mouse buttons should then, in the X server, be read
465 
    as the high-bits of all three bytes.  The x and y motions can still be
466 
    in the first two bytes.  Maybe I'll do this...
467 
  */
468 
 
469 
  /*
470 
    Handler 1 -- 100cpi original Apple mouse protocol.
471 
    Handler 2 -- 200cpi original Apple mouse protocol.
472 
 
473 
    For Apple's standard one-button mouse protocol the data array will
474 
    contain the following values:
475 
 
476 
                BITS    COMMENTS
477 
    data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
478 
    data[1] = bxxx xxxx First button and x-axis motion.
479 
    data[2] = byyy yyyy Second button and y-axis motion.
480 
 
481 
    Handler 4 -- Apple Extended mouse protocol.
482 
 
483 
    For Apple's 3-button mouse protocol the data array will contain the
484 
    following values:
485 
 
486 
                BITS    COMMENTS
487 
    data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
488 
    data[1] = bxxx xxxx Left button and x-axis motion.
489 
    data[2] = byyy yyyy Second button and y-axis motion.
490 
    data[3] = byyy bxxx Third button and fourth button.  Y is additional
491 
              high bits of y-axis motion.  XY is additional
492 
              high bits of x-axis motion.
493 
 
494 
    MacAlly 2-button mouse protocol.
495 
 
496 
    For MacAlly 2-button mouse protocol the data array will contain the
497 
    following values:
498 
 
499 
                BITS    COMMENTS
500 
    data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
501 
    data[1] = bxxx xxxx Left button and x-axis motion.
502 
    data[2] = byyy yyyy Right button and y-axis motion.
503 
    data[3] = ???? ???? unknown
504 
    data[4] = ???? ???? unknown
505 
 
506 
  */
507 
        struct kbd_struct *kbd;
508 
 
509 
        /* If it's a trackpad, we alias the second button to the first.
510 
           NOTE: Apple sends an ADB flush command to the trackpad when
511 
                 the first (the real) button is released. We could do
512 
                 this here using async flush requests.
513 
        */
514 
        switch (adb_mouse_kinds[(data[0]>>4) & 0xf])
515 
        {
516 
            case ADBMOUSE_TRACKPAD:
517 
                data[1] = (data[1] & 0x7f) | ((data[1] & data[2]) & 0x80);
518 
                data[2] = data[2] | 0x80;
519 
                break;
520 
            case ADBMOUSE_MICROSPEED:
521 
                data[1] = (data[1] & 0x7f) | ((data[3] & 0x01) << 7);
522 
                data[2] = (data[2] & 0x7f) | ((data[3] & 0x02) << 6);
523 
                data[3] = (data[3] & 0x77) | ((data[3] & 0x04) << 5)
524 
                        | (data[3] & 0x08);
525 
                break;
526 
            case ADBMOUSE_TRACKBALLPRO:
527 
                data[1] = (data[1] & 0x7f) | (((data[3] & 0x04) << 5)
528 
                        & ((data[3] & 0x08) << 4));
529 
                data[2] = (data[2] & 0x7f) | ((data[3] & 0x01) << 7);
530 
                data[3] = (data[3] & 0x77) | ((data[3] & 0x02) << 6);
531 
                break;
532 
            case ADBMOUSE_MS_A3:
533 
                data[1] = (data[1] & 0x7f) | ((data[3] & 0x01) << 7);
534 
                data[2] = (data[2] & 0x7f) | ((data[3] & 0x02) << 6);
535 
                data[3] = ((data[3] & 0x04) << 5);
536 
                break;
537 
            case ADBMOUSE_MACALLY2:
538 
                data[3] = (data[2] & 0x80) ? 0x80 : 0x00;
539 
                data[2] |= 0x80;  /* Right button is mapped as button 3 */
540 
                nb=4;
541 
                break;
542 
        }
543 
 
544 
        if (adb_mouse_interrupt_hook)
545 
                adb_mouse_interrupt_hook(data, nb);
546 
 
547 
        kbd = kbd_table + fg_console;
548 
 
549 
        /* Only send mouse codes when keyboard is in raw mode. */
550 
        if (kbd->kbdmode == VC_RAW) {
551 
                static unsigned char uch_ButtonStateSecond = 0x80;
552 
                unsigned char uchButtonSecond;
553 
 
554 
                /* Send first button, second button and movement. */
555 
                mac_put_queue(0x7e);
556 
                mac_put_queue(data[1]);
557 
                mac_put_queue(data[2]);
558 
 
559 
                /* [ACA: Are there any two-button ADB mice that use handler 1 or 2?] */
560 
 
561 
                /* Store the button state. */
562 
                uchButtonSecond = (data[2] & 0x80);
563 
 
564 
                /* Send second button. */
565 
                if (uchButtonSecond != uch_ButtonStateSecond) {
566 
                        mac_put_queue(0x3f | uchButtonSecond);
567 
                        uch_ButtonStateSecond = uchButtonSecond;
568 
                }
569 
 
570 
                /* Macintosh 3-button mouse (handler 4). */
571 
                if (nb >= 4) {
572 
                        static unsigned char uch_ButtonStateThird = 0x80;
573 
                        unsigned char uchButtonThird;
574 
 
575 
                        /* Store the button state for speed. */
576 
                        uchButtonThird = (data[3] & 0x80);
577 
 
578 
                        /* Send third button. */
579 
                        if (uchButtonThird != uch_ButtonStateThird) {
580 
                                mac_put_queue(0x40 | uchButtonThird);
581 
                                uch_ButtonStateThird = uchButtonThird;
582 
                        }
583 
                }
584 
        }
585 
}
586 
#endif /* CONFIG_ADBMOUSE */
587 
 
588 
static void
589 
buttons_input(unsigned char *data, int nb, struct pt_regs *regs, int autopoll)
590 
{
591 
#ifdef CONFIG_PMAC_BACKLIGHT
592 
        int backlight = get_backlight_level();
593 
 
594 
        /*
595 
         * XXX: Where is the contrast control for the passive?
596 
         *  -- Cort
597 
         */
598 
 
599 
        /* Ignore data from register other than 0 */
600 
        if ((data[0] & 0x3) || (nb < 2))
601 
                return;
602 
 
603 
        switch (data[1]) {
604 
        case 0x8:               /* mute */
605 
                break;
606 
 
607 
        case 0x7:               /* contrast decrease */
608 
                break;
609 
 
610 
        case 0x6:               /* contrast increase */
611 
                break;
612 
 
613 
        case 0xa:               /* brightness decrease */
614 
                if (backlight < 0)
615 
                        break;
616 
                if (backlight > BACKLIGHT_OFF)
617 
                        set_backlight_level(backlight-1);
618 
                else
619 
                        set_backlight_level(BACKLIGHT_OFF);
620 
                break;
621 
 
622 
        case 0x9:               /* brightness increase */
623 
                if (backlight < 0)
624 
                        break;
625 
                if (backlight < BACKLIGHT_MAX)
626 
                        set_backlight_level(backlight+1);
627 
                else
628 
                        set_backlight_level(BACKLIGHT_MAX);
629 
                break;
630 
        }
631 
#endif /* CONFIG_PMAC_BACKLIGHT */
632 
}
633 
 
634 
/* Map led flags as defined in kbd_kern.h to bits for Apple keyboard. */
635 
static unsigned char mac_ledmap[8] = {
636 
    0,           /* none */
637 
    4,          /* scroll lock */
638 
    1,          /* num lock */
639 
    5,          /* scroll + num lock */
640 
    2,          /* caps lock */
641 
    6,          /* caps + scroll lock */
642 
    3,          /* caps + num lock */
643 
    7,          /* caps + num + scroll lock */
644 
};
645 
 
646 
static struct adb_request led_request;
647 
static int leds_pending[16];
648 
static int pending_devs[16];
649 
static int pending_led_start=0;
650 
static int pending_led_end=0;
651 
 
652 
static void real_mackbd_leds(unsigned char leds, int device)
653 
{
654 
    if (led_request.complete) {
655 
        adb_request(&led_request, leds_done, 0, 3,
656 
                    ADB_WRITEREG(device, KEYB_LEDREG), 0xff,
657 
                    ~mac_ledmap[leds]);
658 
    } else {
659 
        if (!(leds_pending[device] & 0x100)) {
660 
            pending_devs[pending_led_end] = device;
661 
            pending_led_end++;
662 
            pending_led_end = (pending_led_end < 16) ? pending_led_end : 0;
663 
        }
664 
        leds_pending[device] = leds | 0x100;
665 
    }
666 
}
667 
 
668 
void mackbd_leds(unsigned char leds)
669 
{
670 
    int i;
671 
 
672 
    for(i = 0; i < keyboard_ids.nids; i++)
673 
        real_mackbd_leds(leds,keyboard_ids.id[i]);
674 
}
675 
 
676 
static void leds_done(struct adb_request *req)
677 
{
678 
    int leds,device;
679 
 
680 
    if (pending_led_start != pending_led_end) {
681 
        device = pending_devs[pending_led_start];
682 
        leds = leds_pending[device] & 0xff;
683 
        leds_pending[device] = 0;
684 
        pending_led_start++;
685 
        pending_led_start = (pending_led_start < 16) ? pending_led_start : 0;
686 
        real_mackbd_leds(leds,device);
687 
    }
688 
 
689 
}
690 
 
691 
void __init mackbd_init_hw(void)
692 
{
693 
#ifdef CONFIG_PPC
694 
        if ( (_machine != _MACH_chrp) && (_machine != _MACH_Pmac) )
695 
                return;
696 
#endif
697 
#ifdef CONFIG_MAC
698 
        if (!MACH_IS_MAC)
699 
                return;
700 
#endif
701 
 
702 
        /* setup key map */
703 
        memcpy(key_maps[0], macplain_map, sizeof(plain_map));
704 
        memcpy(key_maps[1], macshift_map, sizeof(plain_map));
705 
        memcpy(key_maps[2], macaltgr_map, sizeof(plain_map));
706 
        memcpy(key_maps[4], macctrl_map, sizeof(plain_map));
707 
        memcpy(key_maps[5], macshift_ctrl_map, sizeof(plain_map));
708 
        memcpy(key_maps[8], macalt_map, sizeof(plain_map));
709 
        memcpy(key_maps[12], macctrl_alt_map, sizeof(plain_map));
710 
 
711 
#ifdef CONFIG_ADBMOUSE
712 
        /* initialize mouse interrupt hook */
713 
        adb_mouse_interrupt_hook = NULL;
714 
#endif
715 
 
716 
        led_request.complete = 1;
717 
 
718 
        mackeyb_probe();
719 
 
720 
        notifier_chain_register(&adb_client_list, &mackeyb_adb_notifier);
721 
}
722 
 
723 
static int
724 
adb_message_handler(struct notifier_block *this, unsigned long code, void *x)
725 
{
726 
        unsigned long flags;
727 
 
728 
        switch (code) {
729 
        case ADB_MSG_PRE_RESET:
730 
        case ADB_MSG_POWERDOWN:
731 
                /* Stop the repeat timer. Autopoll is already off at this point */
732 
                save_flags(flags);
733 
                cli();
734 
                del_timer(&repeat_timer);
735 
                restore_flags(flags);
736 
 
737 
                /* Stop pending led requests */
738 
                while(!led_request.complete)
739 
                        adb_poll();
740 
                break;
741 
 
742 
        case ADB_MSG_POST_RESET:
743 
                mackeyb_probe();
744 
                break;
745 
        }
746 
        return NOTIFY_DONE;
747 
}
748 
 
749 
static void
750 
mackeyb_probe(void)
751 
{
752 
        struct adb_request req;
753 
        int i;
754 
 
755 
#ifdef CONFIG_ADBMOUSE
756 
        adb_register(ADB_MOUSE, 0, &mouse_ids, mouse_input);
757 
#endif /* CONFIG_ADBMOUSE */
758 
 
759 
        adb_register(ADB_KEYBOARD, 0, &keyboard_ids, keyboard_input);
760 
        adb_register(0x07, 0x1F, &buttons_ids, buttons_input);
761 
 
762 
        for (i = 0; i < keyboard_ids.nids; i++) {
763 
                int id = keyboard_ids.id[i];
764 
 
765 
                /* turn off all leds */
766 
                adb_request(&req, NULL, ADBREQ_SYNC, 3,
767 
                            ADB_WRITEREG(id, KEYB_LEDREG), 0xff, 0xff);
768 
 
769 
                /* Enable full feature set of the keyboard
770 
                   ->get it to send separate codes for left and right shift,
771 
                   control, option keys */
772 
#if 0           /* handler 5 doesn't send separate codes for R modifiers */
773 
                if (adb_try_handler_change(id, 5))
774 
                        printk("ADB keyboard at %d, handler set to 5\n", id);
775 
                else
776 
#endif
777 
                if (adb_try_handler_change(id, 3))
778 
                        printk("ADB keyboard at %d, handler set to 3\n", id);
779 
                else
780 
                        printk("ADB keyboard at %d, handler 1\n", id);
781 
        }
782 
 
783 
        /* Try to switch all mice to handler 4, or 2 for three-button
784 
           mode and full resolution. */
785 
        for (i = 0; i < mouse_ids.nids; i++) {
786 
                int id = mouse_ids.id[i];
787 
                if (adb_try_handler_change(id, 4)) {
788 
                        printk("ADB mouse at %d, handler set to 4", id);
789 
                        adb_mouse_kinds[id] = ADBMOUSE_EXTENDED;
790 
                }
791 
                else if (adb_try_handler_change(id, 0x2F)) {
792 
                        printk("ADB mouse at %d, handler set to 0x2F", id);
793 
                        adb_mouse_kinds[id] = ADBMOUSE_MICROSPEED;
794 
                }
795 
                else if (adb_try_handler_change(id, 0x42)) {
796 
                        printk("ADB mouse at %d, handler set to 0x42", id);
797 
                        adb_mouse_kinds[id] = ADBMOUSE_TRACKBALLPRO;
798 
                }
799 
                else if (adb_try_handler_change(id, 0x66)) {
800 
                        printk("ADB mouse at %d, handler set to 0x66", id);
801 
                        adb_mouse_kinds[id] = ADBMOUSE_MICROSPEED;
802 
                }
803 
                else if (adb_try_handler_change(id, 0x5F)) {
804 
                        printk("ADB mouse at %d, handler set to 0x5F", id);
805 
                        adb_mouse_kinds[id] = ADBMOUSE_MICROSPEED;
806 
                }
807 
                else if (adb_try_handler_change(id, 3)) {
808 
                        printk("ADB mouse at %d, handler set to 3", id);
809 
                        adb_mouse_kinds[id] = ADBMOUSE_MS_A3;
810 
                }
811 
                else if (adb_try_handler_change(id, 2)) {
812 
                        printk("ADB mouse at %d, handler set to 2", id);
813 
                        adb_mouse_kinds[id] = ADBMOUSE_STANDARD_200;
814 
                }
815 
                else {
816 
                        printk("ADB mouse at %d, handler 1", id);
817 
                        adb_mouse_kinds[id] = ADBMOUSE_STANDARD_100;
818 
                }
819 
 
820 
                if ((adb_mouse_kinds[id] == ADBMOUSE_TRACKBALLPRO)
821 
                    || (adb_mouse_kinds[id] == ADBMOUSE_MICROSPEED)) {
822 
                        init_microspeed(id);
823 
                } else if (adb_mouse_kinds[id] == ADBMOUSE_MS_A3) {
824 
                        init_ms_a3(id);
825 
                }  else if (adb_mouse_kinds[id] ==  ADBMOUSE_EXTENDED) {
826 
                        /*
827 
                         * Register 1 is usually used for device
828 
                         * identification.  Here, we try to identify
829 
                         * a known device and call the appropriate
830 
                         * init function.
831 
                         */
832 
                        adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
833 
                                    ADB_READREG(id, 1));
834 
 
835 
                        if ((req.reply_len) &&
836 
                            (req.reply[1] == 0x9a) && ((req.reply[2] == 0x21)
837 
                                || (req.reply[2] == 0x20)))
838 
                                init_trackball(id);
839 
                        else if ((req.reply_len >= 4) &&
840 
                            (req.reply[1] == 0x74) && (req.reply[2] == 0x70) &&
841 
                            (req.reply[3] == 0x61) && (req.reply[4] == 0x64))
842 
                                init_trackpad(id);
843 
                        else if ((req.reply_len >= 4) &&
844 
                            (req.reply[1] == 0x4b) && (req.reply[2] == 0x4d) &&
845 
                            (req.reply[3] == 0x4c) && (req.reply[4] == 0x31))
846 
                                init_turbomouse(id);
847 
                        else if ((req.reply_len == 9) &&
848 
                            (req.reply[1] == 0x4b) && (req.reply[2] == 0x4f) &&
849 
                            (req.reply[3] == 0x49) && (req.reply[4] == 0x54)){
850 
                                if (adb_try_handler_change(id, 0x42)) {
851 
                                        printk("\nADB MacAlly 2-button mouse at %d, handler set to 0x42", id);
852 
                                        adb_mouse_kinds[id] = ADBMOUSE_MACALLY2;
853 
                                }
854 
                        }
855 
                }
856 
                printk("\n");
857 
        }
858 
}
859 
 
860 
static void
861 
init_trackpad(int id)
862 
{
863 
        struct adb_request req;
864 
        unsigned char r1_buffer[8];
865 
 
866 
        printk(" (trackpad)");
867 
 
868 
        adb_mouse_kinds[id] = ADBMOUSE_TRACKPAD;
869 
 
870 
        adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
871 
        ADB_READREG(id,1));
872 
        if (req.reply_len < 8)
873 
            printk("bad length for reg. 1\n");
874 
        else
875 
        {
876 
            memcpy(r1_buffer, &req.reply[1], 8);
877 
            adb_request(&req, NULL, ADBREQ_SYNC, 9,
878 
                ADB_WRITEREG(id,1),
879 
                    r1_buffer[0],
880 
                    r1_buffer[1],
881 
                    r1_buffer[2],
882 
                    r1_buffer[3],
883 
                    r1_buffer[4],
884 
                    r1_buffer[5],
885 
                    0x0d, /*r1_buffer[6],*/
886 
                    r1_buffer[7]);
887 
 
888 
            adb_request(&req, NULL, ADBREQ_SYNC, 9,
889 
                ADB_WRITEREG(id,2),
890 
                    0x99,
891 
                    0x94,
892 
                    0x19,
893 
                    0xff,
894 
                    0xb2,
895 
                    0x8a,
896 
                    0x1b,
897 
                    0x50);
898 
 
899 
            adb_request(&req, NULL, ADBREQ_SYNC, 9,
900 
                ADB_WRITEREG(id,1),
901 
                    r1_buffer[0],
902 
                    r1_buffer[1],
903 
                    r1_buffer[2],
904 
                    r1_buffer[3],
905 
                    r1_buffer[4],
906 
                    r1_buffer[5],
907 
                    0x03, /*r1_buffer[6],*/
908 
                    r1_buffer[7]);
909 
 
910 
            /* Without this flush, the trackpad may be locked up */
911 
            adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
912 
        }
913 
}
914 
 
915 
static void
916 
init_trackball(int id)
917 
{
918 
        struct adb_request req;
919 
 
920 
        printk(" (trackman/mouseman)");
921 
 
922 
        adb_mouse_kinds[id] = ADBMOUSE_TRACKBALL;
923 
 
924 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
925 
        ADB_WRITEREG(id,1), 00,0x81);
926 
 
927 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
928 
        ADB_WRITEREG(id,1), 01,0x81);
929 
 
930 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
931 
        ADB_WRITEREG(id,1), 02,0x81);
932 
 
933 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
934 
        ADB_WRITEREG(id,1), 03,0x38);
935 
 
936 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
937 
        ADB_WRITEREG(id,1), 00,0x81);
938 
 
939 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
940 
        ADB_WRITEREG(id,1), 01,0x81);
941 
 
942 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
943 
        ADB_WRITEREG(id,1), 02,0x81);
944 
 
945 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
946 
        ADB_WRITEREG(id,1), 03,0x38);
947 
}
948 
 
949 
static void
950 
init_turbomouse(int id)
951 
{
952 
        struct adb_request req;
953 
 
954 
        printk(" (TurboMouse 5)");
955 
 
956 
        adb_mouse_kinds[id] = ADBMOUSE_TURBOMOUSE5;
957 
 
958 
        adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
959 
 
960 
        adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
961 
 
962 
        adb_request(&req, NULL, ADBREQ_SYNC, 9,
963 
        ADB_WRITEREG(3,2),
964 
            0xe7,
965 
            0x8c,
966 
            0,
967 
            0,
968 
            0,
969 
            0xff,
970 
            0xff,
971 
            0x94);
972 
 
973 
        adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
974 
 
975 
        adb_request(&req, NULL, ADBREQ_SYNC, 9,
976 
        ADB_WRITEREG(3,2),
977 
            0xa5,
978 
            0x14,
979 
            0,
980 
            0,
981 
            0x69,
982 
            0xff,
983 
            0xff,
984 
            0x27);
985 
}
986 
 
987 
static void
988 
init_microspeed(int id)
989 
{
990 
        struct adb_request req;
991 
 
992 
        printk(" (Microspeed/MacPoint or compatible)");
993 
 
994 
        adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
995 
 
996 
        /* This will initialize mice using the Microspeed, MacPoint and
997 
           other compatible firmware. Bit 12 enables extended protocol.
998 
 
999 
           Register 1 Listen (4 Bytes)
1000 
 
1001 
            4 -  7     Button is locking (affects change speed also)
1002 
            8 - 11     Button changes speed
1003 
           12          1 = Extended mouse mode, 0 = normal mouse mode
1004 
           13 - 15     unused 0
1005 
           16 - 23     normal speed
1006 
           24 - 31     changed speed
1007 
 
1008 
       Register 1 talk holds version and product identification information.
1009 
       Register 1 Talk (4 Bytes):
1010 
 
1011 
            8 - 23     undefined, reserved
1012 
           24 - 31     Version number
1013 
 
1014 
       Speed 0 is max. 1 to 255 set speed in increments of 1/256 of max.
1015 
 */
1016 
        adb_request(&req, NULL, ADBREQ_SYNC, 5,
1017 
        ADB_WRITEREG(id,1),
1018 
            0x20,       /* alt speed = 0x20 (rather slow) */
1019 
            0x00,       /* norm speed = 0x00 (fastest) */
1020 
            0x10,       /* extended protocol, no speed change */
1021 
            0x07);      /* all buttons enabled as mouse buttons, no locking */
1022 
 
1023 
 
1024 
        adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1025 
}
1026 
 
1027 
static void
1028 
init_ms_a3(int id)
1029 
{
1030 
        struct adb_request req;
1031 
 
1032 
        printk(" (Mouse Systems A3 Mouse, or compatible)");
1033 
        adb_request(&req, NULL, ADBREQ_SYNC, 3,
1034 
        ADB_WRITEREG(id, 0x2),
1035 
            0x00,
1036 
            0x07);
1037 
 
1038 
        adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
1039 
 }
1040 
 

powered by: WebSVN 2.1.0

© copyright 1999-2026 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.