Annotation of sys/arch/hppa/gsc/gsckbd.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: gsckbd.c,v 1.7 2006/12/17 21:26:53 miod Exp $ */
! 2: /*
! 3: * Copyright (c) 2003, Miodrag Vallat.
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: *
! 15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 16: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 18: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 19: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 20: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 21: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 22: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 23: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 24: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 25: * POSSIBILITY OF SUCH DAMAGE.
! 26: *
! 27: */
! 28:
! 29: /*
! 30: * Derived from /sys/dev/pckbc/pckbd.c under the following terms:
! 31: * OpenBSD: pckbd.c,v 1.4 2002/03/14 01:27:00 millert Exp
! 32: * NetBSD: pckbd.c,v 1.24 2000/06/05 22:20:57 sommerfeld Exp
! 33: */
! 34: /*-
! 35: * Copyright (c) 1998 The NetBSD Foundation, Inc.
! 36: * All rights reserved.
! 37: *
! 38: * This code is derived from software contributed to The NetBSD Foundation
! 39: * by Charles M. Hannum.
! 40: *
! 41: * Redistribution and use in source and binary forms, with or without
! 42: * modification, are permitted provided that the following conditions
! 43: * are met:
! 44: * 1. Redistributions of source code must retain the above copyright
! 45: * notice, this list of conditions and the following disclaimer.
! 46: * 2. Redistributions in binary form must reproduce the above copyright
! 47: * notice, this list of conditions and the following disclaimer in the
! 48: * documentation and/or other materials provided with the distribution.
! 49: * 3. All advertising materials mentioning features or use of this software
! 50: * must display the following acknowledgement:
! 51: * This product includes software developed by the NetBSD
! 52: * Foundation, Inc. and its contributors.
! 53: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 54: * contributors may be used to endorse or promote products derived
! 55: * from this software without specific prior written permission.
! 56: *
! 57: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 58: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 59: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 60: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 61: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 62: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 63: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 64: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 65: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 66: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 67: * POSSIBILITY OF SUCH DAMAGE.
! 68: */
! 69:
! 70: /*-
! 71: * Copyright (c) 1990 The Regents of the University of California.
! 72: * All rights reserved.
! 73: *
! 74: * This code is derived from software contributed to Berkeley by
! 75: * William Jolitz and Don Ahn.
! 76: *
! 77: * Redistribution and use in source and binary forms, with or without
! 78: * modification, are permitted provided that the following conditions
! 79: * are met:
! 80: * 1. Redistributions of source code must retain the above copyright
! 81: * notice, this list of conditions and the following disclaimer.
! 82: * 2. Redistributions in binary form must reproduce the above copyright
! 83: * notice, this list of conditions and the following disclaimer in the
! 84: * documentation and/or other materials provided with the distribution.
! 85: * 3. Neither the name of the University nor the names of its contributors
! 86: * may be used to endorse or promote products derived from this software
! 87: * without specific prior written permission.
! 88: *
! 89: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 90: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 91: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 92: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 93: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 94: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 95: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 96: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 97: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 98: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 99: * SUCH DAMAGE.
! 100: *
! 101: * @(#)pccons.c 5.11 (Berkeley) 5/21/91
! 102: */
! 103:
! 104: /*
! 105: * A pckbd-like driver for the GSC keyboards found on various HP workstations.
! 106: */
! 107:
! 108: #include <sys/param.h>
! 109: #include <sys/systm.h>
! 110: #include <sys/device.h>
! 111: #include <sys/malloc.h>
! 112: #include <sys/ioctl.h>
! 113:
! 114: #include <machine/bus.h>
! 115:
! 116: #include <dev/ic/pckbcvar.h>
! 117:
! 118: #include <dev/pckbc/pckbdreg.h>
! 119: #include <hppa/gsc/gsckbdvar.h>
! 120: #include <hppa/gsc/gsckbdmap.h>
! 121:
! 122: #include <dev/wscons/wsconsio.h>
! 123: #include <dev/wscons/wskbdvar.h>
! 124: #include <dev/wscons/wsksymdef.h>
! 125: #include <dev/wscons/wsksymvar.h>
! 126:
! 127: struct gsckbd_internal {
! 128: int t_isconsole;
! 129: pckbc_tag_t t_kbctag;
! 130: pckbc_slot_t t_kbcslot;
! 131:
! 132: int t_lastchar;
! 133: int t_extended;
! 134: int t_releasing;
! 135: int t_extended1;
! 136:
! 137: struct gsckbd_softc *t_sc; /* back pointer */
! 138: };
! 139:
! 140: struct gsckbd_softc {
! 141: struct device sc_dev;
! 142:
! 143: struct gsckbd_internal *id;
! 144: int sc_enabled;
! 145:
! 146: int sc_ledstate;
! 147:
! 148: struct device *sc_wskbddev;
! 149: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 150: int rawkbd;
! 151: #endif
! 152: };
! 153:
! 154: int gsckbd_is_console(pckbc_tag_t, pckbc_slot_t);
! 155:
! 156: int gsckbdprobe(struct device *, void *, void *);
! 157: void gsckbdattach(struct device *, struct device *, void *);
! 158:
! 159: struct cfdriver gsckbd_cd = {
! 160: NULL, "gsckbd", DV_DULL
! 161: };
! 162:
! 163: struct cfattach gsckbd_ca = {
! 164: sizeof(struct gsckbd_softc), gsckbdprobe, gsckbdattach,
! 165: };
! 166:
! 167: int gsckbd_enable(void *, int);
! 168: void gsckbd_set_leds(void *, int);
! 169: int gsckbd_ioctl(void *, u_long, caddr_t, int, struct proc *);
! 170:
! 171: const struct wskbd_accessops gsckbd_accessops = {
! 172: gsckbd_enable,
! 173: gsckbd_set_leds,
! 174: gsckbd_ioctl,
! 175: };
! 176:
! 177: void gsckbd_cngetc(void *, u_int *, int *);
! 178: void gsckbd_cnpollc(void *, int);
! 179:
! 180: const struct wskbd_consops gsckbd_consops = {
! 181: gsckbd_cngetc,
! 182: gsckbd_cnpollc,
! 183: NULL
! 184: };
! 185:
! 186: const struct wskbd_mapdata gsckbd_keymapdata = {
! 187: gsckbd_keydesctab, /* XXX */
! 188: #ifdef GSCKBD_LAYOUT
! 189: GSCKBD_LAYOUT,
! 190: #else
! 191: KB_US,
! 192: #endif
! 193: };
! 194:
! 195: int gsckbd_init(struct gsckbd_internal *, pckbc_tag_t, pckbc_slot_t,
! 196: int);
! 197: void gsckbd_input(void *, int);
! 198:
! 199: static int gsckbd_decode(struct gsckbd_internal *, int,
! 200: u_int *, int *);
! 201: static int gsckbd_led_encode(int);
! 202: static int gsckbd_led_decode(int);
! 203:
! 204: struct gsckbd_internal gsckbd_consdata;
! 205:
! 206: int
! 207: gsckbd_is_console(tag, slot)
! 208: pckbc_tag_t tag;
! 209: pckbc_slot_t slot;
! 210: {
! 211: return (gsckbd_consdata.t_isconsole &&
! 212: (tag == gsckbd_consdata.t_kbctag) &&
! 213: (slot == gsckbd_consdata.t_kbcslot));
! 214: }
! 215:
! 216: /*
! 217: * these are both EXTREMELY bad jokes
! 218: */
! 219: int
! 220: gsckbdprobe(parent, match, aux)
! 221: struct device *parent;
! 222: void *match;
! 223: void *aux;
! 224: {
! 225: struct cfdata *cf = match;
! 226: struct pckbc_attach_args *pa = aux;
! 227: u_char cmd[1], resp[1];
! 228: int res;
! 229:
! 230: /*
! 231: * XXX There are rumours that a keyboard can be connected
! 232: * to the aux port as well. For me, this didn't work.
! 233: * For further experiments, allow it if explicitly
! 234: * wired in the config file.
! 235: */
! 236: if ((pa->pa_slot != PCKBC_KBD_SLOT) &&
! 237: (cf->cf_loc[PCKBCCF_SLOT] == PCKBCCF_SLOT_DEFAULT))
! 238: return (0);
! 239:
! 240: /* Flush any garbage. */
! 241: pckbc_flush(pa->pa_tag, pa->pa_slot);
! 242:
! 243: /* Reset the keyboard. */
! 244: cmd[0] = KBC_RESET;
! 245: res = pckbc_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 1, resp, 1);
! 246: if (res) {
! 247: #ifdef DEBUG
! 248: printf("gsckbdprobe: reset error %d\n", res);
! 249: #endif
! 250: /*
! 251: * There is probably no keyboard connected.
! 252: * Let the probe succeed if the keyboard is used
! 253: * as console input - it can be connected later.
! 254: */
! 255: return (gsckbd_is_console(pa->pa_tag, pa->pa_slot) ? 1 : 0);
! 256: }
! 257: if (resp[0] != KBR_RSTDONE) {
! 258: printf("gsckbdprobe: reset response 0x%x\n", resp[0]);
! 259: return (0);
! 260: }
! 261:
! 262: /*
! 263: * Some keyboards seem to leave a second ack byte after the reset.
! 264: * This is kind of stupid, but we account for them anyway by just
! 265: * flushing the buffer.
! 266: */
! 267: pckbc_flush(pa->pa_tag, pa->pa_slot);
! 268:
! 269: return (2);
! 270: }
! 271:
! 272: void
! 273: gsckbdattach(parent, self, aux)
! 274: struct device *parent, *self;
! 275: void *aux;
! 276: {
! 277: struct gsckbd_softc *sc = (void *)self;
! 278: struct pckbc_attach_args *pa = aux;
! 279: int isconsole;
! 280: struct wskbddev_attach_args a;
! 281: u_char cmd[1];
! 282:
! 283: printf("\n");
! 284:
! 285: isconsole = gsckbd_is_console(pa->pa_tag, pa->pa_slot);
! 286:
! 287: if (isconsole) {
! 288: sc->id = &gsckbd_consdata;
! 289: /*
! 290: * Some keyboards are not enabled after a reset,
! 291: * so make sure it is enabled now.
! 292: */
! 293: cmd[0] = KBC_ENABLE;
! 294: (void) pckbc_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
! 295: cmd, 1, 0, 0, 0);
! 296: sc->sc_enabled = 1;
! 297: } else {
! 298: sc->id = malloc(sizeof(struct gsckbd_internal),
! 299: M_DEVBUF, M_WAITOK);
! 300: (void) gsckbd_init(sc->id, pa->pa_tag, pa->pa_slot, 0);
! 301:
! 302: /* no interrupts until enabled */
! 303: cmd[0] = KBC_DISABLE;
! 304: (void) pckbc_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
! 305: cmd, 1, 0, 0, 0);
! 306: sc->sc_enabled = 0;
! 307: }
! 308:
! 309: sc->id->t_sc = sc;
! 310:
! 311: pckbc_set_inputhandler(sc->id->t_kbctag, sc->id->t_kbcslot,
! 312: gsckbd_input, sc, sc->sc_dev.dv_xname);
! 313:
! 314: a.console = isconsole;
! 315:
! 316: a.keymap = &gsckbd_keymapdata;
! 317:
! 318: a.accessops = &gsckbd_accessops;
! 319: a.accesscookie = sc;
! 320:
! 321: /*
! 322: * Attach the wskbd, saving a handle to it.
! 323: * XXX XXX XXX
! 324: */
! 325: sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
! 326: }
! 327:
! 328: int
! 329: gsckbd_enable(v, on)
! 330: void *v;
! 331: int on;
! 332: {
! 333: struct gsckbd_softc *sc = v;
! 334: u_char cmd[1];
! 335: int res;
! 336:
! 337: if (on) {
! 338: if (sc->sc_enabled && !sc->id->t_isconsole)
! 339: return (EBUSY);
! 340:
! 341: pckbc_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 1);
! 342:
! 343: cmd[0] = KBC_ENABLE;
! 344: res = pckbc_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
! 345: cmd, 1, 0, NULL, 0);
! 346: if (res) {
! 347: printf("gsckbd_enable: command error\n");
! 348: return (res);
! 349: }
! 350:
! 351: sc->sc_enabled = 1;
! 352: } else {
! 353: if (sc->id->t_isconsole)
! 354: return (EBUSY);
! 355:
! 356: cmd[0] = KBC_DISABLE;
! 357: res = pckbc_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
! 358: cmd, 1, 0, 1, 0);
! 359: if (res) {
! 360: printf("gsckbd_disable: command error\n");
! 361: return (res);
! 362: }
! 363:
! 364: pckbc_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 0);
! 365:
! 366: sc->sc_enabled = 0;
! 367: }
! 368:
! 369: return (0);
! 370: }
! 371:
! 372: static int
! 373: gsckbd_decode(id, datain, type, dataout)
! 374: struct gsckbd_internal *id;
! 375: int datain;
! 376: u_int *type;
! 377: int *dataout;
! 378: {
! 379: int key;
! 380:
! 381: if (datain == KBR_BREAK) {
! 382: id->t_releasing = 1; /* next keycode is a release */
! 383: return 0;
! 384: }
! 385:
! 386: if (datain == KBR_EXTENDED0) {
! 387: id->t_extended = 0x80;
! 388: return 0;
! 389: } else if (datain == KBR_EXTENDED1) {
! 390: id->t_extended1 = 2;
! 391: return 0;
! 392: }
! 393:
! 394: /*
! 395: * Map extended keys to codes 128-254
! 396: * Note that we do not use (datain & 0x7f) because function key
! 397: * F7 produces non-extended 0x83 code. Sucker.
! 398: */
! 399: key = datain | id->t_extended;
! 400: id->t_extended = 0;
! 401:
! 402: /*
! 403: * process BREAK sequence (EXT1 14 77):
! 404: * map to (unused) code 7F
! 405: */
! 406: if (id->t_extended1 == 2 && datain == 0x14) {
! 407: id->t_extended1 = 1;
! 408: return 0;
! 409: } else if (id->t_extended1 == 1 && datain == 0x77) {
! 410: id->t_extended1 = 0;
! 411: key = 0x7f;
! 412: } else if (id->t_extended1 > 0) {
! 413: id->t_extended1 = 0;
! 414: }
! 415:
! 416: if (id->t_releasing) {
! 417: id->t_releasing = 0;
! 418: *type = WSCONS_EVENT_KEY_UP;
! 419: *dataout = key;
! 420: id->t_lastchar = 0;
! 421: } else {
! 422: /* Always ignore typematic keys */
! 423: if (key == id->t_lastchar)
! 424: return 0;
! 425: *dataout = id->t_lastchar = key;
! 426: *type = WSCONS_EVENT_KEY_DOWN;
! 427: }
! 428:
! 429: return 1;
! 430: }
! 431:
! 432: int
! 433: gsckbd_init(t, kbctag, kbcslot, console)
! 434: struct gsckbd_internal *t;
! 435: pckbc_tag_t kbctag;
! 436: pckbc_slot_t kbcslot;
! 437: int console;
! 438: {
! 439: bzero(t, sizeof(struct gsckbd_internal));
! 440:
! 441: t->t_isconsole = console;
! 442: t->t_kbctag = kbctag;
! 443: t->t_kbcslot = kbcslot;
! 444:
! 445: return (0);
! 446: }
! 447:
! 448: static int
! 449: gsckbd_led_encode(led)
! 450: int led;
! 451: {
! 452: int res;
! 453:
! 454: res = 0;
! 455:
! 456: if (led & WSKBD_LED_SCROLL)
! 457: res |= 0x01;
! 458: if (led & WSKBD_LED_NUM)
! 459: res |= 0x02;
! 460: if (led & WSKBD_LED_CAPS)
! 461: res |= 0x04;
! 462: return(res);
! 463: }
! 464:
! 465: static int
! 466: gsckbd_led_decode(led)
! 467: int led;
! 468: {
! 469: int res;
! 470:
! 471: res = 0;
! 472: if (led & 0x01)
! 473: res |= WSKBD_LED_SCROLL;
! 474: if (led & 0x02)
! 475: res |= WSKBD_LED_NUM;
! 476: if (led & 0x04)
! 477: res |= WSKBD_LED_CAPS;
! 478: return(res);
! 479: }
! 480:
! 481: void
! 482: gsckbd_set_leds(v, leds)
! 483: void *v;
! 484: int leds;
! 485: {
! 486: struct gsckbd_softc *sc = v;
! 487: u_char cmd[2];
! 488:
! 489: cmd[0] = KBC_MODEIND;
! 490: cmd[1] = gsckbd_led_encode(leds);
! 491: sc->sc_ledstate = cmd[1];
! 492:
! 493: pckbc_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
! 494: cmd, 2, 0, 0, 0);
! 495: }
! 496:
! 497: /*
! 498: * Got a console receive interrupt -
! 499: * the console processor wants to give us a character.
! 500: */
! 501: void
! 502: gsckbd_input(vsc, data)
! 503: void *vsc;
! 504: int data;
! 505: {
! 506: struct gsckbd_softc *sc = vsc;
! 507: int type, key;
! 508:
! 509: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 510: if (sc->rawkbd) {
! 511: char d = data;
! 512: wskbd_rawinput(sc->sc_wskbddev, &d, 1);
! 513: return;
! 514: }
! 515: #endif
! 516: if (gsckbd_decode(sc->id, data, &type, &key))
! 517: wskbd_input(sc->sc_wskbddev, type, key);
! 518: }
! 519:
! 520: int
! 521: gsckbd_ioctl(v, cmd, data, flag, p)
! 522: void *v;
! 523: u_long cmd;
! 524: caddr_t data;
! 525: int flag;
! 526: struct proc *p;
! 527: {
! 528: struct gsckbd_softc *sc = v;
! 529:
! 530: switch (cmd) {
! 531: case WSKBDIO_GTYPE:
! 532: *(int *)data = WSKBD_TYPE_GSC;
! 533: return 0;
! 534: case WSKBDIO_SETLEDS:
! 535: {
! 536: char cmd[2];
! 537: int res;
! 538: cmd[0] = KBC_MODEIND;
! 539: cmd[1] = gsckbd_led_encode(*(int *)data);
! 540: sc->sc_ledstate = cmd[1];
! 541: res = pckbc_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
! 542: cmd, 2, 0, 1, 0);
! 543: return (res);
! 544: }
! 545: case WSKBDIO_GETLEDS:
! 546: *(int *)data = gsckbd_led_decode(sc->sc_ledstate);
! 547: return (0);
! 548: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 549: case WSKBDIO_SETMODE:
! 550: sc->rawkbd = (*(int *)data == WSKBD_RAW);
! 551: return (0);
! 552: #endif
! 553: }
! 554: return -1;
! 555: }
! 556:
! 557: int
! 558: gsckbd_cnattach(kbctag, kbcslot)
! 559: pckbc_tag_t kbctag;
! 560: int kbcslot;
! 561: {
! 562: char cmd[1];
! 563: int res;
! 564:
! 565: res = gsckbd_init(&gsckbd_consdata, kbctag, kbcslot, 1);
! 566: #if 0 /* we allow the console to be attached if no keyboard is present */
! 567: if (res)
! 568: return (res);
! 569: #endif
! 570:
! 571: /* Just to be sure. */
! 572: cmd[0] = KBC_ENABLE;
! 573: res = pckbc_poll_cmd(kbctag, kbcslot, cmd, 1, 0, 0, 0);
! 574: #if 0
! 575: if (res)
! 576: return (res);
! 577: #endif
! 578:
! 579: wskbd_cnattach(&gsckbd_consops, &gsckbd_consdata, &gsckbd_keymapdata);
! 580:
! 581: return (0);
! 582: }
! 583:
! 584: /* ARGSUSED */
! 585: void
! 586: gsckbd_cngetc(v, type, data)
! 587: void *v;
! 588: u_int *type;
! 589: int *data;
! 590: {
! 591: struct gsckbd_internal *t = v;
! 592: int val;
! 593:
! 594: for (;;) {
! 595: val = pckbc_poll_data(t->t_kbctag, t->t_kbcslot);
! 596: if ((val != -1) && gsckbd_decode(t, val, type, data))
! 597: return;
! 598: }
! 599: }
! 600:
! 601: void
! 602: gsckbd_cnpollc(v, on)
! 603: void *v;
! 604: int on;
! 605: {
! 606: struct gsckbd_internal *t = v;
! 607:
! 608: pckbc_set_poll(t->t_kbctag, t->t_kbcslot, on);
! 609: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to gsckbd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / gsc