akbd.c revision 1.12
1 /* $NetBSD: akbd.c,v 1.12 2001/06/05 05:18:36 thorpej Exp $ */ 2 3 /* 4 * Copyright (C) 1998 Colin Wood 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. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Colin Wood. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include "opt_adb.h" 34 35 #include <sys/param.h> 36 #include <sys/device.h> 37 #include <sys/fcntl.h> 38 #include <sys/poll.h> 39 #include <sys/select.h> 40 #include <sys/proc.h> 41 #include <sys/signalvar.h> 42 #include <sys/systm.h> 43 #include <sys/kernel.h> 44 45 #include "aed.h" 46 #include "wskbd.h" 47 48 #include <dev/wscons/wsconsio.h> 49 #include <dev/wscons/wskbdvar.h> 50 #include <dev/wscons/wsksymdef.h> 51 #include <dev/wscons/wsksymvar.h> 52 53 #include <machine/autoconf.h> 54 #include <machine/cpu.h> 55 #define KEYBOARD_ARRAY 56 #include <machine/keyboard.h> 57 #include <machine/viareg.h> 58 59 #include <mac68k/mac68k/macrom.h> 60 #include <mac68k/dev/adbvar.h> 61 #include <mac68k/dev/aedvar.h> 62 #include <mac68k/dev/akbdmap.h> 63 #include <mac68k/dev/akbdvar.h> 64 #include <mac68k/dev/amsvar.h> 65 66 /* 67 * Function declarations. 68 */ 69 static int akbdmatch __P((struct device *, struct cfdata *, void *)); 70 static void akbdattach __P((struct device *, struct device *, void *)); 71 void kbd_adbcomplete __P((caddr_t buffer, caddr_t data_area, int adb_command)); 72 static void kbd_processevent __P((adb_event_t *event, struct akbd_softc *)); 73 #ifdef notyet 74 static u_char getleds __P((int)); 75 static int setleds __P((struct akbd_softc *, u_char)); 76 static void blinkleds __P((struct akbd_softc *)); 77 #endif 78 79 /* 80 * Local variables. 81 */ 82 83 /* Driver definition. */ 84 struct cfattach akbd_ca = { 85 sizeof(struct akbd_softc), akbdmatch, akbdattach 86 }; 87 88 extern struct cfdriver akbd_cd; 89 90 int kbd_intr __P((adb_event_t *event, struct akbd_softc *)); 91 int akbd_enable __P((void *, int)); 92 void akbd_set_leds __P((void *, int)); 93 int akbd_ioctl __P((void *, u_long, caddr_t, int, struct proc *)); 94 95 struct wskbd_accessops akbd_accessops = { 96 akbd_enable, 97 akbd_set_leds, 98 akbd_ioctl, 99 }; 100 101 void akbd_cngetc __P((void *, u_int *, int *)); 102 void akbd_cnpollc __P((void *, int)); 103 int akbd_cnattach __P((void)); 104 105 struct wskbd_consops akbd_consops = { 106 akbd_cngetc, 107 akbd_cnpollc, 108 }; 109 110 struct wskbd_mapdata akbd_keymapdata = { 111 akbd_keydesctab, 112 KB_US, 113 }; 114 115 static int akbd_is_console __P((void)); 116 117 static int 118 akbdmatch(parent, cf, aux) 119 struct device *parent; 120 struct cfdata *cf; 121 void *aux; 122 { 123 struct adb_attach_args *aa_args = (struct adb_attach_args *)aux; 124 125 if (aa_args->origaddr == ADBADDR_KBD) 126 return 1; 127 else 128 return 0; 129 } 130 131 static void 132 akbdattach(parent, self, aux) 133 struct device *parent, *self; 134 void *aux; 135 { 136 ADBSetInfoBlock adbinfo; 137 struct akbd_softc *sc = (struct akbd_softc *)self; 138 struct adb_attach_args *aa_args = (struct adb_attach_args *)aux; 139 int error, kbd_done; 140 short cmd; 141 u_char buffer[9]; 142 #if NWSKBD > 0 143 struct wskbddev_attach_args a; 144 static int akbd_console_initted = 0; 145 int wskbd_eligible; 146 147 wskbd_eligible = 1; 148 #endif 149 150 sc->origaddr = aa_args->origaddr; 151 sc->adbaddr = aa_args->adbaddr; 152 sc->handler_id = aa_args->handler_id; 153 154 sc->sc_leds = (u_int8_t)0x00; /* initially off */ 155 156 adbinfo.siServiceRtPtr = (Ptr)adb_kbd_asmcomplete; 157 adbinfo.siDataAreaAddr = (caddr_t)sc; 158 159 switch (sc->handler_id) { 160 case ADB_STDKBD: 161 printf("standard keyboard\n"); 162 break; 163 case ADB_ISOKBD: 164 printf("standard keyboard (ISO layout)\n"); 165 break; 166 case ADB_EXTKBD: 167 cmd = ADBTALK(sc->adbaddr, 1); 168 kbd_done = 169 (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd) == 0); 170 171 /* Ignore Logitech MouseMan/Trackman pseudo keyboard */ 172 if (kbd_done && buffer[1] == 0x9a && buffer[2] == 0x20) { 173 printf("Mouseman (non-EMP) pseudo keyboard\n"); 174 adbinfo.siServiceRtPtr = (Ptr)0; 175 adbinfo.siDataAreaAddr = (Ptr)0; 176 #if NWSKBD > 0 177 wskbd_eligible = 0; 178 #endif /* NWSKBD > 0 */ 179 } else if (kbd_done && buffer[1] == 0x9a && buffer[2] == 0x21) { 180 printf("Trackman (non-EMP) pseudo keyboard\n"); 181 adbinfo.siServiceRtPtr = (Ptr)0; 182 adbinfo.siDataAreaAddr = (Ptr)0; 183 #if NWSKBD > 0 184 wskbd_eligible = 0; 185 #endif /* NWSKBD > 0 */ 186 } else { 187 printf("extended keyboard\n"); 188 #ifdef notyet 189 blinkleds(sc); 190 #endif 191 } 192 break; 193 case ADB_EXTISOKBD: 194 printf("extended keyboard (ISO layout)\n"); 195 #ifdef notyet 196 blinkleds(sc); 197 #endif 198 break; 199 case ADB_KBDII: 200 printf("keyboard II\n"); 201 break; 202 case ADB_ISOKBDII: 203 printf("keyboard II (ISO layout)\n"); 204 break; 205 case ADB_PBKBD: 206 printf("PowerBook keyboard\n"); 207 break; 208 case ADB_PBISOKBD: 209 printf("PowerBook keyboard (ISO layout)\n"); 210 break; 211 case ADB_ADJKPD: 212 printf("adjustable keypad\n"); 213 #if NWSKBD > 0 214 wskbd_eligible = 0; 215 #endif /* NWSKBD > 0 */ 216 break; 217 case ADB_ADJKBD: 218 printf("adjustable keyboard\n"); 219 break; 220 case ADB_ADJISOKBD: 221 printf("adjustable keyboard (ISO layout)\n"); 222 break; 223 case ADB_ADJJAPKBD: 224 printf("adjustable keyboard (Japanese layout)\n"); 225 break; 226 case ADB_PBEXTISOKBD: 227 printf("PowerBook extended keyboard (ISO layout)\n"); 228 break; 229 case ADB_PBEXTJAPKBD: 230 printf("PowerBook extended keyboard (Japanese layout)\n"); 231 break; 232 case ADB_JPKBDII: 233 printf("keyboard II (Japanese layout)\n"); 234 break; 235 case ADB_PBEXTKBD: 236 printf("PowerBook extended keyboard\n"); 237 break; 238 case ADB_DESIGNKBD: 239 printf("extended keyboard\n"); 240 #ifdef notyet 241 blinkleds(sc); 242 #endif 243 break; 244 case ADB_PBJPKBD: 245 printf("PowerBook keyboard (Japanese layout)\n"); 246 break; 247 default: 248 printf("mapped device (%d)\n", sc->handler_id); 249 #if NWSKBD > 0 250 wskbd_eligible = 0; 251 #endif /* NWSKBD > 0 */ 252 break; 253 } 254 error = SetADBInfo(&adbinfo, sc->adbaddr); 255 #ifdef ADB_DEBUG 256 if (adb_debug) 257 printf("akbd: returned %d from SetADBInfo\n", error); 258 #endif 259 260 #if NWSKBD > 0 261 if (akbd_is_console() && wskbd_eligible) 262 a.console = (++akbd_console_initted == 1); 263 else 264 a.console = 0; 265 a.keymap = &akbd_keymapdata; 266 a.accessops = &akbd_accessops; 267 a.accesscookie = sc; 268 269 sc->sc_wskbddev = config_found(self, &a, wskbddevprint); 270 #endif 271 } 272 273 274 /* 275 * Handle putting the keyboard data received from the ADB into 276 * an ADB event record. 277 */ 278 void 279 kbd_adbcomplete(buffer, data_area, adb_command) 280 caddr_t buffer; 281 caddr_t data_area; 282 int adb_command; 283 { 284 adb_event_t event; 285 struct akbd_softc *ksc; 286 int adbaddr; 287 #ifdef ADB_DEBUG 288 int i; 289 290 if (adb_debug) 291 printf("adb: transaction completion\n"); 292 #endif 293 294 adbaddr = ADB_CMDADDR(adb_command); 295 ksc = (struct akbd_softc *)data_area; 296 297 event.addr = adbaddr; 298 event.hand_id = ksc->handler_id; 299 event.def_addr = ksc->origaddr; 300 event.byte_count = buffer[0]; 301 memcpy(event.bytes, buffer + 1, event.byte_count); 302 303 #ifdef ADB_DEBUG 304 if (adb_debug) { 305 printf("akbd: from %d at %d (org %d) %d:", event.addr, 306 event.hand_id, event.def_addr, buffer[0]); 307 for (i = 1; i <= buffer[0]; i++) 308 printf(" %x", buffer[i]); 309 printf("\n"); 310 } 311 #endif 312 313 microtime(&event.timestamp); 314 315 kbd_processevent(&event, ksc); 316 } 317 318 /* 319 * Given a keyboard ADB event, record the keycodes and call the key 320 * repeat handler, optionally passing the event through the mouse 321 * button emulation handler first. 322 */ 323 static void 324 kbd_processevent(event, ksc) 325 adb_event_t *event; 326 struct akbd_softc *ksc; 327 { 328 adb_event_t new_event; 329 330 new_event = *event; 331 new_event.u.k.key = event->bytes[0]; 332 new_event.bytes[1] = 0xff; 333 #if NAED > 0 334 if (adb_polling || !aed_input(&new_event)) 335 #endif 336 #if NWSKBD > 0 337 if (ksc->sc_wskbddev != NULL) /* wskbd is attached? */ 338 kbd_intr(&new_event, ksc); 339 #else 340 /* do nothing */ ; 341 #endif 342 if (event->bytes[1] != 0xff) { 343 new_event.u.k.key = event->bytes[1]; 344 new_event.bytes[0] = event->bytes[1]; 345 new_event.bytes[1] = 0xff; 346 #if NAED > 0 347 if (adb_polling || !aed_input(&new_event)) 348 #endif 349 #if NWSKBD > 0 350 if (ksc->sc_wskbddev != NULL) /* wskbd is attached? */ 351 kbd_intr(&new_event, ksc); 352 #else 353 /* do nothing */ ; 354 #endif 355 } 356 357 } 358 359 #ifdef notyet 360 /* 361 * Get the actual hardware LED state and convert it to softc format. 362 */ 363 static u_char 364 getleds(addr) 365 int addr; 366 { 367 short cmd; 368 u_char buffer[9], leds; 369 370 leds = 0x00; /* all off */ 371 buffer[0] = 0; 372 373 cmd = ADBTALK(addr, 2); 374 if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd) == 0 && 375 buffer[0] > 0) 376 leds = ~(buffer[2]) & 0x07; 377 378 return (leds); 379 } 380 381 /* 382 * Set the keyboard LED's. 383 * 384 * Automatically translates from ioctl/softc format to the 385 * actual keyboard register format 386 */ 387 static int 388 setleds(ksc, leds) 389 struct akbd_softc *ksc; 390 u_char leds; 391 { 392 int addr; 393 short cmd; 394 u_char buffer[9]; 395 396 if ((leds & 0x07) == (ksc->sc_leds & 0x07)) 397 return (0); 398 399 addr = ksc->adbaddr; 400 buffer[0] = 0; 401 402 cmd = ADBTALK(addr, 2); 403 if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd) || buffer[0] == 0) 404 return (EIO); 405 406 leds = ~leds & 0x07; 407 buffer[2] &= 0xf8; 408 buffer[2] |= leds; 409 410 cmd = ADBLISTEN(addr, 2); 411 adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd); 412 413 /* talk R2 */ 414 cmd = ADBTALK(addr, 2); 415 if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd) || buffer[0] == 0) 416 return (EIO); 417 418 ksc->sc_leds = ~((u_int8_t)buffer[2]) & 0x07; 419 420 if ((buffer[2] & 0xf8) != leds) 421 return (EIO); 422 else 423 return (0); 424 } 425 426 /* 427 * Toggle all of the LED's on and off, just for show. 428 */ 429 static void 430 blinkleds(ksc) 431 struct akbd_softc *ksc; 432 { 433 int addr, i; 434 u_char blinkleds, origleds; 435 436 addr = ksc->adbaddr; 437 origleds = getleds(addr); 438 blinkleds = LED_NUMLOCK | LED_CAPSLOCK | LED_SCROLL_LOCK; 439 440 (void)setleds(ksc, blinkleds); 441 442 for (i = 0; i < 10000; i++) 443 delay(50); 444 445 /* make sure that we restore the LED settings */ 446 i = 10; 447 do { 448 (void)setleds(ksc, (u_char)0x00); 449 } while (setleds(ksc, (u_char)0x00) && (i-- > 0)); 450 451 return; 452 } 453 #endif 454 455 int 456 akbd_is_console() 457 { 458 extern struct mac68k_machine_S mac68k_machine; 459 460 return ((mac68k_machine.serial_console & 0x03) == 0); 461 } 462 463 int 464 akbd_enable(v, on) 465 void *v; 466 int on; 467 { 468 return 0; 469 } 470 471 void 472 akbd_set_leds(v, on) 473 void *v; 474 int on; 475 { 476 } 477 478 int 479 akbd_ioctl(v, cmd, data, flag, p) 480 void *v; 481 u_long cmd; 482 caddr_t data; 483 int flag; 484 struct proc *p; 485 { 486 switch (cmd) { 487 488 case WSKBDIO_GTYPE: 489 *(int *)data = 0; /* XXX */ 490 return 0; 491 case WSKBDIO_SETLEDS: 492 return 0; 493 case WSKBDIO_GETLEDS: 494 *(int *)data = 0; 495 return 0; 496 case WSKBDIO_BELL: 497 case WSKBDIO_COMPLEXBELL: 498 #define d ((struct wskbd_bell_data *)data) 499 mac68k_ring_bell(d->pitch, d->period * hz / 1000, 100); 500 /* comes in as msec, goes out as ticks; volume ignored */ 501 #undef d 502 return (0); 503 } 504 /* kbdioctl(...); */ 505 506 return -1; 507 } 508 509 static int polledkey; 510 extern int adb_polling; 511 512 int 513 kbd_intr(event, sc) 514 adb_event_t *event; 515 struct akbd_softc *sc; 516 { 517 int key, press, val; 518 int type; 519 520 key = event->u.k.key; 521 press = ADBK_PRESS(key); 522 val = ADBK_KEYVAL(key); 523 524 type = press ? WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP; 525 526 if (key == 185) { /* Caps Lock released */ 527 type = WSCONS_EVENT_KEY_DOWN; 528 wskbd_input(sc->sc_wskbddev, type, val); 529 type = WSCONS_EVENT_KEY_UP; 530 } 531 532 if (adb_polling) 533 polledkey = key; 534 else 535 wskbd_input(sc->sc_wskbddev, type, val); 536 537 return 0; 538 } 539 540 int 541 akbd_cnattach() 542 { 543 wskbd_cnattach(&akbd_consops, NULL, &akbd_keymapdata); 544 545 return 0; 546 } 547 548 void 549 akbd_cngetc(v, type, data) 550 void *v; 551 u_int *type; 552 int *data; 553 { 554 int intbits, key, press, val; 555 int s; 556 557 s = splhigh(); 558 559 polledkey = -1; 560 adb_polling = 1; 561 562 while (polledkey == -1) { 563 intbits = via_reg(VIA1, vIFR); 564 565 if (intbits & V1IF_ADBRDY) { 566 mrg_adbintr(); 567 via_reg(VIA1, vIFR) = V1IF_ADBRDY; 568 } 569 if (intbits & 0x10) { 570 mrg_pmintr(); 571 via_reg(VIA1, vIFR) = 0x10; 572 } 573 } 574 575 adb_polling = 0; 576 splx(s); 577 578 key = polledkey; 579 press = ADBK_PRESS(key); 580 val = ADBK_KEYVAL(key); 581 582 *data = val; 583 *type = press ? WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP; 584 } 585 586 void 587 akbd_cnpollc(v, on) 588 void *v; 589 int on; 590 { 591 } 592
Indexes created Tue Sep 30 11:09:46 GMT 2025