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