m68k: missing exports
[linux-2.6.git] / arch / m68k / atari / atakeyb.c
1 /*
2  * linux/atari/atakeyb.c
3  *
4  * Atari Keyboard driver for 680x0 Linux
5  *
6  * This file is subject to the terms and conditions of the GNU General Public
7  * License.  See the file COPYING in the main directory of this archive
8  * for more details.
9  */
10
11 /*
12  * Atari support by Robert de Vries
13  * enhanced by Bjoern Brauel and Roman Hodek
14  */
15
16 #include <linux/module.h>
17 #include <linux/sched.h>
18 #include <linux/kernel.h>
19 #include <linux/interrupt.h>
20 #include <linux/errno.h>
21 #include <linux/keyboard.h>
22 #include <linux/delay.h>
23 #include <linux/timer.h>
24 #include <linux/kd.h>
25 #include <linux/random.h>
26 #include <linux/init.h>
27 #include <linux/kbd_kern.h>
28
29 #include <asm/atariints.h>
30 #include <asm/atarihw.h>
31 #include <asm/atarikb.h>
32 #include <asm/atari_joystick.h>
33 #include <asm/irq.h>
34
35 static void atakeyb_rep(unsigned long ignore);
36 extern unsigned int keymap_count;
37
38 /* Hook for MIDI serial driver */
39 void (*atari_MIDI_interrupt_hook) (void);
40 /* Hook for mouse driver */
41 void (*atari_mouse_interrupt_hook) (char *);
42 /* Hook for keyboard inputdev  driver */
43 void (*atari_input_keyboard_interrupt_hook) (unsigned char, char);
44 /* Hook for mouse inputdev  driver */
45 void (*atari_input_mouse_interrupt_hook) (char *);
46 EXPORT_SYMBOL(atari_mouse_interrupt_hook);
47 EXPORT_SYMBOL(atari_input_keyboard_interrupt_hook);
48 EXPORT_SYMBOL(atari_input_mouse_interrupt_hook);
49
50 /* variables for IKBD self test: */
51
52 /* state: 0: off; >0: in progress; >1: 0xf1 received */
53 static volatile int ikbd_self_test;
54 /* timestamp when last received a char */
55 static volatile unsigned long self_test_last_rcv;
56 /* bitmap of keys reported as broken */
57 static unsigned long broken_keys[128/(sizeof(unsigned long)*8)] = { 0, };
58
59 #define BREAK_MASK      (0x80)
60
61 /*
62  * ++roman: The following changes were applied manually:
63  *
64  *  - The Alt (= Meta) key works in combination with Shift and
65  *    Control, e.g. Alt+Shift+a sends Meta-A (0xc1), Alt+Control+A sends
66  *    Meta-Ctrl-A (0x81) ...
67  *
68  *  - The parentheses on the keypad send '(' and ')' with all
69  *    modifiers (as would do e.g. keypad '+'), but they cannot be used as
70  *    application keys (i.e. sending Esc O c).
71  *
72  *  - HELP and UNDO are mapped to be F21 and F24, resp, that send the
73  *    codes "\E[M" and "\E[P". (This is better than the old mapping to
74  *    F11 and F12, because these codes are on Shift+F1/2 anyway.) This
75  *    way, applications that allow their own keyboard mappings
76  *    (e.g. tcsh, X Windows) can be configured to use them in the way
77  *    the label suggests (providing help or undoing).
78  *
79  *  - Console switching is done with Alt+Fx (consoles 1..10) and
80  *    Shift+Alt+Fx (consoles 11..20).
81  *
82  *  - The misc. special function implemented in the kernel are mapped
83  *    to the following key combinations:
84  *
85  *      ClrHome          -> Home/Find
86  *      Shift + ClrHome  -> End/Select
87  *      Shift + Up       -> Page Up
88  *      Shift + Down     -> Page Down
89  *      Alt + Help       -> show system status
90  *      Shift + Help     -> show memory info
91  *      Ctrl + Help      -> show registers
92  *      Ctrl + Alt + Del -> Reboot
93  *      Alt + Undo       -> switch to last console
94  *      Shift + Undo     -> send interrupt
95  *      Alt + Insert     -> stop/start output (same as ^S/^Q)
96  *      Alt + Up         -> Scroll back console (if implemented)
97  *      Alt + Down       -> Scroll forward console (if implemented)
98  *      Alt + CapsLock   -> NumLock
99  *
100  * ++Andreas:
101  *
102  *  - Help mapped to K_HELP
103  *  - Undo mapped to K_UNDO (= K_F246)
104  *  - Keypad Left/Right Parenthesis mapped to new K_PPAREN[LR]
105  */
106
107 static u_short ataplain_map[NR_KEYS] __initdata = {
108         0xf200, 0xf01b, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036,
109         0xf037, 0xf038, 0xf039, 0xf030, 0xf02d, 0xf03d, 0xf008, 0xf009,
110         0xfb71, 0xfb77, 0xfb65, 0xfb72, 0xfb74, 0xfb79, 0xfb75, 0xfb69,
111         0xfb6f, 0xfb70, 0xf05b, 0xf05d, 0xf201, 0xf702, 0xfb61, 0xfb73,
112         0xfb64, 0xfb66, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c, 0xf03b,
113         0xf027, 0xf060, 0xf700, 0xf05c, 0xfb7a, 0xfb78, 0xfb63, 0xfb76,
114         0xfb62, 0xfb6e, 0xfb6d, 0xf02c, 0xf02e, 0xf02f, 0xf700, 0xf200,
115         0xf703, 0xf020, 0xf207, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104,
116         0xf105, 0xf106, 0xf107, 0xf108, 0xf109, 0xf200, 0xf200, 0xf114,
117         0xf603, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
118         0xf600, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf200, 0xf200,
119         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
120         0xf200, 0xf1ff, 0xf11b, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf307,
121         0xf308, 0xf309, 0xf304, 0xf305, 0xf306, 0xf301, 0xf302, 0xf303,
122         0xf300, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
123         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
124 };
125
126 typedef enum kb_state_t {
127         KEYBOARD, AMOUSE, RMOUSE, JOYSTICK, CLOCK, RESYNC
128 } KB_STATE_T;
129
130 #define IS_SYNC_CODE(sc)        ((sc) >= 0x04 && (sc) <= 0xfb)
131
132 typedef struct keyboard_state {
133         unsigned char buf[6];
134         int len;
135         KB_STATE_T state;
136 } KEYBOARD_STATE;
137
138 KEYBOARD_STATE kb_state;
139
140 #define DEFAULT_KEYB_REP_DELAY  (HZ/4)
141 #define DEFAULT_KEYB_REP_RATE   (HZ/25)
142
143 /* These could be settable by some ioctl() in future... */
144 static unsigned int key_repeat_delay = DEFAULT_KEYB_REP_DELAY;
145 static unsigned int key_repeat_rate = DEFAULT_KEYB_REP_RATE;
146
147 static unsigned char rep_scancode;
148 static struct timer_list atakeyb_rep_timer = {
149         .function = atakeyb_rep,
150 };
151
152 static void atakeyb_rep(unsigned long ignore)
153 {
154         /* Disable keyboard for the time we call handle_scancode(), else a race
155          * in the keyboard tty queue may happen */
156         atari_disable_irq(IRQ_MFP_ACIA);
157         del_timer(&atakeyb_rep_timer);
158
159         /* A keyboard int may have come in before we disabled the irq, so
160          * double-check whether rep_scancode is still != 0 */
161         if (rep_scancode) {
162                 init_timer(&atakeyb_rep_timer);
163                 atakeyb_rep_timer.expires = jiffies + key_repeat_rate;
164                 add_timer(&atakeyb_rep_timer);
165
166                 //handle_scancode(rep_scancode, 1);
167                 if (atari_input_keyboard_interrupt_hook)
168                         atari_input_keyboard_interrupt_hook(rep_scancode, 1);
169         }
170
171         atari_enable_irq(IRQ_MFP_ACIA);
172 }
173
174
175 /* ++roman: If a keyboard overrun happened, we can't tell in general how much
176  * bytes have been lost and in which state of the packet structure we are now.
177  * This usually causes keyboards bytes to be interpreted as mouse movements
178  * and vice versa, which is very annoying. It seems better to throw away some
179  * bytes (that are usually mouse bytes) than to misinterpret them. Therefor I
180  * introduced the RESYNC state for IKBD data. In this state, the bytes up to
181  * one that really looks like a key event (0x04..0xf2) or the start of a mouse
182  * packet (0xf8..0xfb) are thrown away, but at most 2 bytes. This at least
183  * speeds up the resynchronization of the event structure, even if maybe a
184  * mouse movement is lost. However, nothing is perfect. For bytes 0x01..0x03,
185  * it's really hard to decide whether they're mouse or keyboard bytes. Since
186  * overruns usually occur when moving the Atari mouse rapidly, they're seen as
187  * mouse bytes here. If this is wrong, only a make code of the keyboard gets
188  * lost, which isn't too bad. Loosing a break code would be disastrous,
189  * because then the keyboard repeat strikes...
190  */
191
192 static irqreturn_t atari_keyboard_interrupt(int irq, void *dummy)
193 {
194         u_char acia_stat;
195         int scancode;
196         int break_flag;
197
198 repeat:
199         if (acia.mid_ctrl & ACIA_IRQ)
200                 if (atari_MIDI_interrupt_hook)
201                         atari_MIDI_interrupt_hook();
202         acia_stat = acia.key_ctrl;
203         /* check out if the interrupt came from this ACIA */
204         if (!((acia_stat | acia.mid_ctrl) & ACIA_IRQ))
205                 return IRQ_HANDLED;
206
207         if (acia_stat & ACIA_OVRN) {
208                 /* a very fast typist or a slow system, give a warning */
209                 /* ...happens often if interrupts were disabled for too long */
210                 printk(KERN_DEBUG "Keyboard overrun\n");
211                 scancode = acia.key_data;
212                 /* Turn off autorepeating in case a break code has been lost */
213                 del_timer(&atakeyb_rep_timer);
214                 rep_scancode = 0;
215                 if (ikbd_self_test)
216                         /* During self test, don't do resyncing, just process the code */
217                         goto interpret_scancode;
218                 else if (IS_SYNC_CODE(scancode)) {
219                         /* This code seem already to be the start of a new packet or a
220                          * single scancode */
221                         kb_state.state = KEYBOARD;
222                         goto interpret_scancode;
223                 } else {
224                         /* Go to RESYNC state and skip this byte */
225                         kb_state.state = RESYNC;
226                         kb_state.len = 1;       /* skip max. 1 another byte */
227                         goto repeat;
228                 }
229         }
230
231         if (acia_stat & ACIA_RDRF) {
232                 /* received a character */
233                 scancode = acia.key_data;       /* get it or reset the ACIA, I'll get it! */
234                 tasklet_schedule(&keyboard_tasklet);
235         interpret_scancode:
236                 switch (kb_state.state) {
237                 case KEYBOARD:
238                         switch (scancode) {
239                         case 0xF7:
240                                 kb_state.state = AMOUSE;
241                                 kb_state.len = 0;
242                                 break;
243
244                         case 0xF8:
245                         case 0xF9:
246                         case 0xFA:
247                         case 0xFB:
248                                 kb_state.state = RMOUSE;
249                                 kb_state.len = 1;
250                                 kb_state.buf[0] = scancode;
251                                 break;
252
253                         case 0xFC:
254                                 kb_state.state = CLOCK;
255                                 kb_state.len = 0;
256                                 break;
257
258                         case 0xFE:
259                         case 0xFF:
260                                 kb_state.state = JOYSTICK;
261                                 kb_state.len = 1;
262                                 kb_state.buf[0] = scancode;
263                                 break;
264
265                         case 0xF1:
266                                 /* during self-test, note that 0xf1 received */
267                                 if (ikbd_self_test) {
268                                         ++ikbd_self_test;
269                                         self_test_last_rcv = jiffies;
270                                         break;
271                                 }
272                                 /* FALL THROUGH */
273
274                         default:
275                                 break_flag = scancode & BREAK_MASK;
276                                 scancode &= ~BREAK_MASK;
277                                 if (ikbd_self_test) {
278                                         /* Scancodes sent during the self-test stand for broken
279                                          * keys (keys being down). The code *should* be a break
280                                          * code, but nevertheless some AT keyboard interfaces send
281                                          * make codes instead. Therefore, simply ignore
282                                          * break_flag...
283                                          */
284                                         int keyval = plain_map[scancode], keytyp;
285
286                                         set_bit(scancode, broken_keys);
287                                         self_test_last_rcv = jiffies;
288                                         keyval = plain_map[scancode];
289                                         keytyp = KTYP(keyval) - 0xf0;
290                                         keyval = KVAL(keyval);
291
292                                         printk(KERN_WARNING "Key with scancode %d ", scancode);
293                                         if (keytyp == KT_LATIN || keytyp == KT_LETTER) {
294                                                 if (keyval < ' ')
295                                                         printk("('^%c') ", keyval + '@');
296                                                 else
297                                                         printk("('%c') ", keyval);
298                                         }
299                                         printk("is broken -- will be ignored.\n");
300                                         break;
301                                 } else if (test_bit(scancode, broken_keys))
302                                         break;
303
304 #if 0   // FIXME; hangs at boot
305                                 if (break_flag) {
306                                         del_timer(&atakeyb_rep_timer);
307                                         rep_scancode = 0;
308                                 } else {
309                                         del_timer(&atakeyb_rep_timer);
310                                         rep_scancode = scancode;
311                                         atakeyb_rep_timer.expires = jiffies + key_repeat_delay;
312                                         add_timer(&atakeyb_rep_timer);
313                                 }
314 #endif
315
316                                 // handle_scancode(scancode, !break_flag);
317                                 if (atari_input_keyboard_interrupt_hook)
318                                         atari_input_keyboard_interrupt_hook((unsigned char)scancode, !break_flag);
319                                 break;
320                         }
321                         break;
322
323                 case AMOUSE:
324                         kb_state.buf[kb_state.len++] = scancode;
325                         if (kb_state.len == 5) {
326                                 kb_state.state = KEYBOARD;
327                                 /* not yet used */
328                                 /* wake up someone waiting for this */
329                         }
330                         break;
331
332                 case RMOUSE:
333                         kb_state.buf[kb_state.len++] = scancode;
334                         if (kb_state.len == 3) {
335                                 kb_state.state = KEYBOARD;
336                                 if (atari_mouse_interrupt_hook)
337                                         atari_mouse_interrupt_hook(kb_state.buf);
338                         }
339                         break;
340
341                 case JOYSTICK:
342                         kb_state.buf[1] = scancode;
343                         kb_state.state = KEYBOARD;
344 #ifdef FIXED_ATARI_JOYSTICK
345                         atari_joystick_interrupt(kb_state.buf);
346 #endif
347                         break;
348
349                 case CLOCK:
350                         kb_state.buf[kb_state.len++] = scancode;
351                         if (kb_state.len == 6) {
352                                 kb_state.state = KEYBOARD;
353                                 /* wake up someone waiting for this.
354                                    But will this ever be used, as Linux keeps its own time.
355                                    Perhaps for synchronization purposes? */
356                                 /* wake_up_interruptible(&clock_wait); */
357                         }
358                         break;
359
360                 case RESYNC:
361                         if (kb_state.len <= 0 || IS_SYNC_CODE(scancode)) {
362                                 kb_state.state = KEYBOARD;
363                                 goto interpret_scancode;
364                         }
365                         kb_state.len--;
366                         break;
367                 }
368         }
369
370 #if 0
371         if (acia_stat & ACIA_CTS)
372                 /* cannot happen */;
373 #endif
374
375         if (acia_stat & (ACIA_FE | ACIA_PE)) {
376                 printk("Error in keyboard communication\n");
377         }
378
379         /* handle_scancode() can take a lot of time, so check again if
380          * some character arrived
381          */
382         goto repeat;
383 }
384
385 /*
386  * I write to the keyboard without using interrupts, I poll instead.
387  * This takes for the maximum length string allowed (7) at 7812.5 baud
388  * 8 data 1 start 1 stop bit: 9.0 ms
389  * If this takes too long for normal operation, interrupt driven writing
390  * is the solution. (I made a feeble attempt in that direction but I
391  * kept it simple for now.)
392  */
393 void ikbd_write(const char *str, int len)
394 {
395         u_char acia_stat;
396
397         if ((len < 1) || (len > 7))
398                 panic("ikbd: maximum string length exceeded");
399         while (len) {
400                 acia_stat = acia.key_ctrl;
401                 if (acia_stat & ACIA_TDRE) {
402                         acia.key_data = *str++;
403                         len--;
404                 }
405         }
406 }
407
408 /* Reset (without touching the clock) */
409 void ikbd_reset(void)
410 {
411         static const char cmd[2] = { 0x80, 0x01 };
412
413         ikbd_write(cmd, 2);
414
415         /*
416          * if all's well code 0xF1 is returned, else the break codes of
417          * all keys making contact
418          */
419 }
420
421 /* Set mouse button action */
422 void ikbd_mouse_button_action(int mode)
423 {
424         char cmd[2] = { 0x07, mode };
425
426         ikbd_write(cmd, 2);
427 }
428
429 /* Set relative mouse position reporting */
430 void ikbd_mouse_rel_pos(void)
431 {
432         static const char cmd[1] = { 0x08 };
433
434         ikbd_write(cmd, 1);
435 }
436 EXPORT_SYMBOL(ikbd_mouse_rel_pos);
437
438 /* Set absolute mouse position reporting */
439 void ikbd_mouse_abs_pos(int xmax, int ymax)
440 {
441         char cmd[5] = { 0x09, xmax>>8, xmax&0xFF, ymax>>8, ymax&0xFF };
442
443         ikbd_write(cmd, 5);
444 }
445
446 /* Set mouse keycode mode */
447 void ikbd_mouse_kbd_mode(int dx, int dy)
448 {
449         char cmd[3] = { 0x0A, dx, dy };
450
451         ikbd_write(cmd, 3);
452 }
453
454 /* Set mouse threshold */
455 void ikbd_mouse_thresh(int x, int y)
456 {
457         char cmd[3] = { 0x0B, x, y };
458
459         ikbd_write(cmd, 3);
460 }
461 EXPORT_SYMBOL(ikbd_mouse_thresh);
462
463 /* Set mouse scale */
464 void ikbd_mouse_scale(int x, int y)
465 {
466         char cmd[3] = { 0x0C, x, y };
467
468         ikbd_write(cmd, 3);
469 }
470
471 /* Interrogate mouse position */
472 void ikbd_mouse_pos_get(int *x, int *y)
473 {
474         static const char cmd[1] = { 0x0D };
475
476         ikbd_write(cmd, 1);
477
478         /* wait for returning bytes */
479 }
480
481 /* Load mouse position */
482 void ikbd_mouse_pos_set(int x, int y)
483 {
484         char cmd[6] = { 0x0E, 0x00, x>>8, x&0xFF, y>>8, y&0xFF };
485
486         ikbd_write(cmd, 6);
487 }
488
489 /* Set Y=0 at bottom */
490 void ikbd_mouse_y0_bot(void)
491 {
492         static const char cmd[1] = { 0x0F };
493
494         ikbd_write(cmd, 1);
495 }
496
497 /* Set Y=0 at top */
498 void ikbd_mouse_y0_top(void)
499 {
500         static const char cmd[1] = { 0x10 };
501
502         ikbd_write(cmd, 1);
503 }
504 EXPORT_SYMBOL(ikbd_mouse_y0_top);
505
506 /* Resume */
507 void ikbd_resume(void)
508 {
509         static const char cmd[1] = { 0x11 };
510
511         ikbd_write(cmd, 1);
512 }
513
514 /* Disable mouse */
515 void ikbd_mouse_disable(void)
516 {
517         static const char cmd[1] = { 0x12 };
518
519         ikbd_write(cmd, 1);
520 }
521 EXPORT_SYMBOL(ikbd_mouse_disable);
522
523 /* Pause output */
524 void ikbd_pause(void)
525 {
526         static const char cmd[1] = { 0x13 };
527
528         ikbd_write(cmd, 1);
529 }
530
531 /* Set joystick event reporting */
532 void ikbd_joystick_event_on(void)
533 {
534         static const char cmd[1] = { 0x14 };
535
536         ikbd_write(cmd, 1);
537 }
538
539 /* Set joystick interrogation mode */
540 void ikbd_joystick_event_off(void)
541 {
542         static const char cmd[1] = { 0x15 };
543
544         ikbd_write(cmd, 1);
545 }
546
547 /* Joystick interrogation */
548 void ikbd_joystick_get_state(void)
549 {
550         static const char cmd[1] = { 0x16 };
551
552         ikbd_write(cmd, 1);
553 }
554
555 #if 0
556 /* This disables all other ikbd activities !!!! */
557 /* Set joystick monitoring */
558 void ikbd_joystick_monitor(int rate)
559 {
560         static const char cmd[2] = { 0x17, rate };
561
562         ikbd_write(cmd, 2);
563
564         kb_state.state = JOYSTICK_MONITOR;
565 }
566 #endif
567
568 /* some joystick routines not in yet (0x18-0x19) */
569
570 /* Disable joysticks */
571 void ikbd_joystick_disable(void)
572 {
573         static const char cmd[1] = { 0x1A };
574
575         ikbd_write(cmd, 1);
576 }
577
578 /* Time-of-day clock set */
579 void ikbd_clock_set(int year, int month, int day, int hour, int minute, int second)
580 {
581         char cmd[7] = { 0x1B, year, month, day, hour, minute, second };
582
583         ikbd_write(cmd, 7);
584 }
585
586 /* Interrogate time-of-day clock */
587 void ikbd_clock_get(int *year, int *month, int *day, int *hour, int *minute, int second)
588 {
589         static const char cmd[1] = { 0x1C };
590
591         ikbd_write(cmd, 1);
592 }
593
594 /* Memory load */
595 void ikbd_mem_write(int address, int size, char *data)
596 {
597         panic("Attempt to write data into keyboard memory");
598 }
599
600 /* Memory read */
601 void ikbd_mem_read(int address, char data[6])
602 {
603         char cmd[3] = { 0x21, address>>8, address&0xFF };
604
605         ikbd_write(cmd, 3);
606
607         /* receive data and put it in data */
608 }
609
610 /* Controller execute */
611 void ikbd_exec(int address)
612 {
613         char cmd[3] = { 0x22, address>>8, address&0xFF };
614
615         ikbd_write(cmd, 3);
616 }
617
618 /* Status inquiries (0x87-0x9A) not yet implemented */
619
620 /* Set the state of the caps lock led. */
621 void atari_kbd_leds(unsigned int leds)
622 {
623         char cmd[6] = {32, 0, 4, 1, 254 + ((leds & 4) != 0), 0};
624
625         ikbd_write(cmd, 6);
626 }
627
628 /*
629  * The original code sometimes left the interrupt line of
630  * the ACIAs low forever. I hope, it is fixed now.
631  *
632  * Martin Rogge, 20 Aug 1995
633  */
634
635 static int atari_keyb_done = 0;
636
637 int __init atari_keyb_init(void)
638 {
639         if (atari_keyb_done)
640                 return 0;
641
642         /* setup key map */
643         memcpy(key_maps[0], ataplain_map, sizeof(plain_map));
644
645         kb_state.state = KEYBOARD;
646         kb_state.len = 0;
647
648         request_irq(IRQ_MFP_ACIA, atari_keyboard_interrupt, IRQ_TYPE_SLOW,
649                     "keyboard/mouse/MIDI", atari_keyboard_interrupt);
650
651         atari_turnoff_irq(IRQ_MFP_ACIA);
652         do {
653                 /* reset IKBD ACIA */
654                 acia.key_ctrl = ACIA_RESET |
655                                 (atari_switches & ATARI_SWITCH_IKBD) ? ACIA_RHTID : 0;
656                 (void)acia.key_ctrl;
657                 (void)acia.key_data;
658
659                 /* reset MIDI ACIA */
660                 acia.mid_ctrl = ACIA_RESET |
661                                 (atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0;
662                 (void)acia.mid_ctrl;
663                 (void)acia.mid_data;
664
665                 /* divide 500kHz by 64 gives 7812.5 baud */
666                 /* 8 data no parity 1 start 1 stop bit */
667                 /* receive interrupt enabled */
668                 /* RTS low (except if switch selected), transmit interrupt disabled */
669                 acia.key_ctrl = (ACIA_DIV64|ACIA_D8N1S|ACIA_RIE) |
670                                 ((atari_switches & ATARI_SWITCH_IKBD) ?
671                                  ACIA_RHTID : ACIA_RLTID);
672
673                 acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S |
674                                 (atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0;
675
676         /* make sure the interrupt line is up */
677         } while ((mfp.par_dt_reg & 0x10) == 0);
678
679         /* enable ACIA Interrupts */
680         mfp.active_edge &= ~0x10;
681         atari_turnon_irq(IRQ_MFP_ACIA);
682
683         ikbd_self_test = 1;
684         ikbd_reset();
685         /* wait for a period of inactivity (here: 0.25s), then assume the IKBD's
686          * self-test is finished */
687         self_test_last_rcv = jiffies;
688         while (time_before(jiffies, self_test_last_rcv + HZ/4))
689                 barrier();
690         /* if not incremented: no 0xf1 received */
691         if (ikbd_self_test == 1)
692                 printk(KERN_ERR "WARNING: keyboard self test failed!\n");
693         ikbd_self_test = 0;
694
695         ikbd_mouse_disable();
696         ikbd_joystick_disable();
697
698 #ifdef FIXED_ATARI_JOYSTICK
699         atari_joystick_init();
700 #endif
701
702         // flag init done
703         atari_keyb_done = 1;
704         return 0;
705 }
706
707 int atari_kbdrate(struct kbd_repeat *k)
708 {
709         if (k->delay > 0) {
710                 /* convert from msec to jiffies */
711                 key_repeat_delay = (k->delay * HZ + 500) / 1000;
712                 if (key_repeat_delay < 1)
713                         key_repeat_delay = 1;
714         }
715         if (k->period > 0) {
716                 key_repeat_rate = (k->period * HZ + 500) / 1000;
717                 if (key_repeat_rate < 1)
718                         key_repeat_rate = 1;
719         }
720
721         k->delay  = key_repeat_delay * 1000 / HZ;
722         k->period = key_repeat_rate  * 1000 / HZ;
723
724         return 0;
725 }
726
727 int atari_kbd_translate(unsigned char keycode, unsigned char *keycodep, char raw_mode)
728 {
729 #ifdef CONFIG_MAGIC_SYSRQ
730         /* ALT+HELP pressed? */
731         if ((keycode == 98) && ((shift_state & 0xff) == 8))
732                 *keycodep = 0xff;
733         else
734 #endif
735                 *keycodep = keycode;
736         return 1;
737 }