sys/arch/amiga/dev/kbd.c

   1 /*      $NetBSD: kbd.c,v 1.52 2009/03/14 15:36:01 dsl Exp $ */
   2
   3 /*
   4  * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      kbd.c
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __KERNEL_RCSID(0, "$NetBSD: kbd.c,v 1.52 2009/03/14 15:36:01 dsl Exp $");
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/device.h>
  40 #include <sys/ioctl.h>
  41 #include <sys/tty.h>
  42 #include <sys/proc.h>
  43 #include <sys/file.h>
  44 #include <sys/kernel.h>
  45 #include <sys/syslog.h>
  46 #include <sys/signalvar.h>
  47 #include <sys/conf.h>
  48 #include <dev/cons.h>
  49 #include <machine/cpu.h>
  50 #include <amiga/amiga/device.h>
  51 #include <amiga/amiga/custom.h>
  52 #ifdef DRACO
  53 #include <m68k/asm_single.h>
  54 #include <amiga/amiga/drcustom.h>
  55 #endif
  56 #include <amiga/amiga/cia.h>
  57 #include <amiga/dev/itevar.h>
  58 #include <amiga/dev/kbdreg.h>
  59 #include <amiga/dev/kbdmap.h>
  60 #include <amiga/dev/kbdvar.h>
  61 #include <amiga/dev/event_var.h>
  62 #include <amiga/dev/vuid_event.h>
  63
  64 #include "kbd.h"
  65 #include "ite.h"
  66
  67 /* WSKBD */
  68
  69 /*
  70  * If NWSKBD>0 we try to attach an wskbd device to us. What follows
  71  * is definitions of callback functions and structures that are passed
  72  * to wscons when initializing.
  73  */
  74
  75 /*
  76  * Now with wscons this driver exhibits some weird behaviour.
  77  * It may act both as a driver of its own and the md part of the
  78  * wskbd driver. Therefore it can be accessed through /dev/kbd
  79  * and /dev/wskbd0 both.
  80  *
  81  * The data from they keyboard may end up in at least four different
  82  * places:
  83  * - If this driver has been opened (/dev/kbd) and the
  84  *   direct mode (TIOCDIRECT) has been set, data goes to
  85  *   the process who opened the device. Data will transmit itself
  86  *   as described by the firm_event structure.
  87  * - If wskbd support is compiled in and a wskbd driver has been
  88  *   attached then the data is sent to it. Wskbd in turn may
  89  *   - Send the data in the wscons_event form to a process that
  90  *     has opened /dev/wskbd0
  91  *   - Feed the data to a virtual terminal.
  92  * - If an ite is present the data may be fed to it.
  93  */
  94
  95 #include "wskbd.h"
  96
  97 #if NWSKBD>0
  98 #include <dev/wscons/wsconsio.h>
  99 #include <dev/wscons/wskbdvar.h>
 100 #include <dev/wscons/wsksymdef.h>
 101 #include <dev/wscons/wsksymvar.h>
 102 #include <amiga/dev/wskbdmap_amiga.h>
 103
 104 /* accessops */
 105 int     kbd_enable(void *, int);
 106 void    kbd_set_leds(void *, int);
 107 int     kbd_ioctl(void *, u_long, void *, int, struct lwp *);
 108
 109 /* console ops */
 110 void    kbd_getc(void *, u_int *, int *);
 111 void    kbd_pollc(void *, int);
 112 void    kbd_bell(void *, u_int, u_int, u_int);
 113
 114 static struct wskbd_accessops kbd_accessops = {
 115         kbd_enable,
 116         kbd_set_leds,
 117         kbd_ioctl
 118 };
 119
 120 static struct wskbd_consops kbd_consops = {
 121         kbd_getc,
 122         kbd_pollc,
 123         kbd_bell
 124 };
 125
 126 /*
 127  * Pointer to keymaps. They are defined in wskbdmap_amiga.c.
 128  */
 129 static struct wskbd_mapdata kbd_mapdata = {
 130         amigakbd_keydesctab,
 131         KB_US
 132 };
 133
 134 #endif /* WSKBD */
 135
 136 struct kbd_softc {
 137         int k_event_mode;       /* if true, collect events, else pass to ite */
 138         struct evvar k_events;  /* event queue state */
 139 #ifdef DRACO
 140         u_char k_rlprfx;        /* MF-II rel. prefix has been seen */
 141         u_char k_mf2;
 142 #endif
 143
 144         int k_console;          /* true if used as console keyboard */
 145 #if NWSKBD>0
 146         struct device *k_wskbddev; /* pointer to wskbd for sending strokes */
 147         int k_pollingmode;         /* polling mode on? whatever it isss... */
 148 #endif
 149 };
 150 struct kbd_softc kbd_softc;
 151
 152 int kbdmatch(struct device *, struct cfdata *, void *);
 153 void kbdattach(struct device *, struct device *, void *);
 154 void kbdintr(int);
 155 void kbdstuffchar(u_char);
 156
 157 int drkbdgetc(void);
 158 int drkbdrputc(u_int8_t);
 159 int drkbdputc(u_int8_t);
 160 int drkbdputc2(u_int8_t, u_int8_t);
 161 int drkbdwaitfor(int);
 162
 163 CFATTACH_DECL(kbd, sizeof(struct device),
 164     kbdmatch, kbdattach, NULL, NULL);
 165
 166 dev_type_open(kbdopen);
 167 dev_type_close(kbdclose);
 168 dev_type_read(kbdread);
 169 dev_type_ioctl(kbdioctl);
 170 dev_type_poll(kbdpoll);
 171 dev_type_kqfilter(kbdkqfilter);
 172
 173 const struct cdevsw kbd_cdevsw = {
 174         kbdopen, kbdclose, kbdread, nowrite, kbdioctl,
 175         nostop, notty, kbdpoll, nommap, kbdkqfilter,
 176 };
 177
 178 /*ARGSUSED*/
 179 int
 180 kbdmatch(struct device *pdp, struct cfdata *cfp, void *auxp)
 181 {
 182
 183         if (matchname((char *)auxp, "kbd"))
 184                 return(1);
 185         return(0);
 186 }
 187
 188 /*ARGSUSED*/
 189 void
 190 kbdattach(struct device *pdp, struct device *dp, void *auxp)
 191 {
 192 #ifdef DRACO
 193         kbdenable();
 194         if (kbd_softc.k_mf2)
 195                 printf(": QuickLogic type MF-II\n");
 196         else
 197                 printf(": CIA A type Amiga\n");
 198 #else
 199         printf(": CIA A type Amiga\n");
 200 #endif
 201
 202 #if NWSKBD>0
 203         if (dp != NULL) {
 204                 /*
 205                  * Try to attach the wskbd.
 206                  */
 207                 struct wskbddev_attach_args waa;
 208                 waa.console = kbd_softc.k_console;
 209                 waa.keymap = &kbd_mapdata;
 210                 waa.accessops = &kbd_accessops;
 211                 waa.accesscookie = NULL;
 212                 kbd_softc.k_wskbddev = config_found(dp, &waa, wskbddevprint);
 213
 214                 kbd_softc.k_pollingmode = 0;
 215         }
 216         kbdenable();
 217 #endif /* WSKBD */
 218 }
 219
 220 /*
 221  * This is called when somebody wants to use kbd as the console keyboard.
 222  */
 223 void
 224 kbd_cnattach(void)
 225 {
 226 #if NWSKBD>0
 227         wskbd_cnattach(&kbd_consops, NULL, &kbd_mapdata);
 228         kbd_softc.k_console = 1;
 229 #endif
 230 }
 231
 232 /* definitions for amiga keyboard encoding. */
 233 #define KEY_CODE(c)  ((c) & 0x7f)
 234 #define KEY_UP(c)    ((c) & 0x80)
 235
 236 #define DATLO single_inst_bclr_b(draco_ioct->io_control, DRCNTRL_KBDDATOUT)
 237 #define DATHI single_inst_bset_b(draco_ioct->io_control, DRCNTRL_KBDDATOUT)
 238
 239 #define CLKLO single_inst_bclr_b(draco_ioct->io_control, DRCNTRL_KBDCLKOUT)
 240 #define CLKHI single_inst_bset_b(draco_ioct->io_control, DRCNTRL_KBDCLKOUT)
 241
 242 void
 243 kbdenable(void)
 244 {
 245         static int kbd_inited = 0;
 246
 247         int s;
 248
 249 #ifdef DRACO
 250         int id;
 251 #endif
 252         /*
 253          * collides with external ints from SCSI, watch out for this when
 254          * enabling/disabling interrupts there !!
 255          */
 256         s = splhigh();  /* don't lower; might be called from early ddb */
 257         if (kbd_inited) {
 258                 splx(s);
 259                 return;
 260         }
 261         kbd_inited = 1;
 262 #ifdef DRACO
 263         if (is_draco()) {
 264
 265                 CLKLO;
 266                 delay(5000);
 267                 draco_ioct->io_kbdrst = 0;
 268
 269                 if (drkbdputc(0xf2))
 270                         goto LnoMFII;
 271
 272                 id = drkbdgetc() << 8;
 273                 id |= drkbdgetc();
 274
 275                 if (id != 0xab83)
 276                         goto LnoMFII;
 277
 278                 if (drkbdputc2(0xf0, 3))        /* mode 3 */
 279                         goto LnoMFII;
 280
 281                 if (drkbdputc(0xf8))            /* make/break, no typematic */
 282                         goto LnoMFII;
 283
 284                 if (drkbdputc(0xf4))            /* enable */
 285                         goto LnoMFII;
 286                 kbd_softc.k_mf2 = 1;
 287                 single_inst_bclr_b(draco_ioct->io_control, DRCNTRL_KBDINTENA);
 288
 289                 ciaa.icr = CIA_ICR_SP;  /* CIA SP interrupt disable */
 290                 ciaa.cra &= ~(1<<6);    /* serial line == input */
 291                 splx(s);
 292                 return;
 293
 294         LnoMFII:
 295                 kbd_softc.k_mf2 = 0;
 296                 single_inst_bset_b(*draco_intena, DRIRQ_INT2);
 297                 ciaa.icr = CIA_ICR_IR_SC | CIA_ICR_SP;
 298                                         /* SP interrupt enable */
 299                 ciaa.cra &= ~(1<<6);    /* serial line == input */
 300                 splx(s);
 301                 return;
 302
 303         } else {
 304 #endif
 305         custom.intena = INTF_SETCLR | INTF_PORTS;
 306         ciaa.icr = CIA_ICR_IR_SC | CIA_ICR_SP;  /* SP interrupt enable */
 307         ciaa.cra &= ~(1<<6);            /* serial line == input */
 308 #ifdef DRACO
 309         }
 310 #endif
 311         kbd_softc.k_event_mode = 0;
 312         kbd_softc.k_events.ev_io = 0;
 313         splx(s);
 314 }
 315
 316 #ifdef DRACO
 317 /*
 318  * call this with kbd interrupt blocked
 319  */
 320
 321 int
 322 drkbdgetc(void)
 323 {
 324         u_int8_t in;
 325
 326         while ((draco_ioct->io_status & DRSTAT_KBDRECV) == 0);
 327         in = draco_ioct->io_kbddata;
 328         draco_ioct->io_kbdrst = 0;
 329
 330         return in;
 331 }
 332
 333 #define WAIT0 if (drkbdwaitfor(0)) goto Ltimeout
 334 #define WAIT1 if (drkbdwaitfor(DRSTAT_KBDCLKIN)) goto Ltimeout
 335
 336 int
 337 drkbdwaitfor(int bit)
 338 {
 339         int i;
 340
 341
 342
 343         i = 60000;      /* about 50 ms max */
 344
 345         do {
 346                 if ((draco_ioct->io_status & DRSTAT_KBDCLKIN) == bit)
 347                         return 0;
 348
 349         } while (--i >= 0);
 350
 351         return 1;
 352 }
 353
 354 /*
 355  * Output a raw byte to the keyboard (+ parity and stop bit).
 356  * return 0 on success, 1 on timeout.
 357  */
 358 int
 359 drkbdrputc(u_int8_t c)
 360 {
 361         u_int8_t parity;
 362         int bitcnt;
 363
 364         DATLO; CLKHI; WAIT1;
 365         parity = 0;
 366
 367         for (bitcnt=7; bitcnt >= 0; bitcnt--) {
 368                 WAIT0;
 369                 if (c & 1) {
 370                         DATHI;
 371                 } else {
 372                         ++parity;
 373                         DATLO;
 374                 }
 375                 c >>= 1;
 376                 WAIT1;
 377         }
 378         WAIT0;
 379         /* parity bit */
 380         if (parity & 1) {
 381                 DATLO;
 382         } else {
 383                 DATHI;
 384         }
 385         WAIT1;
 386         /* stop bit */
 387         WAIT0; DATHI; WAIT1;
 388
 389         WAIT0; /* XXX should check the ack bit here... */
 390         WAIT1;
 391         draco_ioct->io_kbdrst = 0;
 392         return 0;
 393
 394 Ltimeout:
 395         DATHI;
 396         draco_ioct->io_kbdrst = 0;
 397         return 1;
 398 }
 399
 400 /*
 401  * Output one cooked byte to the keyboard, with wait for ACK or RESEND,
 402  * and retry if necessary. 0 == success, 1 == timeout
 403  */
 404 int
 405 drkbdputc(u_int8_t c)
 406 {
 407         int rc;
 408
 409         do {
 410                 if (drkbdrputc(c))
 411                         return(-1);
 412
 413                 rc = drkbdgetc();
 414         } while (rc == 0xfe);
 415         return (!(rc == 0xfa));
 416 }
 417
 418 /*
 419  * same for twobyte sequence
 420  */
 421
 422 int
 423 drkbdputc2(u_int8_t c1, u_int8_t c2)
 424 {
 425         int rc;
 426
 427         do {
 428                 do {
 429                         if (drkbdrputc(c1))
 430                                 return(-1);
 431
 432                         rc = drkbdgetc();
 433                 } while (rc == 0xfe);
 434                 if (rc != 0xfa)
 435                         return (-1);
 436
 437                 if (drkbdrputc(c2))
 438                         return(-1);
 439
 440                 rc = drkbdgetc();
 441         } while (rc == 0xfe);
 442         return (!(rc == 0xfa));
 443 }
 444 #endif
 445
 446 int
 447 kbdopen(dev_t dev, int flags, int mode, struct lwp *l)
 448 {
 449
 450         kbdenable();
 451         if (kbd_softc.k_events.ev_io)
 452                 return EBUSY;
 453
 454         kbd_softc.k_events.ev_io = l->l_proc;
 455         ev_init(&kbd_softc.k_events);
 456         return (0);
 457 }
 458
 459 int
 460 kbdclose(dev_t dev, int flags, int mode, struct lwp *l)
 461 {
 462
 463         /* Turn off event mode, dump the queue */
 464         kbd_softc.k_event_mode = 0;
 465         ev_fini(&kbd_softc.k_events);
 466         kbd_softc.k_events.ev_io = NULL;
 467         return (0);
 468 }
 469
 470 int
 471 kbdread(dev_t dev, struct uio *uio, int flags)
 472 {
 473         return ev_read (&kbd_softc.k_events, uio, flags);
 474 }
 475
 476 int
 477 kbdioctl(dev_t dev, u_long cmd, register void *data, int flag,
 478          struct lwp *l)
 479 {
 480         register struct kbd_softc *k = &kbd_softc;
 481
 482         switch (cmd) {
 483                 case KIOCTRANS:
 484                         if (*(int *)data == TR_UNTRANS_EVENT)
 485                                 return 0;
 486                         break;
 487
 488                 case KIOCGTRANS:
 489                         /* Get translation mode */
 490                         *(int *)data = TR_UNTRANS_EVENT;
 491                         return 0;
 492
 493                 case KIOCSDIRECT:
 494                         k->k_event_mode = *(int *)data;
 495                         return 0;
 496
 497                 case FIONBIO:   /* we will remove this someday (soon???) */
 498                         return 0;
 499
 500                 case FIOASYNC:
 501                         k->k_events.ev_async = *(int *)data != 0;
 502                         return 0;
 503
 504                 case FIOSETOWN:
 505                         if (-*(int *)data != k->k_events.ev_io->p_pgid
 506                             && *(int *)data != k->k_events.ev_io->p_pid)
 507                                 return EPERM;
 508                         return 0;
 509
 510                 case TIOCSPGRP:
 511                         if (*(int *)data != k->k_events.ev_io->p_pgid)
 512                                 return EPERM;
 513                         return 0;
 514
 515                 default:
 516                         return ENOTTY;
 517         }
 518
 519         /* We identified the ioctl, but we do not handle it. */
 520         return EOPNOTSUPP;      /* misuse, but what the heck */
 521 }
 522
 523 int
 524 kbdpoll(dev_t dev, int events, struct lwp *l)
 525 {
 526         return ev_poll (&kbd_softc.k_events, events, l);
 527 }
 528
 529 int
 530 kbdkqfilter(dev_t dev, struct knote *kn)
 531 {
 532
 533         return (ev_kqfilter(&kbd_softc.k_events, kn));
 534 }
 535
 536 void
 537 kbdintr(int mask)
 538 {
 539         u_char c;
 540 #ifdef KBDRESET
 541         static int reset_warn;
 542 #endif
 543
 544         /*
 545          * now only invoked from generic CIA interrupt handler if there *is*
 546          * a keyboard interrupt pending
 547          */
 548
 549         c = ~ciaa.sdr;  /* keyboard data is inverted */
 550         /* ack */
 551         ciaa.cra |= (1 << 6);   /* serial line output */
 552 #ifdef KBDRESET
 553         if (reset_warn && c == 0xf0) {
 554 #ifdef DEBUG
 555                 printf ("kbdintr: !!!! Reset Warning !!!!\n");
 556 #endif
 557                 bootsync();
 558                 reset_warn = 0;
 559                 DELAY(30000000);
 560         }
 561 #endif
 562         /* wait 200 microseconds (for bloody Cherry keyboards..) */
 563         DELAY(200);                     /* fudge delay a bit for some keyboards */
 564         ciaa.cra &= ~(1 << 6);
 565
 566         /* process the character */
 567         c = (c >> 1) | (c << 7);        /* rotate right once */
 568
 569 #ifdef KBDRESET
 570         if (c == 0x78) {
 571 #ifdef DEBUG
 572                 printf ("kbdintr: Reset Warning started\n");
 573 #endif
 574                 ++reset_warn;
 575                 return;
 576         }
 577 #endif
 578         kbdstuffchar(c);
 579 }
 580
 581 #ifdef DRACO
 582 /* maps MF-II keycodes to Amiga keycodes */
 583
 584 const u_char drkbdtab[] = {
 585         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50,
 586         0x45, 0xff, 0xff, 0xff, 0xff, 0x42, 0x00, 0x51,
 587
 588         0xff, 0x64, 0x60, 0x30, 0x63, 0x10, 0x01, 0x52,
 589         0xff, 0x66, 0x31, 0x21, 0x20, 0x11, 0x02, 0x53,
 590
 591         0xff, 0x33, 0x32, 0x22, 0x12, 0x04, 0x03, 0x54,
 592         0xff, 0x40, 0x34, 0x23, 0x14, 0x13, 0x05, 0x55,
 593
 594         0xff, 0x36, 0x35, 0x25, 0x24, 0x15, 0x06, 0x56,
 595         0xff, 0x67, 0x37, 0x26, 0x16, 0x07, 0x08, 0x57,
 596         /* --- */
 597         0xff, 0x38, 0x27, 0x17, 0x18, 0x0a, 0x09, 0x58,
 598         0xff, 0x39, 0x3a, 0x28, 0x29, 0x19, 0x0b, 0x59,
 599
 600         0xff, 0xff, 0x2a, 0x2b, 0x1a, 0x0c, 0x4b, 0xff,
 601         0x65, 0x61, 0x44, 0x1b, 0xff, 0xff, 0x6f, 0xff,
 602
 603         0x4d, 0x4f, 0xff, 0x4c, 0x0d, 0xff, 0x41, 0x46,
 604         0xff, 0x1d, 0x4e, 0x2d, 0x3d, 0x4a, 0x5f, 0x62,
 605
 606         0x0f, 0x3c, 0x1e, 0x2e, 0x2f, 0x3e, 0x5a, 0x5b,
 607         0xff, 0x43, 0x1f, 0xff, 0x5e, 0x3f, 0x5c, 0xff,
 608         /* --- */
 609         0xff, 0xff, 0xff, 0xff, 0x5d
 610 };
 611 #endif
 612
 613
 614 int
 615 kbdgetcn(void)
 616 {
 617         int s;
 618         u_char ints, mask, c, in;
 619
 620 #ifdef DRACO
 621         if (is_draco() && kbd_softc.k_mf2) {
 622                 do {
 623                         c = 0;
 624                         s = spltty ();
 625                         while ((draco_ioct->io_status & DRSTAT_KBDRECV) == 0);
 626                         in = draco_ioct->io_kbddata;
 627                         draco_ioct->io_kbdrst = 0;
 628                         if (in == 0xF0) { /* release prefix */
 629                                 c = 0x80;
 630                                 while ((draco_ioct->io_status &
 631                                     DRSTAT_KBDRECV) == 0);
 632                                 in = draco_ioct->io_kbddata;
 633                                 draco_ioct->io_kbdrst = 0;
 634                         }
 635                         splx(s);
 636 #ifdef DRACORAWKEYDEBUG
 637                         printf("<%02x>", in);
 638 #endif
 639                         c |= in>=sizeof(drkbdtab) ? 0xff : drkbdtab[in];
 640                 } while (c == 0xff);
 641                 return (c);
 642         }
 643 #endif
 644         s = spltty();
 645         for (ints = 0; ! ((mask = ciaa.icr) & CIA_ICR_SP);
 646             ints |= mask) ;
 647
 648         in = ciaa.sdr;
 649         c = ~in;
 650
 651         /* ack */
 652         ciaa.cra |= (1 << 6);   /* serial line output */
 653         ciaa.sdr = 0xff;        /* ack */
 654         /* wait 200 microseconds */
 655         DELAY(200);     /* XXXX only works as long as DELAY doesn't
 656                          * use a timer and waits.. */
 657         ciaa.cra &= ~(1 << 6);
 658         ciaa.sdr = in;
 659
 660         splx (s);
 661         c = (c >> 1) | (c << 7);
 662
 663         /* take care that no CIA-interrupts are lost */
 664         if (ints)
 665                 dispatch_cia_ints (0, ints);
 666
 667         return c;
 668 }
 669
 670 void
 671 kbdstuffchar(u_char c)
 672 {
 673         struct firm_event *fe;
 674         struct kbd_softc *k = &kbd_softc;
 675         int put;
 676
 677 #if NWSKBD>0
 678         /*
 679          * If we have attached a wskbd and not in polling mode and
 680          * nobody has opened us directly, then send the keystroke
 681          * to the wskbd.
 682          */
 683
 684         if (kbd_softc.k_pollingmode == 0
 685             && kbd_softc.k_wskbddev != NULL
 686             && k->k_event_mode == 0) {
 687                 wskbd_input(kbd_softc.k_wskbddev,
 688                             KEY_UP(c) ?
 689                             WSCONS_EVENT_KEY_UP :
 690                             WSCONS_EVENT_KEY_DOWN,
 691                             KEY_CODE(c));
 692                 return;
 693         }
 694
 695 #endif /* NWSKBD */
 696
 697         /*
 698          * If not in event mode, deliver straight to ite to process
 699          * key stroke
 700          */
 701
 702         if (! k->k_event_mode) {
 703 #if NITE>0
 704                 ite_filter (c, ITEFILT_TTY);
 705 #endif
 706                 return;
 707         }
 708
 709         /*
 710          * Keyboard is generating events. Turn this keystroke into an
 711          * event and put it in the queue. If the queue is full, the
 712          * keystroke is lost (sorry!).
 713          */
 714
 715         put = k->k_events.ev_put;
 716         fe = &k->k_events.ev_q[put];
 717         put = (put + 1) % EV_QSIZE;
 718         if (put == k->k_events.ev_get) {
 719                 log(LOG_WARNING, "keyboard event queue overflow\n");
 720                         /* ??? */
 721                 return;
 722         }
 723         fe->id = KEY_CODE(c);
 724         fe->value = KEY_UP(c) ? VKEY_UP : VKEY_DOWN;
 725         firm_gettime(fe);
 726         k->k_events.ev_put = put;
 727         EV_WAKEUP(&k->k_events);
 728 }
 729
 730
 731 #ifdef DRACO
 732 void
 733 drkbdintr(void)
 734 {
 735         u_char in;
 736         struct kbd_softc *k = &kbd_softc;
 737
 738         in = draco_ioct->io_kbddata;
 739         draco_ioct->io_kbdrst = 0;
 740
 741         if (in == 0xF0)
 742                 k->k_rlprfx = 0x80;
 743         else {
 744                 kbdstuffchar(in>=sizeof(drkbdtab) ? 0xff :
 745                     drkbdtab[in] | k->k_rlprfx);
 746                 k->k_rlprfx = 0;
 747         }
 748 }
 749
 750 #endif
 751
 752
 753 #if NWSKBD>0
 754 /*
 755  * These are the callback functions that are passed to wscons.
 756  * They really don't do anything worth noting, just call the
 757  * other functions above.
 758  */
 759
 760 int
 761 kbd_enable(void *c, int on)
 762 {
 763         /* Wonder what this is supposed to do... */
 764         return (0);
 765 }
 766
 767 void
 768 kbd_set_leds(void *c, int leds)
 769 {
 770 }
 771
 772 int
 773 kbd_ioctl(void *c, u_long cmd, void *data, int flag, struct lwp *l)
 774 {
 775         switch (cmd)
 776         {
 777         case WSKBDIO_COMPLEXBELL:
 778                 return 0;
 779         case WSKBDIO_SETLEDS:
 780                 return 0;
 781         case WSKBDIO_GETLEDS:
 782                 *(int*)data = 0;
 783                 return 0;
 784         case WSKBDIO_GTYPE:
 785                 *(u_int*)data = WSKBD_TYPE_AMIGA;
 786                 return 0;
 787         }
 788
 789         /*
 790          * We are supposed to return EPASSTHROUGH to wscons if we didn't
 791          * understand.
 792          */
 793         return (EPASSTHROUGH);
 794 }
 795
 796 void
 797 kbd_getc(void *c, u_int *type, int *data)
 798 {
 799         int key;
 800
 801         key = kbdgetcn();
 802
 803         *data = KEY_CODE(key);
 804         *type = KEY_UP(key) ? WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN;
 805 }
 806
 807 void
 808 kbd_pollc(void *c, int on)
 809 {
 810         kbd_softc.k_pollingmode = on;
 811 }
 812
 813 void
 814 kbd_bell(void *c, u_int x, u_int y, u_int z)
 815 {
 816 }
 817 #endif /* WSKBD */