drivers/input/keyboard/98kbd.c

   1 /*
   2  *  drivers/input/keyboard/98kbd.c
   3  *
   4  *  PC-9801 keyboard driver for Linux
   5  *
   6  *    Based on atkbd.c and xtkbd.c written by Vojtech Pavlik
   7  *
   8  *  Copyright (c) 2002 Osamu Tomita
   9  *  Copyright (c) 1999-2001 Vojtech Pavlik
  10  */
  11
  12 /*
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26  *
  27  */
  28
  29 #include <linux/delay.h>
  30 #include <linux/slab.h>
  31 #include <linux/module.h>
  32 #include <linux/input.h>
  33 #include <linux/init.h>
  34 #include <linux/serio.h>
  35
  36 #include <asm/io.h>
  37 #include <asm/pc9800.h>
  38
  39 MODULE_AUTHOR("Osamu Tomita <tomita@cinet.co.jp>");
  40 MODULE_DESCRIPTION("PC-9801 keyboard driver");
  41 MODULE_LICENSE("GPL");
  42
  43 #define KBD98_KEY       0x7f
  44 #define KBD98_RELEASE   0x80
  45
  46 static unsigned char kbd98_keycode[256] = {
  47           1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 43, 14, 15,
  48          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 41, 26, 28, 30, 31, 32,
  49          33, 34, 35, 36, 37, 38, 39, 40, 27, 44, 45, 46, 47, 48, 49, 50,
  50          51, 52, 53, 12, 57, 92,109,104,110,111,103,105,106,108,102,107,
  51          74, 98, 71, 72, 73, 55, 75, 76, 77, 78, 79, 80, 81,117, 82,121,
  52          83, 94, 87, 88,183,184,185,  0,  0,  0,  0,  0,  0,  0,102,  0,
  53          99,133, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,  0,  0,  0,  0,
  54          54, 58, 42, 56, 29
  55 };
  56
  57 struct jis_kbd_conv {
  58         unsigned char scancode;
  59         struct {
  60                 unsigned char shift;
  61                 unsigned char keycode;
  62         } emul[2];
  63 };
  64
  65 static struct jis_kbd_conv kbd98_jis[] = {
  66         {0x02, {{0,   3}, {1,  40}}},
  67         {0x06, {{0,   7}, {1,   8}}},
  68         {0x07, {{0,   8}, {0,  40}}},
  69         {0x08, {{0,   9}, {1,  10}}},
  70         {0x09, {{0,  10}, {1,  11}}},
  71         {0x0a, {{0,  11}, {1, 255}}},
  72         {0x0b, {{0,  12}, {0,  13}}},
  73         {0x0c, {{1,   7}, {0,  41}}},
  74         {0x1a, {{1,   3}, {1,  41}}},
  75         {0x26, {{0,  39}, {1,  13}}},
  76         {0x27, {{1,  39}, {1,   9}}},
  77         {0x33, {{0, 255}, {1,  12}}},
  78         {0xff, {{0, 255}, {1, 255}}}    /* terminater */
  79 };
  80
  81 #define KBD98_CMD_SETEXKEY      0x1095  /* Enable/Disable Windows, Appli key */
  82 #define KBD98_CMD_SETRATE       0x109c  /* Set typematic rate */
  83 #define KBD98_CMD_SETLEDS       0x109d  /* Set keyboard leds */
  84 #define KBD98_CMD_GETLEDS       0x119d  /* Get keyboard leds */
  85 #define KBD98_CMD_GETID         0x019f
  86
  87 #define KBD98_RET_ACK           0xfa
  88 #define KBD98_RET_NAK           0xfc    /* Command NACK, send the cmd again */
  89
  90 #define KBD98_KEY_JIS_EMUL      253
  91 #define KBD98_KEY_UNKNOWN       254
  92 #define KBD98_KEY_NULL          255
  93
  94 static char *kbd98_name = "PC-9801 Keyboard";
  95
  96 struct kbd98 {
  97         unsigned char keycode[256];
  98         struct input_dev dev;
  99         struct serio *serio;
 100         char phys[32];
 101         unsigned char cmdbuf[4];
 102         unsigned char cmdcnt;
 103         signed char ack;
 104         unsigned char shift;
 105         struct {
 106                 unsigned char scancode;
 107                 unsigned char keycode;
 108         } emul;
 109         struct jis_kbd_conv jis[16];
 110 };
 111
 112 irqreturn_t kbd98_interrupt(struct serio *serio, unsigned char data,
 113                             unsigned int flags, struct pt_regs *regs)
 114 {
 115         struct kbd98 *kbd98 = serio->private;
 116         unsigned char scancode, keycode;
 117         int press, i;
 118
 119         switch (data) {
 120                 case KBD98_RET_ACK:
 121                         kbd98->ack = 1;
 122                         goto out;
 123                 case KBD98_RET_NAK:
 124                         kbd98->ack = -1;
 125                         goto out;
 126         }
 127
 128         if (kbd98->cmdcnt) {
 129                 kbd98->cmdbuf[--kbd98->cmdcnt] = data;
 130                 goto out;
 131         }
 132
 133         scancode = data & KBD98_KEY;
 134         keycode = kbd98->keycode[scancode];
 135         press = !(data & KBD98_RELEASE);
 136         if (kbd98->emul.scancode != KBD98_KEY_UNKNOWN
 137             && scancode != kbd98->emul.scancode) {
 138                 input_report_key(&kbd98->dev, kbd98->emul.keycode, 0);
 139                 kbd98->emul.scancode = KBD98_KEY_UNKNOWN;
 140         }
 141
 142         if (keycode == KEY_RIGHTSHIFT)
 143                 kbd98->shift = press;
 144
 145         switch (keycode) {
 146                 case KEY_2:
 147                 case KEY_6:
 148                 case KEY_7:
 149                 case KEY_8:
 150                 case KEY_9:
 151                 case KEY_0:
 152                 case KEY_MINUS:
 153                 case KEY_EQUAL:
 154                 case KEY_GRAVE:
 155                 case KEY_SEMICOLON:
 156                 case KEY_APOSTROPHE:
 157                         /* emulation: JIS keyboard to US101 keyboard */
 158                         i = 0;
 159                         while (kbd98->jis[i].scancode != 0xff) {
 160                                 if (scancode == kbd98->jis[i].scancode)
 161                                         break;
 162                                 i ++;
 163                         }
 164
 165                         keycode = kbd98->jis[i].emul[kbd98->shift].keycode;
 166                         if (keycode == KBD98_KEY_NULL)
 167                                 break;
 168
 169                         if (press) {
 170                                 kbd98->emul.scancode = scancode;
 171                                 kbd98->emul.keycode = keycode;
 172                                 if (kbd98->jis[i].emul[kbd98->shift].shift
 173                                                                 != kbd98->shift)
 174                                         input_report_key(&kbd98->dev,
 175                                                         KEY_RIGHTSHIFT,
 176                                                         !(kbd98->shift));
 177                         }
 178
 179                         input_report_key(&kbd98->dev, keycode, press);
 180                         if (!press) {
 181                                 if (kbd98->jis[i].emul[kbd98->shift].shift
 182                                                                 != kbd98->shift)
 183                                         input_report_key(&kbd98->dev,
 184                                                         KEY_RIGHTSHIFT,
 185                                                         kbd98->shift);
 186                                 kbd98->emul.scancode = KBD98_KEY_UNKNOWN;
 187                         }
 188
 189                         input_sync(&kbd98->dev);
 190                         break;
 191
 192                 case KEY_CAPSLOCK:
 193                         input_report_key(&kbd98->dev, keycode, 1);
 194                         input_sync(&kbd98->dev);
 195                         input_report_key(&kbd98->dev, keycode, 0);
 196                         input_sync(&kbd98->dev);
 197                         break;
 198
 199                 case KBD98_KEY_NULL:
 200                         break;
 201
 202                 case 0:
 203                         printk(KERN_WARNING "kbd98.c: Unknown key (scancode %#x) %s.\n",
 204                                 data & KBD98_KEY, data & KBD98_RELEASE ? "released" : "pressed");
 205                         break;
 206
 207                 default:
 208                         input_report_key(&kbd98->dev, keycode, press);
 209                         input_sync(&kbd98->dev);
 210                         break;
 211         }
 212
 213 out:
 214         return IRQ_HANDLED;
 215 }
 216
 217 /*
 218  * kbd98_sendbyte() sends a byte to the keyboard, and waits for
 219  * acknowledge. It doesn't handle resends according to the keyboard
 220  * protocol specs, because if these are needed, the keyboard needs
 221  * replacement anyway, and they only make a mess in the protocol.
 222  */
 223
 224 static int kbd98_sendbyte(struct kbd98 *kbd98, unsigned char byte)
 225 {
 226         int timeout = 10000; /* 100 msec */
 227         kbd98->ack = 0;
 228
 229         if (serio_write(kbd98->serio, byte))
 230                 return -1;
 231
 232         while (!kbd98->ack && timeout--) udelay(10);
 233
 234         return -(kbd98->ack <= 0);
 235 }
 236
 237 /*
 238  * kbd98_command() sends a command, and its parameters to the keyboard,
 239  * then waits for the response and puts it in the param array.
 240  */
 241
 242 static int kbd98_command(struct kbd98 *kbd98, unsigned char *param, int command)
 243 {
 244         int timeout = 50000; /* 500 msec */
 245         int send = (command >> 12) & 0xf;
 246         int receive = (command >> 8) & 0xf;
 247         int i;
 248
 249         kbd98->cmdcnt = receive;
 250
 251         if (command & 0xff)
 252                 if (kbd98_sendbyte(kbd98, command & 0xff))
 253                         return (kbd98->cmdcnt = 0) - 1;
 254
 255         for (i = 0; i < send; i++)
 256                 if (kbd98_sendbyte(kbd98, param[i]))
 257                         return (kbd98->cmdcnt = 0) - 1;
 258
 259         while (kbd98->cmdcnt && timeout--) udelay(10);
 260
 261         if (param)
 262                 for (i = 0; i < receive; i++)
 263                         param[i] = kbd98->cmdbuf[(receive - 1) - i];
 264
 265         if (kbd98->cmdcnt)
 266                 return (kbd98->cmdcnt = 0) - 1;
 267
 268         return 0;
 269 }
 270
 271 /*
 272  * Event callback from the input module. Events that change the state of
 273  * the hardware are processed here.
 274  */
 275
 276 static int kbd98_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 277 {
 278         struct kbd98 *kbd98 = dev->private;
 279         char param[2];
 280
 281         switch (type) {
 282
 283                 case EV_LED:
 284
 285                         if (__PC9800SCA_TEST_BIT(0x481, 3)) {
 286                                 /* 98note with Num Lock key */
 287                                 /* keep Num Lock status     */
 288                                 *param = 0x60;
 289                                 if (kbd98_command(kbd98, param,
 290                                                         KBD98_CMD_GETLEDS))
 291                                         printk(KERN_DEBUG
 292                                                 "kbd98: Get keyboard LED"
 293                                                 " status Error\n");
 294
 295                                 *param &= 1;
 296                         } else {
 297                                 /* desktop PC-9801 */
 298                                 *param = 1;     /* Always set Num Lock */
 299                         }
 300
 301                         *param |= 0x70
 302                                | (test_bit(LED_CAPSL,   dev->led) ? 4 : 0)
 303                                | (test_bit(LED_KANA,    dev->led) ? 8 : 0);
 304                         kbd98_command(kbd98, param, KBD98_CMD_SETLEDS);
 305
 306                         return 0;
 307         }
 308
 309         return -1;
 310 }
 311
 312 void kbd98_connect(struct serio *serio, struct serio_dev *dev)
 313 {
 314         struct kbd98 *kbd98;
 315         int i;
 316
 317         if ((serio->type & SERIO_TYPE) != SERIO_PC9800)
 318                 return;
 319
 320         if (!(kbd98 = kmalloc(sizeof(struct kbd98), GFP_KERNEL)))
 321                 return;
 322
 323         memset(kbd98, 0, sizeof(struct kbd98));
 324         kbd98->emul.scancode = KBD98_KEY_UNKNOWN;
 325
 326         kbd98->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_LED) | BIT(EV_REP);
 327         kbd98->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_KANA);
 328
 329         kbd98->serio = serio;
 330
 331         init_input_dev(&kbd98->dev);
 332         kbd98->dev.keycode = kbd98->keycode;
 333         kbd98->dev.keycodesize = sizeof(unsigned char);
 334         kbd98->dev.keycodemax = ARRAY_SIZE(kbd98_keycode);
 335         kbd98->dev.event = kbd98_event;
 336         kbd98->dev.private = kbd98;
 337
 338         serio->private = kbd98;
 339
 340         if (serio_open(serio, dev)) {
 341                 kfree(kbd98);
 342                 return;
 343         }
 344
 345         memcpy(kbd98->jis, kbd98_jis, sizeof(kbd98_jis));
 346         memcpy(kbd98->keycode, kbd98_keycode, sizeof(kbd98->keycode));
 347         for (i = 0; i < 255; i++)
 348                 set_bit(kbd98->keycode[i], kbd98->dev.keybit);
 349         clear_bit(0, kbd98->dev.keybit);
 350
 351         sprintf(kbd98->phys, "%s/input0", serio->phys);
 352
 353         kbd98->dev.name = kbd98_name;
 354         kbd98->dev.phys = kbd98->phys;
 355         kbd98->dev.id.bustype = BUS_XTKBD;
 356         kbd98->dev.id.vendor = 0x0002;
 357         kbd98->dev.id.product = 0x0001;
 358         kbd98->dev.id.version = 0x0100;
 359
 360         input_register_device(&kbd98->dev);
 361
 362         printk(KERN_INFO "input: %s on %s\n", kbd98_name, serio->phys);
 363 }
 364
 365 void kbd98_disconnect(struct serio *serio)
 366 {
 367         struct kbd98 *kbd98 = serio->private;
 368         input_unregister_device(&kbd98->dev);
 369         serio_close(serio);
 370         kfree(kbd98);
 371 }
 372
 373 struct serio_dev kbd98_dev = {
 374         .interrupt =    kbd98_interrupt,
 375         .connect =      kbd98_connect,
 376         .disconnect =   kbd98_disconnect
 377 };
 378
 379 int __init kbd98_init(void)
 380 {
 381         serio_register_device(&kbd98_dev);
 382         return 0;
 383 }
 384
 385 void __exit kbd98_exit(void)
 386 {
 387         serio_unregister_device(&kbd98_dev);
 388 }
 389
 390 module_init(kbd98_init);
 391 module_exit(kbd98_exit);