kbd.c revision 1.21
1 /* $NetBSD: kbd.c,v 1.21 2002/10/02 05:04:26 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Leo Weppelman 5 * Copyright (c) 1982, 1986, 1990 The Regents of the University of California. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/device.h> 40 #include <sys/ioctl.h> 41 #include <sys/tty.h> 42 #include <sys/proc.h> 43 #include <sys/conf.h> 44 #include <sys/file.h> 45 #include <sys/kernel.h> 46 #include <sys/signalvar.h> 47 #include <sys/syslog.h> 48 #include <dev/cons.h> 49 #include <machine/cpu.h> 50 #include <machine/iomap.h> 51 #include <machine/mfp.h> 52 #include <machine/acia.h> 53 #include <atari/dev/itevar.h> 54 #include <atari/dev/event_var.h> 55 #include <atari/dev/vuid_event.h> 56 #include <atari/dev/ym2149reg.h> 57 #include <atari/dev/kbdreg.h> 58 #include <atari/dev/kbdvar.h> 59 #include <atari/dev/kbdmap.h> 60 #include <atari/dev/msvar.h> 61 62 #include "mouse.h" 63 64 u_char kbd_modifier; /* Modifier mask */ 65 66 static u_char kbd_ring[KBD_RING_SIZE]; 67 static volatile u_int kbd_rbput = 0; /* 'put' index */ 68 static u_int kbd_rbget = 0; /* 'get' index */ 69 static u_char kbd_soft = 0; /* 1: Softint has been scheduled*/ 70 71 static struct kbd_softc kbd_softc; 72 73 /* {b,c}devsw[] function prototypes */ 74 dev_type_open(kbdopen); 75 dev_type_close(kbdclose); 76 dev_type_read(kbdread); 77 dev_type_ioctl(kbdioctl); 78 dev_type_poll(kbdpoll); 79 80 /* Interrupt handler */ 81 void kbdintr __P((int)); 82 83 static void kbdsoft __P((void *, void *)); 84 static void kbdattach __P((struct device *, struct device *, void *)); 85 static int kbdmatch __P((struct device *, struct cfdata *, void *)); 86 static int kbd_do_modifier __P((u_char)); 87 static int kbd_write_poll __P((u_char *, int)); 88 static void kbd_pkg_start __P((struct kbd_softc *, u_char)); 89 90 CFATTACH_DECL(kbd, sizeof(struct device), 91 kbdmatch, kbdattach, NULL, NULL); 92 93 const struct cdevsw kbd_cdevsw = { 94 kbdopen, kbdclose, kbdread, nowrite, kbdioctl, 95 nostop, notty, kbdpoll, nommap, 96 }; 97 98 /*ARGSUSED*/ 99 static int 100 kbdmatch(pdp, cfp, auxp) 101 struct device *pdp; 102 struct cfdata *cfp; 103 void *auxp; 104 { 105 if (!strcmp((char *)auxp, "kbd")) 106 return (1); 107 return (0); 108 } 109 110 /*ARGSUSED*/ 111 static void 112 kbdattach(pdp, dp, auxp) 113 struct device *pdp, *dp; 114 void *auxp; 115 { 116 int timeout; 117 u_char kbd_rst[] = { 0x80, 0x01 }; 118 u_char kbd_icmd[] = { 0x12, 0x15 }; 119 120 /* 121 * Disable keyboard interrupts from MFP 122 */ 123 MFP->mf_ierb &= ~IB_AINT; 124 125 /* 126 * Reset ACIA and intialize to: 127 * divide by 16, 8 data, 1 stop, no parity, enable RX interrupts 128 */ 129 KBD->ac_cs = A_RESET; 130 delay(100); /* XXX: enough? */ 131 KBD->ac_cs = kbd_softc.k_soft_cs = KBD_INIT | A_RXINT; 132 133 /* 134 * Clear error conditions 135 */ 136 while (KBD->ac_cs & (A_IRQ|A_RXRDY)) 137 timeout = KBD->ac_da; 138 139 /* 140 * Now send the reset string, and read+ignore it's response 141 */ 142 if (!kbd_write_poll(kbd_rst, 2)) 143 printf("kbd: error cannot reset keyboard\n"); 144 for (timeout = 1000; timeout > 0; timeout--) { 145 if (KBD->ac_cs & (A_IRQ|A_RXRDY)) { 146 timeout = KBD->ac_da; 147 timeout = 100; 148 } 149 delay(100); 150 } 151 /* 152 * Send init command: disable mice & joysticks 153 */ 154 kbd_write_poll(kbd_icmd, sizeof(kbd_icmd)); 155 156 printf("\n"); 157 } 158 159 void 160 kbdenable() 161 { 162 int s, code; 163 164 s = spltty(); 165 166 /* 167 * Clear error conditions... 168 */ 169 while (KBD->ac_cs & (A_IRQ|A_RXRDY)) 170 code = KBD->ac_da; 171 /* 172 * Enable interrupts from MFP 173 */ 174 MFP->mf_iprb = (u_int8_t)~IB_AINT; 175 MFP->mf_ierb |= IB_AINT; 176 MFP->mf_imrb |= IB_AINT; 177 178 kbd_softc.k_event_mode = 0; 179 kbd_softc.k_events.ev_io = 0; 180 kbd_softc.k_pkg_size = 0; 181 splx(s); 182 } 183 184 int kbdopen(dev_t dev, int flags, int mode, struct proc *p) 185 { 186 if (kbd_softc.k_events.ev_io) 187 return EBUSY; 188 189 kbd_softc.k_events.ev_io = p; 190 ev_init(&kbd_softc.k_events); 191 return (0); 192 } 193 194 int 195 kbdclose(dev_t dev, int flags, int mode, struct proc *p) 196 { 197 /* Turn off event mode, dump the queue */ 198 kbd_softc.k_event_mode = 0; 199 ev_fini(&kbd_softc.k_events); 200 kbd_softc.k_events.ev_io = NULL; 201 return (0); 202 } 203 204 int 205 kbdread(dev_t dev, struct uio *uio, int flags) 206 { 207 return ev_read(&kbd_softc.k_events, uio, flags); 208 } 209 210 int 211 kbdioctl(dev_t dev,u_long cmd,register caddr_t data,int flag,struct proc *p) 212 { 213 register struct kbd_softc *k = &kbd_softc; 214 struct kbdbell *kb; 215 216 switch (cmd) { 217 case KIOCTRANS: 218 if (*(int *)data == TR_UNTRANS_EVENT) 219 return 0; 220 break; 221 222 case KIOCGTRANS: 223 /* 224 * Get translation mode 225 */ 226 *(int *)data = TR_UNTRANS_EVENT; 227 return 0; 228 229 case KIOCSDIRECT: 230 k->k_event_mode = *(int *)data; 231 return 0; 232 233 case KIOCRINGBELL: 234 kb = (struct kbdbell *)data; 235 if (kb) 236 kbd_bell_sparms(kb->volume, kb->pitch, 237 kb->duration); 238 kbdbell(); 239 return 0; 240 241 case FIONBIO: /* we will remove this someday (soon???) */ 242 return 0; 243 244 case FIOASYNC: 245 k->k_events.ev_async = *(int *)data != 0; 246 return 0; 247 248 case TIOCSPGRP: 249 if (*(int *)data != k->k_events.ev_io->p_pgid) 250 return EPERM; 251 return 0; 252 253 default: 254 return ENOTTY; 255 } 256 257 /* 258 * We identified the ioctl, but we do not handle it. 259 */ 260 return EOPNOTSUPP; /* misuse, but what the heck */ 261 } 262 263 int 264 kbdpoll (dev_t dev, int events, struct proc *p) 265 { 266 return ev_poll (&kbd_softc.k_events, events, p); 267 } 268 269 /* 270 * Keyboard interrupt handler called straight from MFP at spl6. 271 */ 272 void 273 kbdintr(sr) 274 int sr; /* sr at time of interrupt */ 275 { 276 int code; 277 int got_char = 0; 278 279 /* 280 * There may be multiple keys available. Read them all. 281 */ 282 while (KBD->ac_cs & (A_RXRDY|A_OE|A_PE)) { 283 got_char = 1; 284 if (KBD->ac_cs & (A_OE|A_PE)) { 285 code = KBD->ac_da; /* Silently ignore errors */ 286 continue; 287 } 288 kbd_ring[kbd_rbput++ & KBD_RING_MASK] = KBD->ac_da; 289 } 290 291 /* 292 * If characters are waiting for transmit, send them. 293 */ 294 if ((kbd_softc.k_soft_cs & A_TXINT) && (KBD->ac_cs & A_TXRDY)) { 295 if (kbd_softc.k_sendp != NULL) 296 KBD->ac_da = *kbd_softc.k_sendp++; 297 if (--kbd_softc.k_send_cnt <= 0) { 298 /* 299 * The total package has been transmitted, 300 * wakeup anyone waiting for it. 301 */ 302 KBD->ac_cs = (kbd_softc.k_soft_cs &= ~A_TXINT); 303 kbd_softc.k_sendp = NULL; 304 kbd_softc.k_send_cnt = 0; 305 wakeup((caddr_t)&kbd_softc.k_send_cnt); 306 } 307 } 308 309 /* 310 * Activate software-level to handle possible input. 311 */ 312 if (got_char) { 313 if (!BASEPRI(sr)) { 314 if (!kbd_soft++) 315 add_sicallback(kbdsoft, 0, 0); 316 } else { 317 spl1(); 318 kbdsoft(NULL, NULL); 319 } 320 } 321 } 322 323 /* 324 * Keyboard soft interrupt handler 325 */ 326 void 327 kbdsoft(junk1, junk2) 328 void *junk1, *junk2; 329 { 330 int s; 331 u_char code; 332 struct kbd_softc *k = &kbd_softc; 333 struct firm_event *fe; 334 int put; 335 int n, get; 336 337 kbd_soft = 0; 338 get = kbd_rbget; 339 340 for (;;) { 341 n = kbd_rbput; 342 if (get == n) /* We're done */ 343 break; 344 n -= get; 345 if (n > KBD_RING_SIZE) { /* Ring buffer overflow */ 346 get += n - KBD_RING_SIZE; 347 n = KBD_RING_SIZE; 348 } 349 while (--n >= 0) { 350 code = kbd_ring[get++ & KBD_RING_MASK]; 351 352 /* 353 * If collecting a package, stuff it in and 354 * continue. 355 */ 356 if (k->k_pkg_size && (k->k_pkg_idx < k->k_pkg_size)) { 357 k->k_package[k->k_pkg_idx++] = code; 358 if (k->k_pkg_idx == k->k_pkg_size) { 359 /* 360 * Package is complete. 361 */ 362 switch(k->k_pkg_type) { 363 #if NMOUSE > 0 364 case KBD_AMS_PKG: 365 case KBD_RMS_PKG: 366 case KBD_JOY1_PKG: 367 mouse_soft((REL_MOUSE *)k->k_package, 368 k->k_pkg_size, k->k_pkg_type); 369 #endif /* NMOUSE */ 370 } 371 k->k_pkg_size = 0; 372 } 373 continue; 374 } 375 /* 376 * If this is a package header, init pkg. handling. 377 */ 378 if (!KBD_IS_KEY(code)) { 379 kbd_pkg_start(k, code); 380 continue; 381 } 382 if (kbd_do_modifier(code) && !k->k_event_mode) 383 continue; 384 385 /* 386 * if not in event mode, deliver straight to ite to 387 * process key stroke 388 */ 389 if (!k->k_event_mode) { 390 /* Gets to spltty() by itself */ 391 ite_filter(code, ITEFILT_TTY); 392 continue; 393 } 394 395 /* 396 * Keyboard is generating events. Turn this keystroke 397 * into an event and put it in the queue. If the queue 398 * is full, the keystroke is lost (sorry!). 399 */ 400 s = spltty(); 401 put = k->k_events.ev_put; 402 fe = &k->k_events.ev_q[put]; 403 put = (put + 1) % EV_QSIZE; 404 if (put == k->k_events.ev_get) { 405 log(LOG_WARNING, 406 "keyboard event queue overflow\n"); 407 splx(s); 408 continue; 409 } 410 fe->id = KBD_SCANCODE(code); 411 fe->value = KBD_RELEASED(code) ? VKEY_UP : VKEY_DOWN; 412 fe->time = time; 413 k->k_events.ev_put = put; 414 EV_WAKEUP(&k->k_events); 415 splx(s); 416 } 417 kbd_rbget = get; 418 } 419 } 420 421 static u_char sound[] = { 422 0xA8,0x01,0xA9,0x01,0xAA,0x01,0x00, 423 0xF8,0x10,0x10,0x10,0x00,0x20,0x03 424 }; 425 426 void 427 kbdbell() 428 { 429 register int i, sps; 430 431 sps = splhigh(); 432 for (i = 0; i < sizeof(sound); i++) { 433 YM2149->sd_selr = i; 434 YM2149->sd_wdat = sound[i]; 435 } 436 splx(sps); 437 } 438 439 440 /* 441 * Set the parameters of the 'default' beep. 442 */ 443 444 #define KBDBELLCLOCK 125000 /* 2MHz / 16 */ 445 #define KBDBELLDURATION 128 /* 256 / 2MHz */ 446 447 void 448 kbd_bell_gparms(volume, pitch, duration) 449 u_int *volume, *pitch, *duration; 450 { 451 u_int tmp; 452 453 tmp = sound[11] | (sound[12] << 8); 454 *duration = (tmp * KBDBELLDURATION) / 1000; 455 456 tmp = sound[0] | (sound[1] << 8); 457 *pitch = KBDBELLCLOCK / tmp; 458 459 *volume = 0; 460 } 461 462 void 463 kbd_bell_sparms(volume, pitch, duration) 464 u_int volume, pitch, duration; 465 { 466 u_int f, t; 467 468 f = pitch > 10 ? pitch : 10; /* minimum pitch */ 469 if (f > 20000) 470 f = 20000; /* maximum pitch */ 471 472 f = KBDBELLCLOCK / f; 473 474 t = (duration * 1000) / KBDBELLDURATION; 475 476 sound[ 0] = f & 0xff; 477 sound[ 1] = (f >> 8) & 0xf; 478 f -= 1; 479 sound[ 2] = f & 0xff; 480 sound[ 3] = (f >> 8) & 0xf; 481 f += 2; 482 sound[ 4] = f & 0xff; 483 sound[ 5] = (f >> 8) & 0xf; 484 485 sound[11] = t & 0xff; 486 sound[12] = (t >> 8) & 0xff; 487 488 sound[13] = 0x03; 489 } 490 491 int 492 kbdgetcn() 493 { 494 u_char code; 495 int s = spltty(); 496 int ints_active; 497 498 ints_active = 0; 499 if (MFP->mf_imrb & IB_AINT) { 500 ints_active = 1; 501 MFP->mf_imrb &= ~IB_AINT; 502 } 503 for (;;) { 504 while (!((KBD->ac_cs & (A_IRQ|A_RXRDY)) == (A_IRQ|A_RXRDY))) 505 ; /* Wait for key */ 506 if (KBD->ac_cs & (A_OE|A_PE)) { 507 code = KBD->ac_da; /* Silently ignore errors */ 508 continue; 509 } 510 code = KBD->ac_da; 511 if (!kbd_do_modifier(code)) 512 break; 513 } 514 515 if (ints_active) { 516 MFP->mf_iprb = (u_int8_t)~IB_AINT; 517 MFP->mf_imrb |= IB_AINT; 518 } 519 520 splx (s); 521 return code; 522 } 523 524 /* 525 * Write a command to the keyboard in 'polled' mode. 526 */ 527 static int 528 kbd_write_poll(cmd, len) 529 u_char *cmd; 530 int len; 531 { 532 int timeout; 533 534 while (len-- > 0) { 535 KBD->ac_da = *cmd++; 536 for (timeout = 100; !(KBD->ac_cs & A_TXRDY); timeout--) 537 delay(10); 538 if (!(KBD->ac_cs & A_TXRDY)) 539 return (0); 540 } 541 return (1); 542 } 543 544 /* 545 * Write a command to the keyboard. Return when command is send. 546 */ 547 void 548 kbd_write(cmd, len) 549 u_char *cmd; 550 int len; 551 { 552 struct kbd_softc *k = &kbd_softc; 553 int sps; 554 555 /* 556 * Get to splhigh, 'real' interrupts arrive at spl6! 557 */ 558 sps = splhigh(); 559 560 /* 561 * Make sure any privious write has ended... 562 */ 563 while (k->k_sendp != NULL) 564 tsleep((caddr_t)&k->k_sendp, TTOPRI, "kbd_write1", 0); 565 566 /* 567 * If the KBD-acia is not currently busy, send the first 568 * character now. 569 */ 570 KBD->ac_cs = (k->k_soft_cs |= A_TXINT); 571 if (KBD->ac_cs & A_TXRDY) { 572 KBD->ac_da = *cmd++; 573 len--; 574 } 575 576 /* 577 * If we're not yet done, wait until all characters are send. 578 */ 579 if (len > 0) { 580 k->k_sendp = cmd; 581 k->k_send_cnt = len; 582 tsleep((caddr_t)&k->k_send_cnt, TTOPRI, "kbd_write2", 0); 583 } 584 splx(sps); 585 586 /* 587 * Wakeup all procs waiting for us. 588 */ 589 wakeup((caddr_t)&k->k_sendp); 590 } 591 592 /* 593 * Setup softc-fields to assemble a keyboard package. 594 */ 595 static void 596 kbd_pkg_start(kp, msg_start) 597 struct kbd_softc *kp; 598 u_char msg_start; 599 { 600 kp->k_pkg_idx = 1; 601 kp->k_package[0] = msg_start; 602 switch (msg_start) { 603 case 0xf6: 604 kp->k_pkg_type = KBD_MEM_PKG; 605 kp->k_pkg_size = 8; 606 break; 607 case 0xf7: 608 kp->k_pkg_type = KBD_AMS_PKG; 609 kp->k_pkg_size = 6; 610 break; 611 case 0xf8: 612 case 0xf9: 613 case 0xfa: 614 case 0xfb: 615 kp->k_pkg_type = KBD_RMS_PKG; 616 kp->k_pkg_size = 3; 617 break; 618 case 0xfc: 619 kp->k_pkg_type = KBD_CLK_PKG; 620 kp->k_pkg_size = 7; 621 break; 622 case 0xfe: 623 kp->k_pkg_type = KBD_JOY0_PKG; 624 kp->k_pkg_size = 2; 625 break; 626 case 0xff: 627 kp->k_pkg_type = KBD_JOY1_PKG; 628 kp->k_pkg_size = 2; 629 break; 630 default: 631 printf("kbd: Unknown packet 0x%x\n", msg_start); 632 break; 633 } 634 } 635 636 /* 637 * Modifier processing 638 */ 639 static int 640 kbd_do_modifier(code) 641 u_char code; 642 { 643 u_char up, mask; 644 645 up = KBD_RELEASED(code); 646 mask = 0; 647 648 switch(KBD_SCANCODE(code)) { 649 case KBD_LEFT_SHIFT: 650 mask = KBD_MOD_LSHIFT; 651 break; 652 case KBD_RIGHT_SHIFT: 653 mask = KBD_MOD_RSHIFT; 654 break; 655 case KBD_CTRL: 656 mask = KBD_MOD_CTRL; 657 break; 658 case KBD_ALT: 659 mask = KBD_MOD_ALT; 660 break; 661 case KBD_CAPS_LOCK: 662 /* CAPSLOCK is a toggle */ 663 if(!up) 664 kbd_modifier ^= KBD_MOD_CAPS; 665 return 1; 666 } 667 if(mask) { 668 if(up) 669 kbd_modifier &= ~mask; 670 else 671 kbd_modifier |= mask; 672 return 1; 673 } 674 return 0; 675 } 676
Indexes created Wed Sep 24 05:09:52 GMT 2025