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 }