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