[PATCH] remove many unneeded #includes of sched.h
[linux-2.6.git] / drivers / tc / lk201.c
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  */
10
11
12 #include <linux/errno.h>
13 #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  */
50 unsigned char lk201_sysrq_xlate[128];
51 unsigned char *kbd_sysrq_xlate = lk201_sysrq_xlate;
52
53 unsigned char kbd_sysrq_key = -1;
54 #endif
55
56 #define KEYB_LINE       3
57
58 static int __init lk201_init(void *);
59 static void __init lk201_info(void *);
60 static void lk201_rx_char(unsigned char, unsigned char);
61
62 static 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  */
74 static 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
94 static void *lk201_handle;
95
96 static 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
105 static inline int lk201_get_id(void)
106 {
107         return lk201_send(LK_CMD_REQ_ID);
108 }
109
110 static 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
122 static 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
148 static 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
178 static struct kbd_repeat kbdrate = {
179         DEFAULT_KEYB_REP_DELAY,
180         DEFAULT_KEYB_REP_RATE
181 };
182
183 static 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
202 static 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
223 static 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
240 static 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
262 void 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
285 int kbd_setkeycode(unsigned int scancode, unsigned int keycode)
286 {
287         return -EINVAL;
288 }
289
290 int kbd_getkeycode(unsigned int scancode)
291 {
292         return -EINVAL;
293 }
294
295 int kbd_translate(unsigned char scancode, unsigned char *keycode,
296                   char raw_mode)
297 {
298         *keycode = scancode;
299         return 1;
300 }
301
302 char kbd_unexpected_up(unsigned char keycode)
303 {
304         return 0x80;
305 }
306
307 static 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
397 static void __init lk201_info(void *handle)
398 {
399 }
400
401 static 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
416 void __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 }