1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Generic keyboard support: streams and administration. 29 */ 30 31 #define KEYMAP_SIZE_VARIABLE 32 33 #include <sys/types.h> 34 #include <sys/cred.h> 35 #include <sys/stream.h> 36 #include <sys/stropts.h> 37 #include <sys/strsun.h> 38 #include <sys/ddi.h> 39 #include <sys/vuid_event.h> 40 #include <sys/modctl.h> 41 #include <sys/errno.h> 42 #include <sys/kmem.h> 43 #include <sys/cmn_err.h> 44 #include <sys/kbd.h> 45 #include <sys/kbio.h> 46 #include <sys/consdev.h> 47 #include <sys/kbtrans.h> 48 #include <sys/policy.h> 49 #include <sys/sunldi.h> 50 #include <sys/class.h> 51 #include <sys/spl.h> 52 #include "kbtrans_lower.h" 53 #include "kbtrans_streams.h" 54 55 #ifdef DEBUG 56 int kbtrans_errmask; 57 int kbtrans_errlevel; 58 #endif 59 60 #define KB_NR_FUNCKEYS 12 61 62 /* 63 * Repeat rates set in static variables so they can be tweeked with 64 * debugger. 65 */ 66 static int kbtrans_repeat_rate; 67 static int kbtrans_repeat_delay; 68 69 /* Printing message on q overflow */ 70 static int kbtrans_overflow_msg = 1; 71 72 /* 73 * This value corresponds approximately to max 10 fingers 74 */ 75 static int kbtrans_downs_size = 15; 76 77 /* 78 * modload support 79 */ 80 extern struct mod_ops mod_miscops; 81 82 static struct modlmisc modlmisc = { 83 &mod_miscops, /* Type of module */ 84 "kbtrans (key translation)" 85 }; 86 87 static struct modlinkage modlinkage = { 88 MODREV_1, (void *)&modlmisc, NULL 89 }; 90 91 int 92 _init(void) 93 { 94 return (mod_install(&modlinkage)); 95 } 96 97 int 98 _fini(void) 99 { 100 return (mod_remove(&modlinkage)); 101 } 102 103 int 104 _info(struct modinfo *modinfop) 105 { 106 return (mod_info(&modlinkage, modinfop)); 107 } 108 109 /* 110 * Internal Function Prototypes 111 */ 112 static char *kbtrans_strsetwithdecimal(char *, uint_t, uint_t); 113 static void kbtrans_set_translation_callback(struct kbtrans *); 114 static void kbtrans_reioctl(void *); 115 static void kbtrans_send_esc_event(char, struct kbtrans *); 116 static void kbtrans_keypressed(struct kbtrans *, uchar_t, Firm_event *, 117 ushort_t); 118 static void kbtrans_putbuf(char *, queue_t *); 119 static void kbtrans_cancelrpt(struct kbtrans *); 120 static void kbtrans_queuepress(struct kbtrans *, uchar_t, Firm_event *); 121 static void kbtrans_putcode(register struct kbtrans *, uint_t); 122 static void kbtrans_keyreleased(struct kbtrans *, uchar_t); 123 static void kbtrans_queueevent(struct kbtrans *, Firm_event *); 124 static void kbtrans_untrans_keypressed_raw(struct kbtrans *, kbtrans_key_t); 125 static void kbtrans_untrans_keyreleased_raw(struct kbtrans *, 126 kbtrans_key_t); 127 static void kbtrans_ascii_keypressed(struct kbtrans *, uint_t, 128 kbtrans_key_t, uint_t); 129 static void kbtrans_ascii_keyreleased(struct kbtrans *, kbtrans_key_t); 130 static void kbtrans_ascii_setup_repeat(struct kbtrans *, uint_t, 131 kbtrans_key_t); 132 static void kbtrans_trans_event_keypressed(struct kbtrans *, uint_t, 133 kbtrans_key_t, uint_t); 134 static void kbtrans_trans_event_keyreleased(struct kbtrans *, 135 kbtrans_key_t); 136 static void kbtrans_trans_event_setup_repeat(struct kbtrans *, uint_t, 137 kbtrans_key_t); 138 static void kbtrans_rpt(void *); 139 static void kbtrans_setled(struct kbtrans *); 140 static void kbtrans_flush(struct kbtrans *); 141 static enum kbtrans_message_response kbtrans_ioctl(struct kbtrans *upper, 142 mblk_t *mp); 143 static int kbtrans_setkey(struct kbtrans_lower *, struct kiockey *, 144 cred_t *); 145 static int kbtrans_getkey(struct kbtrans_lower *, struct kiockey *); 146 static int kbtrans_skey(struct kbtrans_lower *, struct kiockeymap *, 147 cred_t *cr); 148 static int kbtrans_gkey(struct kbtrans_lower *, struct kiockeymap *); 149 150 /* 151 * Keyboard Translation Mode (TR_NONE) 152 * 153 * Functions to be called when keyboard translation is turned off 154 * and up/down key codes are reported. 155 */ 156 struct keyboard_callback untrans_event_callback = { 157 kbtrans_untrans_keypressed_raw, 158 kbtrans_untrans_keyreleased_raw, 159 NULL, 160 NULL, 161 NULL, 162 NULL, 163 NULL, 164 }; 165 166 /* 167 * Keyboard Translation Mode (TR_ASCII) 168 * 169 * Functions to be called when ISO 8859/1 codes are reported 170 */ 171 struct keyboard_callback ascii_callback = { 172 NULL, 173 NULL, 174 kbtrans_ascii_keypressed, 175 kbtrans_ascii_keyreleased, 176 kbtrans_ascii_setup_repeat, 177 kbtrans_cancelrpt, 178 kbtrans_setled, 179 }; 180 181 /* 182 * Keyboard Translation Mode (TR_EVENT) 183 * 184 * Functions to be called when firm_events are reported. 185 */ 186 struct keyboard_callback trans_event_callback = { 187 NULL, 188 NULL, 189 kbtrans_trans_event_keypressed, 190 kbtrans_trans_event_keyreleased, 191 kbtrans_trans_event_setup_repeat, 192 kbtrans_cancelrpt, 193 kbtrans_setled, 194 }; 195 196 static void 197 progressbar_key_abort_thread(struct kbtrans *upper) 198 { 199 ldi_ident_t li; 200 extern void progressbar_key_abort(ldi_ident_t); 201 202 if (ldi_ident_from_stream(upper->kbtrans_streams_readq, &li) != 0) { 203 cmn_err(CE_NOTE, "!ldi_ident_from_stream failed"); 204 } else { 205 mutex_enter(&upper->progressbar_key_abort_lock); 206 while (upper->progressbar_key_abort_flag == 0) 207 cv_wait(&upper->progressbar_key_abort_cv, 208 &upper->progressbar_key_abort_lock); 209 if (upper->progressbar_key_abort_flag == 1) { 210 mutex_exit(&upper->progressbar_key_abort_lock); 211 progressbar_key_abort(li); 212 } else { 213 mutex_exit(&upper->progressbar_key_abort_lock); 214 } 215 ldi_ident_release(li); 216 } 217 218 thread_exit(); 219 } 220 221 /* 222 * kbtrans_streams_init: 223 * Initialize the stream, keytables, callbacks, etc. 224 */ 225 int 226 kbtrans_streams_init( 227 queue_t *q, 228 int sflag, 229 struct kbtrans_hardware *hw, 230 struct kbtrans_callbacks *hw_cb, 231 struct kbtrans **ret_kbd, 232 int initial_leds, 233 int initial_led_mask) 234 { 235 struct kbtrans *upper; 236 struct kbtrans_lower *lower; 237 kthread_t *tid; 238 239 /* 240 * Default to relatively generic tables. 241 */ 242 extern signed char kb_compose_map[]; 243 extern struct compose_sequence_t kb_compose_table[]; 244 extern struct fltaccent_sequence_t kb_fltaccent_table[]; 245 extern char keystringtab[][KTAB_STRLEN]; 246 extern unsigned char kb_numlock_table[]; 247 248 /* Set these up only once so that they could be changed from adb */ 249 if (!kbtrans_repeat_rate) { 250 kbtrans_repeat_rate = (hz+29)/30; 251 kbtrans_repeat_delay = hz/2; 252 } 253 254 switch (sflag) { 255 256 case MODOPEN: 257 break; 258 259 case CLONEOPEN: 260 DPRINTF(PRINT_L1, PRINT_MASK_OPEN, (NULL, 261 "kbtrans_streams_init: Clone open not supported")); 262 263 return (EINVAL); 264 } 265 266 /* allocate keyboard state structure */ 267 upper = kmem_zalloc(sizeof (struct kbtrans), KM_SLEEP); 268 269 *ret_kbd = upper; 270 271 upper->kbtrans_polled_buf[0] = '\0'; 272 upper->kbtrans_polled_pending_chars = upper->kbtrans_polled_buf; 273 274 upper->kbtrans_streams_hw = hw; 275 upper->kbtrans_streams_hw_callbacks = hw_cb; 276 upper->kbtrans_streams_readq = q; 277 upper->kbtrans_streams_iocpending = NULL; 278 upper->kbtrans_streams_translatable = TR_CAN; 279 upper->kbtrans_overflow_cnt = 0; 280 upper->kbtrans_streams_translate_mode = TR_ASCII; 281 282 /* Set the translation callback based on the translation type */ 283 kbtrans_set_translation_callback(upper); 284 285 lower = &upper->kbtrans_lower; 286 287 /* 288 * Set defaults for relatively generic tables. 289 */ 290 lower->kbtrans_compose_map = kb_compose_map; 291 lower->kbtrans_compose_table = kb_compose_table; 292 lower->kbtrans_fltaccent_table = kb_fltaccent_table; 293 lower->kbtrans_numlock_table = kb_numlock_table; 294 lower->kbtrans_keystringtab = keystringtab; 295 296 lower->kbtrans_upper = upper; 297 lower->kbtrans_compat = 1; 298 299 /* 300 * We have a generic default for the LED state, and let the 301 * hardware-specific driver supply overrides. 302 */ 303 lower->kbtrans_led_state = 0; 304 lower->kbtrans_led_state &= ~initial_led_mask; 305 lower->kbtrans_led_state |= initial_leds; 306 lower->kbtrans_togglemask = 0; 307 308 if (lower->kbtrans_led_state & LED_CAPS_LOCK) 309 lower->kbtrans_togglemask |= CAPSMASK; 310 if (lower->kbtrans_led_state & LED_NUM_LOCK) 311 lower->kbtrans_togglemask |= NUMLOCKMASK; 312 313 #if defined(SCROLLMASK) 314 if (lower->kbtrans_led_state & LED_SCROLL_LOCK) 315 lower->kbtrans_togglemask |= SCROLLMASK; 316 #endif 317 318 lower->kbtrans_shiftmask = lower->kbtrans_togglemask; 319 320 upper->kbtrans_streams_vuid_addr.ascii = ASCII_FIRST; 321 upper->kbtrans_streams_vuid_addr.top = TOP_FIRST; 322 upper->kbtrans_streams_vuid_addr.vkey = VKEY_FIRST; 323 324 /* Allocate dynamic memory for downs table */ 325 upper->kbtrans_streams_num_downs_entries = kbtrans_downs_size; 326 upper->kbtrans_streams_downs_bytes = 327 (uint32_t)(kbtrans_downs_size * sizeof (Key_event)); 328 upper->kbtrans_streams_downs = 329 kmem_zalloc(upper->kbtrans_streams_downs_bytes, KM_SLEEP); 330 upper->kbtrans_streams_abortable = B_FALSE; 331 332 upper->kbtrans_streams_flags = KBTRANS_STREAMS_OPEN; 333 334 upper->progressbar_key_abort_flag = 0; 335 cv_init(&upper->progressbar_key_abort_cv, NULL, CV_DEFAULT, NULL); 336 /* this counts on no keyboards being above ipl 12 */ 337 mutex_init(&upper->progressbar_key_abort_lock, NULL, MUTEX_SPIN, 338 (void *)ipltospl(12)); 339 tid = thread_create(NULL, 0, progressbar_key_abort_thread, upper, 340 0, &p0, TS_RUN, minclsyspri); 341 upper->progressbar_key_abort_t_did = tid->t_did; 342 343 DPRINTF(PRINT_L1, PRINT_MASK_OPEN, (upper, "kbtrans_streams_init " 344 "exiting")); 345 return (0); 346 } 347 348 349 /* 350 * kbtrans_streams_fini: 351 * Free structures and uninitialize the stream 352 */ 353 int 354 kbtrans_streams_fini(struct kbtrans *upper) 355 { 356 /* 357 * Since we're about to destroy our private data, turn off 358 * our open flag first, so we don't accept any more input 359 * and try to use that data. 360 */ 361 upper->kbtrans_streams_flags = 0; 362 363 /* clear all timeouts */ 364 if (upper->kbtrans_streams_bufcallid) { 365 qunbufcall(upper->kbtrans_streams_readq, 366 upper->kbtrans_streams_bufcallid); 367 } 368 if (upper->kbtrans_streams_rptid) { 369 (void) quntimeout(upper->kbtrans_streams_readq, 370 upper->kbtrans_streams_rptid); 371 } 372 kmem_free(upper->kbtrans_streams_downs, 373 upper->kbtrans_streams_downs_bytes); 374 375 mutex_enter(&upper->progressbar_key_abort_lock); 376 if (upper->progressbar_key_abort_flag == 0) { 377 upper->progressbar_key_abort_flag = 2; 378 cv_signal(&upper->progressbar_key_abort_cv); 379 mutex_exit(&upper->progressbar_key_abort_lock); 380 thread_join(upper->progressbar_key_abort_t_did); 381 } else { 382 mutex_exit(&upper->progressbar_key_abort_lock); 383 } 384 cv_destroy(&upper->progressbar_key_abort_cv); 385 mutex_destroy(&upper->progressbar_key_abort_lock); 386 387 kmem_free(upper, sizeof (struct kbtrans)); 388 389 DPRINTF(PRINT_L1, PRINT_MASK_CLOSE, (upper, "kbtrans_streams_fini " 390 "exiting")); 391 return (0); 392 } 393 394 /* 395 * kbtrans_streams_releaseall : 396 * This function releases all the held keys. 397 */ 398 void 399 kbtrans_streams_releaseall(struct kbtrans *upper) 400 { 401 register struct key_event *ke; 402 register int i; 403 404 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "USBKBM RELEASE ALL\n")); 405 406 /* Scan table of down key stations */ 407 for (i = 0, ke = upper->kbtrans_streams_downs; 408 i < upper->kbtrans_streams_num_downs_entries; i++, ke++) { 409 410 /* Key station not zero */ 411 if (ke->key_station) { 412 413 kbtrans_keyreleased(upper, ke->key_station); 414 /* kbtrans_keyreleased resets downs entry */ 415 } 416 } 417 } 418 419 /* 420 * kbtrans_streams_message: 421 * keyboard module output queue put procedure: handles M_IOCTL 422 * messages. 423 * 424 * Return KBTRANS_MESSAGE_HANDLED if the message was handled by 425 * kbtrans and KBTRANS_MESSAGE_NOT_HANDLED otherwise. If 426 * KBTRANS_MESSAGE_HANDLED is returned, no further action is required. 427 * If KBTRANS_MESSAGE_NOT_HANDLED is returned, the hardware module 428 * is responsible for any action. 429 */ 430 enum kbtrans_message_response 431 kbtrans_streams_message(struct kbtrans *upper, register mblk_t *mp) 432 { 433 queue_t *q = upper->kbtrans_streams_readq; 434 enum kbtrans_message_response ret; 435 436 DPRINTF(PRINT_L1, PRINT_MASK_ALL, (upper, 437 "kbtrans_streams_message entering")); 438 /* 439 * Process M_FLUSH, and some M_IOCTL, messages here; pass 440 * everything else down. 441 */ 442 switch (mp->b_datap->db_type) { 443 444 case M_IOCTL: 445 ret = kbtrans_ioctl(upper, mp); 446 break; 447 448 case M_FLUSH: 449 if (*mp->b_rptr & FLUSHW) 450 flushq(q, FLUSHDATA); 451 if (*mp->b_rptr & FLUSHR) 452 flushq(RD(q), FLUSHDATA); 453 /* 454 * White lie: we say we didn't handle the message, 455 * so that it gets handled by our client. 456 */ 457 ret = KBTRANS_MESSAGE_NOT_HANDLED; 458 break; 459 460 default: 461 ret = KBTRANS_MESSAGE_NOT_HANDLED; 462 break; 463 464 } 465 DPRINTF(PRINT_L1, PRINT_MASK_ALL, (upper, 466 "kbtrans_streams_message exiting\n")); 467 468 return (ret); 469 } 470 471 /* 472 * kbtrans_streams_key: 473 * When a key is pressed or released, the hardware module should 474 * call kbtrans, passing the key number and its new 475 * state. kbtrans is responsible for autorepeat handling; 476 * the hardware module should report only actual press/release 477 * events, suppressing any hardware-generated autorepeat. 478 */ 479 void 480 kbtrans_streams_key( 481 struct kbtrans *upper, 482 kbtrans_key_t key, 483 enum keystate state) 484 { 485 struct kbtrans_lower *lower; 486 struct keyboard *kp; 487 488 lower = &upper->kbtrans_lower; 489 kp = lower->kbtrans_keyboard; 490 491 /* trigger switch back to text mode */ 492 mutex_enter(&upper->progressbar_key_abort_lock); 493 if (upper->progressbar_key_abort_flag == 0) { 494 upper->progressbar_key_abort_flag = 1; 495 cv_signal(&upper->progressbar_key_abort_cv); 496 } 497 mutex_exit(&upper->progressbar_key_abort_lock); 498 499 if (upper->kbtrans_streams_abortable) { 500 switch (upper->kbtrans_streams_abort_state) { 501 case ABORT_NORMAL: 502 if (state != KEY_PRESSED) 503 break; 504 505 if (key == (kbtrans_key_t)kp->k_abort1 || 506 key == (kbtrans_key_t)kp->k_abort1a) { 507 upper->kbtrans_streams_abort_state = 508 ABORT_ABORT1_RECEIVED; 509 upper->kbtrans_streams_abort1_key = key; 510 return; 511 } 512 /* Shift key needs to be sent to upper immediately */ 513 if (key == (kbtrans_key_t)kp->k_newabort1 || 514 key == (kbtrans_key_t)kp->k_newabort1a) { 515 upper->kbtrans_streams_abort_state = 516 NEW_ABORT_ABORT1_RECEIVED; 517 upper->kbtrans_streams_new_abort1_key = key; 518 } 519 break; 520 case ABORT_ABORT1_RECEIVED: 521 upper->kbtrans_streams_abort_state = ABORT_NORMAL; 522 if (state == KEY_PRESSED && 523 key == (kbtrans_key_t)kp->k_abort2) { 524 abort_sequence_enter((char *)NULL); 525 return; 526 } else { 527 kbtrans_processkey(lower, 528 upper->kbtrans_streams_callback, 529 upper->kbtrans_streams_abort1_key, 530 KEY_PRESSED); 531 } 532 break; 533 case NEW_ABORT_ABORT1_RECEIVED: 534 upper->kbtrans_streams_abort_state = ABORT_NORMAL; 535 if (state == KEY_PRESSED && 536 key == (kbtrans_key_t)kp->k_newabort2) { 537 abort_sequence_enter((char *)NULL); 538 kbtrans_processkey(lower, 539 upper->kbtrans_streams_callback, 540 upper->kbtrans_streams_new_abort1_key, 541 KEY_RELEASED); 542 return; 543 } 544 } 545 } 546 547 kbtrans_processkey(lower, upper->kbtrans_streams_callback, key, state); 548 } 549 550 /* 551 * kbtrans_streams_set_keyboard: 552 * At any time after calling kbtrans_streams_init, the hardware 553 * module should make this call to report the id of the keyboard 554 * attached. id is the keyboard type, typically KB_SUN4, 555 * KB_PC, or KB_USB. 556 */ 557 void 558 kbtrans_streams_set_keyboard( 559 struct kbtrans *upper, 560 int id, 561 struct keyboard *k) 562 { 563 upper->kbtrans_lower.kbtrans_keyboard = k; 564 upper->kbtrans_streams_id = id; 565 } 566 567 /* 568 * kbtrans_streams_has_reset: 569 * At any time between kbtrans_streams_init and kbtrans_streams_fini, 570 * the hardware module can call this routine to report that the 571 * keyboard has been reset, e.g. by being unplugged and reattached. 572 */ 573 /*ARGSUSED*/ 574 void 575 kbtrans_streams_has_reset(struct kbtrans *upper) 576 { 577 /* 578 * If this routine is implemented it should probably (a) 579 * simulate releases of all pressed keys and (b) call 580 * the hardware module to set the LEDs. 581 */ 582 } 583 584 /* 585 * kbtrans_streams_enable: 586 * This is the routine that is called back when the the stream is ready 587 * to take messages. 588 */ 589 void 590 kbtrans_streams_enable(struct kbtrans *upper) 591 { 592 /* Set the LED's */ 593 kbtrans_setled(upper); 594 } 595 596 /* 597 * kbtrans_streams_setled(): 598 * This is the routine that is called to only update the led state 599 * in kbtrans. 600 */ 601 void 602 kbtrans_streams_setled(struct kbtrans *upper, int led_state) 603 { 604 struct kbtrans_lower *lower; 605 606 lower = &upper->kbtrans_lower; 607 lower->kbtrans_led_state = (uchar_t)led_state; 608 609 if (lower->kbtrans_led_state & LED_CAPS_LOCK) 610 lower->kbtrans_togglemask |= CAPSMASK; 611 if (lower->kbtrans_led_state & LED_NUM_LOCK) 612 lower->kbtrans_togglemask |= NUMLOCKMASK; 613 614 #if defined(SCROLLMASK) 615 if (lower->kbtrans_led_state & LED_SCROLL_LOCK) 616 lower->kbtrans_togglemask |= SCROLLMASK; 617 #endif 618 619 lower->kbtrans_shiftmask = lower->kbtrans_togglemask; 620 621 } 622 623 /* 624 * kbtrans_streams_set_queue: 625 * Set the overlying queue, to support multiplexors. 626 */ 627 void 628 kbtrans_streams_set_queue(struct kbtrans *upper, queue_t *q) 629 { 630 631 upper->kbtrans_streams_readq = q; 632 } 633 634 /* 635 * kbtrans_streams_get_queue: 636 * Return the overlying queue. 637 */ 638 queue_t * 639 kbtrans_streams_get_queue(struct kbtrans *upper) 640 { 641 return (upper->kbtrans_streams_readq); 642 } 643 644 /* 645 * kbtrans_streams_untimeout 646 * Cancell all timeout 647 */ 648 void 649 kbtrans_streams_untimeout(struct kbtrans *upper) 650 { 651 /* clear all timeouts */ 652 if (upper->kbtrans_streams_bufcallid) { 653 qunbufcall(upper->kbtrans_streams_readq, 654 upper->kbtrans_streams_bufcallid); 655 upper->kbtrans_streams_bufcallid = 0; 656 } 657 if (upper->kbtrans_streams_rptid) { 658 (void) quntimeout(upper->kbtrans_streams_readq, 659 upper->kbtrans_streams_rptid); 660 upper->kbtrans_streams_rptid = 0; 661 } 662 } 663 664 /* 665 * kbtrans_reioctl: 666 * This function is set up as call-back function should an ioctl fail 667 * to allocate required resources. 668 */ 669 static void 670 kbtrans_reioctl(void *arg) 671 { 672 struct kbtrans *upper = (struct kbtrans *)arg; 673 mblk_t *mp; 674 675 upper->kbtrans_streams_bufcallid = 0; 676 677 if ((mp = upper->kbtrans_streams_iocpending) != NULL) { 678 /* not pending any more */ 679 upper->kbtrans_streams_iocpending = NULL; 680 (void) kbtrans_ioctl(upper, mp); 681 } 682 } 683 684 /* 685 * kbtrans_ioctl: 686 * process ioctls we recognize and own. Otherwise, pass it down. 687 */ 688 static enum kbtrans_message_response 689 kbtrans_ioctl(struct kbtrans *upper, register mblk_t *mp) 690 { 691 register struct iocblk *iocp; 692 register short new_translate; 693 register Vuid_addr_probe *addr_probe; 694 register short *addr_ptr; 695 size_t ioctlrespsize; 696 int err = 0; 697 struct kbtrans_lower *lower; 698 mblk_t *datap; 699 int translate; 700 701 static int kiocgetkey, kiocsetkey; 702 703 lower = &upper->kbtrans_lower; 704 705 iocp = (struct iocblk *)mp->b_rptr; 706 707 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, 708 "kbtrans_ioctl: ioc_cmd 0x%x - ", iocp->ioc_cmd)); 709 switch (iocp->ioc_cmd) { 710 711 case VUIDSFORMAT: 712 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDSFORMAT\n")); 713 714 err = miocpullup(mp, sizeof (int)); 715 if (err != 0) 716 break; 717 new_translate = (*(int *)mp->b_cont->b_rptr == VUID_NATIVE) ? 718 TR_ASCII : TR_EVENT; 719 720 if (new_translate == upper->kbtrans_streams_translate_mode) 721 break; 722 upper->kbtrans_streams_translate_mode = new_translate; 723 724 kbtrans_set_translation_callback(upper); 725 726 kbtrans_flush(upper); 727 break; 728 729 case KIOCTRANS: 730 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTRANS\n")); 731 err = miocpullup(mp, sizeof (int)); 732 if (err != 0) 733 break; 734 new_translate = *(int *)mp->b_cont->b_rptr; 735 if (new_translate == upper->kbtrans_streams_translate_mode) 736 break; 737 upper->kbtrans_streams_translate_mode = new_translate; 738 kbtrans_set_translation_callback(upper); 739 740 kbtrans_flush(upper); 741 break; 742 743 case KIOCSLED: 744 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSLED\n")); 745 746 err = miocpullup(mp, sizeof (uchar_t)); 747 if (err != 0) 748 break; 749 lower->kbtrans_led_state = *(uchar_t *)mp->b_cont->b_rptr; 750 751 kbtrans_setled(upper); 752 break; 753 754 case KIOCGLED: 755 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGLED\n")); 756 if ((datap = allocb(sizeof (uchar_t), BPRI_HI)) == NULL) { 757 ioctlrespsize = sizeof (int); 758 goto allocfailure; 759 } 760 761 *(uchar_t *)datap->b_wptr = lower->kbtrans_led_state; 762 datap->b_wptr += sizeof (uchar_t); 763 if (mp->b_cont) 764 freemsg(mp->b_cont); 765 mp->b_cont = datap; 766 iocp->ioc_count = sizeof (uchar_t); 767 break; 768 769 case VUIDGFORMAT: 770 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDGFORMAT\n")); 771 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 772 ioctlrespsize = sizeof (int); 773 goto allocfailure; 774 } 775 *(int *)datap->b_wptr = 776 (upper->kbtrans_streams_translate_mode == TR_EVENT || 777 upper->kbtrans_streams_translate_mode == TR_UNTRANS_EVENT) ? 778 VUID_FIRM_EVENT: VUID_NATIVE; 779 datap->b_wptr += sizeof (int); 780 if (mp->b_cont) /* free msg to prevent memory leak */ 781 freemsg(mp->b_cont); 782 mp->b_cont = datap; 783 iocp->ioc_count = sizeof (int); 784 break; 785 786 case KIOCGTRANS: 787 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGTRANS\n")); 788 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 789 ioctlrespsize = sizeof (int); 790 goto allocfailure; 791 } 792 *(int *)datap->b_wptr = upper->kbtrans_streams_translate_mode; 793 datap->b_wptr += sizeof (int); 794 if (mp->b_cont) /* free msg to prevent memory leak */ 795 freemsg(mp->b_cont); 796 mp->b_cont = datap; 797 iocp->ioc_count = sizeof (int); 798 break; 799 800 case VUIDSADDR: 801 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDSADDR\n")); 802 803 err = miocpullup(mp, sizeof (Vuid_addr_probe)); 804 if (err != 0) 805 break; 806 addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr; 807 switch (addr_probe->base) { 808 809 case ASCII_FIRST: 810 addr_ptr = &upper->kbtrans_streams_vuid_addr.ascii; 811 break; 812 813 case TOP_FIRST: 814 addr_ptr = &upper->kbtrans_streams_vuid_addr.top; 815 break; 816 817 case VKEY_FIRST: 818 addr_ptr = &upper->kbtrans_streams_vuid_addr.vkey; 819 break; 820 821 default: 822 err = ENODEV; 823 } 824 825 if ((err == 0) && (*addr_ptr != addr_probe->data.next)) { 826 *addr_ptr = addr_probe->data.next; 827 kbtrans_flush(upper); 828 } 829 break; 830 831 case VUIDGADDR: 832 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDGADDR\n")); 833 834 err = miocpullup(mp, sizeof (Vuid_addr_probe)); 835 if (err != 0) 836 break; 837 addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr; 838 switch (addr_probe->base) { 839 840 case ASCII_FIRST: 841 addr_probe->data.current = 842 upper->kbtrans_streams_vuid_addr.ascii; 843 break; 844 845 case TOP_FIRST: 846 addr_probe->data.current = 847 upper->kbtrans_streams_vuid_addr.top; 848 break; 849 850 case VKEY_FIRST: 851 addr_probe->data.current = 852 upper->kbtrans_streams_vuid_addr.vkey; 853 break; 854 855 default: 856 err = ENODEV; 857 } 858 break; 859 860 case KIOCTRANSABLE: 861 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTRANSABLE\n")); 862 863 err = miocpullup(mp, sizeof (int)); 864 if (err != 0) 865 break; 866 /* 867 * called during console setup in kbconfig() 868 * If set to false, means we are a serial keyboard, 869 * and we should pass all data up without modification. 870 */ 871 translate = *(int *)mp->b_cont->b_rptr; 872 if (upper->kbtrans_streams_translatable != translate) 873 upper->kbtrans_streams_translatable = translate; 874 875 if (translate != TR_CAN) 876 DPRINTF(PRINT_L4, PRINT_MASK_ALL, (upper, 877 "Cannot translate keyboard using tables.\n")); 878 break; 879 880 case KIOCGTRANSABLE: 881 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGTRANSABLE\n")); 882 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 883 ioctlrespsize = sizeof (int); 884 goto allocfailure; 885 } 886 *(int *)datap->b_wptr = upper->kbtrans_streams_translatable; 887 datap->b_wptr += sizeof (int); 888 if (mp->b_cont) /* free msg to prevent memory leak */ 889 freemsg(mp->b_cont); 890 mp->b_cont = datap; 891 iocp->ioc_count = sizeof (int); 892 break; 893 894 case KIOCSCOMPAT: 895 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSCOMPAT\n")); 896 897 err = miocpullup(mp, sizeof (int)); 898 if (err != 0) 899 break; 900 lower->kbtrans_compat = *(int *)mp->b_cont->b_rptr; 901 break; 902 903 case KIOCGCOMPAT: 904 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGCOMPAT\n")); 905 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 906 ioctlrespsize = sizeof (int); 907 goto allocfailure; 908 } 909 *(int *)datap->b_wptr = lower->kbtrans_compat; 910 datap->b_wptr += sizeof (int); 911 if (mp->b_cont) /* free msg to prevent memory leak */ 912 freemsg(mp->b_cont); 913 mp->b_cont = datap; 914 iocp->ioc_count = sizeof (int); 915 break; 916 917 case KIOCSETKEY: 918 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSETKEY %d\n", 919 kiocsetkey++)); 920 err = miocpullup(mp, sizeof (struct kiockey)); 921 if (err != 0) 922 break; 923 err = kbtrans_setkey(&upper->kbtrans_lower, 924 (struct kiockey *)mp->b_cont->b_rptr, iocp->ioc_cr); 925 /* 926 * Since this only affects any subsequent key presses, 927 * don't flush soft state. One might want to 928 * toggle the keytable entries dynamically. 929 */ 930 break; 931 932 case KIOCGETKEY: 933 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGETKEY %d\n", 934 kiocgetkey++)); 935 err = miocpullup(mp, sizeof (struct kiockey)); 936 if (err != 0) 937 break; 938 err = kbtrans_getkey(&upper->kbtrans_lower, 939 (struct kiockey *)mp->b_cont->b_rptr); 940 break; 941 942 case KIOCSKEY: 943 err = miocpullup(mp, sizeof (struct kiockeymap)); 944 if (err != 0) 945 break; 946 err = kbtrans_skey(&upper->kbtrans_lower, 947 (struct kiockeymap *)mp->b_cont->b_rptr, iocp->ioc_cr); 948 /* 949 * Since this only affects any subsequent key presses, 950 * don't flush soft state. One might want to 951 * toggle the keytable entries dynamically. 952 */ 953 break; 954 955 case KIOCGKEY: 956 err = miocpullup(mp, sizeof (struct kiockeymap)); 957 if (err != 0) 958 break; 959 err = kbtrans_gkey(&upper->kbtrans_lower, 960 (struct kiockeymap *)mp->b_cont->b_rptr); 961 break; 962 963 case KIOCSDIRECT: 964 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSDIRECT\n")); 965 kbtrans_flush(upper); 966 break; 967 968 case KIOCGDIRECT: 969 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSGDIRECT\n")); 970 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 971 ioctlrespsize = sizeof (int); 972 goto allocfailure; 973 } 974 *(int *)datap->b_wptr = 1; /* always direct */ 975 datap->b_wptr += sizeof (int); 976 if (mp->b_cont) /* free msg to prevent memory leak */ 977 freemsg(mp->b_cont); 978 mp->b_cont = datap; 979 iocp->ioc_count = sizeof (int); 980 break; 981 982 case KIOCTYPE: 983 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTYPE\n")); 984 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 985 ioctlrespsize = sizeof (int); 986 goto allocfailure; 987 } 988 *(int *)datap->b_wptr = upper->kbtrans_streams_id; 989 datap->b_wptr += sizeof (int); 990 if (mp->b_cont) /* free msg to prevent memory leak */ 991 freemsg(mp->b_cont); 992 mp->b_cont = datap; 993 iocp->ioc_count = sizeof (int); 994 break; 995 996 case CONSSETABORTENABLE: 997 /* 998 * Peek as it goes by; must be a TRANSPARENT ioctl. 999 */ 1000 if (iocp->ioc_count != TRANSPARENT) { 1001 err = EINVAL; 1002 break; 1003 } 1004 1005 upper->kbtrans_streams_abortable = 1006 (boolean_t)*(intptr_t *)mp->b_cont->b_rptr; 1007 1008 /* 1009 * Let the hardware module see it too. 1010 */ 1011 return (KBTRANS_MESSAGE_NOT_HANDLED); 1012 1013 case KIOCGRPTDELAY: 1014 /* 1015 * Report the autorepeat delay, unit in millisecond 1016 */ 1017 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGRPTDELAY\n")); 1018 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 1019 ioctlrespsize = sizeof (int); 1020 goto allocfailure; 1021 } 1022 *(int *)datap->b_wptr = TICK_TO_MSEC(kbtrans_repeat_delay); 1023 datap->b_wptr += sizeof (int); 1024 1025 /* free msg to prevent memory leak */ 1026 if (mp->b_cont != NULL) 1027 freemsg(mp->b_cont); 1028 mp->b_cont = datap; 1029 iocp->ioc_count = sizeof (int); 1030 break; 1031 1032 case KIOCSRPTDELAY: 1033 /* 1034 * Set the autorepeat delay 1035 */ 1036 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSRPTDELAY\n")); 1037 err = miocpullup(mp, sizeof (int)); 1038 1039 if (err != 0) 1040 break; 1041 1042 /* validate the input */ 1043 if (*(int *)mp->b_cont->b_rptr < KIOCRPTDELAY_MIN) { 1044 err = EINVAL; 1045 break; 1046 } 1047 kbtrans_repeat_delay = MSEC_TO_TICK(*(int *)mp->b_cont->b_rptr); 1048 if (kbtrans_repeat_delay <= 0) 1049 kbtrans_repeat_delay = 1; 1050 break; 1051 1052 case KIOCGRPTRATE: 1053 /* 1054 * Report the autorepeat rate 1055 */ 1056 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGRPTRATE\n")); 1057 if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 1058 ioctlrespsize = sizeof (int); 1059 goto allocfailure; 1060 } 1061 *(int *)datap->b_wptr = TICK_TO_MSEC(kbtrans_repeat_rate); 1062 datap->b_wptr += sizeof (int); 1063 1064 /* free msg to prevent memory leak */ 1065 if (mp->b_cont != NULL) 1066 freemsg(mp->b_cont); 1067 mp->b_cont = datap; 1068 iocp->ioc_count = sizeof (int); 1069 break; 1070 1071 case KIOCSRPTRATE: 1072 /* 1073 * Set the autorepeat rate 1074 */ 1075 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSRPTRATE\n")); 1076 err = miocpullup(mp, sizeof (int)); 1077 1078 if (err != 0) 1079 break; 1080 1081 /* validate the input */ 1082 if (*(int *)mp->b_cont->b_rptr < KIOCRPTRATE_MIN) { 1083 err = EINVAL; 1084 break; 1085 } 1086 kbtrans_repeat_rate = MSEC_TO_TICK(*(int *)mp->b_cont->b_rptr); 1087 if (kbtrans_repeat_rate <= 0) 1088 kbtrans_repeat_rate = 1; 1089 break; 1090 1091 default: 1092 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "unknown\n")); 1093 return (KBTRANS_MESSAGE_NOT_HANDLED); 1094 } /* end switch */ 1095 1096 if (err != 0) { 1097 iocp->ioc_rval = 0; 1098 iocp->ioc_error = err; 1099 mp->b_datap->db_type = M_IOCNAK; 1100 } else { 1101 iocp->ioc_rval = 0; 1102 iocp->ioc_error = 0; /* brain rot */ 1103 mp->b_datap->db_type = M_IOCACK; 1104 } 1105 putnext(upper->kbtrans_streams_readq, mp); 1106 1107 return (KBTRANS_MESSAGE_HANDLED); 1108 1109 allocfailure: 1110 /* 1111 * We needed to allocate something to handle this "ioctl", but 1112 * couldn't; save this "ioctl" and arrange to get called back when 1113 * it's more likely that we can get what we need. 1114 * If there's already one being saved, throw it out, since it 1115 * must have timed out. 1116 */ 1117 if (upper->kbtrans_streams_iocpending != NULL) 1118 freemsg(upper->kbtrans_streams_iocpending); 1119 upper->kbtrans_streams_iocpending = mp; 1120 if (upper->kbtrans_streams_bufcallid) { 1121 qunbufcall(upper->kbtrans_streams_readq, 1122 upper->kbtrans_streams_bufcallid); 1123 } 1124 upper->kbtrans_streams_bufcallid = 1125 qbufcall(upper->kbtrans_streams_readq, ioctlrespsize, BPRI_HI, 1126 kbtrans_reioctl, upper); 1127 /* 1128 * This is a white lie... we *will* handle it, eventually. 1129 */ 1130 return (KBTRANS_MESSAGE_HANDLED); 1131 } 1132 1133 /* 1134 * kbtrans_flush: 1135 * Flush data upstream 1136 */ 1137 static void 1138 kbtrans_flush(register struct kbtrans *upper) 1139 { 1140 register queue_t *q; 1141 1142 /* Flush pending data already sent upstream */ 1143 if ((q = upper->kbtrans_streams_readq) != NULL && q->q_next != NULL) 1144 (void) putnextctl1(q, M_FLUSH, FLUSHR); 1145 1146 /* Flush pending ups */ 1147 bzero(upper->kbtrans_streams_downs, upper->kbtrans_streams_downs_bytes); 1148 1149 kbtrans_cancelrpt(upper); 1150 } 1151 1152 /* 1153 * kbtrans_setled: 1154 * Update the keyboard LEDs to match the current keyboard state. 1155 */ 1156 static void 1157 kbtrans_setled(struct kbtrans *upper) 1158 { 1159 upper->kbtrans_streams_hw_callbacks->kbtrans_streams_setled( 1160 upper->kbtrans_streams_hw, 1161 upper->kbtrans_lower.kbtrans_led_state); 1162 } 1163 1164 /* 1165 * kbtrans_rpt: 1166 * If a key is held down, this function is set up to be called 1167 * after kbtrans_repeat_rate time elapses. 1168 */ 1169 static void 1170 kbtrans_rpt(void *arg) 1171 { 1172 struct kbtrans *upper = arg; 1173 struct kbtrans_lower *lower = &upper->kbtrans_lower; 1174 1175 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, 1176 "kbtrans_rpt: repeat key %X\n", 1177 lower->kbtrans_repeatkey)); 1178 1179 upper->kbtrans_streams_rptid = 0; 1180 1181 /* 1182 * NB: polled code zaps kbtrans_repeatkey without cancelling 1183 * timeout. 1184 */ 1185 if (lower->kbtrans_repeatkey != 0) { 1186 kbtrans_keyreleased(upper, lower->kbtrans_repeatkey); 1187 1188 kbtrans_processkey(lower, 1189 upper->kbtrans_streams_callback, 1190 lower->kbtrans_repeatkey, 1191 KEY_PRESSED); 1192 1193 upper->kbtrans_streams_rptid = 1194 qtimeout(upper->kbtrans_streams_readq, kbtrans_rpt, 1195 (caddr_t)upper, kbtrans_repeat_rate); 1196 } 1197 } 1198 1199 /* 1200 * kbtrans_cancelrpt: 1201 * Cancel the repeating key 1202 */ 1203 static void 1204 kbtrans_cancelrpt(struct kbtrans *upper) 1205 { 1206 upper->kbtrans_lower.kbtrans_repeatkey = 0; 1207 1208 if (upper->kbtrans_streams_rptid != 0) { 1209 (void) quntimeout(upper->kbtrans_streams_readq, 1210 upper->kbtrans_streams_rptid); 1211 upper->kbtrans_streams_rptid = 0; 1212 } 1213 } 1214 1215 /* 1216 * kbtrans_send_esc_event: 1217 * Send character up stream. Used for the case of 1218 * sending strings upstream. 1219 */ 1220 static void 1221 kbtrans_send_esc_event(char c, register struct kbtrans *upper) 1222 { 1223 Firm_event fe; 1224 1225 fe.id = c; 1226 fe.value = 1; 1227 fe.pair_type = FE_PAIR_NONE; 1228 fe.pair = 0; 1229 /* 1230 * Pretend as if each cp pushed and released 1231 * Calling kbtrans_queueevent avoids addr translation 1232 * and pair base determination of kbtrans_keypressed. 1233 */ 1234 kbtrans_queueevent(upper, &fe); 1235 fe.value = 0; 1236 kbtrans_queueevent(upper, &fe); 1237 } 1238 1239 /* 1240 * kbtrans_strsetwithdecimal: 1241 * Used for expanding a function key to the ascii equivalent 1242 */ 1243 static char * 1244 kbtrans_strsetwithdecimal(char *buf, uint_t val, uint_t maxdigs) 1245 { 1246 int hradix = 5; 1247 char *bp; 1248 int lowbit; 1249 char *tab = "0123456789abcdef"; 1250 1251 bp = buf + maxdigs; 1252 *(--bp) = '\0'; 1253 while (val) { 1254 lowbit = val & 1; 1255 val = (val >> 1); 1256 *(--bp) = tab[val % hradix * 2 + lowbit]; 1257 val /= hradix; 1258 } 1259 return (bp); 1260 } 1261 1262 /* 1263 * kbtrans_keypressed: 1264 * Modify Firm event to be sent up the stream 1265 */ 1266 static void 1267 kbtrans_keypressed(struct kbtrans *upper, uchar_t key_station, 1268 Firm_event *fe, ushort_t base) 1269 { 1270 1271 register short id_addr; 1272 struct kbtrans_lower *lower = &upper->kbtrans_lower; 1273 1274 /* Set pair values */ 1275 if (fe->id < (ushort_t)VKEY_FIRST) { 1276 /* 1277 * If CTRLed, find the ID that would have been used had it 1278 * not been CTRLed. 1279 */ 1280 if (lower->kbtrans_shiftmask & (CTRLMASK | CTLSMASK)) { 1281 unsigned short *ke; 1282 unsigned int mask; 1283 1284 mask = lower->kbtrans_shiftmask & 1285 ~(CTRLMASK | CTLSMASK | UPMASK); 1286 1287 ke = kbtrans_find_entry(lower, mask, key_station); 1288 if (ke == NULL) 1289 return; 1290 1291 base = *ke; 1292 } 1293 if (base != fe->id) { 1294 fe->pair_type = FE_PAIR_SET; 1295 fe->pair = (uchar_t)base; 1296 1297 goto send; 1298 } 1299 } 1300 fe->pair_type = FE_PAIR_NONE; 1301 fe->pair = 0; 1302 1303 send: 1304 /* Adjust event id address for multiple keyboard/workstation support */ 1305 switch (vuid_id_addr(fe->id)) { 1306 case ASCII_FIRST: 1307 id_addr = upper->kbtrans_streams_vuid_addr.ascii; 1308 break; 1309 case TOP_FIRST: 1310 id_addr = upper->kbtrans_streams_vuid_addr.top; 1311 break; 1312 case VKEY_FIRST: 1313 id_addr = upper->kbtrans_streams_vuid_addr.vkey; 1314 break; 1315 default: 1316 id_addr = vuid_id_addr(fe->id); 1317 break; 1318 } 1319 fe->id = vuid_id_offset(fe->id) | id_addr; 1320 1321 kbtrans_queuepress(upper, key_station, fe); 1322 } 1323 1324 /* 1325 * kbtrans_queuepress: 1326 * Add keypress to the "downs" table 1327 */ 1328 static void 1329 kbtrans_queuepress(struct kbtrans *upper, 1330 uchar_t key_station, Firm_event *fe) 1331 { 1332 register struct key_event *ke, *ke_free; 1333 register int i; 1334 1335 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "kbtrans_queuepress:" 1336 " key=%d", key_station)); 1337 1338 ke_free = 0; 1339 1340 /* Scan table of down key stations */ 1341 1342 for (i = 0, ke = upper->kbtrans_streams_downs; 1343 i < upper->kbtrans_streams_num_downs_entries; i++, ke++) { 1344 1345 /* Keycode already down? */ 1346 if (ke->key_station == key_station) { 1347 1348 DPRINTF(PRINT_L0, PRINT_MASK_ALL, 1349 (NULL, "kbtrans: Double " 1350 "entry in downs table (%d,%d)!\n", 1351 key_station, i)); 1352 1353 goto add_event; 1354 } 1355 1356 if (ke->key_station == 0) 1357 ke_free = ke; 1358 } 1359 1360 if (ke_free) { 1361 ke = ke_free; 1362 goto add_event; 1363 } 1364 1365 ke = upper->kbtrans_streams_downs; 1366 1367 add_event: 1368 ke->key_station = key_station; 1369 ke->event = *fe; 1370 kbtrans_queueevent(upper, fe); 1371 } 1372 1373 /* 1374 * kbtrans_keyreleased: 1375 * Remove entry from the downs table 1376 */ 1377 static void 1378 kbtrans_keyreleased(register struct kbtrans *upper, uchar_t key_station) 1379 { 1380 register struct key_event *ke; 1381 register int i; 1382 1383 DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "RELEASE key=%d\n", 1384 key_station)); 1385 1386 if (upper->kbtrans_streams_translate_mode != TR_EVENT && 1387 upper->kbtrans_streams_translate_mode != TR_UNTRANS_EVENT) { 1388 1389 return; 1390 } 1391 1392 /* Scan table of down key stations */ 1393 for (i = 0, ke = upper->kbtrans_streams_downs; 1394 i < upper->kbtrans_streams_num_downs_entries; 1395 i++, ke++) { 1396 /* Found? */ 1397 if (ke->key_station == key_station) { 1398 ke->key_station = 0; 1399 ke->event.value = 0; 1400 kbtrans_queueevent(upper, &ke->event); 1401 } 1402 } 1403 1404 /* 1405 * Ignore if couldn't find because may be called twice 1406 * for the same key station in the case of the kbtrans_rpt 1407 * routine being called unnecessarily. 1408 */ 1409 } 1410 1411 1412 /* 1413 * kbtrans_putcode: 1414 * Pass a keycode up the stream, if you can, otherwise throw it away. 1415 */ 1416 static void 1417 kbtrans_putcode(register struct kbtrans *upper, uint_t code) 1418 { 1419 register mblk_t *bp; 1420 1421 /* 1422 * If we can't send it up, then we just drop it. 1423 */ 1424 if (!canputnext(upper->kbtrans_streams_readq)) { 1425 1426 return; 1427 } 1428 1429 /* 1430 * Allocate a messsage block to send up. 1431 */ 1432 if ((bp = allocb(sizeof (uint_t), BPRI_HI)) == NULL) { 1433 1434 cmn_err(CE_WARN, "kbtrans_putcode: Can't allocate block\ 1435 for keycode."); 1436 1437 return; 1438 } 1439 1440 /* 1441 * We will strip out any high order information here. 1442 */ 1443 /* NOTE the implicit cast here */ 1444 *bp->b_wptr++ = (uchar_t)code; 1445 1446 /* 1447 * Send the message up. 1448 */ 1449 (void) putnext(upper->kbtrans_streams_readq, bp); 1450 } 1451 1452 1453 /* 1454 * kbtrans_putbuf: 1455 * Pass generated keycode sequence to upstream, if possible. 1456 */ 1457 static void 1458 kbtrans_putbuf(char *buf, queue_t *q) 1459 { 1460 register mblk_t *bp; 1461 1462 if (!canputnext(q)) { 1463 cmn_err(CE_WARN, "kbtrans_putbuf: Can't put block for keycode"); 1464 } else { 1465 if ((bp = allocb((int)strlen(buf), BPRI_HI)) == NULL) { 1466 cmn_err(CE_WARN, "kbtrans_putbuf: " 1467 "Can't allocate block for keycode"); 1468 } else { 1469 while (*buf) { 1470 *bp->b_wptr++ = *buf; 1471 buf++; 1472 } 1473 putnext(q, bp); 1474 } 1475 } 1476 } 1477 1478 /* 1479 * kbtrans_queueevent: 1480 * Pass a VUID "firm event" up the stream, if you can. 1481 */ 1482 static void 1483 kbtrans_queueevent(struct kbtrans *upper, Firm_event *fe) 1484 { 1485 register queue_t *q; 1486 register mblk_t *bp; 1487 1488 if ((q = upper->kbtrans_streams_readq) == NULL) 1489 1490 return; 1491 1492 if (!canputnext(q)) { 1493 if (kbtrans_overflow_msg) { 1494 DPRINTF(PRINT_L2, PRINT_MASK_ALL, (NULL, 1495 "kbtrans: Buffer flushed when overflowed.")); 1496 } 1497 1498 kbtrans_flush(upper); 1499 upper->kbtrans_overflow_cnt++; 1500 } else { 1501 if ((bp = allocb(sizeof (Firm_event), BPRI_HI)) == NULL) { 1502 cmn_err(CE_WARN, "kbtrans_queueevent: Can't allocate \ 1503 block for event."); 1504 } else { 1505 uniqtime32(&fe->time); 1506 *(Firm_event *)bp->b_wptr = *fe; 1507 bp->b_wptr += sizeof (Firm_event); 1508 (void) putnext(q, bp); 1509 1510 1511 } 1512 } 1513 } 1514 1515 /* 1516 * kbtrans_set_translation_callback: 1517 * This code sets the translation_callback pointer based on the 1518 * translation mode. 1519 */ 1520 static void 1521 kbtrans_set_translation_callback(register struct kbtrans *upper) 1522 { 1523 switch (upper->kbtrans_streams_translate_mode) { 1524 1525 default: 1526 case TR_ASCII: 1527 upper->vt_switch_keystate = VT_SWITCH_KEY_NONE; 1528 1529 /* Discard any obsolete CTRL/ALT/SHIFT keys */ 1530 upper->kbtrans_lower.kbtrans_shiftmask &= 1531 ~(CTRLMASK | ALTMASK | SHIFTMASK); 1532 upper->kbtrans_lower.kbtrans_togglemask &= 1533 ~(CTRLMASK | ALTMASK | SHIFTMASK); 1534 1535 upper->kbtrans_streams_callback = &ascii_callback; 1536 1537 break; 1538 1539 case TR_EVENT: 1540 upper->kbtrans_streams_callback = &trans_event_callback; 1541 1542 break; 1543 1544 case TR_UNTRANS_EVENT: 1545 upper->kbtrans_streams_callback = &untrans_event_callback; 1546 1547 break; 1548 } 1549 } 1550 1551 /* 1552 * kbtrans_untrans_keypressed_raw: 1553 * This is the callback we get if we are in TR_UNTRANS_EVENT and a 1554 * key is pressed. This code will just send the scancode up the 1555 * stream. 1556 */ 1557 static void 1558 kbtrans_untrans_keypressed_raw(struct kbtrans *upper, kbtrans_key_t key) 1559 { 1560 Firm_event fe; 1561 1562 bzero(&fe, sizeof (fe)); 1563 1564 /* 1565 * fill in the event 1566 */ 1567 fe.id = (unsigned short)key; 1568 fe.value = 1; 1569 1570 /* 1571 * Send the event upstream. 1572 */ 1573 kbtrans_queuepress(upper, key, &fe); 1574 } 1575 1576 /* 1577 * kbtrans_untrans_keyreleased_raw: 1578 * This is the callback we get if we are in TR_UNTRANS_EVENT mode 1579 * and a key is released. This code will just send the scancode up 1580 * the stream. 1581 */ 1582 static void 1583 kbtrans_untrans_keyreleased_raw(struct kbtrans *upper, kbtrans_key_t key) 1584 { 1585 /* 1586 * Deal with a key released event. 1587 */ 1588 kbtrans_keyreleased(upper, key); 1589 } 1590 1591 /* 1592 * kbtrans_vt_compose: 1593 * To compose the key sequences for virtual terminal switching. 1594 * 1595 * 'ALTL + F#' for 1-12 terminals 1596 * 'ALTGR + F#' for 13-24 terminals 1597 * 'ALT + UPARROW' for last terminal 1598 * 'ALT + LEFTARROW' for previous terminal 1599 * 'ALT + RIGHTARROW' for next terminal 1600 * 1601 * the vt switching message is encoded as: 1602 * 1603 * ------------------------------------------------------------- 1604 * | \033 | 'Q' | vtno + 'A' | opcode | 'z' | '\0' | 1605 * ------------------------------------------------------------- 1606 * 1607 * opcode: 1608 * 'B' to switch to previous terminal 1609 * 'F' to switch to next terminal 1610 * 'L' to switch to last terminal 1611 * 'H' to switch to the terminal as specified by vtno, 1612 * which is from 1 to 24. 1613 * 1614 * Here keyid is the keycode of UPARROW, LEFTARROW, or RIGHTARROW 1615 * when it is a kind of arrow key as indicated by is_arrow_key, 1616 * otherwise it indicates a function key and keyid is the number 1617 * corresponding to that function key. 1618 */ 1619 static void 1620 kbtrans_vt_compose(struct kbtrans *upper, unsigned short keyid, 1621 boolean_t is_arrow_key, char *buf) 1622 { 1623 char *bufp; 1624 1625 bufp = buf; 1626 *bufp++ = '\033'; /* Escape */ 1627 *bufp++ = 'Q'; 1628 if (is_arrow_key) { 1629 *bufp++ = 'A'; 1630 switch (keyid) { 1631 case UPARROW: /* last vt */ 1632 *bufp++ = 'L'; 1633 break; 1634 case LEFTARROW: /* previous vt */ 1635 *bufp++ = 'B'; 1636 break; 1637 case RIGHTARROW: /* next vt */ 1638 *bufp++ = 'F'; 1639 break; 1640 default: 1641 break; 1642 } 1643 } else { 1644 /* this is funckey specifying vtno for switch */ 1645 *bufp++ = keyid + 1646 (upper->vt_switch_keystate - VT_SWITCH_KEY_ALT) * 1647 KB_NR_FUNCKEYS + 'A'; 1648 *bufp++ = 'H'; 1649 } 1650 *bufp++ = 'z'; 1651 *bufp = '\0'; 1652 1653 /* 1654 * Send the result upstream. 1655 */ 1656 kbtrans_putbuf(buf, upper->kbtrans_streams_readq); 1657 1658 } 1659 1660 /* 1661 * kbtrans_ascii_keypressed: 1662 * This is the code if we are in TR_ASCII mode and a key 1663 * is pressed. This is where we will do any special processing that 1664 * is specific to ASCII key translation. 1665 */ 1666 /* ARGSUSED */ 1667 static void 1668 kbtrans_ascii_keypressed( 1669 struct kbtrans *upper, 1670 uint_t entrytype, 1671 kbtrans_key_t key, 1672 uint_t entry) 1673 { 1674 register char *cp; 1675 register char *bufp; 1676 char buf[14]; 1677 unsigned short keyid; 1678 struct kbtrans_lower *lower = &upper->kbtrans_lower; 1679 1680 /* 1681 * Based on the type of key, we may need to do some ASCII 1682 * specific post processing. Note that the translated entry 1683 * is constructed as the actual keycode plus entrytype. see 1684 * sys/kbd.h for details of each entrytype. 1685 */ 1686 switch (entrytype) { 1687 1688 case BUCKYBITS: 1689 return; 1690 1691 case SHIFTKEYS: 1692 keyid = entry & 0xFF; 1693 if (keyid == ALT) { 1694 upper->vt_switch_keystate = VT_SWITCH_KEY_ALT; 1695 } else if (keyid == ALTGRAPH) { 1696 upper->vt_switch_keystate = VT_SWITCH_KEY_ALTGR; 1697 } 1698 return; 1699 1700 case FUNNY: 1701 /* 1702 * There is no ascii equivalent. We will ignore these 1703 * keys 1704 */ 1705 return; 1706 1707 case FUNCKEYS: 1708 if (upper->vt_switch_keystate > VT_SWITCH_KEY_NONE) { 1709 if (entry >= TOPFUNC && 1710 entry < (TOPFUNC + KB_NR_FUNCKEYS)) { 1711 1712 /* 1713 * keyid is the number correspoding to F# 1714 * and its value is from 1 to 12. 1715 */ 1716 keyid = (entry & 0xF) + 1; 1717 1718 kbtrans_vt_compose(upper, keyid, B_FALSE, buf); 1719 return; 1720 } 1721 } 1722 1723 /* 1724 * We need to expand this key to get the ascii 1725 * equivalent. These are the function keys (F1, F2 ...) 1726 */ 1727 bufp = buf; 1728 cp = kbtrans_strsetwithdecimal(bufp + 2, 1729 (uint_t)((entry & 0x003F) + 192), 1730 sizeof (buf) - 5); 1731 *bufp++ = '\033'; /* Escape */ 1732 *bufp++ = '['; 1733 while (*cp != '\0') 1734 *bufp++ = *cp++; 1735 *bufp++ = 'z'; 1736 *bufp = '\0'; 1737 1738 /* 1739 * Send the result upstream. 1740 */ 1741 kbtrans_putbuf(buf, upper->kbtrans_streams_readq); 1742 1743 return; 1744 1745 case STRING: 1746 if (upper->vt_switch_keystate > VT_SWITCH_KEY_NONE) { 1747 keyid = entry & 0xFF; 1748 if (keyid == UPARROW || 1749 keyid == RIGHTARROW || 1750 keyid == LEFTARROW) { 1751 1752 kbtrans_vt_compose(upper, keyid, B_TRUE, buf); 1753 return; 1754 } 1755 } 1756 1757 /* 1758 * These are the multi byte keys (Home, Up, Down ...) 1759 */ 1760 cp = &lower->kbtrans_keystringtab[entry & 0x0F][0]; 1761 1762 /* 1763 * Copy the string from the keystringtable, and send it 1764 * upstream a character at a time. 1765 */ 1766 while (*cp != '\0') { 1767 1768 kbtrans_putcode(upper, (uchar_t)*cp); 1769 1770 cp++; 1771 } 1772 1773 return; 1774 1775 case PADKEYS: 1776 /* 1777 * These are the keys on the keypad. Look up the 1778 * answer in the kb_numlock_table and send it upstream. 1779 */ 1780 kbtrans_putcode(upper, 1781 lower->kbtrans_numlock_table[entry&0x1F]); 1782 1783 return; 1784 1785 case 0: /* normal character */ 1786 default: 1787 break; 1788 } 1789 1790 /* 1791 * Send the byte upstream. 1792 */ 1793 kbtrans_putcode(upper, entry); 1794 1795 } 1796 1797 #define KB_SCANCODE_ALT 0xe2 1798 #define KB_SCANCODE_ALTGRAPH 0xe6 1799 1800 /* 1801 * kbtrans_ascii_keyreleased: 1802 * This is the function if we are in TR_ASCII mode and a key 1803 * is released. ASCII doesn't have the concept of released keys, 1804 * or make/break codes. So there is nothing for us to do except 1805 * checking 'Alt/AltGraph' release key in order to reset the state 1806 * of vt switch key sequence. 1807 */ 1808 /* ARGSUSED */ 1809 static void 1810 kbtrans_ascii_keyreleased(struct kbtrans *upper, kbtrans_key_t key) 1811 { 1812 if (key == KB_SCANCODE_ALT || key == KB_SCANCODE_ALTGRAPH) { 1813 upper->vt_switch_keystate = VT_SWITCH_KEY_NONE; 1814 } 1815 } 1816 1817 /* 1818 * kbtrans_ascii_setup_repeat: 1819 * This is the function if we are in TR_ASCII mode and the 1820 * translation module has decided that a key needs to be repeated. 1821 */ 1822 /* ARGSUSED */ 1823 static void 1824 kbtrans_ascii_setup_repeat( 1825 struct kbtrans *upper, 1826 uint_t entrytype, 1827 kbtrans_key_t key) 1828 { 1829 struct kbtrans_lower *lower = &upper->kbtrans_lower; 1830 1831 /* 1832 * Cancel any currently repeating keys. This will be a new 1833 * key to repeat. 1834 */ 1835 kbtrans_cancelrpt(upper); 1836 1837 /* 1838 * Set the value of the key to be repeated. 1839 */ 1840 lower->kbtrans_repeatkey = key; 1841 1842 /* 1843 * Start the timeout for repeating this key. kbtrans_rpt will 1844 * be called to repeat the key. 1845 */ 1846 upper->kbtrans_streams_rptid = qtimeout(upper->kbtrans_streams_readq, 1847 kbtrans_rpt, (caddr_t)upper, kbtrans_repeat_delay); 1848 } 1849 1850 /* 1851 * kbtrans_trans_event_keypressed: 1852 * This is the function if we are in TR_EVENT mode and a key 1853 * is pressed. This is where we will do any special processing that 1854 * is specific to EVENT key translation. 1855 */ 1856 static void 1857 kbtrans_trans_event_keypressed( 1858 struct kbtrans *upper, 1859 uint_t entrytype, 1860 kbtrans_key_t key, 1861 uint_t entry) 1862 { 1863 Firm_event fe; 1864 register char *cp; 1865 struct kbtrans_lower *lower = &upper->kbtrans_lower; 1866 1867 /* 1868 * Based on the type of key, we may need to do some EVENT 1869 * specific post processing. 1870 */ 1871 switch (entrytype) { 1872 1873 case SHIFTKEYS: 1874 /* 1875 * Relying on ordinal correspondence between 1876 * vuid_event.h SHIFT_META-SHIFT_TOP & 1877 * kbd.h METABIT-SYSTEMBIT in order to 1878 * correctly translate entry into fe.id. 1879 */ 1880 fe.id = SHIFT_CAPSLOCK + (entry & 0x0F); 1881 fe.value = 1; 1882 kbtrans_keypressed(upper, key, &fe, fe.id); 1883 1884 return; 1885 1886 case BUCKYBITS: 1887 /* 1888 * Relying on ordinal correspondence between 1889 * vuid_event.h SHIFT_CAPSLOCK-SHIFT_RIGHTCTRL & 1890 * kbd.h CAPSLOCK-RIGHTCTRL in order to 1891 * correctly translate entry into fe.id. 1892 */ 1893 fe.id = SHIFT_META + (entry & 0x0F); 1894 fe.value = 1; 1895 kbtrans_keypressed(upper, key, &fe, fe.id); 1896 1897 return; 1898 1899 case FUNCKEYS: 1900 /* 1901 * Take advantage of the similar 1902 * ordering of kbd.h function keys and 1903 * vuid_event.h function keys to do a 1904 * simple translation to achieve a 1905 * mapping between the 2 different 1906 * address spaces. 1907 */ 1908 fe.id = KEY_LEFTFIRST + (entry & 0x003F); 1909 fe.value = 1; 1910 1911 /* 1912 * Assume "up" table only generates 1913 * shift changes. 1914 */ 1915 kbtrans_keypressed(upper, key, &fe, fe.id); 1916 1917 /* 1918 * Function key events can be expanded 1919 * by terminal emulator software to 1920 * produce the standard escape sequence 1921 * generated by the TR_ASCII case above 1922 * if a function key event is not used 1923 * by terminal emulator software 1924 * directly. 1925 */ 1926 return; 1927 1928 case STRING: 1929 /* 1930 * These are the multi byte keys (Home, Up, Down ...) 1931 */ 1932 cp = &lower->kbtrans_keystringtab[entry & 0x0F][0]; 1933 1934 /* 1935 * Copy the string from the keystringtable, and send it 1936 * upstream a character at a time. 1937 */ 1938 while (*cp != '\0') { 1939 1940 kbtrans_send_esc_event(*cp, upper); 1941 1942 cp++; 1943 } 1944 1945 return; 1946 1947 case PADKEYS: 1948 /* 1949 * Take advantage of the similar 1950 * ordering of kbd.h keypad keys and 1951 * vuid_event.h keypad keys to do a 1952 * simple translation to achieve a 1953 * mapping between the 2 different 1954 * address spaces. 1955 */ 1956 fe.id = VKEY_FIRSTPAD + (entry & 0x001F); 1957 fe.value = 1; 1958 1959 /* 1960 * Assume "up" table only generates 1961 * shift changes. 1962 */ 1963 kbtrans_keypressed(upper, key, &fe, fe.id); 1964 1965 /* 1966 * Keypad key events can be expanded 1967 * by terminal emulator software to 1968 * produce the standard ascii character 1969 * generated by the TR_ASCII case above 1970 * if a keypad key event is not used 1971 * by terminal emulator software 1972 * directly. 1973 */ 1974 return; 1975 1976 case FUNNY: 1977 /* 1978 * These are not events. 1979 */ 1980 switch (entry) { 1981 case IDLE: 1982 case RESET: 1983 case ERROR: 1984 /* 1985 * Something has happened. Mark all keys as released. 1986 */ 1987 kbtrans_streams_releaseall(upper); 1988 break; 1989 } 1990 1991 return; 1992 1993 case 0: /* normal character */ 1994 default: 1995 break; 1996 } 1997 1998 /* 1999 * Send the event upstream. 2000 */ 2001 fe.id = entry; 2002 2003 fe.value = 1; 2004 2005 kbtrans_queueevent(upper, &fe); 2006 } 2007 2008 /* 2009 * kbtrans_trans_event_keyreleased: 2010 * This is the function if we are in TR_EVENT mode and a key 2011 * is released. 2012 */ 2013 /* ARGSUSED */ 2014 static void 2015 kbtrans_trans_event_keyreleased(struct kbtrans *upper, kbtrans_key_t key) 2016 { 2017 /* 2018 * Mark the key as released and send an event upstream. 2019 */ 2020 kbtrans_keyreleased(upper, key); 2021 } 2022 2023 /* 2024 * kbtrans_trans_event_setup_repeat: 2025 * This is the function if we are in TR_EVENT mode and the 2026 * translation module has decided that a key needs to be repeated. 2027 * We will set a timeout to retranslate the repeat key. 2028 */ 2029 static void 2030 kbtrans_trans_event_setup_repeat( 2031 struct kbtrans *upper, 2032 uint_t entrytype, 2033 kbtrans_key_t key) 2034 { 2035 struct kbtrans_lower *lower = &upper->kbtrans_lower; 2036 2037 /* 2038 * Function keys and keypad keys do not repeat when we are in 2039 * EVENT mode. 2040 */ 2041 if (entrytype == FUNCKEYS || entrytype == PADKEYS) { 2042 2043 return; 2044 } 2045 2046 /* 2047 * Cancel any currently repeating keys. This will be a new 2048 * key to repeat. 2049 */ 2050 kbtrans_cancelrpt(upper); 2051 2052 /* 2053 * Set the value of the key to be repeated. 2054 */ 2055 lower->kbtrans_repeatkey = key; 2056 2057 /* 2058 * Start the timeout for repeating this key. kbtrans_rpt will 2059 * be called to repeat the key. 2060 */ 2061 upper->kbtrans_streams_rptid = qtimeout(upper->kbtrans_streams_readq, 2062 kbtrans_rpt, (caddr_t)upper, kbtrans_repeat_delay); 2063 } 2064 2065 /* 2066 * Administer the key tables. 2067 */ 2068 2069 /* 2070 * Old special codes. 2071 */ 2072 #define OLD_SHIFTKEYS 0x80 2073 #define OLD_BUCKYBITS 0x90 2074 #define OLD_FUNNY 0xA0 2075 #define OLD_FA_UMLAUT 0xA9 2076 #define OLD_FA_CFLEX 0xAA 2077 #define OLD_FA_TILDE 0xAB 2078 #define OLD_FA_CEDILLA 0xAC 2079 #define OLD_FA_ACUTE 0xAD 2080 #define OLD_FA_GRAVE 0xAE 2081 #define OLD_ISOCHAR 0xAF 2082 #define OLD_STRING 0xB0 2083 #define OLD_LEFTFUNC 0xC0 2084 #define OLD_RIGHTFUNC 0xD0 2085 #define OLD_TOPFUNC 0xE0 2086 #define OLD_BOTTOMFUNC 0xF0 2087 2088 /* 2089 * Map old special codes to new ones. 2090 * Indexed by ((old special code) >> 4) & 0x07; add (old special code) & 0x0F. 2091 */ 2092 static ushort_t special_old_to_new[] = { 2093 SHIFTKEYS, 2094 BUCKYBITS, 2095 FUNNY, 2096 STRING, 2097 LEFTFUNC, 2098 RIGHTFUNC, 2099 TOPFUNC, 2100 BOTTOMFUNC, 2101 }; 2102 2103 2104 /* 2105 * kbtrans_setkey: 2106 * Set individual keystation translation from old-style entry. 2107 */ 2108 static int 2109 kbtrans_setkey(struct kbtrans_lower *lower, struct kiockey *key, cred_t *cr) 2110 { 2111 int strtabindex, i; 2112 unsigned short *ke; 2113 register int tablemask; 2114 register ushort_t entry; 2115 register struct keyboard *kp; 2116 2117 kp = lower->kbtrans_keyboard; 2118 2119 if (key->kio_station >= kp->k_keymap_size) 2120 2121 return (EINVAL); 2122 2123 if (lower->kbtrans_keyboard == NULL) 2124 2125 return (EINVAL); 2126 2127 tablemask = key->kio_tablemask; 2128 2129 switch (tablemask) { 2130 case KIOCABORT1: 2131 case KIOCABORT1A: 2132 case KIOCABORT2: 2133 i = secpolicy_console(cr); 2134 if (i != 0) 2135 return (i); 2136 2137 switch (tablemask) { 2138 case KIOCABORT1: 2139 kp->k_abort1 = key->kio_station; 2140 break; 2141 case KIOCABORT1A: 2142 kp->k_abort1a = key->kio_station; 2143 break; 2144 case KIOCABORT2: 2145 kp->k_abort2 = key->kio_station; 2146 break; 2147 } 2148 return (0); 2149 } 2150 2151 if (tablemask & ALTGRAPHMASK) 2152 return (EINVAL); 2153 2154 ke = kbtrans_find_entry(lower, (uint_t)tablemask, key->kio_station); 2155 if (ke == NULL) 2156 return (EINVAL); 2157 2158 if (key->kio_entry >= (uchar_t)OLD_STRING && 2159 key->kio_entry <= (uchar_t)(OLD_STRING + 15)) { 2160 strtabindex = key->kio_entry - OLD_STRING; 2161 bcopy(key->kio_string, 2162 lower->kbtrans_keystringtab[strtabindex], KTAB_STRLEN); 2163 lower->kbtrans_keystringtab[strtabindex][KTAB_STRLEN-1] = '\0'; 2164 } 2165 2166 entry = key->kio_entry; 2167 2168 /* 2169 * There's nothing we need do with OLD_ISOCHAR. 2170 */ 2171 if (entry != OLD_ISOCHAR) { 2172 if (entry & 0x80) { 2173 if (entry >= OLD_FA_UMLAUT && entry <= OLD_FA_GRAVE) 2174 entry = FA_CLASS + (entry & 0x0F) - 9; 2175 else 2176 entry = 2177 special_old_to_new[entry >> 4 & 0x07] 2178 + (entry & 0x0F); 2179 } 2180 } 2181 2182 *ke = entry; 2183 2184 return (0); 2185 } 2186 2187 2188 /* 2189 * Map new special codes to old ones. 2190 * Indexed by (new special code) >> 8; add (new special code) & 0xFF. 2191 */ 2192 static uchar_t special_new_to_old[] = { 2193 0, /* normal */ 2194 OLD_SHIFTKEYS, /* SHIFTKEYS */ 2195 OLD_BUCKYBITS, /* BUCKYBITS */ 2196 OLD_FUNNY, /* FUNNY */ 2197 OLD_FA_UMLAUT, /* FA_CLASS */ 2198 OLD_STRING, /* STRING */ 2199 OLD_LEFTFUNC, /* FUNCKEYS */ 2200 }; 2201 2202 2203 /* 2204 * kbtrans_getkey: 2205 * Get individual keystation translation as old-style entry. 2206 */ 2207 static int 2208 kbtrans_getkey(struct kbtrans_lower *lower, struct kiockey *key) 2209 { 2210 int strtabindex; 2211 unsigned short *ke; 2212 register ushort_t entry; 2213 struct keyboard *kp; 2214 2215 kp = lower->kbtrans_keyboard; 2216 2217 if (key->kio_station >= kp->k_keymap_size) 2218 return (EINVAL); 2219 2220 if (lower->kbtrans_keyboard == NULL) 2221 return (EINVAL); 2222 2223 switch (key->kio_tablemask) { 2224 case KIOCABORT1: 2225 key->kio_station = kp->k_abort1; 2226 return (0); 2227 case KIOCABORT1A: 2228 key->kio_station = kp->k_abort1a; 2229 return (0); 2230 case KIOCABORT2: 2231 key->kio_station = kp->k_abort2; 2232 return (0); 2233 } 2234 2235 ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask, 2236 key->kio_station); 2237 if (ke == NULL) 2238 return (EINVAL); 2239 2240 entry = *ke; 2241 2242 if (entry & 0xFF00) 2243 key->kio_entry = 2244 special_new_to_old[(ushort_t)(entry & 0xFF00) >> 8] 2245 + (entry & 0x00FF); 2246 else { 2247 if (entry & 0x80) 2248 key->kio_entry = (ushort_t)OLD_ISOCHAR; /* you lose */ 2249 else 2250 key->kio_entry = (ushort_t)entry; 2251 } 2252 2253 if (entry >= STRING && entry <= (uchar_t)(STRING + 15)) { 2254 strtabindex = entry - STRING; 2255 bcopy(lower->kbtrans_keystringtab[strtabindex], 2256 key->kio_string, KTAB_STRLEN); 2257 } 2258 return (0); 2259 } 2260 2261 2262 /* 2263 * kbtrans_skey: 2264 * Set individual keystation translation from new-style entry. 2265 */ 2266 static int 2267 kbtrans_skey(struct kbtrans_lower *lower, struct kiockeymap *key, cred_t *cr) 2268 { 2269 int strtabindex, i; 2270 unsigned short *ke; 2271 struct keyboard *kp; 2272 2273 kp = lower->kbtrans_keyboard; 2274 2275 if (key->kio_station >= kp->k_keymap_size) { 2276 return (EINVAL); 2277 2278 } 2279 2280 if (lower->kbtrans_keyboard == NULL) { 2281 return (EINVAL); 2282 } 2283 2284 switch (key->kio_tablemask) { 2285 case KIOCABORT1: 2286 case KIOCABORT1A: 2287 case KIOCABORT2: 2288 i = secpolicy_console(cr); 2289 if (i != 0) 2290 return (i); 2291 switch (key->kio_tablemask) { 2292 case KIOCABORT1: 2293 kp->k_abort1 = key->kio_station; 2294 break; 2295 case KIOCABORT1A: 2296 kp->k_abort1a = key->kio_station; 2297 break; 2298 case KIOCABORT2: 2299 kp->k_abort2 = key->kio_station; 2300 break; 2301 } 2302 return (0); 2303 } 2304 2305 ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask, 2306 key->kio_station); 2307 if (ke == NULL) 2308 return (EINVAL); 2309 2310 if (key->kio_entry >= STRING && 2311 key->kio_entry <= (ushort_t)(STRING + 15)) { 2312 strtabindex = key->kio_entry-STRING; 2313 bcopy(key->kio_string, 2314 lower->kbtrans_keystringtab[strtabindex], KTAB_STRLEN); 2315 lower->kbtrans_keystringtab[strtabindex][KTAB_STRLEN-1] = '\0'; 2316 } 2317 2318 *ke = key->kio_entry; 2319 2320 return (0); 2321 } 2322 2323 2324 /* 2325 * kbtrans_gkey: 2326 * Get individual keystation translation as new-style entry. 2327 */ 2328 static int 2329 kbtrans_gkey(struct kbtrans_lower *lower, struct kiockeymap *key) 2330 { 2331 int strtabindex; 2332 unsigned short *ke; 2333 struct keyboard *kp; 2334 2335 kp = lower->kbtrans_keyboard; 2336 2337 if (key->kio_station >= kp->k_keymap_size) 2338 return (EINVAL); 2339 2340 if (lower->kbtrans_keyboard == NULL) 2341 return (EINVAL); 2342 2343 switch (key->kio_tablemask) { 2344 case KIOCABORT1: 2345 key->kio_station = kp->k_abort1; 2346 return (0); 2347 case KIOCABORT1A: 2348 key->kio_station = kp->k_abort1a; 2349 return (0); 2350 case KIOCABORT2: 2351 key->kio_station = kp->k_abort2; 2352 return (0); 2353 } 2354 2355 ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask, 2356 key->kio_station); 2357 if (ke == NULL) 2358 return (EINVAL); 2359 2360 key->kio_entry = *ke; 2361 2362 if (key->kio_entry >= STRING && 2363 key->kio_entry <= (ushort_t)(STRING + 15)) { 2364 strtabindex = key->kio_entry-STRING; 2365 bcopy(lower->kbtrans_keystringtab[strtabindex], 2366 key->kio_string, KTAB_STRLEN); 2367 } 2368 return (0); 2369 } 2370
Indexes created Wed Feb 10 05:58:14 UTC 2010
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Site Map |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
© 2010, Oracle Corporation and/or its affiliates
