zs_kbd.c revision 1.4
1 /* $NetBSD: zs_kbd.c,v 1.4 2004/07/20 05:19:23 rumble Exp $ */ 2 3 /* 4 * Copyright (c) 2004 Steve Rumble 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. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 /* 31 * IP12/IP20 serial keyboard driver attached to zs channel 0 at 600bps. 32 * This layer is the parent of wskbd. 33 */ 34 35 #include <sys/cdefs.h> 36 __KERNEL_RCSID(0, "$NetBSD: zs_kbd.c,v 1.4 2004/07/20 05:19:23 rumble Exp $"); 37 38 #include <sys/param.h> 39 #include <sys/malloc.h> 40 #include <sys/systm.h> 41 #include <sys/conf.h> 42 #include <sys/device.h> 43 44 #include <dev/wscons/wsconsio.h> 45 #include <dev/wscons/wskbdvar.h> 46 #include <dev/wscons/wsksymdef.h> 47 #include <dev/wscons/wsksymvar.h> 48 49 #include <dev/ic/z8530reg.h> 50 #include <machine/machtype.h> 51 #include <machine/z8530var.h> 52 53 #define ZSKBD_BAUD 600 54 #define ZSKBD_TXQ_LEN 16 /* power of 2 */ 55 #define ZSKBD_RXQ_LEN 64 /* power of 2 */ 56 57 #define ZSKBD_DIP_SYNC 0x6E 58 #define ZSKBD_KEY_UP 0x80 59 60 #ifdef ZSKBD_DEBUG 61 int zskbd_debug = 0; 62 63 #define DPRINTF(_x) if (zskbd_debug) printf _x 64 #else 65 #define DPRINTF(_x) 66 #endif 67 68 struct zskbd_softc { 69 struct device sc_dev; 70 71 struct zskbd_devconfig *sc_dc; 72 }; 73 74 struct zskbd_devconfig { 75 /* transmit tail-chasing fifo */ 76 u_char txq[ZSKBD_TXQ_LEN]; 77 u_int txq_head; 78 u_int txq_tail; 79 80 /* receive tail-chasing fifo */ 81 u_char rxq[ZSKBD_RXQ_LEN]; 82 u_int rxq_head; 83 u_int rxq_tail; 84 85 /* state */ 86 #define TX_READY 0x1 87 #define RX_DIP 0x2 88 u_int state; 89 90 /* keyboard configuration */ 91 #define ZSKBD_CTRL_A 0x0 92 #define ZSKBD_CTRL_A_SBEEP 0x2 /* 200 ms */ 93 #define ZSKBD_CTRL_A_LBEEP 0x4 /* 1000 ms */ 94 #define ZSKBD_CTRL_A_NOCLICK 0x8 /* turn off keyboard click */ 95 #define ZSKBD_CTRL_A_RCB 0x10 /* request config byte */ 96 #define ZSKBD_CTRL_A_NUMLK 0x20 /* num lock led */ 97 #define ZSKBD_CTRL_A_CAPSLK 0x40 /* caps lock led */ 98 #define ZSKBD_CTRL_A_AUTOREP 0x80 /* auto-repeat after 650 ms, 28x/sec */ 99 100 #define ZSKBD_CTRL_B 0x1 101 #define ZSKBD_CTRL_B_CMPL_DS1_2 0x2 /* complement of ds1+ds2 (num+capslk) */ 102 #define ZSKBD_CTRL_B_SCRLK 0x4 /* scroll lock light */ 103 #define ZSKBD_CTRL_B_L1 0x8 /* user-configurable lights */ 104 #define ZSKBD_CTRL_B_L2 0x10 105 #define ZSKBD_CTRL_B_L3 0x20 106 #define ZSKBD_CTRL_B_L4 0x40 107 u_char kbd_conf[2]; 108 109 /* dip switch settings */ 110 u_char dip; 111 112 /* wscons glue */ 113 struct device *wskbddev; 114 int enabled; 115 }; 116 117 static int zskbd_match(struct device *, struct cfdata *, void *); 118 static void zskbd_attach(struct device *, struct device *, void *); 119 static void zskbd_rxint(struct zs_chanstate *); 120 static void zskbd_stint(struct zs_chanstate *, int); 121 static void zskbd_txint(struct zs_chanstate *); 122 static void zskbd_softint(struct zs_chanstate *); 123 static void zskbd_send(struct zs_chanstate *, u_char *, u_int); 124 static void zskbd_ctrl(struct zs_chanstate *, u_char, u_char, 125 u_char, u_char); 126 127 static void zskbd_wskbd_input(struct zs_chanstate *, u_char); 128 static int zskbd_wskbd_enable(void *, int); 129 static void zskbd_wskbd_set_leds(void *, int); 130 static int zskbd_wskbd_get_leds(void *); 131 static void zskbd_wskbd_set_keyclick(void *, int); 132 static int zskbd_wskbd_get_keyclick(void *); 133 static int zskbd_wskbd_ioctl(void *, u_long, caddr_t, int, struct proc *); 134 135 void zskbd_cnattach(int, int); 136 static void zskbd_wskbd_getc(void *, u_int *, int *); 137 static void zskbd_wskbd_pollc(void *, int); 138 static void zskbd_wskbd_bell(void *, u_int, u_int, u_int); 139 140 extern struct zschan *zs_get_chan_addr(int, int); 141 extern int zs_getc(void *); 142 extern void zs_putc(void *, int); 143 144 CFATTACH_DECL(zskbd, sizeof(struct zskbd_softc), 145 zskbd_match, zskbd_attach, NULL, NULL); 146 147 static struct zsops zskbd_zsops = { 148 zskbd_rxint, 149 zskbd_stint, 150 zskbd_txint, 151 zskbd_softint 152 }; 153 154 extern const struct wscons_keydesc wssgi_keydesctab[]; 155 const struct wskbd_mapdata sgikbd_wskbd_keymapdata = { 156 wssgi_keydesctab, KB_US 157 }; 158 159 const struct wskbd_accessops zskbd_wskbd_accessops = { 160 zskbd_wskbd_enable, 161 zskbd_wskbd_set_leds, 162 zskbd_wskbd_ioctl 163 }; 164 165 const struct wskbd_consops zskbd_wskbd_consops = { 166 zskbd_wskbd_getc, 167 zskbd_wskbd_pollc, 168 zskbd_wskbd_bell 169 }; 170 171 static struct zskbd_devconfig zskbd_console_dc; 172 static int zskbd_is_console = 0; 173 174 static int 175 zskbd_match(struct device *parent, struct cfdata *cf, void *aux) 176 { 177 178 if (mach_type == MACH_SGI_IP12 || mach_type == MACH_SGI_IP20) { 179 struct zsc_attach_args *args = aux; 180 181 if (args->channel == 0) 182 return (1); 183 } 184 185 return (0); 186 } 187 188 static void 189 zskbd_attach(struct device *parent, struct device *self, void *aux) 190 { 191 struct zskbd_softc *sc; 192 struct zs_chanstate *cs; 193 struct zsc_softc *zsc; 194 struct zsc_attach_args *args; 195 struct wskbddev_attach_args wskaa; 196 int s, channel; 197 198 zsc = (struct zsc_softc *)parent; 199 sc = (struct zskbd_softc *)self; 200 args = (struct zsc_attach_args *)aux; 201 202 /* Establish ourself with the MD z8530 driver */ 203 channel = args->channel; 204 cs = zsc->zsc_cs[channel]; 205 cs->cs_ops = &zskbd_zsops; 206 cs->cs_private = sc; 207 208 if (zskbd_is_console) { 209 sc->sc_dc = &zskbd_console_dc; 210 wskaa.console = 1; 211 sc->sc_dc->enabled = 1; 212 } else { 213 wskaa.console = 0; 214 215 sc->sc_dc = malloc(sizeof(struct zskbd_devconfig), M_DEVBUF, 216 M_WAITOK); 217 if (sc->sc_dc == NULL) 218 panic("zskbd out of memory"); 219 220 sc->sc_dc->enabled = 0; 221 } 222 223 sc->sc_dc->txq_head = 0; 224 sc->sc_dc->txq_tail = 0; 225 sc->sc_dc->rxq_head = 0; 226 sc->sc_dc->rxq_tail = 0; 227 sc->sc_dc->state = TX_READY; 228 sc->sc_dc->dip = 0; 229 sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] = 0; 230 sc->sc_dc->kbd_conf[ZSKBD_CTRL_B] = 0; 231 232 printf(": baud rate %d\n", ZSKBD_BAUD); 233 234 s = splzs(); 235 zs_write_reg(cs, 9, (channel == 0) ? ZSWR9_A_RESET : ZSWR9_B_RESET); 236 cs->cs_preg[1] = ZSWR1_RIE | ZSWR1_TIE; 237 cs->cs_preg[4] = (cs->cs_preg[4] & ZSWR4_CLK_MASK) | 238 (ZSWR4_ONESB | ZSWR4_PARENB); /* 1 stop, odd parity */ 239 zs_set_speed(cs, ZSKBD_BAUD); 240 zs_loadchannelregs(cs); 241 242 /* request DIP switch settings just in case */ 243 zskbd_ctrl(cs, ZSKBD_CTRL_A_RCB, 0, 0, 0); 244 245 splx(s); 246 247 /* attach wskbd */ 248 wskaa.keymap = &sgikbd_wskbd_keymapdata; 249 wskaa.accessops = &zskbd_wskbd_accessops; 250 wskaa.accesscookie = cs; 251 sc->sc_dc->wskbddev = config_found(self, &wskaa, wskbddevprint); 252 } 253 254 static void 255 zskbd_rxint(struct zs_chanstate *cs) 256 { 257 struct zskbd_softc *sc; 258 struct zskbd_devconfig *dc; 259 u_char c, r; 260 261 sc = (struct zskbd_softc *)cs->cs_private; 262 dc = sc->sc_dc; 263 264 /* clear errors */ 265 r = zs_read_reg(cs, 1); 266 if (r & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) 267 zs_write_csr(cs, ZSWR0_RESET_ERRORS); 268 269 /* read byte and append to our queue */ 270 c = zs_read_data(cs); 271 272 dc->rxq[dc->rxq_tail] = c; 273 dc->rxq_tail = (dc->rxq_tail + 1) & ~ZSKBD_RXQ_LEN; 274 275 cs->cs_softreq = 1; 276 } 277 278 static void 279 zskbd_stint(struct zs_chanstate *cs, int force) 280 { 281 282 zs_write_csr(cs, ZSWR0_RESET_STATUS); 283 cs->cs_softreq = 1; 284 } 285 286 static void 287 zskbd_txint(struct zs_chanstate *cs) 288 { 289 struct zskbd_softc *sc; 290 291 sc = (struct zskbd_softc *)cs->cs_private; 292 zs_write_reg(cs, 0, ZSWR0_RESET_TXINT); 293 sc->sc_dc->state |= TX_READY; 294 cs->cs_softreq = 1; 295 } 296 297 static void 298 zskbd_softint(struct zs_chanstate *cs) 299 { 300 struct zskbd_softc *sc; 301 struct zskbd_devconfig *dc; 302 303 sc = (struct zskbd_softc *)cs->cs_private; 304 dc = sc->sc_dc; 305 306 /* handle pending transmissions */ 307 if (dc->txq_head != dc->txq_tail && (dc->state & TX_READY)) { 308 int s; 309 310 dc->state &= ~TX_READY; 311 312 s = splzs(); 313 zs_write_data(cs, dc->txq[dc->txq_head]); 314 splx(s); 315 316 dc->txq_head = (dc->txq_head + 1) & ~ZSKBD_TXQ_LEN; 317 } 318 319 /* don't bother if nobody is listening */ 320 if (!dc->enabled) { 321 dc->rxq_head = dc->rxq_tail; 322 return; 323 } 324 325 /* handle incoming keystrokes/config */ 326 while (dc->rxq_head != dc->rxq_tail) { 327 u_char key = dc->rxq[dc->rxq_head]; 328 329 if (dc->state & RX_DIP) { 330 dc->dip = key; 331 dc->state &= ~RX_DIP; 332 } else if (key == ZSKBD_DIP_SYNC) { 333 dc->state |= RX_DIP; 334 } else { 335 /* toss wskbd a bone */ 336 zskbd_wskbd_input(cs, key); 337 } 338 339 dc->rxq_head = (dc->rxq_head + 1) & ~ZSKBD_RXQ_LEN; 340 } 341 } 342 343 /* expects to be in splzs() */ 344 static void 345 zskbd_send(struct zs_chanstate *cs, u_char *c, u_int len) 346 { 347 u_int i; 348 struct zskbd_softc *sc; 349 struct zskbd_devconfig *dc; 350 351 sc = (struct zskbd_softc *)cs->cs_private; 352 dc = sc->sc_dc; 353 354 for (i = 0; i < len; i++) { 355 if (dc->state & TX_READY) { 356 zs_write_data(cs, c[i]); 357 dc->state &= ~TX_READY; 358 } else { 359 dc->txq[dc->txq_tail] = c[i]; 360 dc->txq_tail = (dc->txq_tail + 1) & ~ZSKBD_TXQ_LEN; 361 cs->cs_softreq = 1; 362 } 363 } 364 } 365 366 /* expects to be in splzs() */ 367 static void 368 zskbd_ctrl(struct zs_chanstate *cs, u_char a_on, u_char a_off, 369 u_char b_on, u_char b_off) 370 { 371 struct zskbd_softc *sc; 372 struct zskbd_devconfig *dc; 373 374 sc = (struct zskbd_softc *)cs->cs_private; 375 dc = sc->sc_dc; 376 377 dc->kbd_conf[ZSKBD_CTRL_A] |= a_on; 378 dc->kbd_conf[ZSKBD_CTRL_A] &= ~(a_off | ZSKBD_CTRL_B); 379 dc->kbd_conf[ZSKBD_CTRL_B] &= ~b_off; 380 dc->kbd_conf[ZSKBD_CTRL_B] |= (b_on | ZSKBD_CTRL_B); 381 382 zskbd_send(cs, dc->kbd_conf, 2); 383 384 /* make sure we don't resend these each time */ 385 dc->kbd_conf[ZSKBD_CTRL_A] &= ~(ZSKBD_CTRL_A_RCB | ZSKBD_CTRL_A_SBEEP | 386 ZSKBD_CTRL_A_LBEEP); 387 } 388 389 /****************************************************************************** 390 * wskbd glue 391 ******************************************************************************/ 392 393 static void 394 zskbd_wskbd_input(struct zs_chanstate *cs, u_char key) 395 { 396 struct zskbd_softc *sc; 397 u_int type; 398 399 sc = (struct zskbd_softc *)cs->cs_private; 400 401 if (key & ZSKBD_KEY_UP) 402 type = WSCONS_EVENT_KEY_UP; 403 else 404 type = WSCONS_EVENT_KEY_DOWN; 405 406 wskbd_input(sc->sc_dc->wskbddev, type, (key & ~ZSKBD_KEY_UP)); 407 408 DPRINTF(("zskbd_wskbd_input: inputted key 0x%x\n", key)); 409 410 #ifdef WSDISPLAY_COMPAT_RAWKBD 411 wskbd_rawinput(sc->sc_dc->wskbddev, &key, 1); 412 #endif 413 } 414 415 static int 416 zskbd_wskbd_enable(void *cookie, int on) 417 { 418 struct zskbd_softc *sc; 419 420 sc = (struct zskbd_softc *)((struct zs_chanstate *)cookie)->cs_private; 421 422 if (on) { 423 if (sc->sc_dc->enabled) 424 return (EBUSY); 425 else 426 sc->sc_dc->enabled = 1; 427 } else 428 sc->sc_dc->enabled = 0; 429 430 DPRINTF(("zskbd_wskbd_enable: %s\n", on ? "enabled" : "disabled")); 431 432 return (0); 433 } 434 435 static void 436 zskbd_wskbd_set_leds(void *cookie, int leds) 437 { 438 int s; 439 u_char a_on, a_off, b_on, b_off; 440 441 a_on = a_off = b_on = b_off = 0; 442 443 if (leds & WSKBD_LED_CAPS) 444 a_on |= ZSKBD_CTRL_A_CAPSLK; 445 else 446 a_off |= ZSKBD_CTRL_A_CAPSLK; 447 448 if (leds & WSKBD_LED_NUM) 449 a_on |= ZSKBD_CTRL_A_NUMLK; 450 else 451 a_off |= ZSKBD_CTRL_A_NUMLK; 452 453 if (leds & WSKBD_LED_SCROLL) 454 b_on |= ZSKBD_CTRL_B_SCRLK; 455 else 456 b_off |= ZSKBD_CTRL_B_SCRLK; 457 458 s = splzs(); 459 zskbd_ctrl((struct zs_chanstate *)cookie, a_on, a_off, b_on, b_off); 460 splx(s); 461 } 462 463 static int 464 zskbd_wskbd_get_leds(void *cookie) 465 { 466 struct zskbd_softc *sc; 467 int leds; 468 469 sc = (struct zskbd_softc *)((struct zs_chanstate *)cookie)->cs_private; 470 leds = 0; 471 472 if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_NUMLK) 473 leds |= WSKBD_LED_NUM; 474 475 if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_CAPSLK) 476 leds |= WSKBD_LED_CAPS; 477 478 if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_B] & ZSKBD_CTRL_B_SCRLK) 479 leds |= WSKBD_LED_SCROLL; 480 481 return (leds); 482 } 483 484 static void 485 zskbd_wskbd_set_keyclick(void *cookie, int on) 486 { 487 int s; 488 struct zs_chanstate *cs; 489 490 cs = (struct zs_chanstate *)cookie; 491 492 if (on) { 493 if (!zskbd_wskbd_get_keyclick(cookie)) { 494 s = splzs(); 495 zskbd_ctrl(cs, 0, ZSKBD_CTRL_A_NOCLICK, 0, 0); 496 splx(s); 497 } 498 } else { 499 if (zskbd_wskbd_get_keyclick(cookie)) { 500 s = splzs(); 501 zskbd_ctrl(cs, ZSKBD_CTRL_A_NOCLICK, 0, 0, 0); 502 splx(s); 503 } 504 } 505 } 506 507 static int 508 zskbd_wskbd_get_keyclick(void *cookie) 509 { 510 struct zskbd_softc *sc; 511 512 sc = (struct zskbd_softc *)((struct zs_chanstate *)cookie)->cs_private; 513 514 if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_NOCLICK) 515 return (0); 516 else 517 return (1); 518 } 519 520 static int 521 zskbd_wskbd_ioctl(void *cookie, u_long cmd, 522 caddr_t data, int flag, struct proc *p) 523 { 524 525 switch (cmd) { 526 case WSKBDIO_GTYPE: 527 *(int *)data = WSKBD_TYPE_SGI; 528 break; 529 530 #ifdef notyet 531 case WSKBDIO_BELL: 532 case WSKBDIO_COMPLEXBELL: 533 case WSKBDIO_SETBELL: 534 case WSKBDIO_GETBELL: 535 case WSKBDIO_SETDEFAULTBELL: 536 case WSKBDIO_GETDEFAULTBELL: 537 case WSKBDIO_SETKEYREPEAT: 538 case WSKBDIO_GETKEYREPEAT: 539 case WSKBDIO_SETDEFAULTKEYREPEAT: 540 case WSKBDIO_GETDEFAULTKEYREPEAT: 541 #endif 542 543 case WSKBDIO_SETLEDS: 544 zskbd_wskbd_set_leds(cookie, *(int *)data); 545 break; 546 547 case WSKBDIO_GETLEDS: 548 *(int *)data = zskbd_wskbd_get_leds(cookie); 549 break; 550 551 #ifdef notyet 552 case WSKBDIO_GETMAP: 553 case WSKBDIO_SETMAP: 554 case WSKBDIO_GETENCODING: 555 case WSKBDIO_SETENCODING: 556 case WSKBDIO_SETMODE: 557 case WSKBDIO_GETMODE: 558 #endif 559 560 case WSKBDIO_SETKEYCLICK: 561 zskbd_wskbd_set_keyclick(cookie, *(int *)data); 562 break; 563 564 case WSKBDIO_GETKEYCLICK: 565 *(int *)data = zskbd_wskbd_get_keyclick(cookie); 566 break; 567 568 default: 569 return (EPASSTHROUGH); 570 } 571 572 return (0); 573 } 574 575 /* 576 * console routines 577 */ 578 void 579 zskbd_cnattach(int zsunit, int zschan) 580 { 581 582 wskbd_cnattach(&zskbd_wskbd_consops, zs_get_chan_addr(zsunit, zschan), 583 &sgikbd_wskbd_keymapdata); 584 zskbd_is_console = 1; 585 } 586 587 static void 588 zskbd_wskbd_getc(void *cookie, u_int *type, int *data) 589 { 590 int key; 591 592 key = zs_getc(cookie); 593 594 if (key & ZSKBD_KEY_UP) 595 *type = WSCONS_EVENT_KEY_UP; 596 else 597 *type = WSCONS_EVENT_KEY_DOWN; 598 599 *data = key & ~ZSKBD_KEY_UP; 600 } 601 602 static void 603 zskbd_wskbd_pollc(void *cookie, int on) 604 { 605 } 606 607 static void 608 zskbd_wskbd_bell(void *cookie, u_int pitch, u_int period, u_int volume) 609 { 610 611 /* 612 * Since we don't have any state, this'll nuke our lights, 613 * key click, and other bits in ZSKBD_CTRL_A. 614 */ 615 if (period >= 1000) 616 zs_putc(cookie, ZSKBD_CTRL_A_LBEEP); 617 else 618 zs_putc(cookie, ZSKBD_CTRL_A_SBEEP); 619 } 620
Indexes created Thu Oct 02 14:10:14 GMT 2025