1 /* $NetBSD: ewskbd.c,v 1.10 2012/10/13 06:08:30 tsutsui Exp $ */ 2 3 /*- 4 * Copyright (c) 2005 Izumi Tsutsui. 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 WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 /* 28 * Copyright (c) 2004 Steve Rumble 29 * All rights reserved. 30 * 31 * Redistribution and use in source and binary forms, with or without 32 * modification, are permitted provided that the following conditions 33 * are met: 34 * 1. Redistributions of source code must retain the above copyright 35 * notice, this list of conditions and the following disclaimer. 36 * 2. Redistributions in binary form must reproduce the above copyright 37 * notice, this list of conditions and the following disclaimer in the 38 * documentation and/or other materials provided with the distribution. 39 * 3. The name of the author may not be used to endorse or promote products 40 * derived from this software without specific prior written permission. 41 * 42 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 43 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 44 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 45 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 46 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 47 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 48 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 49 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 50 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 51 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 52 */ 53 54 /* 55 * EWS4800 serial keyboard driver attached to zs channel 0 at 4800 bps. 56 * This layer is the parent of wskbd. 57 * 58 * This driver is taken from sgimips. 59 */ 60 61 #include <sys/cdefs.h> 62 __KERNEL_RCSID(0, "$NetBSD: ewskbd.c,v 1.10 2012/10/13 06:08:30 tsutsui Exp $"); 63 64 #include <sys/param.h> 65 #include <sys/malloc.h> 66 #include <sys/systm.h> 67 #include <sys/conf.h> 68 #include <sys/device.h> 69 70 #include <dev/wscons/wsconsio.h> 71 #include <dev/wscons/wskbdvar.h> 72 #include <dev/wscons/wsksymdef.h> 73 #include <dev/wscons/wsksymvar.h> 74 75 #include <dev/ic/z8530reg.h> 76 #include <machine/z8530var.h> 77 78 #include <ews4800mips/dev/ews4800keymap.h> 79 80 #define EWSKBD_BAUD 4800 81 82 #define EWSKBD_TXQ_LEN 16 /* power of 2 */ 83 #define EWSKBD_TXQ_LEN_MASK (EWSKBD_TXQ_LEN - 1) 84 #define EWSKBD_NEXTTXQ(x) (((x) + 1) & EWSKBD_TXQ_LEN_MASK) 85 86 #define EWSKBD_RXQ_LEN 64 /* power of 2 */ 87 #define EWSKBD_RXQ_LEN_MASK (EWSKBD_RXQ_LEN - 1) 88 #define EWSKBD_NEXTRXQ(x) (((x) + 1) & EWSKBD_RXQ_LEN_MASK) 89 90 #define EWSKBD_KEY_UP 0x80 91 #define EWSKBD_KEY_MASK 0x7f 92 93 #ifdef EWSKBD_DEBUG 94 int ewskbd_debug = 0; 95 #define DPRINTF(_x) if (ewskbd_debug) printf _x 96 #else 97 #define DPRINTF(_x) 98 #endif 99 100 struct ewskbd_softc { 101 device_t sc_dev; 102 struct ewskbd_devconfig *sc_dc; 103 }; 104 105 struct ewskbd_devconfig { 106 /* transmit tail-chasing fifo */ 107 uint8_t txq[EWSKBD_TXQ_LEN]; 108 u_int txq_head; 109 u_int txq_tail; 110 111 /* receive tail-chasing fifo */ 112 uint8_t rxq[EWSKBD_RXQ_LEN]; 113 u_int rxq_head; 114 u_int rxq_tail; 115 116 /* state */ 117 u_int state; 118 #define TX_READY 0x01 119 120 /* LED status */ 121 uint8_t leds; 122 #define EWSKBD_SETLEDS 0x90 123 #define EWSKBD_CAPSLOCK 0x02 124 #define EWSKBD_KANA 0x04 125 126 /* wscons glue */ 127 device_t wskbddev; 128 int enabled; 129 }; 130 131 static int ewskbd_zsc_match(device_t, cfdata_t, void *); 132 static void ewskbd_zsc_attach(device_t, device_t, void *); 133 static int ewskbd_zsc_init(struct zs_chanstate *); 134 static void ewskbd_zsc_rxint(struct zs_chanstate *); 135 static void ewskbd_zsc_stint(struct zs_chanstate *, int); 136 static void ewskbd_zsc_txint(struct zs_chanstate *); 137 static void ewskbd_zsc_softint(struct zs_chanstate *); 138 static void ewskbd_zsc_send(struct zs_chanstate *, uint8_t *, u_int); 139 140 static void ewskbd_wskbd_input(struct zs_chanstate *, u_char); 141 static int ewskbd_wskbd_enable(void *, int); 142 static void ewskbd_wskbd_set_leds(void *, int); 143 static int ewskbd_wskbd_get_leds(void *); 144 static int ewskbd_wskbd_ioctl(void *, u_long, void *, int, struct lwp *); 145 146 void ewskbd_zsc_cnattach(uint32_t, uint32_t, int); 147 static void ewskbd_zsc_wskbd_getc(void *, u_int *, int *); 148 static void ewskbd_wskbd_pollc(void *, int); 149 static void ewskbd_wskbd_bell(void *, u_int, u_int, u_int); 150 151 CFATTACH_DECL_NEW(ewskbd_zsc, sizeof(struct ewskbd_softc), 152 ewskbd_zsc_match, ewskbd_zsc_attach, NULL, NULL); 153 154 static struct zsops ewskbd_zsops = { 155 ewskbd_zsc_rxint, 156 ewskbd_zsc_stint, 157 ewskbd_zsc_txint, 158 ewskbd_zsc_softint 159 }; 160 161 const struct wskbd_mapdata ews4800kbd_wskbd_keymapdata = { 162 ews4800kbd_keydesctab, 163 KB_JP 164 }; 165 166 const struct wskbd_accessops ewskbd_wskbd_accessops = { 167 ewskbd_wskbd_enable, 168 ewskbd_wskbd_set_leds, 169 ewskbd_wskbd_ioctl 170 }; 171 172 const struct wskbd_consops ewskbd_wskbd_consops = { 173 ewskbd_zsc_wskbd_getc, 174 ewskbd_wskbd_pollc, 175 ewskbd_wskbd_bell 176 }; 177 178 static struct ewskbd_devconfig ewskbd_console_dc; 179 static struct zs_chanstate conschan; 180 static int ewskbd_is_console; 181 182 static int 183 ewskbd_zsc_match(device_t parent, cfdata_t cf, void *aux) 184 { 185 struct zsc_attach_args *zsc_args = aux; 186 struct zsc_softc *zsc = device_private(parent); 187 188 /* keyboard is on channel B */ 189 if ((zsc->zsc_flags & 0x0001 /* kbms port */) != 0 && 190 zsc_args->channel == 1) 191 /* prior to generic zstty(4) */ 192 return 3; 193 194 return 0; 195 } 196 197 static void 198 ewskbd_zsc_attach(device_t parent, device_t self, void *aux) 199 { 200 struct ewskbd_softc *sc; 201 struct zsc_softc *zsc; 202 struct zs_chanstate *cs; 203 struct zsc_attach_args *zsc_args; 204 struct wskbddev_attach_args wskaa; 205 int channel; 206 207 sc = device_private(self); 208 zsc = device_private(parent); 209 sc->sc_dev = self; 210 zsc_args = aux; 211 212 /* Establish ourself with the MD z8530 driver */ 213 channel = zsc_args->channel; 214 cs = zsc->zsc_cs[channel]; 215 216 if (ewskbd_is_console) { 217 sc->sc_dc = &ewskbd_console_dc; 218 wskaa.console = 1; 219 sc->sc_dc->enabled = 1; 220 } else { 221 wskaa.console = 0; 222 223 sc->sc_dc = malloc(sizeof(struct ewskbd_devconfig), M_DEVBUF, 224 M_WAITOK | M_ZERO); 225 if (sc->sc_dc == NULL) { 226 printf(": can't allocate memory\n"); 227 return; 228 } 229 sc->sc_dc->enabled = 0; 230 } 231 cs->cs_defspeed = EWSKBD_BAUD; 232 cs->cs_ops = &ewskbd_zsops; 233 cs->cs_private = sc; 234 235 sc->sc_dc->txq_head = 0; 236 sc->sc_dc->txq_tail = 0; 237 sc->sc_dc->rxq_head = 0; 238 sc->sc_dc->rxq_tail = 0; 239 sc->sc_dc->state = TX_READY; 240 sc->sc_dc->leds = 0; 241 242 ewskbd_zsc_init(cs); 243 244 /* set default LED */ 245 ewskbd_wskbd_set_leds(cs, 0); 246 247 printf(": baud rate %d\n", EWSKBD_BAUD); 248 249 /* attach wskbd */ 250 wskaa.keymap = &ews4800kbd_wskbd_keymapdata; 251 wskaa.accessops = &ewskbd_wskbd_accessops; 252 wskaa.accesscookie = cs; 253 sc->sc_dc->wskbddev = config_found(self, &wskaa, wskbddevprint); 254 } 255 256 static int 257 ewskbd_zsc_init(struct zs_chanstate *cs) 258 { 259 int s; 260 261 s = splzs(); 262 263 zs_write_reg(cs, 9, ZSWR9_B_RESET); 264 DELAY(100); 265 zs_write_reg(cs, 9, ZSWR9_MASTER_IE | ZSWR9_NO_VECTOR); 266 267 cs->cs_preg[1] = ZSWR1_RIE | ZSWR1_TIE; 268 cs->cs_preg[2] = 0; 269 cs->cs_preg[3] = ZSWR3_RX_8 | ZSWR3_RX_ENABLE; 270 cs->cs_preg[4] = ZSWR4_CLK_X16 | ZSWR4_ONESB | ZSWR4_PARENB; 271 cs->cs_preg[5] = ZSWR5_TX_8 | ZSWR5_RTS | ZSWR5_TX_ENABLE; 272 cs->cs_preg[6] = 0; 273 cs->cs_preg[7] = 0; 274 cs->cs_preg[8] = 0; 275 cs->cs_preg[9] = ZSWR9_MASTER_IE | ZSWR9_NO_VECTOR; 276 cs->cs_preg[10] = 0; 277 cs->cs_preg[11] = ZSWR11_RXCLK_BAUD | ZSWR11_TXCLK_BAUD | 278 ZSWR11_TRXC_OUT_ENA | ZSWR11_TRXC_BAUD; 279 /* reg[11] and reg[12] are set by zs_set_speed() with cs_brg_clk */ 280 zs_set_speed(cs, EWSKBD_BAUD); 281 cs->cs_preg[14] = ZSWR14_BAUD_FROM_PCLK | ZSWR14_BAUD_ENA; 282 cs->cs_preg[15] = 0; 283 284 zs_loadchannelregs(cs); 285 286 splx(s); 287 288 return 0; 289 } 290 291 static void 292 ewskbd_zsc_rxint(struct zs_chanstate *cs) 293 { 294 struct ewskbd_softc *sc; 295 struct ewskbd_devconfig *dc; 296 uint8_t c, r; 297 298 sc = cs->cs_private; 299 dc = sc->sc_dc; 300 301 /* clear errors */ 302 r = zs_read_reg(cs, 1); 303 if (r & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) 304 zs_write_csr(cs, ZSWR0_RESET_ERRORS); 305 306 /* read byte and append to our queue */ 307 c = zs_read_data(cs); 308 309 dc->rxq[dc->rxq_tail] = c; 310 dc->rxq_tail = EWSKBD_NEXTRXQ(dc->rxq_tail); 311 312 cs->cs_softreq = 1; 313 } 314 315 static void 316 ewskbd_zsc_stint(struct zs_chanstate *cs, int force) 317 { 318 319 zs_write_csr(cs, ZSWR0_RESET_STATUS); 320 cs->cs_softreq = 1; 321 } 322 323 static void 324 ewskbd_zsc_txint(struct zs_chanstate *cs) 325 { 326 struct ewskbd_softc *sc; 327 328 sc = cs->cs_private; 329 zs_write_reg(cs, 0, ZSWR0_RESET_TXINT); 330 sc->sc_dc->state |= TX_READY; 331 cs->cs_softreq = 1; 332 } 333 334 static void 335 ewskbd_zsc_softint(struct zs_chanstate *cs) 336 { 337 struct ewskbd_softc *sc; 338 struct ewskbd_devconfig *dc; 339 340 sc = cs->cs_private; 341 dc = sc->sc_dc; 342 343 /* handle pending transmissions */ 344 if (dc->txq_head != dc->txq_tail && (dc->state & TX_READY)) { 345 int s; 346 347 dc->state &= ~TX_READY; 348 349 s = splzs(); 350 zs_write_data(cs, dc->txq[dc->txq_head]); 351 splx(s); 352 353 dc->txq_head = EWSKBD_NEXTTXQ(dc->txq_head); 354 } 355 356 /* don't bother if nobody is listening */ 357 if (!dc->enabled) { 358 dc->rxq_head = dc->rxq_tail; 359 return; 360 } 361 362 /* handle incoming keystrokes/config */ 363 while (dc->rxq_head != dc->rxq_tail) { 364 uint8_t key = dc->rxq[dc->rxq_head]; 365 366 /* toss wskbd a bone */ 367 ewskbd_wskbd_input(cs, key); 368 369 dc->rxq_head = EWSKBD_NEXTRXQ(dc->rxq_head); 370 } 371 } 372 373 /* expects to be in splzs() */ 374 static void 375 ewskbd_zsc_send(struct zs_chanstate *cs, uint8_t *c, u_int len) 376 { 377 struct ewskbd_softc *sc; 378 struct ewskbd_devconfig *dc; 379 int i; 380 381 sc = cs->cs_private; 382 dc = sc->sc_dc; 383 384 for (i = 0; i < len; i++) { 385 if (dc->state & TX_READY) { 386 zs_write_data(cs, c[i]); 387 dc->state &= ~TX_READY; 388 } else { 389 dc->txq[dc->txq_tail] = c[i]; 390 dc->txq_tail = EWSKBD_NEXTTXQ(dc->txq_tail); 391 cs->cs_softreq = 1; 392 } 393 } 394 } 395 396 /****************************************************************************** 397 * wskbd glue 398 ******************************************************************************/ 399 400 static void 401 ewskbd_wskbd_input(struct zs_chanstate *cs, uint8_t key) 402 { 403 struct ewskbd_softc *sc; 404 u_int type; 405 406 sc = cs->cs_private; 407 408 if (key & EWSKBD_KEY_UP) 409 type = WSCONS_EVENT_KEY_UP; 410 else 411 type = WSCONS_EVENT_KEY_DOWN; 412 413 wskbd_input(sc->sc_dc->wskbddev, type, (key & EWSKBD_KEY_MASK)); 414 415 DPRINTF(("ewskbd_wskbd_input: inputted key 0x%x\n", key)); 416 417 #ifdef WSDISPLAY_COMPAT_RAWKBD 418 wskbd_rawinput(sc->sc_dc->wskbddev, &key, 1); 419 #endif 420 } 421 422 static int 423 ewskbd_wskbd_enable(void *cookie, int on) 424 { 425 struct zs_chanstate *cs; 426 struct ewskbd_softc *sc; 427 428 cs = cookie; 429 sc = cs->cs_private; 430 431 if (on) { 432 if (sc->sc_dc->enabled) 433 return EBUSY; 434 else 435 sc->sc_dc->enabled = 1; 436 } else 437 sc->sc_dc->enabled = 0; 438 439 DPRINTF(("ewskbd_wskbd_enable: %s\n", on ? "enabled" : "disabled")); 440 441 return 0; 442 } 443 444 static void 445 ewskbd_wskbd_set_leds(void *cookie, int leds) 446 { 447 struct zs_chanstate *cs; 448 struct ewskbd_softc *sc; 449 int s; 450 uint8_t cmd; 451 452 cs = cookie; 453 sc = cs->cs_private; 454 cmd = 0; 455 456 if (leds & WSKBD_LED_CAPS) 457 cmd |= EWSKBD_CAPSLOCK; 458 459 sc->sc_dc->leds = cmd; 460 461 cmd |= EWSKBD_SETLEDS; 462 463 s = splzs(); 464 ewskbd_zsc_send(cs, &cmd, 1); 465 splx(s); 466 } 467 468 static int 469 ewskbd_wskbd_get_leds(void *cookie) 470 { 471 struct zs_chanstate *cs; 472 struct ewskbd_softc *sc; 473 int leds; 474 475 cs = cookie; 476 sc = cs->cs_private; 477 leds = 0; 478 479 if (sc->sc_dc->leds & EWSKBD_CAPSLOCK) 480 leds |= WSKBD_LED_CAPS; 481 482 return leds; 483 } 484 485 static int 486 ewskbd_wskbd_ioctl(void *cookie, u_long cmd, void *data, int flag, 487 struct lwp *l) 488 { 489 490 switch (cmd) { 491 case WSKBDIO_GTYPE: 492 *(int *)data = WSKBD_TYPE_EWS4800; 493 break; 494 495 #ifdef notyet 496 case WSKBDIO_BELL: 497 case WSKBDIO_COMPLEXBELL: 498 case WSKBDIO_SETBELL: 499 case WSKBDIO_GETBELL: 500 case WSKBDIO_SETDEFAULTBELL: 501 case WSKBDIO_GETDEFAULTBELL: 502 case WSKBDIO_SETKEYREPEAT: 503 case WSKBDIO_GETKEYREPEAT: 504 case WSKBDIO_SETDEFAULTKEYREPEAT: 505 case WSKBDIO_GETDEFAULTKEYREPEAT: 506 #endif 507 508 case WSKBDIO_SETLEDS: 509 ewskbd_wskbd_set_leds(cookie, *(int *)data); 510 break; 511 512 case WSKBDIO_GETLEDS: 513 *(int *)data = ewskbd_wskbd_get_leds(cookie); 514 break; 515 516 #ifdef notyet 517 case WSKBDIO_GETMAP: 518 case WSKBDIO_SETMAP: 519 case WSKBDIO_GETENCODING: 520 case WSKBDIO_SETENCODING: 521 case WSKBDIO_SETMODE: 522 case WSKBDIO_GETMODE: 523 case WSKBDIO_SETKEYCLICK: 524 case WSKBDIO_GETKEYCLICK: 525 #endif 526 527 default: 528 return EPASSTHROUGH; 529 } 530 531 return 0; 532 } 533 534 /* 535 * console routines 536 */ 537 void 538 ewskbd_zsc_cnattach(uint32_t csr, uint32_t data, int pclk) 539 { 540 struct zs_chanstate *cs; 541 542 cs = &conschan; 543 544 cs->cs_reg_csr = (void *)csr; 545 cs->cs_reg_data = (void *)data; 546 cs->cs_brg_clk = pclk / 16; 547 cs->cs_defspeed = EWSKBD_BAUD; 548 549 ewskbd_zsc_init(cs); 550 551 zs_putc(cs, EWSKBD_SETLEDS); 552 553 wskbd_cnattach(&ewskbd_wskbd_consops, cs, &ews4800kbd_wskbd_keymapdata); 554 ewskbd_is_console = 1; 555 } 556 557 static void 558 ewskbd_zsc_wskbd_getc(void *cookie, u_int *type, int *data) 559 { 560 int key; 561 562 key = zs_getc(cookie); 563 564 if (key & EWSKBD_KEY_UP) 565 *type = WSCONS_EVENT_KEY_UP; 566 else 567 *type = WSCONS_EVENT_KEY_DOWN; 568 569 *data = key & EWSKBD_KEY_MASK; 570 } 571 572 static void 573 ewskbd_wskbd_pollc(void *cookie, int on) 574 { 575 576 static bool __polling = false; 577 static int s; 578 579 if (on && !__polling) { 580 /* disable interrupt driven I/O */ 581 s = splhigh(); 582 __polling = true; 583 } else if (!on && __polling) { 584 /* enable interrupt driven I/O */ 585 __polling = false; 586 splx(s); 587 } 588 } 589 590 static void 591 ewskbd_wskbd_bell(void *cookie, u_int pitch, u_int period, u_int volume) 592 { 593 594 /* nothing */ 595 } 596