![[BACK]](/icons/back.gif){kind=icon}
Return to dnkbd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / dev|
Return to dnkbd.c CVS log | Up to [local] / sys / arch / hp300 / dev |
1.1 ! nbrk 1: /* $OpenBSD: dnkbd.c,v 1.15 2007/04/10 22:37:14 miod Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2005, Miodrag Vallat
! 5: * Copyright (c) 1997 Michael Smith. 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: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 17: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 18: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 19: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 20: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 26: * SUCH DAMAGE.
! 27: */
! 28:
! 29: /*
! 30: * Driver for the Apollo Domain keyboard and mouse.
! 31: */
! 32:
! 33: #include <sys/param.h>
! 34: #include <sys/systm.h>
! 35: #include <sys/device.h>
! 36: #include <sys/ioctl.h>
! 37: #include <sys/kernel.h>
! 38: #include <sys/timeout.h>
! 39:
! 40: #include <machine/autoconf.h>
! 41: #include <machine/bus.h>
! 42: #include <machine/cpu.h>
! 43:
! 44: #include <dev/cons.h>
! 45:
! 46: #include <dev/wscons/wsconsio.h>
! 47: #include <dev/wscons/wskbdvar.h>
! 48: #include <dev/wscons/wsksymdef.h>
! 49: #include <dev/wscons/wsksymvar.h>
! 50: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 51: #include <dev/wscons/wskbdraw.h>
! 52: #endif
! 53: #include "wsmouse.h"
! 54: #if NWSMOUSE > 0
! 55: #include <dev/wscons/wsmousevar.h>
! 56: #endif
! 57:
! 58: #include <hp300/dev/apcireg.h>
! 59: #include <hp300/dev/apcivar.h>
! 60: #include <hp300/dev/dcareg.h>
! 61: #include <hp300/dev/dnkbdmap.h>
! 62: #include <hp300/dev/frodoreg.h>
! 63: #include <hp300/dev/frodovar.h>
! 64:
! 65: #include "hilkbd.h"
! 66:
! 67: /*
! 68: * Keyboard key codes
! 69: */
! 70:
! 71: #define DNKEY_CAPSLOCK 0x7e
! 72: #define DNKEY_REPEAT 0x7f
! 73: #define DNKEY_RELEASE 0x80
! 74: #define DNKEY_CHANNEL 0xff
! 75:
! 76: /*
! 77: * Channels
! 78: */
! 79:
! 80: #define DNCHANNEL_RESET 0x00
! 81: #define DNCHANNEL_KBD 0x01
! 82: #define DNCHANNEL_MOUSE 0x02
! 83:
! 84: /*
! 85: * Keyboard modes
! 86: */
! 87:
! 88: #define DNMODE_COOKED 0x00
! 89: #define DNMODE_RAW 0x01
! 90:
! 91: /*
! 92: * Keyboard commands
! 93: */
! 94:
! 95: #define DNCMD_PREFIX 0xff
! 96: #define DNCMD_COOKED DNMODE_COOKED
! 97: #define DNCMD_RAW DNMODE_RAW
! 98: #define DNCMD_IDENT_1 0x12
! 99: #define DNCMD_IDENT_2 0x21
! 100:
! 101: /*
! 102: * Bell commands
! 103: */
! 104:
! 105: #define DNCMD_BELL 0x21
! 106: #define DNCMD_BELL_ON 0x81
! 107: #define DNCMD_BELL_OFF 0x82
! 108:
! 109: /*
! 110: * Mouse status
! 111: */
! 112:
! 113: #define DNBUTTON_L 0x10
! 114: #define DNBUTTON_R 0x20
! 115: #define DNBUTTON_M 0x40
! 116:
! 117: struct dnkbd_softc {
! 118: struct device sc_dev;
! 119: struct isr sc_isr;
! 120: struct apciregs *sc_regs;
! 121:
! 122: int sc_flags;
! 123: #define SF_ENABLED 0x01 /* keyboard enabled */
! 124: #define SF_CONSOLE 0x02 /* keyboard is console */
! 125: #define SF_POLLING 0x04 /* polling mode */
! 126: #define SF_PLUGGED 0x08 /* keyboard has been seen plugged */
! 127: #define SF_ATTACHED 0x10 /* subdevices have been attached */
! 128: #define SF_MOUSE 0x20 /* mouse enabled */
! 129: #define SF_BELL 0x40 /* bell is active */
! 130: #define SF_BELL_TMO 0x80 /* bell stop timeout is scheduled */
! 131:
! 132: u_int sc_identlen;
! 133: #define MAX_IDENTLEN 32
! 134: char sc_ident[MAX_IDENTLEN];
! 135: kbd_t sc_layout;
! 136:
! 137: enum { STATE_KEYBOARD, STATE_MOUSE, STATE_CHANNEL, STATE_ECHO }
! 138: sc_state, sc_prevstate;
! 139: u_int sc_echolen;
! 140:
! 141: u_int8_t sc_mousepkt[3]; /* mouse packet being constructed */
! 142: u_int sc_mousepos; /* index in above */
! 143:
! 144: struct timeout sc_bellstop_tmo;
! 145:
! 146: struct device *sc_wskbddev;
! 147: #if NWSMOUSE > 0
! 148: struct device *sc_wsmousedev;
! 149: #endif
! 150:
! 151: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 152: int sc_rawkbd;
! 153: int sc_nrep;
! 154: char sc_rep[2]; /* at most, one key */
! 155: struct timeout sc_rawrepeat_ch;
! 156: #define REP_DELAY1 400
! 157: #define REP_DELAYN 100
! 158: #endif
! 159: };
! 160:
! 161: int dnkbd_match(struct device *, void *, void *);
! 162: void dnkbd_attach(struct device *, struct device *, void *);
! 163:
! 164: struct cfdriver dnkbd_cd = {
! 165: NULL, "dnkbd", DV_DULL
! 166: };
! 167:
! 168: struct cfattach dnkbd_ca = {
! 169: sizeof(struct dnkbd_softc), dnkbd_match, dnkbd_attach
! 170: };
! 171:
! 172: int dnkbd_enable(void *, int);
! 173: void dnkbd_set_leds(void *, int);
! 174: int dnkbd_ioctl(void *, u_long, caddr_t, int, struct proc *);
! 175:
! 176: const struct wskbd_accessops dnkbd_accessops = {
! 177: dnkbd_enable,
! 178: dnkbd_set_leds,
! 179: dnkbd_ioctl
! 180: };
! 181:
! 182: #if NWSMOUSE > 0
! 183: int dnmouse_enable(void *);
! 184: int dnmouse_ioctl(void *, u_long, caddr_t, int, struct proc *);
! 185: void dnmouse_disable(void *);
! 186:
! 187: const struct wsmouse_accessops dnmouse_accessops = {
! 188: dnmouse_enable,
! 189: dnmouse_ioctl,
! 190: dnmouse_disable
! 191: };
! 192: #endif
! 193:
! 194: void dnkbd_bell(void *, u_int, u_int, u_int);
! 195: void dnkbd_cngetc(void *, u_int *, int *);
! 196: void dnkbd_cnpollc(void *, int);
! 197:
! 198: const struct wskbd_consops dnkbd_consops = {
! 199: dnkbd_cngetc,
! 200: dnkbd_cnpollc,
! 201: dnkbd_bell
! 202: };
! 203:
! 204: struct wskbd_mapdata dnkbd_keymapdata = {
! 205: dnkbd_keydesctab,
! 206: #ifdef DNKBD_LAYOUT
! 207: DNKBD_LAYOUT
! 208: #else
! 209: KB_US
! 210: #endif
! 211: };
! 212:
! 213: typedef enum { EVENT_NONE, EVENT_KEYBOARD, EVENT_MOUSE } dnevent;
! 214:
! 215: void dnevent_kbd(struct dnkbd_softc *, int);
! 216: void dnevent_kbd_internal(struct dnkbd_softc *, int);
! 217: void dnevent_mouse(struct dnkbd_softc *, u_int8_t *);
! 218: void dnkbd_attach_subdevices(struct dnkbd_softc *);
! 219: void dnkbd_bellstop(void *);
! 220: void dnkbd_decode(int, u_int *, int *);
! 221: int dnkbd_init(struct apciregs *);
! 222: dnevent dnkbd_input(struct dnkbd_softc *, int);
! 223: int dnkbd_intr(void *);
! 224: int dnkbd_pollin(struct apciregs *, u_int);
! 225: int dnkbd_pollout(struct apciregs *, int);
! 226: int dnkbd_probe(struct dnkbd_softc *);
! 227: void dnkbd_rawrepeat(void *);
! 228: int dnkbd_send(struct apciregs *, const u_int8_t *, size_t);
! 229: int dnsubmatch_kbd(struct device *, void *, void *);
! 230: int dnsubmatch_mouse(struct device *, void *, void *);
! 231:
! 232: int
! 233: dnkbd_match(struct device *parent, void *match, void *aux)
! 234: {
! 235: struct frodo_attach_args *fa = aux;
! 236:
! 237: if (strcmp(fa->fa_name, dnkbd_cd.cd_name) != 0)
! 238: return (0);
! 239:
! 240: /* only attach to the first frodo port */
! 241: return (fa->fa_offset == FRODO_APCI_OFFSET(0));
! 242: }
! 243:
! 244: void
! 245: dnkbd_attach(struct device *parent, struct device *self, void *aux)
! 246: {
! 247: struct dnkbd_softc *sc = (struct dnkbd_softc *)self;
! 248: struct frodo_attach_args *fa = aux;
! 249:
! 250: printf(": ");
! 251:
! 252: sc->sc_regs = (struct apciregs *)IIOV(FRODO_BASE + fa->fa_offset);
! 253:
! 254: timeout_set(&sc->sc_bellstop_tmo, dnkbd_bellstop, sc);
! 255: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 256: timeout_set(&sc->sc_rawrepeat_ch, dnkbd_rawrepeat, sc);
! 257: #endif
! 258:
! 259: /* reset the port */
! 260: apciinit(sc->sc_regs, 1200, CFCR_8BITS | CFCR_PEVEN | CFCR_PENAB);
! 261:
! 262: sc->sc_isr.isr_func = dnkbd_intr;
! 263: sc->sc_isr.isr_arg = sc;
! 264: sc->sc_isr.isr_priority = IPL_TTY;
! 265: frodo_intr_establish(parent, fa->fa_line, &sc->sc_isr, self->dv_xname);
! 266:
! 267: /* probe for keyboard */
! 268: if (dnkbd_probe(sc) != 0) {
! 269: printf("no keyboard\n");
! 270: return;
! 271: }
! 272:
! 273: dnkbd_attach_subdevices(sc);
! 274: }
! 275:
! 276: void
! 277: dnkbd_attach_subdevices(struct dnkbd_softc *sc)
! 278: {
! 279: struct wskbddev_attach_args ka;
! 280: #if NWSMOUSE > 0
! 281: struct wsmousedev_attach_args ma;
! 282: #endif
! 283: #if NHILKBD > 0
! 284: extern int hil_is_console;
! 285: #endif
! 286: extern struct consdev wsdisplay_cons;
! 287:
! 288: /*
! 289: * If both hilkbd and dnkbd are configured, prefer the Domain
! 290: * keyboard as console (if we are here, we know the keyboard is
! 291: * plugged), unless the console keyboard has been claimed already
! 292: * (i.e. late hotplug with hil keyboard plugged first).
! 293: */
! 294: if (cn_tab == &wsdisplay_cons) {
! 295: #if NHILKBD > 0
! 296: if (hil_is_console == -1) {
! 297: ka.console = 1;
! 298: hil_is_console = 0;
! 299: } else
! 300: ka.console = 0;
! 301: #else
! 302: ka.console = 1;
! 303: #endif
! 304: } else
! 305: ka.console = 0;
! 306:
! 307: ka.keymap = &dnkbd_keymapdata;
! 308: ka.accessops = &dnkbd_accessops;
! 309: ka.accesscookie = sc;
! 310: #ifndef DKKBD_LAYOUT
! 311: dnkbd_keymapdata.layout = sc->sc_layout;
! 312: #endif
! 313:
! 314: if (ka.console) {
! 315: sc->sc_flags = SF_PLUGGED | SF_CONSOLE | SF_ENABLED;
! 316: wskbd_cnattach(&dnkbd_consops, sc, &dnkbd_keymapdata);
! 317: } else {
! 318: sc->sc_flags = SF_PLUGGED;
! 319: }
! 320:
! 321: sc->sc_wskbddev = config_found_sm(&sc->sc_dev, &ka, wskbddevprint,
! 322: dnsubmatch_kbd);
! 323:
! 324: #if NWSMOUSE > 0
! 325: ma.accessops = &dnmouse_accessops;
! 326: ma.accesscookie = sc;
! 327:
! 328: sc->sc_wsmousedev = config_found_sm(&sc->sc_dev, &ma, wsmousedevprint,
! 329: dnsubmatch_mouse);
! 330: #endif
! 331:
! 332: SET(sc->sc_flags, SF_ATTACHED);
! 333: }
! 334:
! 335: int
! 336: dnsubmatch_kbd(struct device *parent, void *match, void *aux)
! 337: {
! 338: struct cfdata *cf = match;
! 339: extern struct cfdriver wskbd_cd;
! 340:
! 341: if (strcmp(cf->cf_driver->cd_name, wskbd_cd.cd_name) != 0)
! 342: return (0);
! 343:
! 344: return ((*cf->cf_attach->ca_match)(parent, cf, aux));
! 345: }
! 346:
! 347: #if NWSMOUSE > 0
! 348: int
! 349: dnsubmatch_mouse(struct device *parent, void *match, void *aux)
! 350: {
! 351: struct cfdata *cf = match;
! 352: extern struct cfdriver wsmouse_cd;
! 353:
! 354: if (strcmp(cf->cf_driver->cd_name, wsmouse_cd.cd_name) != 0)
! 355: return (0);
! 356:
! 357: return ((*cf->cf_attach->ca_match)(parent, cf, aux));
! 358: }
! 359: #endif
! 360:
! 361: int
! 362: dnkbd_probe(struct dnkbd_softc *sc)
! 363: {
! 364: int dat, rc, flags;
! 365: u_int8_t cmdbuf[2];
! 366: char rspbuf[MAX_IDENTLEN], *word, *end;
! 367: u_int i;
! 368: int s;
! 369:
! 370: s = spltty();
! 371: flags = sc->sc_flags;
! 372: SET(sc->sc_flags, SF_POLLING);
! 373: sc->sc_state = STATE_CHANNEL;
! 374: splx(s);
! 375:
! 376: /*
! 377: * Switch keyboard to raw mode.
! 378: */
! 379: cmdbuf[0] = DNCMD_RAW;
! 380: rc = dnkbd_send(sc->sc_regs, cmdbuf, 1);
! 381: if (rc != 0)
! 382: goto out;
! 383:
! 384: /*
! 385: * Send the identify command.
! 386: */
! 387: cmdbuf[0] = DNCMD_IDENT_1;
! 388: cmdbuf[1] = DNCMD_IDENT_2;
! 389: rc = dnkbd_send(sc->sc_regs, cmdbuf, 2);
! 390: if (rc != 0)
! 391: goto out;
! 392:
! 393: for (i = 0; ; i++) {
! 394: dat = dnkbd_pollin(sc->sc_regs, 10000);
! 395: if (dat == -1)
! 396: break;
! 397:
! 398: if (i < sizeof(rspbuf))
! 399: rspbuf[i] = dat;
! 400: }
! 401:
! 402: if (i > sizeof(rspbuf) || i == 0) {
! 403: printf("%s: unexpected identify string length %d\n",
! 404: sc->sc_dev.dv_xname, i);
! 405: rc = ENXIO;
! 406: goto out;
! 407: }
! 408:
! 409: /*
! 410: * Make sure the identification string is NULL terminated
! 411: * (overwriting the keyboard mode byte if necessary).
! 412: */
! 413: i--;
! 414: if (rspbuf[i] != 0)
! 415: rspbuf[i] = 0;
! 416:
! 417: /*
! 418: * Now display the identification strings, if they changed.
! 419: */
! 420: if (i != sc->sc_identlen || bcmp(rspbuf, sc->sc_ident, i) != 0) {
! 421: sc->sc_layout = KB_US;
! 422: sc->sc_identlen = i;
! 423: bcopy(rspbuf, sc->sc_ident, i);
! 424:
! 425: if (cold == 0)
! 426: printf("%s: ", sc->sc_dev.dv_xname);
! 427: printf("model ");
! 428: word = rspbuf;
! 429: for (i = 0; i < 3; i++) {
! 430: end = strchr(word, '\r');
! 431: if (end == NULL)
! 432: break;
! 433: *end++ = '\0';
! 434: printf("<%s> ", word);
! 435: /*
! 436: * Parse the layout code if applicable
! 437: */
! 438: if (i == 1 && *word++ == '3') {
! 439: if (*word == '-')
! 440: word++;
! 441: switch (*word) {
! 442: #if 0
! 443: default:
! 444: case ' ':
! 445: sc->sc_layout = KB_US;
! 446: break;
! 447: #endif
! 448: case 'a':
! 449: sc->sc_layout = KB_DE;
! 450: break;
! 451: case 'b':
! 452: sc->sc_layout = KB_FR;
! 453: break;
! 454: case 'c':
! 455: sc->sc_layout = KB_DK;
! 456: break;
! 457: case 'd':
! 458: sc->sc_layout = KB_SV;
! 459: break;
! 460: case 'e':
! 461: sc->sc_layout = KB_UK;
! 462: break;
! 463: case 'f':
! 464: sc->sc_layout = KB_JP;
! 465: break;
! 466: case 'g':
! 467: sc->sc_layout = KB_SG;
! 468: break;
! 469: }
! 470: }
! 471: word = end;
! 472: }
! 473: printf("\n");
! 474: }
! 475:
! 476: /*
! 477: * Ready to work, the default channel is the keyboard.
! 478: */
! 479: sc->sc_state = STATE_KEYBOARD;
! 480:
! 481: out:
! 482: s = spltty();
! 483: sc->sc_flags = flags;
! 484: splx(s);
! 485:
! 486: return (rc);
! 487: }
! 488:
! 489: /*
! 490: * State machine.
! 491: *
! 492: * In raw mode, the keyboard may feed us the following sequences:
! 493: * - on the keyboard channel:
! 494: * + a raw key code, in the range 0x01-0x7e, or'ed with 0x80 if key release.
! 495: * + the key repeat sequence 0x7f.
! 496: * - on the mouse channel:
! 497: * + a 3 byte mouse sequence (buttons state, dx move, dy move).
! 498: * - at any time:
! 499: * + a 2 byte channel sequence (0xff followed by the channel number) telling
! 500: * us which device the following input will come from.
! 501: * + if we get 0xff but an invalid channel number, this is a command echo.
! 502: * Currently we only handle this for bell commands, which size are known.
! 503: * Other commands are issued through dnkbd_send() which ``eats'' the echo.
! 504: *
! 505: * Older keyboards reset the channel to the keyboard (by sending ff 01) after
! 506: * every mouse packet.
! 507: */
! 508:
! 509: dnevent
! 510: dnkbd_input(struct dnkbd_softc *sc, int dat)
! 511: {
! 512: dnevent event = EVENT_NONE;
! 513:
! 514: switch (sc->sc_state) {
! 515: case STATE_KEYBOARD:
! 516: switch (dat) {
! 517: case DNKEY_REPEAT:
! 518: /*
! 519: * We ignore event repeats, as wskbd does its own
! 520: * soft repeat processing.
! 521: */
! 522: break;
! 523: case DNKEY_CHANNEL:
! 524: sc->sc_prevstate = sc->sc_state;
! 525: sc->sc_state = STATE_CHANNEL;
! 526: break;
! 527: default:
! 528: event = EVENT_KEYBOARD;
! 529: break;
! 530: }
! 531: break;
! 532:
! 533: case STATE_MOUSE:
! 534: if (dat == DNKEY_CHANNEL && sc->sc_mousepos == 0) {
! 535: sc->sc_prevstate = sc->sc_state;
! 536: sc->sc_state = STATE_CHANNEL;
! 537: } else {
! 538: sc->sc_mousepkt[sc->sc_mousepos++] = dat;
! 539: if (sc->sc_mousepos == sizeof(sc->sc_mousepkt)) {
! 540: sc->sc_mousepos = 0;
! 541: event = EVENT_MOUSE;
! 542: }
! 543: }
! 544: break;
! 545:
! 546: case STATE_CHANNEL:
! 547: switch (dat) {
! 548: case DNKEY_CHANNEL:
! 549: /*
! 550: * During hotplug, we might get spurious 0xff bytes.
! 551: * Ignore them.
! 552: */
! 553: break;
! 554: case DNCHANNEL_RESET:
! 555: /*
! 556: * Identify the keyboard again. This will switch it to
! 557: * raw mode again. If this fails, we'll consider the
! 558: * keyboard as unplugged (to ignore further events until
! 559: * a successfull reset).
! 560: */
! 561: if (dnkbd_probe(sc) == 0) {
! 562: /*
! 563: * We need to attach wskbd and wsmouse children
! 564: * if this is a live first plug.
! 565: */
! 566: if (!ISSET(sc->sc_flags, SF_ATTACHED))
! 567: dnkbd_attach_subdevices(sc);
! 568: SET(sc->sc_flags, SF_PLUGGED);
! 569: } else {
! 570: CLR(sc->sc_flags, SF_PLUGGED);
! 571: }
! 572:
! 573: sc->sc_state = STATE_KEYBOARD;
! 574: break;
! 575: case DNCHANNEL_KBD:
! 576: sc->sc_state = STATE_KEYBOARD;
! 577: break;
! 578: case DNCHANNEL_MOUSE:
! 579: sc->sc_state = STATE_MOUSE;
! 580: sc->sc_mousepos = 0; /* just in case */
! 581: break;
! 582: case DNCMD_BELL:
! 583: /*
! 584: * We are getting a bell command echoed to us.
! 585: * Ignore it.
! 586: */
! 587: sc->sc_state = STATE_ECHO;
! 588: sc->sc_echolen = 1; /* one byte to follow */
! 589: break;
! 590: default:
! 591: printf("%s: unexpected channel byte %02x\n",
! 592: sc->sc_dev.dv_xname, dat);
! 593: break;
! 594: }
! 595: break;
! 596:
! 597: case STATE_ECHO:
! 598: if (--sc->sc_echolen == 0) {
! 599: /* get back to the state we were in before the echo */
! 600: sc->sc_state = sc->sc_prevstate;
! 601: }
! 602: break;
! 603: }
! 604:
! 605: return (event);
! 606: }
! 607:
! 608: /*
! 609: * Event breakers.
! 610: */
! 611:
! 612: void
! 613: dnkbd_decode(int keycode, u_int *type, int *key)
! 614: {
! 615: *type = (keycode & DNKEY_RELEASE) ?
! 616: WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN;
! 617: *key = (keycode & ~DNKEY_RELEASE);
! 618: }
! 619:
! 620: void
! 621: dnevent_kbd(struct dnkbd_softc *sc, int dat)
! 622: {
! 623: if (!ISSET(sc->sc_flags, SF_PLUGGED))
! 624: return;
! 625:
! 626: if (sc->sc_wskbddev == NULL)
! 627: return;
! 628:
! 629: if (!ISSET(sc->sc_flags, SF_ENABLED))
! 630: return;
! 631:
! 632: /*
! 633: * Even in raw mode, the caps lock key is treated specially:
! 634: * first key press causes event 0x7e, release causes no event;
! 635: * then a new key press causes nothing, and release causes
! 636: * event 0xfe. Moreover, while kept down, it does not produce
! 637: * repeat events.
! 638: *
! 639: * So the best we can do is fake the missed events, but this
! 640: * will not allow the capslock key to be remapped as a control
! 641: * key since it will not be possible to chord it with anything.
! 642: */
! 643: dnevent_kbd_internal(sc, dat);
! 644: if ((dat & ~DNKEY_RELEASE) == DNKEY_CAPSLOCK)
! 645: dnevent_kbd_internal(sc, dat ^ DNKEY_RELEASE);
! 646: }
! 647:
! 648: void
! 649: dnevent_kbd_internal(struct dnkbd_softc *sc, int dat)
! 650: {
! 651: u_int type;
! 652: int key;
! 653: int s;
! 654:
! 655: dnkbd_decode(dat, &type, &key);
! 656:
! 657: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 658: if (sc->sc_rawkbd) {
! 659: u_char cbuf[2];
! 660: int c, j = 0;
! 661:
! 662: c = dnkbd_raw[key];
! 663: if (c != RAWKEY_Null) {
! 664: /* fake extended scancode if necessary */
! 665: if (c & 0x80)
! 666: cbuf[j++] = 0xe0;
! 667: cbuf[j] = c & 0x7f;
! 668: if (type == WSCONS_EVENT_KEY_UP)
! 669: cbuf[j] |= 0x80;
! 670: else {
! 671: /* remember pressed key for autorepeat */
! 672: bcopy(cbuf, sc->sc_rep, sizeof(sc->sc_rep));
! 673: }
! 674: j++;
! 675: }
! 676:
! 677: if (j != 0) {
! 678: s = spltty();
! 679: wskbd_rawinput(sc->sc_wskbddev, cbuf, j);
! 680: splx(s);
! 681: timeout_del(&sc->sc_rawrepeat_ch);
! 682: sc->sc_nrep = j;
! 683: timeout_add(&sc->sc_rawrepeat_ch,
! 684: (hz * REP_DELAY1) / 1000);
! 685: }
! 686: } else
! 687: #endif
! 688: {
! 689: s = spltty();
! 690: wskbd_input(sc->sc_wskbddev, type, key);
! 691: splx(s);
! 692: }
! 693: }
! 694:
! 695: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 696: void
! 697: dnkbd_rawrepeat(void *v)
! 698: {
! 699: struct dnkbd_softc *sc = v;
! 700: int s;
! 701:
! 702: s = spltty();
! 703: wskbd_rawinput(sc->sc_wskbddev, sc->sc_rep, sc->sc_nrep);
! 704: splx(s);
! 705:
! 706: timeout_add(&sc->sc_rawrepeat_ch, (hz * REP_DELAYN) / 1000);
! 707: }
! 708: #endif
! 709:
! 710: #if NWSMOUSE > 0
! 711: void
! 712: dnevent_mouse(struct dnkbd_softc *sc, u_int8_t *dat)
! 713: {
! 714: if (!ISSET(sc->sc_flags, SF_PLUGGED))
! 715: return;
! 716:
! 717: if (sc->sc_wsmousedev == NULL)
! 718: return;
! 719:
! 720: if (!ISSET(sc->sc_flags, SF_MOUSE))
! 721: return;
! 722:
! 723: /*
! 724: * First byte is button status. It has the 0x80 bit always set, and
! 725: * the next 3 bits are *cleared* when the mouse buttons are pressed.
! 726: */
! 727: #ifdef DEBUG
! 728: if (!ISSET(*dat, 0x80)) {
! 729: printf("%s: incorrect mouse packet %02x %02x %02x\n",
! 730: sc->sc_dev.dv_xname, dat[0], dat[1], dat[2]);
! 731: return;
! 732: }
! 733: #endif
! 734:
! 735: wsmouse_input(sc->sc_wsmousedev,
! 736: (~dat[0] & (DNBUTTON_L | DNBUTTON_M | DNBUTTON_R)) >> 4,
! 737: (int8_t)dat[1], (int8_t)dat[2], 0, 0, WSMOUSE_INPUT_DELTA);
! 738: }
! 739: #endif
! 740:
! 741: /*
! 742: * Low-level communication routines.
! 743: */
! 744:
! 745: int
! 746: dnkbd_pollin(struct apciregs *apci, u_int tries)
! 747: {
! 748: u_int cnt;
! 749:
! 750: for (cnt = tries; cnt != 0; cnt--) {
! 751: if (apci->ap_lsr & LSR_RXRDY)
! 752: break;
! 753: DELAY(10);
! 754: }
! 755:
! 756: if (cnt == 0)
! 757: return (-1);
! 758: else
! 759: return ((int)apci->ap_data);
! 760: }
! 761:
! 762: int
! 763: dnkbd_pollout(struct apciregs *apci, int dat)
! 764: {
! 765: u_int cnt;
! 766:
! 767: for (cnt = 10000; cnt != 0; cnt--) {
! 768: if (apci->ap_lsr & LSR_TXRDY)
! 769: break;
! 770: DELAY(10);
! 771: }
! 772: if (cnt == 0)
! 773: return (EBUSY);
! 774: else {
! 775: apci->ap_data = dat;
! 776: return (0);
! 777: }
! 778: }
! 779:
! 780: int
! 781: dnkbd_send(struct apciregs *apci, const u_int8_t *cmdbuf, size_t cmdlen)
! 782: {
! 783: int cnt, rc, dat;
! 784: u_int cmdpos;
! 785:
! 786: /* drain rxfifo */
! 787: for (cnt = 10; cnt != 0; cnt--) {
! 788: if (dnkbd_pollin(apci, 10) == -1)
! 789: break;
! 790: }
! 791: if (cnt == 0)
! 792: return (EBUSY);
! 793:
! 794: /* send command escape */
! 795: if ((rc = dnkbd_pollout(apci, DNCMD_PREFIX)) != 0)
! 796: return (rc);
! 797:
! 798: /* send command buffer */
! 799: for (cmdpos = 0; cmdpos < cmdlen; cmdpos++) {
! 800: if ((rc = dnkbd_pollout(apci, cmdbuf[cmdpos])) != 0)
! 801: return (rc);
! 802: }
! 803:
! 804: /* wait for command echo */
! 805: do {
! 806: dat = dnkbd_pollin(apci, 10000);
! 807: if (dat == -1)
! 808: return (EIO);
! 809: } while (dat != DNCMD_PREFIX);
! 810:
! 811: for (cmdpos = 0; cmdpos < cmdlen; cmdpos++) {
! 812: dat = dnkbd_pollin(apci, 10000);
! 813: if (dat != cmdbuf[cmdpos])
! 814: return (EIO);
! 815: }
! 816:
! 817: return (0);
! 818: }
! 819:
! 820: int
! 821: dnkbd_intr(void *v)
! 822: {
! 823: struct dnkbd_softc *sc = v;
! 824: struct apciregs *apci = sc->sc_regs;
! 825: u_int8_t iir, lsr, c;
! 826: int claimed = 0;
! 827:
! 828: for (;;) {
! 829: iir = apci->ap_iir;
! 830:
! 831: switch (iir & IIR_IMASK) {
! 832: case IIR_RLS:
! 833: /*
! 834: * Line status change. This should never happen,
! 835: * so silently ack the interrupt.
! 836: */
! 837: c = apci->ap_lsr;
! 838: break;
! 839:
! 840: case IIR_RXRDY:
! 841: case IIR_RXTOUT:
! 842: /*
! 843: * Data available. We process it byte by byte,
! 844: * unless we are doing polling work...
! 845: */
! 846: if (ISSET(sc->sc_flags, SF_POLLING)) {
! 847: return (1);
! 848: }
! 849:
! 850: for (;;) {
! 851: c = apci->ap_data;
! 852: switch (dnkbd_input(sc, c)) {
! 853: case EVENT_KEYBOARD:
! 854: dnevent_kbd(sc, c);
! 855: break;
! 856: #if NWSMOUSE > 0
! 857: case EVENT_MOUSE:
! 858: dnevent_mouse(sc, sc->sc_mousepkt);
! 859: break;
! 860: #endif
! 861: default: /* appease gcc */
! 862: break;
! 863: }
! 864: lsr = apci->ap_lsr & LSR_RCV_MASK;
! 865: if (lsr == 0)
! 866: break;
! 867: else if (lsr != LSR_RXRDY) {
! 868: /* ignore error */
! 869: break;
! 870: }
! 871: }
! 872: break;
! 873:
! 874: case IIR_TXRDY:
! 875: /*
! 876: * Transmit available. Since we do all our commands
! 877: * in polling mode, we do not need to do anything here.
! 878: */
! 879: break;
! 880:
! 881: default:
! 882: if (iir & IIR_NOPEND)
! 883: return (claimed);
! 884: /* FALLTHROUGH */
! 885:
! 886: case IIR_MLSC:
! 887: /*
! 888: * Modem status change. This should never happen,
! 889: * so silently ack the interrupt.
! 890: */
! 891: c = apci->ap_msr;
! 892: break;
! 893: }
! 894:
! 895: claimed = 1;
! 896: }
! 897: }
! 898:
! 899: /*
! 900: * Wskbd callbacks
! 901: */
! 902:
! 903: int
! 904: dnkbd_enable(void *v, int on)
! 905: {
! 906: struct dnkbd_softc *sc = v;
! 907:
! 908: if (on) {
! 909: if (ISSET(sc->sc_flags, SF_ENABLED))
! 910: return (EBUSY);
! 911: SET(sc->sc_flags, SF_ENABLED);
! 912: } else {
! 913: if (ISSET(sc->sc_flags, SF_CONSOLE))
! 914: return (EBUSY);
! 915: CLR(sc->sc_flags, SF_ENABLED);
! 916: }
! 917:
! 918: return (0);
! 919: }
! 920:
! 921: void
! 922: dnkbd_set_leds(void *v, int leds)
! 923: {
! 924: /*
! 925: * Not supported. There is only one LED on this keyboard, and
! 926: * is hardware tied to the caps lock key.
! 927: */
! 928: }
! 929:
! 930: int
! 931: dnkbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
! 932: {
! 933: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 934: struct dnkbd_softc *sc = v;
! 935: #endif
! 936:
! 937: switch (cmd) {
! 938: case WSKBDIO_GTYPE:
! 939: *(int *)data = WSKBD_TYPE_DOMAIN;
! 940: return (0);
! 941: case WSKBDIO_SETLEDS:
! 942: return (ENXIO);
! 943: case WSKBDIO_GETLEDS:
! 944: *(int *)data = 0;
! 945: return (0);
! 946: case WSKBDIO_COMPLEXBELL:
! 947: #define d ((struct wskbd_bell_data *)data)
! 948: dnkbd_bell(v, d->period, d->pitch, d->volume);
! 949: #undef d
! 950: return (0);
! 951: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 952: case WSKBDIO_SETMODE:
! 953: sc->sc_rawkbd = *(int *)data == WSKBD_RAW;
! 954: timeout_del(&sc->sc_rawrepeat_ch);
! 955: return (0);
! 956: #endif
! 957: }
! 958:
! 959: return (-1);
! 960: }
! 961:
! 962: #if NWSMOUSE > 0
! 963: /*
! 964: * Wsmouse callbacks
! 965: */
! 966:
! 967: int
! 968: dnmouse_enable(void *v)
! 969: {
! 970: struct dnkbd_softc *sc = v;
! 971:
! 972: if (ISSET(sc->sc_flags, SF_MOUSE))
! 973: return (EBUSY);
! 974: SET(sc->sc_flags, SF_MOUSE);
! 975:
! 976: return (0);
! 977: }
! 978:
! 979: int
! 980: dnmouse_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
! 981: {
! 982: #if 0
! 983: struct dnkbd_softc *sc = v;
! 984: #endif
! 985:
! 986: switch (cmd) {
! 987: case WSMOUSEIO_GTYPE:
! 988: *(int *)data = WSMOUSE_TYPE_DOMAIN;
! 989: return (0);
! 990: }
! 991:
! 992: return (-1);
! 993: }
! 994:
! 995: void
! 996: dnmouse_disable(void *v)
! 997: {
! 998: struct dnkbd_softc *sc = v;
! 999:
! 1000: CLR(sc->sc_flags, SF_MOUSE);
! 1001: }
! 1002: #endif
! 1003:
! 1004: /*
! 1005: * Console support
! 1006: */
! 1007:
! 1008: void
! 1009: dnkbd_cngetc(void *v, u_int *type, int *data)
! 1010: {
! 1011: static int lastdat = 0;
! 1012: struct dnkbd_softc *sc = v;
! 1013: int s;
! 1014: int dat;
! 1015:
! 1016: /* Take care of caps lock */
! 1017: if ((lastdat & ~DNKEY_RELEASE) == DNKEY_CAPSLOCK) {
! 1018: dat = lastdat ^ DNKEY_RELEASE;
! 1019: lastdat = 0;
! 1020: } else {
! 1021: for (;;) {
! 1022: s = splhigh();
! 1023: dat = dnkbd_pollin(sc->sc_regs, 10000);
! 1024: if (dat != -1) {
! 1025: if (dnkbd_input(sc, dat) == EVENT_KEYBOARD) {
! 1026: splx(s);
! 1027: break;
! 1028: }
! 1029: }
! 1030: splx(s);
! 1031: }
! 1032: lastdat = dat;
! 1033: }
! 1034:
! 1035: dnkbd_decode(dat, type, data);
! 1036: }
! 1037:
! 1038: void
! 1039: dnkbd_cnpollc(void *v, int on)
! 1040: {
! 1041: struct dnkbd_softc *sc = v;
! 1042:
! 1043: if (on)
! 1044: SET(sc->sc_flags, SF_POLLING);
! 1045: else
! 1046: CLR(sc->sc_flags, SF_POLLING);
! 1047: }
! 1048:
! 1049: /*
! 1050: * Bell routines.
! 1051: */
! 1052: void
! 1053: dnkbd_bell(void *v, u_int period, u_int pitch, u_int volume)
! 1054: {
! 1055: struct dnkbd_softc *sc = v;
! 1056: int ticks, s;
! 1057:
! 1058: s = spltty();
! 1059:
! 1060: if (pitch == 0 || period == 0 || volume == 0) {
! 1061: if (ISSET(sc->sc_flags, SF_BELL_TMO)) {
! 1062: timeout_del(&sc->sc_bellstop_tmo);
! 1063: dnkbd_bellstop(v);
! 1064: }
! 1065: } else {
! 1066: ticks = (period * hz) / 1000;
! 1067: if (ticks <= 0)
! 1068: ticks = 1;
! 1069:
! 1070: if (!ISSET(sc->sc_flags, SF_BELL)) {
! 1071: dnkbd_pollout(sc->sc_regs, DNCMD_PREFIX);
! 1072: dnkbd_pollout(sc->sc_regs, DNCMD_BELL);
! 1073: dnkbd_pollout(sc->sc_regs, DNCMD_BELL_ON);
! 1074: SET(sc->sc_flags, SF_BELL);
! 1075: }
! 1076:
! 1077: if (ISSET(sc->sc_flags, SF_BELL_TMO))
! 1078: timeout_del(&sc->sc_bellstop_tmo);
! 1079: timeout_add(&sc->sc_bellstop_tmo, ticks);
! 1080: SET(sc->sc_flags, SF_BELL_TMO);
! 1081: }
! 1082:
! 1083: splx(s);
! 1084: }
! 1085:
! 1086: void
! 1087: dnkbd_bellstop(void *v)
! 1088: {
! 1089: struct dnkbd_softc *sc = v;
! 1090: int s;
! 1091:
! 1092: s = spltty();
! 1093:
! 1094: dnkbd_pollout(sc->sc_regs, DNCMD_PREFIX);
! 1095: dnkbd_pollout(sc->sc_regs, DNCMD_BELL);
! 1096: dnkbd_pollout(sc->sc_regs, DNCMD_BELL_OFF);
! 1097: CLR(sc->sc_flags, SF_BELL);
! 1098: CLR(sc->sc_flags, SF_BELL_TMO);
! 1099:
! 1100: splx(s);
! 1101: }