drivers/tc/lk201.c

   1 /*
   2  *
   3  * This file is subject to the terms and conditions of the GNU General Public
   4  * License.  See the file "COPYING" in the main directory of this archive
   5  * for more details.
   6  *
   7  * Copyright (C) 1999-2002 Harald Koerfgen <hkoerfg@web.de>
   8  * Copyright (C) 2001, 2002, 2003, 2004  Maciej W. Rozycki
   9  */
  10
  11
  12 #include <linux/errno.h>
  13 #include <linux/sched.h>
  14 #include <linux/tty.h>
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/delay.h>
  18 #include <linux/kbd_ll.h>
  19 #include <linux/kbd_kern.h>
  20 #include <linux/vt_kern.h>
  21
  22 #include <asm/keyboard.h>
  23 #include <asm/dec/tc.h>
  24 #include <asm/dec/machtype.h>
  25 #include <asm/dec/serial.h>
  26
  27 #include "lk201.h"
  28
  29 /*
  30  * Only handle DECstations that have an LK201 interface.
  31  * Maxine uses LK501 at the Access.Bus and various DECsystems
  32  * have no keyboard interface at all.
  33  */
  34 #define LK_IFACE        (mips_machtype == MACH_DS23100    || \
  35                          mips_machtype == MACH_DS5000_200 || \
  36                          mips_machtype == MACH_DS5000_1XX || \
  37                          mips_machtype == MACH_DS5000_2X0)
  38 /*
  39  * These use the Z8530 SCC.  Others use the DZ11.
  40  */
  41 #define LK_IFACE_ZS     (mips_machtype == MACH_DS5000_1XX || \
  42                          mips_machtype == MACH_DS5000_2X0)
  43
  44 /* Simple translation table for the SysRq keys */
  45
  46 #ifdef CONFIG_MAGIC_SYSRQ
  47 /*
  48  * Actually no translation at all, at least until we figure out
  49  * how to define SysRq for LK201 and friends. --macro
  50  */
  51 unsigned char lk201_sysrq_xlate[128];
  52 unsigned char *kbd_sysrq_xlate = lk201_sysrq_xlate;
  53
  54 unsigned char kbd_sysrq_key = -1;
  55 #endif
  56
  57 #define KEYB_LINE       3
  58
  59 static int __init lk201_init(void *);
  60 static void __init lk201_info(void *);
  61 static void lk201_rx_char(unsigned char, unsigned char);
  62
  63 static struct dec_serial_hook lk201_hook = {
  64         .init_channel   = lk201_init,
  65         .init_info      = lk201_info,
  66         .rx_char        = NULL,
  67         .poll_rx_char   = NULL,
  68         .poll_tx_char   = NULL,
  69         .cflags         = B4800 | CS8 | CSTOPB | CLOCAL,
  70 };
  71
  72 /*
  73  * This is used during keyboard initialisation
  74  */
  75 static unsigned char lk201_reset_string[] = {
  76         LK_CMD_SET_DEFAULTS,
  77         LK_CMD_MODE(LK_MODE_RPT_DOWN, 1),
  78         LK_CMD_MODE(LK_MODE_RPT_DOWN, 2),
  79         LK_CMD_MODE(LK_MODE_RPT_DOWN, 3),
  80         LK_CMD_MODE(LK_MODE_RPT_DOWN, 4),
  81         LK_CMD_MODE(LK_MODE_DOWN_UP, 5),
  82         LK_CMD_MODE(LK_MODE_DOWN_UP, 6),
  83         LK_CMD_MODE(LK_MODE_RPT_DOWN, 7),
  84         LK_CMD_MODE(LK_MODE_RPT_DOWN, 8),
  85         LK_CMD_MODE(LK_MODE_RPT_DOWN, 9),
  86         LK_CMD_MODE(LK_MODE_RPT_DOWN, 10),
  87         LK_CMD_MODE(LK_MODE_RPT_DOWN, 11),
  88         LK_CMD_MODE(LK_MODE_RPT_DOWN, 12),
  89         LK_CMD_MODE(LK_MODE_DOWN, 13),
  90         LK_CMD_MODE(LK_MODE_RPT_DOWN, 14),
  91         LK_CMD_DIS_KEYCLK,
  92         LK_CMD_ENB_BELL, LK_PARAM_VOLUME(4),
  93 };
  94
  95 static void *lk201_handle;
  96
  97 static int lk201_send(unsigned char ch)
  98 {
  99         if (lk201_hook.poll_tx_char(lk201_handle, ch)) {
 100                 printk(KERN_ERR "lk201: transmit timeout\n");
 101                 return -EIO;
 102         }
 103         return 0;
 104 }
 105
 106 static inline int lk201_get_id(void)
 107 {
 108         return lk201_send(LK_CMD_REQ_ID);
 109 }
 110
 111 static int lk201_reset(void)
 112 {
 113         int i, r;
 114
 115         for (i = 0; i < sizeof(lk201_reset_string); i++) {
 116                 r = lk201_send(lk201_reset_string[i]);
 117                 if (r < 0)
 118                         return r;
 119         }
 120         return 0;
 121 }
 122
 123 static void lk201_report(unsigned char id[6])
 124 {
 125         char *report = "lk201: keyboard attached, ";
 126
 127         switch (id[2]) {
 128         case LK_STAT_PWRUP_OK:
 129                 printk(KERN_INFO "%sself-test OK\n", report);
 130                 break;
 131         case LK_STAT_PWRUP_KDOWN:
 132                 /* The keyboard will resend the power-up ID
 133                    after all keys are released, so we don't
 134                    bother handling the error specially.  Still
 135                    there may be a short-circuit inside.
 136                  */
 137                 printk(KERN_ERR "%skey down (stuck?), code: 0x%02x\n",
 138                        report, id[3]);
 139                 break;
 140         case LK_STAT_PWRUP_ERROR:
 141                 printk(KERN_ERR "%sself-test failure\n", report);
 142                 break;
 143         default:
 144                 printk(KERN_ERR "%sunknown error: 0x%02x\n",
 145                        report, id[2]);
 146         }
 147 }
 148
 149 static void lk201_id(unsigned char id[6])
 150 {
 151         /*
 152          * Report whether there is an LK201 or an LK401
 153          * The LK401 has ALT keys...
 154          */
 155         switch (id[4]) {
 156         case 1:
 157                 printk(KERN_INFO "lk201: LK201 detected\n");
 158                 break;
 159         case 2:
 160                 printk(KERN_INFO "lk201: LK401 detected\n");
 161                 break;
 162         case 3:
 163                 printk(KERN_INFO "lk201: LK443 detected\n");
 164                 break;
 165         case 4:
 166                 printk(KERN_INFO "lk201: LK421 detected\n");
 167                 break;
 168         default:
 169                 printk(KERN_WARNING
 170                        "lk201: unknown keyboard detected, ID %d\n", id[4]);
 171                 printk(KERN_WARNING "lk201: ... please report to "
 172                        "<linux-mips@linux-mips.org>\n");
 173         }
 174 }
 175
 176 #define DEFAULT_KEYB_REP_DELAY  (250/5) /* [5ms] */
 177 #define DEFAULT_KEYB_REP_RATE   30      /* [cps] */
 178
 179 static struct kbd_repeat kbdrate = {
 180         DEFAULT_KEYB_REP_DELAY,
 181         DEFAULT_KEYB_REP_RATE
 182 };
 183
 184 static void parse_kbd_rate(struct kbd_repeat *r)
 185 {
 186         if (r->delay <= 0)
 187                 r->delay = kbdrate.delay;
 188         if (r->rate <= 0)
 189                 r->rate = kbdrate.rate;
 190
 191         if (r->delay < 5)
 192                 r->delay = 5;
 193         if (r->delay > 630)
 194                 r->delay = 630;
 195         if (r->rate < 12)
 196                 r->rate = 12;
 197         if (r->rate > 127)
 198                 r->rate = 127;
 199         if (r->rate == 125)
 200                 r->rate = 124;
 201 }
 202
 203 static int write_kbd_rate(struct kbd_repeat *rep)
 204 {
 205         int delay, rate;
 206         int i;
 207
 208         delay = rep->delay / 5;
 209         rate = rep->rate;
 210         for (i = 0; i < 4; i++) {
 211                 if (lk201_hook.poll_tx_char(lk201_handle,
 212                                             LK_CMD_RPT_RATE(i)))
 213                         return 1;
 214                 if (lk201_hook.poll_tx_char(lk201_handle,
 215                                             LK_PARAM_DELAY(delay)))
 216                         return 1;
 217                 if (lk201_hook.poll_tx_char(lk201_handle,
 218                                             LK_PARAM_RATE(rate)))
 219                         return 1;
 220         }
 221         return 0;
 222 }
 223
 224 static int lk201_kbd_rate(struct kbd_repeat *rep)
 225 {
 226         if (rep == NULL)
 227                 return -EINVAL;
 228
 229         parse_kbd_rate(rep);
 230
 231         if (write_kbd_rate(rep)) {
 232                 memcpy(rep, &kbdrate, sizeof(struct kbd_repeat));
 233                 return -EIO;
 234         }
 235
 236         memcpy(&kbdrate, rep, sizeof(struct kbd_repeat));
 237
 238         return 0;
 239 }
 240
 241 static void lk201_kd_mksound(unsigned int hz, unsigned int ticks)
 242 {
 243         if (!ticks)
 244                 return;
 245
 246         /*
 247          * Can't set frequency and we "approximate"
 248          * duration by volume. ;-)
 249          */
 250         ticks /= HZ / 32;
 251         if (ticks > 7)
 252                 ticks = 7;
 253         ticks = 7 - ticks;
 254
 255         if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_ENB_BELL))
 256                 return;
 257         if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_VOLUME(ticks)))
 258                 return;
 259         if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_BELL))
 260                 return;
 261 }
 262
 263 void kbd_leds(unsigned char leds)
 264 {
 265         unsigned char l = 0;
 266
 267         if (!lk201_handle)              /* FIXME */
 268                 return;
 269
 270         /* FIXME -- Only Hold and Lock LEDs for now. --macro */
 271         if (leds & LED_SCR)
 272                 l |= LK_LED_HOLD;
 273         if (leds & LED_CAP)
 274                 l |= LK_LED_LOCK;
 275
 276         if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_LEDS_ON))
 277                 return;
 278         if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_LED_MASK(l)))
 279                 return;
 280         if (lk201_hook.poll_tx_char(lk201_handle, LK_CMD_LEDS_OFF))
 281                 return;
 282         if (lk201_hook.poll_tx_char(lk201_handle, LK_PARAM_LED_MASK(~l)))
 283                 return;
 284 }
 285
 286 int kbd_setkeycode(unsigned int scancode, unsigned int keycode)
 287 {
 288         return -EINVAL;
 289 }
 290
 291 int kbd_getkeycode(unsigned int scancode)
 292 {
 293         return -EINVAL;
 294 }
 295
 296 int kbd_translate(unsigned char scancode, unsigned char *keycode,
 297                   char raw_mode)
 298 {
 299         *keycode = scancode;
 300         return 1;
 301 }
 302
 303 char kbd_unexpected_up(unsigned char keycode)
 304 {
 305         return 0x80;
 306 }
 307
 308 static void lk201_rx_char(unsigned char ch, unsigned char fl)
 309 {
 310         static unsigned char id[6];
 311         static int id_i;
 312
 313         static int shift_state = 0;
 314         static int prev_scancode;
 315         unsigned char c = scancodeRemap[ch];
 316
 317         if (fl != TTY_NORMAL && fl != TTY_OVERRUN) {
 318                 printk(KERN_ERR "lk201: keyboard receive error: 0x%02x\n", fl);
 319                 return;
 320         }
 321
 322         /* Assume this is a power-up ID. */
 323         if (ch == LK_STAT_PWRUP_ID && !id_i) {
 324                 id[id_i++] = ch;
 325                 return;
 326         }
 327
 328         /* Handle the power-up sequence. */
 329         if (id_i) {
 330                 id[id_i++] = ch;
 331                 if (id_i == 4) {
 332                         /* OK, the power-up concluded. */
 333                         lk201_report(id);
 334                         if (id[2] == LK_STAT_PWRUP_OK)
 335                                 lk201_get_id();
 336                         else {
 337                                 id_i = 0;
 338                                 printk(KERN_ERR "lk201: keyboard power-up "
 339                                        "error, skipping initialization\n");
 340                         }
 341                 } else if (id_i == 6) {
 342                         /* We got the ID; report it and start operation. */
 343                         id_i = 0;
 344                         lk201_id(id);
 345                         lk201_reset();
 346                 }
 347                 return;
 348         }
 349
 350         /* Everything else is a scancode/status response. */
 351         id_i = 0;
 352         switch (ch) {
 353         case LK_STAT_RESUME_ERR:
 354         case LK_STAT_ERROR:
 355         case LK_STAT_INHIBIT_ACK:
 356         case LK_STAT_TEST_ACK:
 357         case LK_STAT_MODE_KEYDOWN:
 358         case LK_STAT_MODE_ACK:
 359                 break;
 360         case LK_KEY_LOCK:
 361                 shift_state ^= LK_LOCK;
 362                 handle_scancode(c, (shift_state & LK_LOCK) ? 1 : 0);
 363                 break;
 364         case LK_KEY_SHIFT:
 365                 shift_state ^= LK_SHIFT;
 366                 handle_scancode(c, (shift_state & LK_SHIFT) ? 1 : 0);
 367                 break;
 368         case LK_KEY_CTRL:
 369                 shift_state ^= LK_CTRL;
 370                 handle_scancode(c, (shift_state & LK_CTRL) ? 1 : 0);
 371                 break;
 372         case LK_KEY_COMP:
 373                 shift_state ^= LK_COMP;
 374                 handle_scancode(c, (shift_state & LK_COMP) ? 1 : 0);
 375                 break;
 376         case LK_KEY_RELEASE:
 377                 if (shift_state & LK_SHIFT)
 378                         handle_scancode(scancodeRemap[LK_KEY_SHIFT], 0);
 379                 if (shift_state & LK_CTRL)
 380                         handle_scancode(scancodeRemap[LK_KEY_CTRL], 0);
 381                 if (shift_state & LK_COMP)
 382                         handle_scancode(scancodeRemap[LK_KEY_COMP], 0);
 383                 if (shift_state & LK_LOCK)
 384                         handle_scancode(scancodeRemap[LK_KEY_LOCK], 0);
 385                 shift_state = 0;
 386                 break;
 387         case LK_KEY_REPEAT:
 388                 handle_scancode(prev_scancode, 1);
 389                 break;
 390         default:
 391                 prev_scancode = c;
 392                 handle_scancode(c, 1);
 393                 break;
 394         }
 395         tasklet_schedule(&keyboard_tasklet);
 396 }
 397
 398 static void __init lk201_info(void *handle)
 399 {
 400 }
 401
 402 static int __init lk201_init(void *handle)
 403 {
 404         /* First install handlers. */
 405         lk201_handle = handle;
 406         kbd_rate = lk201_kbd_rate;
 407         kd_mksound = lk201_kd_mksound;
 408
 409         lk201_hook.rx_char = lk201_rx_char;
 410
 411         /* Then just issue a reset -- the handlers will do the rest. */
 412         lk201_send(LK_CMD_POWER_UP);
 413
 414         return 0;
 415 }
 416
 417 void __init kbd_init_hw(void)
 418 {
 419         /* Maxine uses LK501 at the Access.Bus. */
 420         if (!LK_IFACE)
 421                 return;
 422
 423         printk(KERN_INFO "lk201: DECstation LK keyboard driver v0.05.\n");
 424
 425         if (LK_IFACE_ZS) {
 426                 /*
 427                  * kbd_init_hw() is being called before
 428                  * rs_init() so just register the kbd hook
 429                  * and let zs_init do the rest :-)
 430                  */
 431                 if (!register_dec_serial_hook(KEYB_LINE, &lk201_hook))
 432                         unregister_dec_serial_hook(KEYB_LINE);
 433         } else {
 434                 /*
 435                  * TODO: modify dz.c to allow similar hooks
 436                  * for LK201 handling on DS2100, DS3100, and DS5000/200
 437                  */
 438                 printk(KERN_ERR "lk201: support for DZ11 not yet ready.\n");
 439         }
 440 }