Annotation of sys/dev/adb/akbd.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: akbd.c,v 1.6 2007/03/13 20:56:56 miod Exp $ */
! 2: /* $NetBSD: akbd.c,v 1.17 2005/01/15 16:00:59 chs Exp $ */
! 3:
! 4: /*
! 5: * Copyright (C) 1998 Colin Wood
! 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. All advertising materials mentioning features or use of this software
! 17: * must display the following acknowledgement:
! 18: * This product includes software developed by Colin Wood.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
! 31: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34: #include <sys/param.h>
! 35: #include <sys/timeout.h>
! 36: #include <sys/kernel.h>
! 37: #include <sys/device.h>
! 38: #include <sys/systm.h>
! 39:
! 40: #include <dev/wscons/wsconsio.h>
! 41: #include <dev/wscons/wskbdvar.h>
! 42: #include <dev/wscons/wsksymdef.h>
! 43: #include <dev/wscons/wsksymvar.h>
! 44:
! 45: #include <machine/autoconf.h>
! 46: #include <machine/cpu.h>
! 47:
! 48: #include <dev/adb/adb.h>
! 49: #include <dev/adb/akbdmap.h>
! 50: #include <dev/adb/akbdvar.h>
! 51:
! 52: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 53: #define KEYBOARD_ARRAY
! 54: #endif
! 55: #include <dev/adb/keyboard.h>
! 56:
! 57: /*
! 58: * Function declarations.
! 59: */
! 60: int akbdmatch(struct device *, void *, void *);
! 61: void akbdattach(struct device *, struct device *, void *);
! 62:
! 63: /* Driver definition. */
! 64: struct cfattach akbd_ca = {
! 65: sizeof(struct akbd_softc), akbdmatch, akbdattach
! 66: };
! 67: struct cfdriver akbd_cd = {
! 68: NULL, "akbd", DV_DULL
! 69: };
! 70:
! 71: int akbd_enable(void *, int);
! 72: void akbd_set_leds(void *, int);
! 73: int akbd_ioctl(void *, u_long, caddr_t, int, struct proc *);
! 74:
! 75:
! 76: struct wskbd_accessops akbd_accessops = {
! 77: akbd_enable,
! 78: akbd_set_leds,
! 79: akbd_ioctl,
! 80: };
! 81:
! 82: struct wskbd_mapdata akbd_keymapdata = {
! 83: akbd_keydesctab,
! 84: #ifdef AKBD_LAYOUT
! 85: AKBD_LAYOUT,
! 86: #else
! 87: KB_US,
! 88: #endif
! 89: };
! 90:
! 91: void akbd_adbcomplete(caddr_t, caddr_t, int);
! 92: void akbd_capslockwrapper(struct akbd_softc *, int);
! 93: void akbd_input(struct akbd_softc *, int);
! 94: void akbd_processevent(struct akbd_softc *, adb_event_t *);
! 95: void akbd_rawrepeat(void *v);
! 96: #ifdef notyet
! 97: u_char getleds(int);
! 98: int setleds(struct akbd_softc *, u_char);
! 99: void blinkleds(struct akbd_softc *);
! 100: #endif
! 101:
! 102: int
! 103: akbdmatch(struct device *parent, void *vcf, void *aux)
! 104: {
! 105: struct adb_attach_args *aa_args = (struct adb_attach_args *)aux;
! 106:
! 107: if (aa_args->origaddr == ADBADDR_KBD)
! 108: return (1);
! 109: else
! 110: return (0);
! 111: }
! 112:
! 113: void
! 114: akbdattach(struct device *parent, struct device *self, void *aux)
! 115: {
! 116: ADBSetInfoBlock adbinfo;
! 117: struct akbd_softc *sc = (struct akbd_softc *)self;
! 118: struct adb_attach_args *aa_args = (struct adb_attach_args *)aux;
! 119: int error, kbd_done;
! 120: short cmd;
! 121: u_char buffer[9];
! 122: struct wskbddev_attach_args a;
! 123: static int akbd_console_initted;
! 124: int wskbd_eligible = 1;
! 125:
! 126: sc->origaddr = aa_args->origaddr;
! 127: sc->adbaddr = aa_args->adbaddr;
! 128: sc->handler_id = aa_args->handler_id;
! 129:
! 130: sc->sc_leds = (u_int8_t)0x00; /* initially off */
! 131: sc->sc_caps = 0;
! 132:
! 133: adbinfo.siServiceRtPtr = (Ptr)akbd_adbcomplete;
! 134: adbinfo.siDataAreaAddr = (caddr_t)sc;
! 135:
! 136: printf(": ");
! 137: switch (sc->handler_id) {
! 138: case ADB_STDKBD:
! 139: printf("standard keyboard\n");
! 140: break;
! 141: case ADB_ISOKBD:
! 142: printf("standard keyboard (ISO layout)\n");
! 143: break;
! 144: case ADB_EXTKBD:
! 145: cmd = ADBTALK(sc->adbaddr, 1);
! 146: kbd_done =
! 147: (adb_op_sync((Ptr)buffer, cmd) == 0);
! 148:
! 149: /* Ignore Logitech MouseMan/Trackman pseudo keyboard */
! 150: if (kbd_done && buffer[1] == 0x9a && buffer[2] == 0x20) {
! 151: printf("Mouseman (non-EMP) pseudo keyboard\n");
! 152: adbinfo.siServiceRtPtr = (Ptr)0;
! 153: adbinfo.siDataAreaAddr = (Ptr)0;
! 154: wskbd_eligible = 0;
! 155: } else if (kbd_done && buffer[1] == 0x9a && buffer[2] == 0x21) {
! 156: printf("Trackman (non-EMP) pseudo keyboard\n");
! 157: adbinfo.siServiceRtPtr = (Ptr)0;
! 158: adbinfo.siDataAreaAddr = (Ptr)0;
! 159: wskbd_eligible = 0;
! 160: } else {
! 161: printf("extended keyboard\n");
! 162: #ifdef notyet
! 163: blinkleds(sc);
! 164: #endif
! 165: }
! 166: break;
! 167: case ADB_EXTISOKBD:
! 168: printf("extended keyboard (ISO layout)\n");
! 169: #ifdef notyet
! 170: blinkleds(sc);
! 171: #endif
! 172: break;
! 173: case ADB_KBDII:
! 174: printf("keyboard II\n");
! 175: break;
! 176: case ADB_ISOKBDII:
! 177: printf("keyboard II (ISO layout)\n");
! 178: break;
! 179: case ADB_PBKBD:
! 180: printf("PowerBook keyboard\n");
! 181: break;
! 182: case ADB_PBISOKBD:
! 183: printf("PowerBook keyboard (ISO layout)\n");
! 184: break;
! 185: case ADB_ADJKPD:
! 186: printf("adjustable keypad\n");
! 187: wskbd_eligible = 0;
! 188: break;
! 189: case ADB_ADJKBD:
! 190: printf("adjustable keyboard\n");
! 191: break;
! 192: case ADB_ADJISOKBD:
! 193: printf("adjustable keyboard (ISO layout)\n");
! 194: break;
! 195: case ADB_ADJJAPKBD:
! 196: printf("adjustable keyboard (Japanese layout)\n");
! 197: break;
! 198: case ADB_PBEXTISOKBD:
! 199: printf("PowerBook extended keyboard (ISO layout)\n");
! 200: break;
! 201: case ADB_PBEXTJAPKBD:
! 202: printf("PowerBook extended keyboard (Japanese layout)\n");
! 203: break;
! 204: case ADB_JPKBDII:
! 205: printf("keyboard II (Japanese layout)\n");
! 206: break;
! 207: case ADB_PBEXTKBD:
! 208: printf("PowerBook extended keyboard\n");
! 209: break;
! 210: case ADB_DESIGNKBD:
! 211: printf("extended keyboard\n");
! 212: #ifdef notyet
! 213: blinkleds(sc);
! 214: #endif
! 215: break;
! 216: case ADB_PBJPKBD:
! 217: printf("PowerBook keyboard (Japanese layout)\n");
! 218: break;
! 219: case ADB_PBG3JPKBD:
! 220: printf("PowerBook G3 keyboard (Japanese layout)\n");
! 221: break;
! 222: case ADB_PBG4KBD:
! 223: printf("PowerBook G4 keyboard (Inverted T)\n");
! 224: break;
! 225: case ADB_IBITISOKBD:
! 226: printf("iBook keyboard with inverted T (ISO layout)\n");
! 227: break;
! 228: default:
! 229: printf("mapped device (%d)\n", sc->handler_id);
! 230: #if 0
! 231: wskbd_eligible = 0;
! 232: #endif
! 233: break;
! 234: }
! 235: error = set_adb_info(&adbinfo, sc->adbaddr);
! 236: #ifdef ADB_DEBUG
! 237: if (adb_debug)
! 238: printf("akbd: returned %d from set_adb_info\n", error);
! 239: #endif
! 240:
! 241: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 242: timeout_set(&sc->sc_rawrepeat_ch, akbd_rawrepeat, sc);
! 243: #endif
! 244:
! 245: if (akbd_is_console() && wskbd_eligible)
! 246: a.console = (++akbd_console_initted == 1);
! 247: else
! 248: a.console = 0;
! 249: a.keymap = &akbd_keymapdata;
! 250: a.accessops = &akbd_accessops;
! 251: a.accesscookie = sc;
! 252:
! 253: sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
! 254: }
! 255:
! 256:
! 257: /*
! 258: * Handle putting the keyboard data received from the ADB into
! 259: * an ADB event record.
! 260: */
! 261: void
! 262: akbd_adbcomplete(caddr_t buffer, caddr_t data_area, int adb_command)
! 263: {
! 264: adb_event_t event;
! 265: struct akbd_softc *sc;
! 266: int adbaddr;
! 267: #ifdef ADB_DEBUG
! 268: int i;
! 269:
! 270: if (adb_debug)
! 271: printf("adb: transaction completion\n");
! 272: #endif
! 273:
! 274: adbaddr = ADB_CMDADDR(adb_command);
! 275: sc = (struct akbd_softc *)data_area;
! 276:
! 277: event.byte_count = buffer[0];
! 278: memcpy(event.bytes, buffer + 1, event.byte_count);
! 279:
! 280: #ifdef ADB_DEBUG
! 281: if (adb_debug) {
! 282: printf("akbd: from %d at %d (org %d) %d:", adbaddr,
! 283: sc->handler_id, sc->origaddr, buffer[0]);
! 284: for (i = 1; i <= buffer[0]; i++)
! 285: printf(" %x", buffer[i]);
! 286: printf("\n");
! 287: }
! 288: #endif
! 289:
! 290: if (sc->sc_wskbddev != NULL)
! 291: akbd_processevent(sc, &event);
! 292: }
! 293:
! 294: #ifdef notyet
! 295: /*
! 296: * Get the actual hardware LED state and convert it to softc format.
! 297: */
! 298: u_char
! 299: getleds(int addr)
! 300: {
! 301: short cmd;
! 302: u_char buffer[9], leds;
! 303:
! 304: leds = 0x00; /* all off */
! 305: buffer[0] = 0;
! 306:
! 307: cmd = ADBTALK(addr, 2);
! 308: if (adb_op_sync((Ptr)buffer, cmd) == 0 &&
! 309: buffer[0] > 0)
! 310: leds = ~(buffer[2]) & 0x07;
! 311:
! 312: return (leds);
! 313: }
! 314:
! 315: /*
! 316: * Set the keyboard LED's.
! 317: *
! 318: * Automatically translates from ioctl/softc format to the
! 319: * actual keyboard register format
! 320: */
! 321: int
! 322: setleds(struct akbd_softc *sc, u_char leds)
! 323: {
! 324: int addr;
! 325: short cmd;
! 326: u_char buffer[9];
! 327:
! 328: addr = sc->adbaddr;
! 329: buffer[0] = 0;
! 330:
! 331: cmd = ADBTALK(addr, 2);
! 332: if (adb_op_sync((Ptr)buffer, cmd) || buffer[0] == 0)
! 333: return (EIO);
! 334:
! 335: leds = ~leds & 0x07;
! 336: buffer[2] &= 0xf8;
! 337: buffer[2] |= leds;
! 338:
! 339: cmd = ADBLISTEN(addr, 2);
! 340: adb_op_sync((Ptr)buffer, cmd);
! 341:
! 342: /* talk R2 */
! 343: cmd = ADBTALK(addr, 2);
! 344: if (adb_op_sync((Ptr)buffer, cmd) || buffer[0] == 0)
! 345: return (EIO);
! 346:
! 347: if ((buffer[2] & 0xf8) != leds)
! 348: return (EIO);
! 349: else
! 350: return (0);
! 351: }
! 352:
! 353: /*
! 354: * Toggle all of the LED's on and off, just for show.
! 355: */
! 356: void
! 357: blinkleds(struct akbd_softc *sc)
! 358: {
! 359: u_char origleds;
! 360:
! 361: origleds = getleds(sc->adbaddr);
! 362: setleds(sc, LED_NUMLOCK | LED_CAPSLOCK | LED_SCROLL_LOCK);
! 363: delay(400000);
! 364: setleds(sc, origleds);
! 365:
! 366: if (origleds & LED_NUMLOCK)
! 367: sc->sc_leds |= WSKBD_LED_NUM;
! 368: if (origleds & LED_CAPSLOCK)
! 369: sc->sc_leds |= WSKBD_LED_CAPS;
! 370: if (origleds & LED_SCROLL_LOCK)
! 371: sc->sc_leds |= WSKBD_LED_SCROLL;
! 372: }
! 373: #endif
! 374:
! 375: int
! 376: akbd_enable(void *v, int on)
! 377: {
! 378: return 0;
! 379: }
! 380:
! 381: void
! 382: akbd_set_leds(void *v, int on)
! 383: {
! 384: #ifdef notyet
! 385: struct akbd_softc *sc = v;
! 386: int leds;
! 387:
! 388: if (sc->sc_extended) {
! 389: if (sc->sc_leds == on)
! 390: return;
! 391:
! 392: leds = 0;
! 393: if (on & WSKBD_LED_NUM)
! 394: leds |= LED_NUMLOCK;
! 395: if (on & WSKBD_LED_CAPS)
! 396: leds |= LED_CAPSLOCK;
! 397: if (on & WSKBD_LED_SCROLL)
! 398: leds |= LED_SCROLL_LOCK;
! 399:
! 400: setleds(sc, leds);
! 401: }
! 402: #endif
! 403: }
! 404:
! 405: int
! 406: akbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
! 407: {
! 408: struct akbd_softc *sc = v;
! 409:
! 410: switch (cmd) {
! 411:
! 412: case WSKBDIO_GTYPE:
! 413: *(int *)data = WSKBD_TYPE_ADB;
! 414: return 0;
! 415: case WSKBDIO_SETLEDS:
! 416: akbd_set_leds(v, *(int *)data);
! 417: return 0;
! 418: case WSKBDIO_GETLEDS:
! 419: *(int *)data = sc->sc_leds;
! 420: return 0;
! 421: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 422: case WSKBDIO_SETMODE:
! 423: sc->sc_rawkbd = *(int *)data == WSKBD_RAW;
! 424: timeout_del(&sc->sc_rawrepeat_ch);
! 425: return (0);
! 426: #endif
! 427:
! 428: #ifdef mac68k /* XXX not worth creating akbd_machdep_ioctl() */
! 429: case WSKBDIO_BELL:
! 430: case WSKBDIO_COMPLEXBELL:
! 431: #define d ((struct wskbd_bell_data *)data)
! 432: mac68k_ring_bell(d->pitch, d->period * hz / 1000, d->volume);
! 433: #undef d
! 434: return (0);
! 435: #endif
! 436:
! 437: default:
! 438: return (-1);
! 439: }
! 440: }
! 441:
! 442: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 443: void
! 444: akbd_rawrepeat(void *v)
! 445: {
! 446: struct akbd_softc *sc = v;
! 447: int s;
! 448:
! 449: s = spltty();
! 450: wskbd_rawinput(sc->sc_wskbddev, sc->sc_rep, sc->sc_nrep);
! 451: splx(s);
! 452: timeout_add(&sc->sc_rawrepeat_ch, hz * REP_DELAYN / 1000);
! 453: }
! 454: #endif
! 455:
! 456: /*
! 457: * The ``caps lock'' key is special: since on earlier keyboards, the physical
! 458: * key stays down when pressed, we will get a notification of the key press,
! 459: * but not of the key release. Then, when it is pressed again, we will not get
! 460: * a notification of the key press, but will see the key release.
! 461: *
! 462: * This is not exactly true. We see the missing release and press events both
! 463: * as the release of the power (reset) key.
! 464: *
! 465: * To avoid confusing them with real power key presses, we maintain two
! 466: * states for the caps lock key: logically down (from wscons' point of view),
! 467: * and ``physically'' down (from the adb messages point of view), to ignore
! 468: * the power key. But since one may press the power key while the caps lock
! 469: * is held down, we also have to remember the state of the power key... this
! 470: * is quite messy.
! 471: */
! 472:
! 473: /*
! 474: * Values for caps lock state machine
! 475: */
! 476: #define CL_DOWN_ADB 0x01
! 477: #define CL_DOWN_LOGICAL 0x02
! 478: #define CL_DOWN_RESET 0x04
! 479:
! 480: /*
! 481: * Given a keyboard ADB event, decode the keycodes and pass them to wskbd.
! 482: */
! 483: void
! 484: akbd_processevent(struct akbd_softc *sc, adb_event_t *event)
! 485: {
! 486: switch (event->byte_count) {
! 487: case 1:
! 488: akbd_capslockwrapper(sc, event->bytes[0]);
! 489: break;
! 490: case 2:
! 491: /*
! 492: * The reset (or power) key sends 0x7f7f on press and
! 493: * 0xffff on release, and we ignore it.
! 494: */
! 495: if (event->bytes[0] == event->bytes[1] &&
! 496: ADBK_KEYVAL(event->bytes[0]) == ADBK_RESET) {
! 497: if (event->bytes[0] == ADBK_KEYDOWN(ADBK_RESET))
! 498: SET(sc->sc_caps, CL_DOWN_RESET);
! 499: else {
! 500: if (ISSET(sc->sc_caps, CL_DOWN_RESET))
! 501: CLR(sc->sc_caps, CL_DOWN_RESET);
! 502: else if (ISSET(sc->sc_caps, CL_DOWN_ADB)) {
! 503: akbd_input(sc, ISSET(sc->sc_caps,
! 504: CL_DOWN_LOGICAL) ?
! 505: ADBK_KEYDOWN(ADBK_CAPSLOCK) :
! 506: ADBK_KEYUP(ADBK_CAPSLOCK));
! 507: sc->sc_caps ^= CL_DOWN_LOGICAL;
! 508: }
! 509: }
! 510: } else {
! 511: akbd_capslockwrapper(sc, event->bytes[0]);
! 512: akbd_capslockwrapper(sc, event->bytes[1]);
! 513: }
! 514: break;
! 515: default:
! 516: #ifdef DIAGNOSTIC
! 517: printf("%s: unexpected message length %d\n",
! 518: sc->sc_dev.dv_xname, event->byte_count);
! 519: #endif
! 520: break;
! 521: }
! 522:
! 523: }
! 524:
! 525: void
! 526: akbd_capslockwrapper(struct akbd_softc *sc, int key)
! 527: {
! 528: if (ADBK_KEYVAL(key) == ADBK_CAPSLOCK)
! 529: sc->sc_caps ^= CL_DOWN_ADB;
! 530:
! 531: if (key != 0xff)
! 532: akbd_input(sc, key);
! 533: }
! 534:
! 535: int adb_polledkey;
! 536: void
! 537: akbd_input(struct akbd_softc *sc, int key)
! 538: {
! 539: int press, val;
! 540: int type;
! 541:
! 542: press = ADBK_PRESS(key);
! 543: val = ADBK_KEYVAL(key);
! 544:
! 545: type = press ? WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP;
! 546:
! 547: if (adb_polling) {
! 548: adb_polledkey = key;
! 549: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 550: } else if (sc->sc_rawkbd) {
! 551: char cbuf[MAXKEYS *2];
! 552: int c, j, s;
! 553: int npress;
! 554:
! 555: j = npress = 0;
! 556:
! 557: c = keyboard[val];
! 558: if (c == 0) {
! 559: return; /* XXX */
! 560: }
! 561: if (c & 0x80)
! 562: cbuf[j++] = 0xe0;
! 563: cbuf[j] = c & 0x7f;
! 564: if (type == WSCONS_EVENT_KEY_UP) {
! 565: cbuf[j] |= 0x80;
! 566: } else {
! 567: /* this only records last key pressed */
! 568: if (c & 0x80)
! 569: sc->sc_rep[npress++] = 0xe0;
! 570: sc->sc_rep[npress++] = c & 0x7f;
! 571: }
! 572: j++;
! 573: s = spltty();
! 574: wskbd_rawinput(sc->sc_wskbddev, cbuf, j);
! 575: splx(s);
! 576: timeout_del(&sc->sc_rawrepeat_ch);
! 577: sc->sc_nrep = npress;
! 578: if (npress != 0)
! 579: timeout_add(&sc->sc_rawrepeat_ch, hz * REP_DELAY1/1000);
! 580: #endif
! 581: } else {
! 582: wskbd_input(sc->sc_wskbddev, type, val);
! 583: }
! 584: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to akbd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / adb