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