ia64/linux-2.6.18-xen.hg

view drivers/tc/lk201.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
1 /*
2 *
3 * This file is subject to the terms and conditions of the GNU General Public
4 * License. See the file "COPYING" in the main directory of this archive
5 * for more details.
6 *
7 * Copyright (C) 1999-2002 Harald Koerfgen <hkoerfg@web.de>
8 * Copyright (C) 2001, 2002, 2003, 2004 Maciej W. Rozycki
9 */
12 #include <linux/errno.h>
13 #include <linux/sched.h>
14 #include <linux/tty.h>
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/delay.h>
18 #include <linux/kbd_ll.h>
19 #include <linux/kbd_kern.h>
20 #include <linux/vt_kern.h>
22 #include <asm/keyboard.h>
23 #include <asm/dec/tc.h>
24 #include <asm/dec/machtype.h>
25 #include <asm/dec/serial.h>
27 #include "lk201.h"
29 /*
30 * Only handle DECstations that have an LK201 interface.
31 * Maxine uses LK501 at the Access.Bus and various DECsystems
32 * have no keyboard interface at all.
33 */
34 #define LK_IFACE (mips_machtype == MACH_DS23100 || \
35 mips_machtype == MACH_DS5000_200 || \
36 mips_machtype == MACH_DS5000_1XX || \
37 mips_machtype == MACH_DS5000_2X0)
38 /*
39 * These use the Z8530 SCC. Others use the DZ11.
40 */
41 #define LK_IFACE_ZS (mips_machtype == MACH_DS5000_1XX || \
42 mips_machtype == MACH_DS5000_2X0)
44 /* Simple translation table for the SysRq keys */
46 #ifdef CONFIG_MAGIC_SYSRQ
47 /*
48 * Actually no translation at all, at least until we figure out
49 * how to define SysRq for LK201 and friends. --macro
50 */
51 unsigned char lk201_sysrq_xlate[128];
52 unsigned char *kbd_sysrq_xlate = lk201_sysrq_xlate;
54 unsigned char kbd_sysrq_key = -1;
55 #endif
57 #define KEYB_LINE 3
59 static int __init lk201_init(void *);
60 static void __init lk201_info(void *);
61 static void lk201_rx_char(unsigned char, unsigned char);
63 static struct dec_serial_hook lk201_hook = {
64 .init_channel = lk201_init,
65 .init_info = lk201_info,
66 .rx_char = NULL,
67 .poll_rx_char = NULL,
68 .poll_tx_char = NULL,
69 .cflags = B4800 | CS8 | CSTOPB | CLOCAL,
70 };
72 /*
73 * This is used during keyboard initialisation
74 */
75 static unsigned char lk201_reset_string[] = {
76 LK_CMD_SET_DEFAULTS,
77 LK_CMD_MODE(LK_MODE_RPT_DOWN, 1),
78 LK_CMD_MODE(LK_MODE_RPT_DOWN, 2),
79 LK_CMD_MODE(LK_MODE_RPT_DOWN, 3),
80 LK_CMD_MODE(LK_MODE_RPT_DOWN, 4),
81 LK_CMD_MODE(LK_MODE_DOWN_UP, 5),
82 LK_CMD_MODE(LK_MODE_DOWN_UP, 6),
83 LK_CMD_MODE(LK_MODE_RPT_DOWN, 7),
84 LK_CMD_MODE(LK_MODE_RPT_DOWN, 8),
85 LK_CMD_MODE(LK_MODE_RPT_DOWN, 9),
86 LK_CMD_MODE(LK_MODE_RPT_DOWN, 10),
87 LK_CMD_MODE(LK_MODE_RPT_DOWN, 11),
88 LK_CMD_MODE(LK_MODE_RPT_DOWN, 12),
89 LK_CMD_MODE(LK_MODE_DOWN, 13),
90 LK_CMD_MODE(LK_MODE_RPT_DOWN, 14),
91 LK_CMD_DIS_KEYCLK,
92 LK_CMD_ENB_BELL, LK_PARAM_VOLUME(4),
93 };
95 static void *lk201_handle;
97 static int lk201_send(unsigned char ch)
98 {
99 if (lk201_hook.poll_tx_char(lk201_handle, ch)) {
100 printk(KERN_ERR "lk201: transmit timeout\n");
101 return -EIO;
102 }
103 return 0;
104 }
106 static inline int lk201_get_id(void)
107 {
108 return lk201_send(LK_CMD_REQ_ID);
109 }
111 static int lk201_reset(void)
112 {
113 int i, r;
115 for (i = 0; i < sizeof(lk201_reset_string); i++) {
116 r = lk201_send(lk201_reset_string[i]);
117 if (r < 0)
118 return r;
119 }
120 return 0;
121 }
123 static void lk201_report(unsigned char id[6])
124 {
125 char *report = "lk201: keyboard attached, ";
127 switch (id[2]) {
128 case LK_STAT_PWRUP_OK:
129 printk(KERN_INFO "%sself-test OK\n", report);
130 break;
131 case LK_STAT_PWRUP_KDOWN:
132 /* The keyboard will resend the power-up ID
133 after all keys are released, so we don't
134 bother handling the error specially. Still
135 there may be a short-circuit inside.
136 */
137 printk(KERN_ERR "%skey down (stuck?), code: 0x%02x\n",
138 report, id[3]);
139 break;
140 case LK_STAT_PWRUP_ERROR:
141 printk(KERN_ERR "%sself-test failure\n", report);
142 break;
143 default:
144 printk(KERN_ERR "%sunknown error: 0x%02x\n",
145 report, id[2]);
146 }
147 }
149 static void lk201_id(unsigned char id[6])
150 {
151 /*
152 * Report whether there is an LK201 or an LK401
153 * The LK401 has ALT keys...
154 */
155 switch (id[4]) {
156 case 1:
157 printk(KERN_INFO "lk201: LK201 detected\n");
158 break;
159 case 2:
160 printk(KERN_INFO "lk201: LK401 detected\n");
161 break;
162 case 3:
163 printk(KERN_INFO "lk201: LK443 detected\n");
164 break;
165 case 4:
166 printk(KERN_INFO "lk201: LK421 detected\n");
167 break;
168 default:
169 printk(KERN_WARNING
170 "lk201: unknown keyboard detected, ID %d\n", id[4]);
171 printk(KERN_WARNING "lk201: ... please report to "
172 "<linux-mips@linux-mips.org>\n");
173 }
174 }
176 #define DEFAULT_KEYB_REP_DELAY (250/5) /* [5ms] */
177 #define DEFAULT_KEYB_REP_RATE 30 /* [cps] */
179 static struct kbd_repeat kbdrate = {
180 DEFAULT_KEYB_REP_DELAY,
181 DEFAULT_KEYB_REP_RATE
182 };
184 static void parse_kbd_rate(struct kbd_repeat *r)
185 {
186 if (r->delay <= 0)
187 r->delay = kbdrate.delay;
188 if (r->rate <= 0)
189 r->rate = kbdrate.rate;
191 if (r->delay < 5)
192 r->delay = 5;
193 if (r->delay > 630)
194 r->delay = 630;
195 if (r->rate < 12)
196 r->rate = 12;
197 if (r->rate > 127)
198 r->rate = 127;
199 if (r->rate == 125)
200 r->rate = 124;
201 }
203 static int write_kbd_rate(struct kbd_repeat *rep)
204 {
205 int delay, rate;
206 int i;
208 delay = rep->delay / 5;
209 rate = rep->rate;
210 for (i = 0; i < 4; i++) {
211 if (lk201_hook.poll_tx_char(lk201_handle,
212 LK_CMD_RPT_RATE(i)))
213 return 1;
214 if (lk201_hook.poll_tx_char(lk201_handle,
215 LK_PARAM_DELAY(delay)))
216 return 1;
217 if (lk201_hook.poll_tx_char(lk201_handle,
218 LK_PARAM_RATE(rate)))
219 return 1;
220 }
221 return 0;
222 }
224 static int lk201_kbd_rate(struct kbd_repeat *rep)
225 {
226 if (rep == NULL)
227 return -EINVAL;
229 parse_kbd_rate(rep);
231 if (write_kbd_rate(rep)) {
232 memcpy(rep, &kbdrate, sizeof(struct kbd_repeat));
233 return -EIO;
234 }
236 memcpy(&kbdrate, rep, sizeof(struct kbd_repeat));
238 return 0;
239 }
241 static void lk201_kd_mksound(unsigned int hz, unsigned int ticks)
242 {
243 if (!ticks)
244 return;
246 /*
247 * Can't set frequency and we "approximate"
248 * duration by volume. ;-)
249 */
250 ticks /= HZ / 32;
251 if (ticks > 7)
252 ticks = 7;
253 ticks = 7 - ticks;
255 if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_ENB_BELL))
256 return;
257 if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_VOLUME(ticks)))
258 return;
259 if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_BELL))
260 return;
261 }
263 void kbd_leds(unsigned char leds)
264 {
265 unsigned char l = 0;
267 if (!lk201_handle) /* FIXME */
268 return;
270 /* FIXME -- Only Hold and Lock LEDs for now. --macro */
271 if (leds & LED_SCR)
272 l |= LK_LED_HOLD;
273 if (leds & LED_CAP)
274 l |= LK_LED_LOCK;
276 if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_LEDS_ON))
277 return;
278 if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_LED_MASK(l)))
279 return;
280 if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_LEDS_OFF))
281 return;
282 if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_LED_MASK(~l)))
283 return;
284 }
286 int kbd_setkeycode(unsigned int scancode, unsigned int keycode)
287 {
288 return -EINVAL;
289 }
291 int kbd_getkeycode(unsigned int scancode)
292 {
293 return -EINVAL;
294 }
296 int kbd_translate(unsigned char scancode, unsigned char *keycode,
297 char raw_mode)
298 {
299 *keycode = scancode;
300 return 1;
301 }
303 char kbd_unexpected_up(unsigned char keycode)
304 {
305 return 0x80;
306 }
308 static void lk201_rx_char(unsigned char ch, unsigned char fl)
309 {
310 static unsigned char id[6];
311 static int id_i;
313 static int shift_state = 0;
314 static int prev_scancode;
315 unsigned char c = scancodeRemap[ch];
317 if (fl != TTY_NORMAL && fl != TTY_OVERRUN) {
318 printk(KERN_ERR "lk201: keyboard receive error: 0x%02x\n", fl);
319 return;
320 }
322 /* Assume this is a power-up ID. */
323 if (ch == LK_STAT_PWRUP_ID && !id_i) {
324 id[id_i++] = ch;
325 return;
326 }
328 /* Handle the power-up sequence. */
329 if (id_i) {
330 id[id_i++] = ch;
331 if (id_i == 4) {
332 /* OK, the power-up concluded. */
333 lk201_report(id);
334 if (id[2] == LK_STAT_PWRUP_OK)
335 lk201_get_id();
336 else {
337 id_i = 0;
338 printk(KERN_ERR "lk201: keyboard power-up "
339 "error, skipping initialization\n");
340 }
341 } else if (id_i == 6) {
342 /* We got the ID; report it and start operation. */
343 id_i = 0;
344 lk201_id(id);
345 lk201_reset();
346 }
347 return;
348 }
350 /* Everything else is a scancode/status response. */
351 id_i = 0;
352 switch (ch) {
353 case LK_STAT_RESUME_ERR:
354 case LK_STAT_ERROR:
355 case LK_STAT_INHIBIT_ACK:
356 case LK_STAT_TEST_ACK:
357 case LK_STAT_MODE_KEYDOWN:
358 case LK_STAT_MODE_ACK:
359 break;
360 case LK_KEY_LOCK:
361 shift_state ^= LK_LOCK;
362 handle_scancode(c, (shift_state & LK_LOCK) ? 1 : 0);
363 break;
364 case LK_KEY_SHIFT:
365 shift_state ^= LK_SHIFT;
366 handle_scancode(c, (shift_state & LK_SHIFT) ? 1 : 0);
367 break;
368 case LK_KEY_CTRL:
369 shift_state ^= LK_CTRL;
370 handle_scancode(c, (shift_state & LK_CTRL) ? 1 : 0);
371 break;
372 case LK_KEY_COMP:
373 shift_state ^= LK_COMP;
374 handle_scancode(c, (shift_state & LK_COMP) ? 1 : 0);
375 break;
376 case LK_KEY_RELEASE:
377 if (shift_state & LK_SHIFT)
378 handle_scancode(scancodeRemap[LK_KEY_SHIFT], 0);
379 if (shift_state & LK_CTRL)
380 handle_scancode(scancodeRemap[LK_KEY_CTRL], 0);
381 if (shift_state & LK_COMP)
382 handle_scancode(scancodeRemap[LK_KEY_COMP], 0);
383 if (shift_state & LK_LOCK)
384 handle_scancode(scancodeRemap[LK_KEY_LOCK], 0);
385 shift_state = 0;
386 break;
387 case LK_KEY_REPEAT:
388 handle_scancode(prev_scancode, 1);
389 break;
390 default:
391 prev_scancode = c;
392 handle_scancode(c, 1);
393 break;
394 }
395 tasklet_schedule(&keyboard_tasklet);
396 }
398 static void __init lk201_info(void *handle)
399 {
400 }
402 static int __init lk201_init(void *handle)
403 {
404 /* First install handlers. */
405 lk201_handle = handle;
406 kbd_rate = lk201_kbd_rate;
407 kd_mksound = lk201_kd_mksound;
409 lk201_hook.rx_char = lk201_rx_char;
411 /* Then just issue a reset -- the handlers will do the rest. */
412 lk201_send(LK_CMD_POWER_UP);
414 return 0;
415 }
417 void __init kbd_init_hw(void)
418 {
419 /* Maxine uses LK501 at the Access.Bus. */
420 if (!LK_IFACE)
421 return;
423 printk(KERN_INFO "lk201: DECstation LK keyboard driver v0.05.\n");
425 if (LK_IFACE_ZS) {
426 /*
427 * kbd_init_hw() is being called before
428 * rs_init() so just register the kbd hook
429 * and let zs_init do the rest :-)
430 */
431 if (!register_dec_serial_hook(KEYB_LINE, &lk201_hook))
432 unregister_dec_serial_hook(KEYB_LINE);
433 } else {
434 /*
435 * TODO: modify dz.c to allow similar hooks
436 * for LK201 handling on DS2100, DS3100, and DS5000/200
437 */
438 printk(KERN_ERR "lk201: support for DZ11 not yet ready.\n");
439 }
440 }