drivers/acorn/char/keyb_arc.c

   1 /*
   2  *  linux/drivers/acorn/char/keyb_arc.c
   3  *
   4  *  Copyright (C) 2000 Russell King
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  *  Acorn keyboard driver for ARM Linux.
  11  *
  12  *  The Acorn keyboard appears to have a ***very*** buggy reset protocol -
  13  *  every reset behaves differently.  We try to get round this by attempting
  14  *  a few things...
  15  */
  16 #include <linux/config.h>
  17 #include <linux/sched.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/tty.h>
  20 #include <linux/tty_flip.h>
  21 #include <linux/mm.h>
  22 #include <linux/slab.h>
  23 #include <linux/ptrace.h>
  24 #include <linux/signal.h>
  25 #include <linux/timer.h>
  26 #include <linux/random.h>
  27 #include <linux/ctype.h>
  28 #include <linux/init.h>
  29 #include <linux/kbd_ll.h>
  30 #include <linux/kbd_kern.h>
  31 #include <linux/delay.h>
  32
  33 #include <asm/bitops.h>
  34 #include <asm/keyboard.h>
  35 #include <asm/irq.h>
  36 #include <asm/hardware.h>
  37 #include <asm/hardware/ioc.h>
  38
  39 #include "../../char/busmouse.h"
  40
  41 extern struct tasklet_struct keyboard_tasklet;
  42 extern void kbd_reset_kdown(void);
  43
  44 #define VERSION 108
  45
  46 #define KBD_REPORT_ERR
  47 #define KBD_REPORT_UNKN
  48
  49 #include <asm/io.h>
  50 #include <asm/system.h>
  51
  52 static char kbd_txval[4];
  53 static unsigned char kbd_txhead, kbd_txtail;
  54 #define KBD_INCTXPTR(ptr) ((ptr) = ((ptr) + 1) & 3)
  55 static int kbd_id = -1;
  56 static DECLARE_WAIT_QUEUE_HEAD(kbd_waitq);
  57 #ifdef CONFIG_KBDMOUSE
  58 static int mousedev;
  59 #endif
  60
  61 /*
  62  * Protocol codes to send the keyboard.
  63  */
  64 #define HRST 0xff       /* reset keyboard */
  65 #define RAK1 0xfe       /* reset response */
  66 #define RAK2 0xfd       /* reset response */
  67 #define BACK 0x3f       /* Ack for first keyboard pair */
  68 #define SMAK 0x33       /* Last data byte ack (key scanning + mouse movement scanning) */
  69 #define MACK 0x32       /* Last data byte ack (mouse movement scanning) */
  70 #define SACK 0x31       /* Last data byte ack (key scanning) */
  71 #define NACK 0x30       /* Last data byte ack (no scanning, mouse data) */
  72 #define RQMP 0x22       /* Request mouse data */
  73 #define PRST 0x21       /* nothing */
  74 #define RQID 0x20       /* Request ID */
  75
  76 #define UP_FLAG 1
  77
  78 #ifdef CONFIG_MAGIC_SYSRQ
  79 unsigned char a5kkbd_sysrq_xlate[] =
  80 {
  81     27,    0,    0,    0,    0,    0,    0,    0,
  82      0,    0,    0,    0,    0,    0,    0,    0,
  83    '`',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
  84    '8',  '9',  '0',  '-',  '=',  '£',  127,    0,
  85      0,    0,    0,  '/',  '*',  '#',    9,  'q',
  86    'w',  'e',  'r',  't',  'y',  'u',  'i',  'o',
  87    'p',  '[',  ']', '\\',  22,    23,   25,  '7',
  88    '8',  '9',  '-',    0,  'a',  's',  'd',  'f',
  89    'g',  'h',  'j',  'k',  'l',  ';', '\'',   13,
  90    '4',  '5',  '6',  '+',    0,    0,  'z',  'x',
  91    'c',  'v',  'b',  'n',  'm',  ',',  '.',  '/',
  92      0,    0,  '1',  '2',  '3',    0,    0,  ' ',
  93      0,    0,    0,    0,    0,  '0',  '.',   10,
  94      0,    0,    0,    0,    0,    0,    0,    0,
  95      0,    0,    0,    0,    0,    0,    0,    0,
  96      0,    0,    0,    0,    0,    0,    0,    0,
  97 };
  98 #endif
  99
 100 /*
 101  * This array converts the scancode that we get from the keyboard to the
 102  * real rows/columns on the A5000 keyboard.  This might be keyboard specific...
 103  *
 104  * It is these values that we use to maintain the key down array.  That way, we
 105  * should pick up on the ghost key presses (which is what happens when you press
 106  * three keys, and the keyboard thinks you have pressed four!)
 107  *
 108  * Row 8 (0x80+c) is actually a column with one key per row.  It is isolated from
 109  * the other keys, and can't cause these problems (its used for shift, ctrl, alt etc).
 110  *
 111  * Illegal scancodes are denoted by an 0xff (in other words, we don't know about
 112  * them, and can't process them for ghosts).  This does however, cause problems with
 113  * autorepeat processing...
 114  */
 115 static unsigned char scancode_2_colrow[256] = {
 116   0x01, 0x42, 0x32, 0x33, 0x43, 0x56, 0x5a, 0x6c, 0x7c, 0x5c, 0x5b, 0x6b, 0x7b, 0x84, 0x70, 0x60,
 117   0x11, 0x51, 0x62, 0x63, 0x44, 0x54, 0x55, 0x45, 0x46, 0x4a, 0x3c, 0x4b, 0x59, 0x49, 0x69, 0x79,
 118   0x83, 0x40, 0x30, 0x3b, 0x39, 0x38, 0x31, 0x61, 0x72, 0x73, 0x64, 0x74, 0x75, 0x65, 0x66, 0x6a,
 119   0x1c, 0x2c, 0x7a, 0x36, 0x48, 0x68, 0x78, 0x20, 0x2b, 0x29, 0x28, 0x81, 0x71, 0x22, 0x23, 0x34,
 120   0x24, 0x25, 0x35, 0x26, 0x3a, 0x0c, 0x2a, 0x76, 0x10, 0x1b, 0x19, 0x18, 0x82, 0xff, 0x21, 0x12,
 121   0x13, 0x14, 0x04, 0x05, 0x15, 0x16, 0x1a, 0x0a, 0x85, 0x77, 0x00, 0x0b, 0x09, 0x02, 0x80, 0x03,
 122   0x87, 0x86, 0x06, 0x17, 0x27, 0x07, 0x37, 0x08, 0xff,
 123 };
 124
 125 #define BITS_PER_SHORT (8*sizeof(unsigned short))
 126 static unsigned short ghost_down[128/BITS_PER_SHORT];
 127
 128 static void a5kkbd_key(unsigned int keycode, unsigned int up_flag)
 129 {
 130         unsigned int real_keycode;
 131
 132         if (keycode > 0x72) {
 133 #ifdef KBD_REPORT_UNKN
 134                 printk ("kbd: unknown scancode 0x%04x\n", keycode);
 135 #endif
 136                 return;
 137         }
 138         if (keycode >= 0x70) {
 139 #ifdef CONFIG_KBDMOUSE
 140                 if (mousedev >= 0)
 141                         switch (keycode) {
 142                         case 0x70: /* Left mouse button */
 143                                 busmouse_add_buttons(mousedev, 4, up_flag ? 4 : 0);
 144                                 break;
 145
 146                         case 0x71: /* Middle mouse button */
 147                                 busmouse_add_buttons(mousedev, 2, up_flag ? 2 : 0);
 148                                 break;
 149
 150                         case 0x72:/* Right mouse button */
 151                                 busmouse_add_buttons(mousedev, 1, up_flag ? 1 : 0);
 152                                 break;
 153                         }
 154 #endif
 155                 return;
 156         }
 157
 158         /*
 159          * We have to work out if we accept this key press as a real key, or
 160          * if it is a ghost.  IE. If you press three keys, the keyboard will think
 161          * that you've pressed a fourth: (@ = key down, # = ghost)
 162          *
 163          *   0 1 2 3 4 5 6 7
 164          *   | | | | | | | |
 165          * 0-+-+-+-+-+-+-+-+-
 166          *   | | | | | | | |
 167          * 1-+-@-+-+-+-@-+-+-
 168          *   | | | | | | | |
 169          * 2-+-+-+-+-+-+-+-+-
 170          *   | | | | | | | |
 171          * 3-+-@-+-+-+-#-+-+-
 172          *   | | | | | | | |
 173          *
 174          * This is what happens when you have a matrix keyboard...
 175          */
 176
 177         real_keycode = scancode_2_colrow[keycode];
 178
 179         if ((real_keycode & 0x80) == 0) {
 180                 int rr, kc = (real_keycode >> 4) & 7;
 181                 int cc;
 182                 unsigned short res, kdownkc;
 183
 184                 kdownkc = ghost_down[kc] | (1 << (real_keycode & 15));
 185
 186                 for (rr = 0; rr < 128/BITS_PER_SHORT; rr++)
 187                         if (rr != kc && (res = ghost_down[rr] & kdownkc)) {
 188                                 /*
 189                                  * we have found a second row with at least one key pressed in the
 190                                  * same column.
 191                                  */
 192                                 for (cc = 0; res; res >>= 1)
 193                                         cc += (res & 1);
 194                                 if (cc > 1)
 195                                         return; /* ignore it */
 196                         }
 197                 if (up_flag)
 198                         clear_bit (real_keycode, ghost_down);
 199                 else
 200                         set_bit (real_keycode, ghost_down);
 201         }
 202
 203         handle_scancode(keycode, !up_flag);
 204 }
 205
 206 static inline void a5kkbd_sendbyte(unsigned char val)
 207 {
 208         kbd_txval[kbd_txhead] = val;
 209         KBD_INCTXPTR(kbd_txhead);
 210         enable_irq(IRQ_KEYBOARDTX);
 211 }
 212
 213 static inline void a5kkbd_reset(void)
 214 {
 215         int i;
 216
 217         for (i = 0; i < NR_SCANCODES/BITS_PER_SHORT; i++)
 218                 ghost_down[i] = 0;
 219
 220         kbd_reset_kdown();
 221 }
 222
 223 void a5kkbd_leds(unsigned char leds)
 224 {
 225         leds =  ((leds & (1<<VC_SCROLLOCK))?4:0) | ((leds & (1<<VC_NUMLOCK))?2:0) |
 226                 ((leds & (1<<VC_CAPSLOCK))?1:0);
 227         a5kkbd_sendbyte(leds);
 228 }
 229
 230 /* Keyboard states:
 231  *  0 initial reset condition, receive HRST, send RRAK1
 232  *  1 Sent RAK1, wait for RAK1, send RRAK2
 233  *  2 Sent RAK2, wait for RAK2, send SMAK or RQID
 234  *  3 Sent RQID, expect KBID, send SMAK
 235  *  4 Sent SMAK, wait for anything
 236  *  5 Wait for second keyboard nibble for key pressed
 237  *  6 Wait for second keyboard nibble for key released
 238  *  7 Wait for second part of mouse data
 239  *
 240  * This function returns 1 when we successfully enter the IDLE state
 241  * (and hence need to do some keyboard processing).
 242  */
 243 #define KBD_INITRST     0
 244 #define KBD_RAK1        1
 245 #define KBD_RAK2        2
 246 #define KBD_ID          3
 247 #define KBD_IDLE        4
 248 #define KBD_KEYDOWN     5
 249 #define KBD_KEYUP       6
 250 #define KBD_MOUSE       7
 251
 252 static int handle_rawcode(unsigned int keyval)
 253 {
 254         static signed char kbd_mousedx = 0;
 255                signed char kbd_mousedy;
 256         static unsigned char kbd_state = KBD_INITRST;
 257         static unsigned char kbd_keyhigh = 0;
 258
 259         if (keyval == HRST && kbd_state != KBD_INITRST && kbd_state != KBD_ID) {
 260                 a5kkbd_sendbyte (HRST);
 261                 a5kkbd_reset ();
 262                 kbd_state = KBD_INITRST;
 263         } else switch(kbd_state) {
 264         case KBD_INITRST:                       /* hard reset - sent HRST */
 265                 if (keyval == HRST) {
 266                         a5kkbd_sendbyte (RAK1);
 267                         kbd_state = KBD_RAK1;
 268                 } else if (keyval == RAK1) {
 269                         /* Some A5000 keyboards are very fussy and don't follow Acorn's
 270                          * specs - this appears to fix them, but them it might stop
 271                          * them from being initialised.
 272                          *  fix by Philip Blundell
 273                          */
 274                         printk(KERN_DEBUG "keyboard sent early RAK1 -- ignored\n");
 275                 } else
 276                         goto kbd_wontreset;
 277                 break;
 278
 279         case KBD_RAK1:                          /* sent RAK1 - expect RAK1 and send RAK2 */
 280                 if (keyval == RAK1) {
 281                         a5kkbd_sendbyte (RAK2);
 282                         kbd_state = KBD_RAK2;
 283                 } else
 284                         goto kbd_wontreset;
 285                 break;
 286
 287         case KBD_RAK2:                          /* Sent RAK2 - expect RAK2 and send either RQID or SMAK */
 288                 if (keyval == RAK2) {
 289                         if (kbd_id == -1) {
 290                                 a5kkbd_sendbyte (NACK);
 291                                 a5kkbd_sendbyte (RQID);
 292                                 kbd_state = KBD_ID;
 293                         } else {
 294                                 a5kkbd_sendbyte (SMAK);
 295                                 kbd_state = KBD_IDLE;
 296                         }
 297                 } else
 298                         goto kbd_wontreset;
 299                 break;
 300
 301         case KBD_ID:                            /* Sent RQID - expect KBID */
 302                 if (keyval == HRST) {
 303                         kbd_id = -2;
 304                         a5kkbd_reset ();
 305                         a5kkbd_sendbyte (HRST);
 306                         kbd_state = KBD_INITRST;
 307                         wake_up (&kbd_waitq);
 308                 } else if ((keyval & 0xc0) == 0x80) {
 309                         kbd_id = keyval & 0x3f;
 310                         a5kkbd_sendbyte (SMAK);
 311                         kbd_state = KBD_IDLE;
 312                         wake_up (&kbd_waitq);
 313                 }
 314                 break;
 315
 316         case KBD_IDLE:                          /* Send SMAK, ready for any reply */
 317                 switch (keyval & 0xf0) {
 318                 default:        /* 0x00 - 0x7f */
 319                         kbd_mousedx = keyval & 0x40 ? keyval|0x80 : keyval;
 320                         kbd_state   = KBD_MOUSE;
 321                         a5kkbd_sendbyte (BACK);
 322                         break;
 323
 324                 case 0x80:
 325                 case 0x90:
 326                 case 0xa0:
 327                 case 0xb0:
 328                         if (kbd_id == -1)
 329                                 kbd_id = keyval & 0x3f;
 330                         break;
 331
 332                 case 0xc0:
 333                         kbd_keyhigh = keyval;
 334                         kbd_state   = KBD_KEYDOWN;
 335                         a5kkbd_sendbyte (BACK);
 336                         break;
 337
 338                 case 0xd0:
 339                         kbd_keyhigh = keyval;
 340                         kbd_state   = KBD_KEYUP;
 341                         a5kkbd_sendbyte (BACK);
 342                         break;
 343
 344                 case 0xe0:
 345                 case 0xf0:
 346                         goto kbd_error;
 347                 }
 348                 break;
 349
 350         case KBD_KEYDOWN:
 351                 if ((keyval & 0xf0) != 0xc0)
 352                         goto kbd_error;
 353                 else {
 354                         kbd_state = KBD_IDLE;
 355                         a5kkbd_sendbyte (SMAK);
 356                         if (((kbd_keyhigh ^ keyval) & 0xf0) == 0)
 357                                 a5kkbd_key ((keyval & 0x0f) | ((kbd_keyhigh << 4) & 0xf0), 0);
 358                 }
 359                 break;
 360
 361         case KBD_KEYUP:
 362                 if ((keyval & 0xf0) != 0xd0)
 363                         goto kbd_error;
 364                 else {
 365                         kbd_state = KBD_IDLE;
 366                         a5kkbd_sendbyte (SMAK);
 367                         if (((kbd_keyhigh ^ keyval) & 0xf0) == 0)
 368                                 a5kkbd_key ((keyval & 0x0f) | ((kbd_keyhigh << 4) & 0xf0), UP_FLAG);
 369                 }
 370                 break;
 371
 372         case KBD_MOUSE:
 373                 if (keyval & 0x80)
 374                         goto kbd_error;
 375                 else {
 376                         kbd_state = KBD_IDLE;
 377                         a5kkbd_sendbyte (SMAK);
 378                         kbd_mousedy = (char)(keyval & 0x40 ? keyval | 0x80 : keyval);
 379 #ifdef CONFIG_KBDMOUSE
 380                         if (mousedev >= 0)
 381                                 busmouse_add_movement(mousedev, (int)kbd_mousedx, (int)kbd_mousedy);
 382 #endif
 383                 }
 384         }
 385         return kbd_state == KBD_IDLE ? 1 : 0;
 386
 387 kbd_wontreset:
 388 #ifdef KBD_REPORT_ERR
 389         printk ("kbd: keyboard won't reset (kbdstate %d, keyval %02X)\n",
 390                 kbd_state, keyval);
 391 #endif
 392         mdelay(1);
 393         ioc_readb(IOC_KARTRX);
 394         a5kkbd_sendbyte (HRST);
 395         kbd_state = KBD_INITRST;
 396         return 0;
 397
 398 kbd_error:
 399 #ifdef KBD_REPORT_ERR
 400         printk ("kbd: keyboard out of sync - resetting\n");
 401 #endif
 402         a5kkbd_sendbyte (HRST);
 403         kbd_state = KBD_INITRST;
 404         return 0;
 405 }
 406
 407 static void a5kkbd_rx(int irq, void *dev_id, struct pt_regs *regs)
 408 {
 409         kbd_pt_regs = regs;
 410         if (handle_rawcode(ioc_readb(IOC_KARTRX)))
 411                 tasklet_schedule(&keyboard_tasklet);
 412 }
 413
 414 static void a5kkbd_tx(int irq, void *dev_id, struct pt_regs *regs)
 415 {
 416         ioc_writeb (kbd_txval[kbd_txtail], IOC_KARTTX);
 417         KBD_INCTXPTR(kbd_txtail);
 418         if (kbd_txtail == kbd_txhead)
 419                 disable_irq(irq);
 420 }
 421
 422 #ifdef CONFIG_KBDMOUSE
 423 static struct busmouse a5kkbd_mouse = {
 424         6, "kbdmouse", NULL, NULL, NULL, 7
 425 };
 426 #endif
 427
 428 void __init a5kkbd_init_hw (void)
 429 {
 430         if (request_irq (IRQ_KEYBOARDTX, a5kkbd_tx, 0, "keyboard", NULL) != 0)
 431                 panic("Could not allocate keyboard transmit IRQ!");
 432         (void)ioc_readb(IOC_KARTRX);
 433         if (request_irq (IRQ_KEYBOARDRX, a5kkbd_rx, 0, "keyboard", NULL) != 0)
 434                 panic("Could not allocate keyboard receive IRQ!");
 435
 436         a5kkbd_sendbyte (HRST); /* send HRST (expect HRST) */
 437
 438         /* wait 1s for keyboard to initialise */
 439         interruptible_sleep_on_timeout(&kbd_waitq, HZ);
 440
 441 #ifdef CONFIG_KBDMOUSE
 442         mousedev = register_busmouse(&a5kkbd_mouse);
 443         if (mousedev < 0)
 444                 printk(KERN_ERR "Unable to register mouse driver\n");
 445 #endif
 446
 447         printk (KERN_INFO "Keyboard driver v%d.%02d. (", VERSION/100, VERSION%100);
 448         if (kbd_id != -1)
 449               printk ("id=%d ", kbd_id);
 450         printk ("English)\n");
 451 }