sys/arch/atari/dev/kbd.c

   1 /*      $NetBSD: kbd.c,v 1.39 2009/07/03 14:00:41 tsutsui Exp $ */
   2
   3 /*
   4  * Copyright (c) 1995 Leo Weppelman
   5  * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __KERNEL_RCSID(0, "$NetBSD: kbd.c,v 1.39 2009/07/03 14:00:41 tsutsui Exp $");
  35
  36 #include "mouse.h"
  37 #include "ite.h"
  38 #include "wskbd.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/device.h>
  43 #include <sys/ioctl.h>
  44 #include <sys/tty.h>
  45 #include <sys/proc.h>
  46 #include <sys/conf.h>
  47 #include <sys/file.h>
  48 #include <sys/kernel.h>
  49 #include <sys/signalvar.h>
  50 #include <sys/syslog.h>
  51 #include <dev/cons.h>
  52 #include <machine/cpu.h>
  53 #include <machine/iomap.h>
  54 #include <machine/mfp.h>
  55 #include <machine/acia.h>
  56 #include <atari/dev/itevar.h>
  57 #include <atari/dev/event_var.h>
  58 #include <atari/dev/vuid_event.h>
  59 #include <atari/dev/ym2149reg.h>
  60 #include <atari/dev/kbdreg.h>
  61 #include <atari/dev/kbdvar.h>
  62 #include <atari/dev/kbdmap.h>
  63 #include <atari/dev/msvar.h>
  64
  65 #if NWSKBD>0
  66 #include <dev/wscons/wsconsio.h>
  67 #include <dev/wscons/wskbdvar.h>
  68 #include <dev/wscons/wsksymdef.h>
  69 #include <dev/wscons/wsksymvar.h>
  70 #include <atari/dev/wskbdmap_atari.h>
  71 #endif
  72
  73 /* WSKBD */
  74 /*
  75  * If NWSKBD>0 we try to attach an wskbd device to us. What follows
  76  * is definitions of callback functions and structures that are passed
  77  * to wscons when initializing.
  78  */
  79
  80 /*
  81  * Now with wscons this driver exhibits some weird behaviour.
  82  * It may act both as a driver of its own and the md part of the
  83  * wskbd driver. Therefore it can be accessed through /dev/kbd
  84  * and /dev/wskbd0 both.
  85  *
  86  * The data from they keyboard may end up in at least four different
  87  * places:
  88  * - If this driver has been opened (/dev/kbd) and the
  89  *   direct mode (TIOCDIRECT) has been set, data goes to
  90  *   the process who opened the device. Data will transmit itself
  91  *   as described by the firm_event structure.
  92  * - If wskbd support is compiled in and a wskbd driver has been
  93  *   attached then the data is sent to it. Wskbd in turn may
  94  *   - Send the data in the wscons_event form to a process that
  95  *     has opened /dev/wskbd0
  96  *   - Feed the data to a virtual terminal.
  97  * - If an ite is present the data may be fed to it.
  98  */
  99
 100 uint8_t                 kbd_modifier;   /* Modifier mask                */
 101
 102 static uint8_t          kbd_ring[KBD_RING_SIZE];
 103 static volatile u_int   kbd_rbput = 0;  /* 'put' index                  */
 104 static u_int            kbd_rbget = 0;  /* 'get' index                  */
 105
 106 static struct kbd_softc kbd_softc;
 107
 108 /* {b,c}devsw[] function prototypes */
 109 dev_type_open(kbdopen);
 110 dev_type_close(kbdclose);
 111 dev_type_read(kbdread);
 112 dev_type_ioctl(kbdioctl);
 113 dev_type_poll(kbdpoll);
 114 dev_type_kqfilter(kbdkqfilter);
 115
 116 /* Interrupt handler */
 117 void    kbdintr(int);
 118
 119 static void kbdsoft(void *);
 120 static void kbdattach(struct device *, struct device *, void *);
 121 static int  kbdmatch(struct device *, struct cfdata *, void *);
 122 #if NITE>0
 123 static int  kbd_do_modifier(uint8_t);
 124 #endif
 125 static int  kbd_write_poll(const uint8_t *, int);
 126 static void kbd_pkg_start(struct kbd_softc *, uint8_t);
 127
 128 CFATTACH_DECL(kbd, sizeof(struct device),
 129     kbdmatch, kbdattach, NULL, NULL);
 130
 131 const struct cdevsw kbd_cdevsw = {
 132         kbdopen, kbdclose, kbdread, nowrite, kbdioctl,
 133         nostop, notty, kbdpoll, nommap, kbdkqfilter,
 134 };
 135
 136 #if NWSKBD>0
 137 /* accessops */
 138 static int      kbd_enable(void *, int);
 139 static void     kbd_set_leds(void *, int);
 140 static int      kbd_ioctl(void *, u_long, void *, int, struct lwp *);
 141
 142 /* console ops */
 143 static void     kbd_getc(void *, u_int *, int *);
 144 static void     kbd_pollc(void *, int);
 145 static void     kbd_bell(void *, u_int, u_int, u_int);
 146
 147 static struct wskbd_accessops kbd_accessops = {
 148         kbd_enable,
 149         kbd_set_leds,
 150         kbd_ioctl
 151 };
 152
 153 static struct wskbd_consops kbd_consops = {
 154         kbd_getc,
 155         kbd_pollc,
 156         kbd_bell
 157 };
 158
 159 /* Pointer to keymaps. */
 160 static struct wskbd_mapdata kbd_mapdata = {
 161         atarikbd_keydesctab,
 162         KB_US
 163 };
 164 #endif /* WSKBD */
 165
 166 /*ARGSUSED*/
 167 static  int
 168 kbdmatch(struct device *pdp, struct cfdata *cfp, void *auxp)
 169 {
 170
 171         if (!strcmp((char *)auxp, "kbd"))
 172                 return 1;
 173         return 0;
 174 }
 175
 176 /*ARGSUSED*/
 177 static void
 178 kbdattach(struct device *pdp, struct device *dp, void *auxp)
 179 {
 180         int timeout;
 181         const uint8_t kbd_rst[]  = { 0x80, 0x01 };
 182         const uint8_t kbd_icmd[] = { 0x12, 0x15 };
 183
 184         /*
 185          * Disable keyboard interrupts from MFP
 186          */
 187         MFP->mf_ierb &= ~IB_AINT;
 188
 189         /*
 190          * Reset ACIA and intialize to:
 191          *    divide by 16, 8 data, 1 stop, no parity, enable RX interrupts
 192          */
 193         KBD->ac_cs = A_RESET;
 194         delay(100);     /* XXX: enough? */
 195         KBD->ac_cs = kbd_softc.k_soft_cs = KBD_INIT | A_RXINT;
 196
 197         /*
 198          * Clear error conditions
 199          */
 200         while (KBD->ac_cs & (A_IRQ|A_RXRDY))
 201                 timeout = KBD->ac_da;
 202
 203         /*
 204          * Now send the reset string, and read+ignore it's response
 205          */
 206         if (!kbd_write_poll(kbd_rst, 2))
 207                 printf("kbd: error cannot reset keyboard\n");
 208         for (timeout = 1000; timeout > 0; timeout--) {
 209                 if (KBD->ac_cs & (A_IRQ|A_RXRDY)) {
 210                         timeout = KBD->ac_da;
 211                         timeout = 100;
 212                 }
 213                 delay(100);
 214         }
 215         /*
 216          * Send init command: disable mice & joysticks
 217          */
 218         kbd_write_poll(kbd_icmd, sizeof(kbd_icmd));
 219
 220         printf("\n");
 221
 222         kbd_softc.k_sicookie = softint_establish(SOFTINT_SERIAL, kbdsoft, NULL);
 223
 224 #if NWSKBD>0
 225         if (dp != NULL) {
 226                 /*
 227                  * Try to attach the wskbd.
 228                  */
 229                 struct wskbddev_attach_args waa;
 230
 231                 /* Maybe should be done before this?... */
 232                 wskbd_cnattach(&kbd_consops, NULL, &kbd_mapdata);
 233
 234                 waa.console = 1;
 235                 waa.keymap = &kbd_mapdata;
 236                 waa.accessops = &kbd_accessops;
 237                 waa.accesscookie = NULL;
 238                 kbd_softc.k_wskbddev = config_found(dp, &waa, wskbddevprint);
 239
 240                 kbd_softc.k_pollingmode = 0;
 241
 242                 kbdenable();
 243         }
 244 #endif /* WSKBD */
 245 }
 246
 247 void
 248 kbdenable(void)
 249 {
 250         int s, code;
 251
 252         s = spltty();
 253
 254         /*
 255          * Clear error conditions...
 256          */
 257         while (KBD->ac_cs & (A_IRQ|A_RXRDY))
 258                 code = KBD->ac_da;
 259         /*
 260          * Enable interrupts from MFP
 261          */
 262         MFP->mf_iprb  = (u_int8_t)~IB_AINT;
 263         MFP->mf_ierb |= IB_AINT;
 264         MFP->mf_imrb |= IB_AINT;
 265
 266         kbd_softc.k_event_mode   = 0;
 267         kbd_softc.k_events.ev_io = 0;
 268         kbd_softc.k_pkg_size     = 0;
 269         splx(s);
 270 }
 271
 272 int kbdopen(dev_t dev, int flags, int mode, struct lwp *l)
 273 {
 274
 275         if (kbd_softc.k_events.ev_io)
 276                 return EBUSY;
 277
 278         kbd_softc.k_events.ev_io = l->l_proc;
 279         ev_init(&kbd_softc.k_events);
 280         return 0;
 281 }
 282
 283 int
 284 kbdclose(dev_t dev, int flags, int mode, struct lwp *l)
 285 {
 286
 287         /* Turn off event mode, dump the queue */
 288         kbd_softc.k_event_mode = 0;
 289         ev_fini(&kbd_softc.k_events);
 290         kbd_softc.k_events.ev_io = NULL;
 291         return 0;
 292 }
 293
 294 int
 295 kbdread(dev_t dev, struct uio *uio, int flags)
 296 {
 297
 298         return ev_read(&kbd_softc.k_events, uio, flags);
 299 }
 300
 301 int
 302 kbdioctl(dev_t dev, u_long cmd, register void *data, int flag, struct lwp *l)
 303 {
 304         register struct kbd_softc *k = &kbd_softc;
 305         struct kbdbell  *kb;
 306
 307         switch (cmd) {
 308                 case KIOCTRANS:
 309                         if (*(int *)data == TR_UNTRANS_EVENT)
 310                                 return 0;
 311                         break;
 312
 313                 case KIOCGTRANS:
 314                         /*
 315                          * Get translation mode
 316                          */
 317                         *(int *)data = TR_UNTRANS_EVENT;
 318                         return 0;
 319
 320                 case KIOCSDIRECT:
 321                         k->k_event_mode = *(int *)data;
 322                         return 0;
 323
 324                 case KIOCRINGBELL:
 325                         kb = (struct kbdbell *)data;
 326                         if (kb)
 327                                 kbd_bell_sparms(kb->volume, kb->pitch,
 328                                     kb->duration);
 329                         kbdbell();
 330                         return 0;
 331
 332                 case FIONBIO:   /* we will remove this someday (soon???) */
 333                         return 0;
 334
 335                 case FIOASYNC:
 336                         k->k_events.ev_async = *(int *)data != 0;
 337                                 return 0;
 338
 339                 case FIOSETOWN:
 340                         if (-*(int *)data != k->k_events.ev_io->p_pgid
 341                             && *(int *)data != k->k_events.ev_io->p_pid)
 342                                 return EPERM;
 343                         return 0;
 344
 345                 case TIOCSPGRP:
 346                         if (*(int *)data != k->k_events.ev_io->p_pgid)
 347                                 return EPERM;
 348                         return 0;
 349
 350                 default:
 351                         return ENOTTY;
 352         }
 353
 354         /*
 355          * We identified the ioctl, but we do not handle it.
 356          */
 357         return EOPNOTSUPP;              /* misuse, but what the heck */
 358 }
 359
 360 int
 361 kbdpoll (dev_t dev, int events, struct lwp *l)
 362 {
 363
 364         return ev_poll(&kbd_softc.k_events, events, l);
 365 }
 366
 367 int
 368 kbdkqfilter(dev_t dev, struct knote *kn)
 369 {
 370
 371         return ev_kqfilter(&kbd_softc.k_events, kn);
 372 }
 373
 374 /*
 375  * Keyboard interrupt handler called straight from MFP at spl6.
 376  */
 377 void
 378 kbdintr(int sr)
 379         /* sr:   sr at time of interrupt        */
 380 {
 381         int     code;
 382         int     got_char = 0;
 383
 384         /*
 385          * There may be multiple keys available. Read them all.
 386          */
 387         while (KBD->ac_cs & (A_RXRDY|A_OE|A_PE)) {
 388                 got_char = 1;
 389                 if (KBD->ac_cs & (A_OE|A_PE)) {
 390                         code = KBD->ac_da;      /* Silently ignore errors */
 391                         continue;
 392                 }
 393                 kbd_ring[kbd_rbput++ & KBD_RING_MASK] = KBD->ac_da;
 394         }
 395
 396         /*
 397          * If characters are waiting for transmit, send them.
 398          */
 399         if ((kbd_softc.k_soft_cs & A_TXINT) && (KBD->ac_cs & A_TXRDY)) {
 400                 if (kbd_softc.k_sendp != NULL)
 401                         KBD->ac_da = *kbd_softc.k_sendp++;
 402                 if (--kbd_softc.k_send_cnt <= 0) {
 403                         /*
 404                          * The total package has been transmitted,
 405                          * wakeup anyone waiting for it.
 406                          */
 407                         KBD->ac_cs = (kbd_softc.k_soft_cs &= ~A_TXINT);
 408                         kbd_softc.k_sendp    = NULL;
 409                         kbd_softc.k_send_cnt = 0;
 410                         wakeup((void *)&kbd_softc.k_send_cnt);
 411                 }
 412         }
 413
 414         /*
 415          * Activate software-level to handle possible input.
 416          */
 417         if (got_char)
 418                 softint_schedule(kbd_softc.k_sicookie);
 419 }
 420
 421 /*
 422  * Keyboard soft interrupt handler
 423  */
 424 static void
 425 kbdsoft(void *junk1)
 426 {
 427         int s;
 428         uint8_t code;
 429         struct kbd_softc *k = &kbd_softc;
 430         struct firm_event *fe;
 431         int put, get, n;
 432
 433         get      = kbd_rbget;
 434
 435         for (;;) {
 436                 n = kbd_rbput;
 437                 if (get == n) /* We're done     */
 438                         break;
 439                 n -= get;
 440                 if (n > KBD_RING_SIZE) { /* Ring buffer overflow        */
 441                         get += n - KBD_RING_SIZE;
 442                         n    = KBD_RING_SIZE;
 443                 }
 444                 while (--n >= 0) {
 445                         code = kbd_ring[get++ & KBD_RING_MASK];
 446
 447                         /*
 448                          * If collecting a package, stuff it in and
 449                          * continue.
 450                          */
 451                         if (k->k_pkg_size && (k->k_pkg_idx < k->k_pkg_size)) {
 452                             k->k_package[k->k_pkg_idx++] = code;
 453                             if (k->k_pkg_idx == k->k_pkg_size) {
 454                                 /*
 455                                  * Package is complete.
 456                                  */
 457                                 switch (k->k_pkg_type) {
 458 #if NMOUSE > 0
 459                                     case KBD_AMS_PKG:
 460                                     case KBD_RMS_PKG:
 461                                     case KBD_JOY1_PKG:
 462                                         mouse_soft((REL_MOUSE *)k->k_package,
 463                                             k->k_pkg_size, k->k_pkg_type);
 464 #endif /* NMOUSE */
 465                                 }
 466                                 k->k_pkg_size = 0;
 467                             }
 468                             continue;
 469                         }
 470                         /*
 471                          * If this is a package header, init pkg. handling.
 472                          */
 473                         if (!KBD_IS_KEY(code)) {
 474                                 kbd_pkg_start(k, code);
 475                                 continue;
 476                         }
 477 #if NWSKBD>0
 478                         /*
 479                          * If we have attached a wskbd and not in polling mode
 480                          * and nobody has opened us directly, then send the
 481                          * keystroke to the wskbd.
 482                          */
 483
 484                         if (kbd_softc.k_pollingmode == 0
 485                             && kbd_softc.k_wskbddev != NULL
 486                             && k->k_event_mode == 0) {
 487                                 wskbd_input(kbd_softc.k_wskbddev,
 488                                             KBD_RELEASED(code) ?
 489                                             WSCONS_EVENT_KEY_UP :
 490                                             WSCONS_EVENT_KEY_DOWN,
 491                                             KBD_SCANCODE(code));
 492                                 continue;
 493                         }
 494 #endif /* NWSKBD */
 495 #if NITE>0
 496                         if (kbd_do_modifier(code) && !k->k_event_mode)
 497                                 continue;
 498 #endif
 499
 500                         /*
 501                          * if not in event mode, deliver straight to ite to
 502                          * process key stroke
 503                          */
 504                         if (!k->k_event_mode) {
 505                                 /* Gets to spltty() by itself   */
 506 #if NITE>0
 507                                 ite_filter(code, ITEFILT_TTY);
 508 #endif
 509                                 continue;
 510                         }
 511
 512                         /*
 513                          * Keyboard is generating events.  Turn this keystroke
 514                          * into an event and put it in the queue.  If the queue
 515                          * is full, the keystroke is lost (sorry!).
 516                          */
 517                         s = spltty();
 518                         put = k->k_events.ev_put;
 519                         fe  = &k->k_events.ev_q[put];
 520                         put = (put + 1) % EV_QSIZE;
 521                         if (put == k->k_events.ev_get) {
 522                                 log(LOG_WARNING,
 523                                     "keyboard event queue overflow\n");
 524                                 splx(s);
 525                                 continue;
 526                         }
 527                         fe->id    = KBD_SCANCODE(code);
 528                         fe->value = KBD_RELEASED(code) ? VKEY_UP : VKEY_DOWN;
 529                         firm_gettime(fe);
 530                         k->k_events.ev_put = put;
 531                         EV_WAKEUP(&k->k_events);
 532                         splx(s);
 533                 }
 534                 kbd_rbget = get;
 535         }
 536 }
 537
 538 static  uint8_t sound[] = {
 539         0xA8, 0x01, 0xA9, 0x01, 0xAA, 0x01, 0x00,
 540         0xF8, 0x10, 0x10, 0x10, 0x00, 0x20, 0x03
 541 };
 542
 543 void
 544 kbdbell(void)
 545 {
 546         register int    i, sps;
 547
 548         sps = splhigh();
 549         for (i = 0; i < sizeof(sound); i++) {
 550                 YM2149->sd_selr = i;
 551                 YM2149->sd_wdat = sound[i];
 552         }
 553         splx(sps);
 554 }
 555
 556
 557 /*
 558  * Set the parameters of the 'default' beep.
 559  */
 560
 561 #define KBDBELLCLOCK    125000  /* 2MHz / 16 */
 562 #define KBDBELLDURATION 128     /* 256 / 2MHz */
 563
 564 void
 565 kbd_bell_gparms(u_int *volume, u_int *pitch, u_int *duration)
 566 {
 567         u_int   tmp;
 568
 569         tmp = sound[11] | (sound[12] << 8);
 570         *duration = (tmp * KBDBELLDURATION) / 1000;
 571
 572         tmp = sound[0] | (sound[1] << 8);
 573         *pitch = KBDBELLCLOCK / tmp;
 574
 575         *volume = 0;
 576 }
 577
 578 void
 579 kbd_bell_sparms(u_int volume, u_int pitch, u_int duration)
 580 {
 581         u_int   f, t;
 582
 583         f = pitch > 10 ? pitch : 10;    /* minimum pitch */
 584         if (f > 20000)
 585                 f = 20000;              /* maximum pitch */
 586
 587         f = KBDBELLCLOCK / f;
 588
 589         t = (duration * 1000) / KBDBELLDURATION;
 590
 591         sound[ 0] = f & 0xff;
 592         sound[ 1] = (f >> 8) & 0xf;
 593         f -= 1;
 594         sound[ 2] = f & 0xff;
 595         sound[ 3] = (f >> 8) & 0xf;
 596         f += 2;
 597         sound[ 4] = f & 0xff;
 598         sound[ 5] = (f >> 8) & 0xf;
 599
 600         sound[11] = t & 0xff;
 601         sound[12] = (t >> 8) & 0xff;
 602
 603         sound[13] = 0x03;
 604 }
 605
 606 int
 607 kbdgetcn(void)
 608 {
 609         uint8_t code;
 610         int s = spltty();
 611         int ints_active;
 612
 613         ints_active = 0;
 614         if (MFP->mf_imrb & IB_AINT) {
 615                 ints_active   = 1;
 616                 MFP->mf_imrb &= ~IB_AINT;
 617         }
 618         for (;;) {
 619                 while (!((KBD->ac_cs & (A_IRQ|A_RXRDY)) == (A_IRQ|A_RXRDY)))
 620                         ;       /* Wait for key */
 621                 if (KBD->ac_cs & (A_OE|A_PE)) {
 622                         code = KBD->ac_da;      /* Silently ignore errors */
 623                         continue;
 624                 }
 625                 code = KBD->ac_da;
 626 #if NITE>0
 627                 if (!kbd_do_modifier(code))
 628 #endif
 629                         break;
 630         }
 631
 632         if (ints_active) {
 633                 MFP->mf_iprb  = (uint8_t)~IB_AINT;
 634                 MFP->mf_imrb |=  IB_AINT;
 635         }
 636
 637         splx(s);
 638         return code;
 639 }
 640
 641 /*
 642  * Write a command to the keyboard in 'polled' mode.
 643  */
 644 static int
 645 kbd_write_poll(const uint8_t *cmd, int len)
 646 {
 647         int     timeout;
 648
 649         while (len-- > 0) {
 650                 KBD->ac_da = *cmd++;
 651                 for (timeout = 100; !(KBD->ac_cs & A_TXRDY); timeout--)
 652                         delay(10);
 653                 if ((KBD->ac_cs & A_TXRDY) == 0)
 654                         return 0;
 655         }
 656         return 1;
 657 }
 658
 659 /*
 660  * Write a command to the keyboard. Return when command is send.
 661  */
 662 void
 663 kbd_write(const uint8_t *cmd, int len)
 664 {
 665         struct kbd_softc        *k = &kbd_softc;
 666         int                     sps;
 667
 668         /*
 669          * Get to splhigh, 'real' interrupts arrive at spl6!
 670          */
 671         sps = splhigh();
 672
 673         /*
 674          * Make sure any privious write has ended...
 675          */
 676         while (k->k_sendp != NULL)
 677                 tsleep((void *)&k->k_sendp, TTOPRI, "kbd_write1", 0);
 678
 679         /*
 680          * If the KBD-acia is not currently busy, send the first
 681          * character now.
 682          */
 683         KBD->ac_cs = (k->k_soft_cs |= A_TXINT);
 684         if (KBD->ac_cs & A_TXRDY) {
 685                 KBD->ac_da = *cmd++;
 686                 len--;
 687         }
 688
 689         /*
 690          * If we're not yet done, wait until all characters are send.
 691          */
 692         if (len > 0) {
 693                 k->k_sendp    = cmd;
 694                 k->k_send_cnt = len;
 695                 tsleep((void *)&k->k_send_cnt, TTOPRI, "kbd_write2", 0);
 696         }
 697         splx(sps);
 698
 699         /*
 700          * Wakeup all procs waiting for us.
 701          */
 702         wakeup((void *)&k->k_sendp);
 703 }
 704
 705 /*
 706  * Setup softc-fields to assemble a keyboard package.
 707  */
 708 static void
 709 kbd_pkg_start(struct kbd_softc *kp, uint8_t msg_start)
 710 {
 711
 712         kp->k_pkg_idx    = 1;
 713         kp->k_package[0] = msg_start;
 714         switch (msg_start) {
 715                 case 0xf6:
 716                         kp->k_pkg_type = KBD_MEM_PKG;
 717                         kp->k_pkg_size = 8;
 718                         break;
 719                 case 0xf7:
 720                         kp->k_pkg_type = KBD_AMS_PKG;
 721                         kp->k_pkg_size = 6;
 722                         break;
 723                 case 0xf8:
 724                 case 0xf9:
 725                 case 0xfa:
 726                 case 0xfb:
 727                         kp->k_pkg_type = KBD_RMS_PKG;
 728                         kp->k_pkg_size = 3;
 729                         break;
 730                 case 0xfc:
 731                         kp->k_pkg_type = KBD_CLK_PKG;
 732                         kp->k_pkg_size = 7;
 733                         break;
 734                 case 0xfe:
 735                         kp->k_pkg_type = KBD_JOY0_PKG;
 736                         kp->k_pkg_size = 2;
 737                         break;
 738                 case 0xff:
 739                         kp->k_pkg_type = KBD_JOY1_PKG;
 740                         kp->k_pkg_size = 2;
 741                         break;
 742                 default:
 743                         printf("kbd: Unknown packet 0x%x\n", msg_start);
 744                         break;
 745         }
 746 }
 747
 748 #if NITE > 0
 749 /*
 750  * Modifier processing
 751  */
 752 static int
 753 kbd_do_modifier(uint8_t code)
 754 {
 755         uint8_t up, mask;
 756
 757         up   = KBD_RELEASED(code);
 758         mask = 0;
 759
 760         switch (KBD_SCANCODE(code)) {
 761                 case KBD_LEFT_SHIFT:
 762                         mask = KBD_MOD_LSHIFT;
 763                         break;
 764                 case KBD_RIGHT_SHIFT:
 765                         mask = KBD_MOD_RSHIFT;
 766                         break;
 767                 case KBD_CTRL:
 768                         mask = KBD_MOD_CTRL;
 769                         break;
 770                 case KBD_ALT:
 771                         mask = KBD_MOD_ALT;
 772                         break;
 773                 case KBD_CAPS_LOCK:
 774                         /* CAPSLOCK is a toggle */
 775                         if (!up)
 776                                 kbd_modifier ^= KBD_MOD_CAPS;
 777                         return 1;
 778         }
 779         if (mask) {
 780                 if(up)
 781                         kbd_modifier &= ~mask;
 782                 else
 783                         kbd_modifier |= mask;
 784                 return 1;
 785         }
 786         return 0;
 787 }
 788 #endif
 789
 790 #if NWSKBD>0
 791 /*
 792  * These are the callback functions that are passed to wscons.
 793  * They really don't do anything worth noting, just call the
 794  * other functions above.
 795  */
 796
 797 static int
 798 kbd_enable(void *c, int on)
 799 {
 800
 801         /* Wonder what this is supposed to do... */
 802         return 0;
 803 }
 804
 805 static void
 806 kbd_set_leds(void *c, int leds)
 807 {
 808
 809         /* we can not set the leds */
 810 }
 811
 812 static int
 813 kbd_ioctl(void *c, u_long cmd, void *data, int flag, struct lwp *p)
 814 {
 815         struct wskbd_bell_data *kd;
 816
 817         switch (cmd) {
 818         case WSKBDIO_COMPLEXBELL:
 819                 kd = (struct wskbd_bell_data *)data;
 820                 kbd_bell(0, kd->pitch, kd->period, kd->volume);
 821                 return 0;
 822         case WSKBDIO_SETLEDS:
 823                 return 0;
 824         case WSKBDIO_GETLEDS:
 825                 *(int *)data = 0;
 826                 return 0;
 827         case WSKBDIO_GTYPE:
 828                 *(u_int *)data = WSKBD_TYPE_ATARI;
 829                 return 0;
 830         }
 831
 832         /*
 833          * We are supposed to return EPASSTHROUGH to wscons if we didn't
 834          * understand.
 835          */
 836         return EPASSTHROUGH;
 837 }
 838
 839 static void
 840 kbd_getc(void *c, u_int *type, int *data)
 841 {
 842         int key;
 843         key = kbdgetcn();
 844
 845         *data = KBD_SCANCODE(key);
 846         *type = KBD_RELEASED(key) ? WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN;
 847 }
 848
 849 static void
 850 kbd_pollc(void *c, int on)
 851 {
 852
 853         kbd_softc.k_pollingmode = on;
 854 }
 855
 856 static void
 857 kbd_bell(void *v, u_int pitch, u_int duration, u_int volume)
 858 {
 859
 860         kbd_bell_sparms(volume, pitch, duration);
 861         kbdbell();
 862 }
 863 #endif /* NWSKBD */