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 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * This module performs two functions. First, it kicks off the driver loading 29 * of the console devices during boot in dynamic_console_config(). 30 * The loading of the drivers for the console devices triggers the 31 * additional device autoconfiguration to link the drivers into the keyboard 32 * and mouse console streams. 33 * 34 * The second function of this module is to provide the dacf functions 35 * to be called after a driver has attached and before it detaches. For 36 * example, a driver associated with the keyboard will have kb_config called 37 * after the driver attaches and kb_unconfig before it detaches. Similar 38 * configuration actions are performed on behalf of minor nodes representing 39 * mice. The configuration functions for the attach case take a module 40 * name as a parameter. The module is pushed on top of the driver during 41 * the configuration. 42 * 43 * Although the dacf framework is used to configure all keyboards and mice, 44 * its primary function is to allow keyboard and mouse hotplugging. 45 * 46 * This module supports multiple keyboards and mice at the same time. 47 * 48 * From the kernel perspective, there are roughly three different possible 49 * console configurations. Across these three configurations, the following 50 * elements are constant: 51 * wsconsvp = IWSCN_PATH 52 * rwsconsvp = WC_PATH 53 * consms -> msdev 54 * 55 * The "->" syntax indicates that the streams device on the right is 56 * linked under the streams device on the left. 57 * 58 * The following lists how the system is configured for different setups: 59 * 60 * stdin is a local keyboard. use stdin and stdout as the console. 61 * sp->cons_input_type = CONSOLE_LOCAL 62 * rconsvp = IWSCN_PATH 63 * wc -> conskbd -> kbddev 64 * 65 * stdin is not a keyboard and stdin is the same as stdout. 66 * assume we running on a tip line and use stdin/stdout as the console. 67 * sp->cons_input_type = CONSOLE_TIP 68 * rconsvp = (stdindev/stdoutdev) 69 * wc -> conskbd -> kbddev 70 * 71 * stdin is not a keyboard device and it's not the same as stdout. 72 * assume we have a serial keyboard hooked up and use it along with 73 * stdout as the console. 74 * sp->cons_input_type = CONSOLE_SERIAL_KEYBOARD 75 * rconsvp = IWSCN_PATH 76 * wc -> stdindev 77 * conskbd -> kbddev 78 * 79 * CAVEAT: 80 * The above is all true except for one possible Intel configuration. 81 * If stdin is set to a local keyboard but stdout is set to something 82 * other than the local display (a tip port for example) stdout will 83 * still go to the local display. This is an artifact of the console 84 * implementation on intel. 85 */ 86 87 #include <sys/types.h> 88 #include <sys/param.h> 89 #include <sys/cmn_err.h> 90 #include <sys/user.h> 91 #include <sys/vfs.h> 92 #include <sys/vnode.h> 93 #include <sys/pathname.h> 94 #include <sys/systm.h> 95 #include <sys/file.h> 96 #include <sys/stropts.h> 97 #include <sys/stream.h> 98 #include <sys/strsubr.h> 99 100 #include <sys/consdev.h> 101 #include <sys/console.h> 102 #include <sys/wscons.h> 103 #include <sys/kbio.h> 104 #include <sys/debug.h> 105 #include <sys/reboot.h> 106 #include <sys/termios.h> 107 108 #include <sys/ddi.h> 109 #include <sys/sunddi.h> 110 #include <sys/sunldi.h> 111 #include <sys/sunndi.h> 112 #include <sys/ndi_impldefs.h> 113 #include <sys/modctl.h> 114 #include <sys/ddi_impldefs.h> 115 #include <sys/ddi_implfuncs.h> 116 #include <sys/promif.h> 117 #include <sys/fs/snode.h> 118 119 #include <sys/errno.h> 120 #include <sys/devops.h> 121 #include <sys/note.h> 122 123 #include <sys/tem_impl.h> 124 #include <sys/polled_io.h> 125 #include <sys/kmem.h> 126 #include <sys/dacf.h> 127 #include <sys/consconfig_dacf.h> 128 #include <sys/consplat.h> 129 #include <sys/log.h> 130 #include <sys/disp.h> 131 132 /* 133 * External global variables 134 */ 135 extern vnode_t *rconsvp; 136 extern dev_t rwsconsdev; 137 138 /* 139 * External functions 140 */ 141 extern uintptr_t space_fetch(char *key); 142 extern int space_store(char *key, uintptr_t ptr); 143 144 /* 145 * Tasks 146 */ 147 static int kb_config(dacf_infohdl_t, dacf_arghdl_t, int); 148 static int kb_unconfig(dacf_infohdl_t, dacf_arghdl_t, int); 149 static int ms_config(dacf_infohdl_t, dacf_arghdl_t, int); 150 static int ms_unconfig(dacf_infohdl_t, dacf_arghdl_t, int); 151 152 /* 153 * Internal functions 154 */ 155 static int consconfig_setmodes(dev_t dev, struct termios *termiosp); 156 static void consconfig_check_phys_kbd(cons_state_t *); 157 static void consconfig_rem_dev(cons_state_t *, dev_t); 158 static void consconfig_add_dev(cons_state_t *, cons_prop_t *); 159 static cons_prop_t *consconfig_find_dev(cons_state_t *, dev_t); 160 static void consconfig_free_prop(cons_prop_t *prop); 161 static void flush_usb_serial_buf(void); 162 163 164 /* 165 * On supported configurations, the firmware defines the keyboard and mouse 166 * paths. However, during USB development, it is useful to be able to use 167 * the USB keyboard and mouse on machines without full USB firmware support. 168 * These variables may be set in /etc/system according to a machine's 169 * USB configuration. This module will override the firmware's values 170 * with these. 171 * 172 * NOTE: 173 * The master copies of these variables in the misc/consconfig module. 174 * The reason for this is historic. In versions of solaris up to and 175 * including solaris 9 the conscole configuration code was split into a 176 * seperate sparc and intel version. These variables were defined 177 * in misc/consconfig on sparc and dacf/consconfig_dacf on intel. 178 * 179 * Unfortunatly the sparc variables were well documented. 180 * So to aviod breaking either sparc or intel we'll declare the variables 181 * in both modules. This will allow any /etc/system entries that 182 * users may have to continue working. 183 * 184 * The variables in misc/consconfig will take precedence over the variables 185 * found in this file. Since we eventually want to remove the variables 186 * local to this this file, if the user set them we'll emmit an error 187 * message telling them they need to set the variables in misc/consconfig 188 * instead. 189 */ 190 static char *usb_kb_path = NULL; 191 static char *usb_ms_path = NULL; 192 193 /* 194 * Access functions in the misc/consconfig module used to retrieve the 195 * values of it local usb_kb_path and usb_ms_path variables 196 */ 197 extern char *consconfig_get_usb_kb_path(); 198 extern char *consconfig_get_usb_ms_path(); 199 200 /* 201 * Local variables used to store the value of the usb_kb_path and 202 * usb_ms_path variables found in misc/consconfig 203 */ 204 static char *consconfig_usb_kb_path = NULL; 205 static char *consconfig_usb_ms_path = NULL; 206 207 /* 208 * Internal variables 209 */ 210 static dev_t stdoutdev; 211 static cons_state_t *consconfig_sp; 212 213 /* 214 * consconfig_errlevel: debug verbosity; smaller numbers are more 215 * verbose. 216 */ 217 int consconfig_errlevel = DPRINT_L3; 218 219 /* 220 * Baud rate table 221 */ 222 #define MAX_SPEEDS 24 223 static struct speed { 224 char *name; 225 int code; 226 } speedtab[MAX_SPEEDS] = { 227 {"0", B0}, {"50", B50}, {"75", B75}, 228 {"110", B110}, {"134", B134}, {"150", B150}, 229 {"200", B200}, {"300", B300}, {"600", B600}, 230 {"1200", B1200}, {"1800", B1800}, {"2400", B2400}, 231 {"4800", B4800}, {"9600", B9600}, {"19200", B19200}, 232 {"38400", B38400}, {"57600", B57600}, {"76800", B76800}, 233 {"115200", B115200}, {"153600", B153600}, {"230400", B230400}, 234 {"307200", B307200}, {"460800", B460800}, {"", 0} 235 }; 236 237 static dacf_op_t kbconfig_op[] = { 238 { DACF_OPID_POSTATTACH, kb_config }, 239 { DACF_OPID_PREDETACH, kb_unconfig }, 240 { DACF_OPID_END, NULL }, 241 }; 242 243 static dacf_op_t msconfig_op[] = { 244 { DACF_OPID_POSTATTACH, ms_config }, 245 { DACF_OPID_PREDETACH, ms_unconfig }, 246 { DACF_OPID_END, NULL }, 247 }; 248 249 static dacf_opset_t opsets[] = { 250 { "kb_config", kbconfig_op }, 251 { "ms_config", msconfig_op }, 252 { NULL, NULL } 253 }; 254 255 struct dacfsw dacfsw = { 256 DACF_MODREV_1, 257 opsets, 258 }; 259 260 struct modldacf modldacf = { 261 &mod_dacfops, /* Type of module */ 262 "Consconfig DACF", 263 &dacfsw 264 }; 265 266 struct modlinkage modlinkage = { 267 MODREV_1, (void *)&modldacf, NULL 268 }; 269 270 int 271 _init(void) { 272 return (mod_install(&modlinkage)); 273 } 274 275 int 276 _fini(void) 277 { 278 /* 279 * This modules state is held in the kernel by space.c 280 * allowing this module to be unloaded. 281 */ 282 return (mod_remove(&modlinkage)); 283 } 284 285 int 286 _info(struct modinfo *modinfop) 287 { 288 return (mod_info(&modlinkage, modinfop)); 289 } 290 291 /*PRINTFLIKE2*/ 292 static void consconfig_dprintf(int, const char *, ...) 293 __KPRINTFLIKE(2); 294 295 static void 296 consconfig_dprintf(int l, const char *fmt, ...) 297 { 298 va_list ap; 299 300 #ifndef DEBUG 301 if (!l) { 302 return; 303 } 304 #endif /* DEBUG */ 305 if (l < consconfig_errlevel) { 306 return; 307 } 308 309 va_start(ap, fmt); 310 (void) vprintf(fmt, ap); 311 va_end(ap); 312 } 313 314 /* 315 * Return a property value for the specified alias in /aliases. 316 */ 317 char * 318 get_alias(char *alias, char *buf) 319 { 320 pnode_t node; 321 int len; 322 323 /* The /aliases node only exists in OBP >= 2.4. */ 324 if ((node = prom_alias_node()) == OBP_BADNODE) 325 return (NULL); 326 327 if ((len = prom_getproplen(node, (caddr_t)alias)) <= 0) 328 return (NULL); 329 330 (void) prom_getprop(node, (caddr_t)alias, (caddr_t)buf); 331 332 /* 333 * The IEEE 1275 standard specifies that /aliases string property 334 * values should be null-terminated. Unfortunatly the reality 335 * is that most aren't and the OBP can't easily be modified to 336 * add null termination to these strings. So we'll add the 337 * null termination here. If the string already contains a 338 * null termination character then that's ok too because we'll 339 * just be adding a second one. 340 */ 341 buf[len] = '\0'; 342 343 prom_pathname(buf); 344 return (buf); 345 } 346 347 /* 348 * i_consconfig_createvp: 349 * This routine is a convenience routine that is passed a path and returns 350 * a vnode. 351 */ 352 static vnode_t * 353 i_consconfig_createvp(char *path) 354 { 355 int error; 356 vnode_t *vp; 357 char *buf = NULL, *fullpath; 358 359 DPRINTF(DPRINT_L0, "i_consconfig_createvp: %s\n", path); 360 fullpath = kmem_alloc(MAXPATHLEN, KM_SLEEP); 361 362 if (strchr(path, ':') == NULL) { 363 /* convert an OBP path to a /devices path */ 364 buf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 365 if (i_ddi_prompath_to_devfspath(path, buf) != DDI_SUCCESS) { 366 kmem_free(buf, MAXPATHLEN); 367 kmem_free(fullpath, MAXPATHLEN); 368 return (NULL); 369 } 370 (void) snprintf(fullpath, MAXPATHLEN, "/devices%s", buf); 371 kmem_free(buf, MAXPATHLEN); 372 } else { 373 /* convert a devfs path to a /devices path */ 374 (void) snprintf(fullpath, MAXPATHLEN, "/devices%s", path); 375 } 376 377 DPRINTF(DPRINT_L0, "lookupname(%s)\n", fullpath); 378 error = lookupname(fullpath, UIO_SYSSPACE, FOLLOW, NULLVPP, &vp); 379 kmem_free(fullpath, MAXPATHLEN); 380 if (error) 381 return (NULL); 382 383 DPRINTF(DPRINT_L0, "create vnode = 0x%p - dev 0x%lx\n", vp, vp->v_rdev); 384 ASSERT(vn_matchops(vp, spec_getvnodeops())); 385 386 return (vp); 387 } 388 389 /* 390 * consconfig_print_paths: 391 * Function to print out the various paths 392 */ 393 static void 394 consconfig_print_paths(void) 395 { 396 char *path; 397 398 if (usb_kb_path != NULL) 399 cmn_err(CE_WARN, 400 "consconfig_dacf:usb_kb_path has been deprecated, " 401 "use consconfig:usb_kb_path instead"); 402 403 if (usb_ms_path != NULL) 404 cmn_err(CE_WARN, 405 "consconfig_dacf:usb_ms_path has been deprecated, " 406 "use consconfig:usb_ms_path instead"); 407 408 if (consconfig_errlevel > DPRINT_L0) 409 return; 410 411 path = NULL; 412 if (consconfig_usb_kb_path != NULL) 413 path = consconfig_usb_kb_path; 414 else if (usb_kb_path != NULL) 415 path = usb_kb_path; 416 if (path != NULL) 417 DPRINTF(DPRINT_L0, "usb keyboard path = %s\n", path); 418 419 path = plat_kbdpath(); 420 if (path != NULL) 421 DPRINTF(DPRINT_L0, "keyboard path = %s\n", path); 422 423 path = NULL; 424 if (consconfig_usb_ms_path != NULL) 425 path = consconfig_usb_ms_path; 426 else if (usb_ms_path != NULL) 427 path = usb_ms_path; 428 if (path != NULL) 429 DPRINTF(DPRINT_L0, "usb mouse path = %s\n", path); 430 431 path = plat_mousepath(); 432 if (path != NULL) 433 DPRINTF(DPRINT_L0, "mouse path = %s\n", path); 434 435 path = plat_stdinpath(); 436 if (path != NULL) 437 DPRINTF(DPRINT_L0, "stdin path = %s\n", path); 438 439 path = plat_stdoutpath(); 440 if (path != NULL) 441 DPRINTF(DPRINT_L0, "stdout path = %s\n", path); 442 443 path = plat_fbpath(); 444 if (path != NULL) 445 DPRINTF(DPRINT_L0, "fb path = %s\n", path); 446 } 447 448 /* 449 * consconfig_kbd_abort_enable: 450 * Send the CONSSETABORTENABLE ioctl to the lower layers. This ioctl 451 * will only be sent to the device if it is the console device. 452 * This ioctl tells the device to pay attention to abort sequences. 453 * In the case of kbtrans, this would tell the driver to pay attention 454 * to the two key abort sequences like STOP-A. In the case of the 455 * serial keyboard, it would be an abort sequence like a break. 456 */ 457 static int 458 consconfig_kbd_abort_enable(ldi_handle_t lh) 459 { 460 int err, rval; 461 462 DPRINTF(DPRINT_L0, "consconfig_kbd_abort_enable\n"); 463 464 err = ldi_ioctl(lh, CONSSETABORTENABLE, (uintptr_t)B_TRUE, 465 FKIOCTL, kcred, &rval); 466 return (err); 467 } 468 469 /* 470 * consconfig_kbd_abort_disable: 471 * Send CONSSETABORTENABLE ioctl to lower layers. This ioctl 472 * will only be sent to the device if it is the console device. 473 * This ioctl tells the physical device to ignore abort sequences, 474 * and send the sequences up to virtual keyboard(conskbd) so that 475 * STOP and A (or F1 and A) can be combined. 476 */ 477 static int 478 consconfig_kbd_abort_disable(ldi_handle_t lh) 479 { 480 int err, rval; 481 482 DPRINTF(DPRINT_L0, "consconfig_kbd_abort_disable\n"); 483 484 err = ldi_ioctl(lh, CONSSETABORTENABLE, (uintptr_t)B_FALSE, 485 FKIOCTL, kcred, &rval); 486 return (err); 487 } 488 489 #ifdef _HAVE_TEM_FIRMWARE 490 static int 491 consconfig_tem_supported(cons_state_t *sp) 492 { 493 dev_t dev; 494 dev_info_t *dip; 495 int *int_array; 496 uint_t nint; 497 int rv = 0; 498 499 if (sp->cons_fb_path == NULL) 500 return (0); 501 502 if ((dev = ddi_pathname_to_dev_t(sp->cons_fb_path)) == NODEV) 503 return (0); /* warning printed later by common code */ 504 505 /* 506 * Here we hold the driver and check "tem-support" property. 507 * We're doing this with e_ddi_hold_devi_by_dev and 508 * ddi_prop_lookup_int_array without opening the driver since 509 * some video cards that don't support the kernel terminal 510 * emulator could hang or crash if opened too early during 511 * boot. 512 */ 513 if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) { 514 cmn_err(CE_WARN, "consconfig: cannot hold fb dev %s", 515 sp->cons_fb_path); 516 return (0); 517 } 518 519 /* 520 * Check that the tem-support property exists AND that 521 * it is equal to 1. 522 */ 523 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, 524 DDI_PROP_DONTPASS, "tem-support", &int_array, &nint) == 525 DDI_SUCCESS) { 526 if (nint > 0) 527 rv = int_array[0] == 1; 528 ddi_prop_free(int_array); 529 } 530 531 ddi_release_devi(dip); 532 533 return (rv); 534 } 535 #endif /* _HAVE_TEM_FIRMWARE */ 536 537 /* 538 * consconfig_get_polledio: 539 * Query the console with the CONSPOLLEDIO ioctl. 540 * The polled I/O routines are used by debuggers to perform I/O while 541 * interrupts and normal kernel services are disabled. 542 */ 543 static cons_polledio_t * 544 consconfig_get_polledio(ldi_handle_t lh) 545 { 546 int err, rval; 547 struct strioctl strioc; 548 cons_polledio_t *polled_io; 549 550 /* 551 * Setup the ioctl to be sent down to the lower driver. 552 */ 553 strioc.ic_cmd = CONSOPENPOLLEDIO; 554 strioc.ic_timout = INFTIM; 555 strioc.ic_len = sizeof (polled_io); 556 strioc.ic_dp = (char *)&polled_io; 557 558 /* 559 * Send the ioctl to the driver. The ioctl will wait for 560 * the response to come back from wc. wc has already issued 561 * the CONSOPENPOLLEDIO to the lower layer driver. 562 */ 563 err = ldi_ioctl(lh, I_STR, (intptr_t)&strioc, FKIOCTL, kcred, &rval); 564 565 if (err != 0) { 566 /* 567 * If the lower driver does not support polled I/O, then 568 * return NULL. This will be the case if the driver does 569 * not handle polled I/O, or OBP is going to handle polled 570 * I/O for the device. 571 */ 572 573 return (NULL); 574 } 575 576 /* 577 * Return the polled I/O structure. 578 */ 579 return (polled_io); 580 } 581 582 /* 583 * consconfig_setup_polledio: 584 * This routine does the setup work for polled I/O. First we get 585 * the polled_io structure from the lower layers 586 * and then we register the polled I/O 587 * callbacks with the debugger that will be using them. 588 */ 589 static void 590 consconfig_setup_polledio(cons_state_t *sp, dev_t dev) 591 { 592 cons_polledio_t *polled_io; 593 ldi_handle_t lh; 594 595 DPRINTF(DPRINT_L0, "consconfig_setup_polledio: start\n"); 596 597 598 if (ldi_open_by_dev(&dev, OTYP_CHR, 599 FREAD|FWRITE|FNOCTTY, kcred, &lh, sp->cons_li) != 0) 600 return; 601 602 603 /* 604 * Get the polled io routines so that we can use this 605 * device with the debuggers. 606 */ 607 polled_io = consconfig_get_polledio(lh); 608 609 /* 610 * If the get polledio failed, then we do not want to throw 611 * the polled I/O switch. 612 */ 613 if (polled_io == NULL) { 614 DPRINTF(DPRINT_L0, 615 "consconfig_setup_polledio: get_polledio failed\n"); 616 (void) ldi_close(lh, FREAD|FWRITE, kcred); 617 return; 618 } 619 620 /* Initialize the polled input */ 621 polled_io_init(); 622 623 /* Register the callbacks */ 624 DPRINTF(DPRINT_L0, 625 "consconfig_setup_polledio: registering callbacks\n"); 626 (void) polled_io_register_callbacks(polled_io, 0); 627 628 (void) ldi_close(lh, FREAD|FWRITE, kcred); 629 630 DPRINTF(DPRINT_L0, "consconfig_setup_polledio: end\n"); 631 } 632 633 static cons_state_t * 634 consconfig_state_init(void) 635 { 636 cons_state_t *sp; 637 int rval; 638 639 /* Initialize console information */ 640 sp = kmem_zalloc(sizeof (cons_state_t), KM_SLEEP); 641 sp->cons_keyboard_problem = B_FALSE; 642 643 mutex_init(&sp->cons_lock, NULL, MUTEX_DRIVER, NULL); 644 645 /* check if consconfig:usb_kb_path is set in /etc/system */ 646 consconfig_usb_kb_path = consconfig_get_usb_kb_path(); 647 648 /* check if consconfig:usb_ms_path is set in /etc/system */ 649 consconfig_usb_ms_path = consconfig_get_usb_ms_path(); 650 651 consconfig_print_paths(); 652 653 /* init external globals */ 654 stdoutdev = NODEV; 655 656 /* 657 * Find keyboard, mouse, stdin and stdout devices, if they 658 * exist on this platform. 659 */ 660 661 if (consconfig_usb_kb_path != NULL) { 662 sp->cons_keyboard_path = consconfig_usb_kb_path; 663 } else if (usb_kb_path != NULL) { 664 sp->cons_keyboard_path = usb_kb_path; 665 } else { 666 sp->cons_keyboard_path = plat_kbdpath(); 667 } 668 669 if (consconfig_usb_ms_path != NULL) { 670 sp->cons_mouse_path = consconfig_usb_ms_path; 671 } else if (usb_ms_path != NULL) { 672 sp->cons_mouse_path = usb_ms_path; 673 } else { 674 sp->cons_mouse_path = plat_mousepath(); 675 } 676 677 /* Identify the stdout driver */ 678 sp->cons_stdout_path = plat_stdoutpath(); 679 sp->cons_stdout_is_fb = plat_stdout_is_framebuffer(); 680 681 sp->cons_stdin_is_kbd = plat_stdin_is_keyboard(); 682 683 if (sp->cons_stdin_is_kbd && 684 (usb_kb_path != NULL || consconfig_usb_kb_path != NULL)) { 685 sp->cons_stdin_path = sp->cons_keyboard_path; 686 } else { 687 /* 688 * The standard in device may or may not be the same as 689 * the keyboard. Even if the keyboard is not the 690 * standard input, the keyboard console stream will 691 * still be built if the keyboard alias provided by the 692 * firmware exists and is valid. 693 */ 694 sp->cons_stdin_path = plat_stdinpath(); 695 } 696 697 if (sp->cons_stdout_is_fb) { 698 sp->cons_fb_path = sp->cons_stdout_path; 699 700 #ifdef _HAVE_TEM_FIRMWARE 701 sp->cons_tem_supported = consconfig_tem_supported(sp); 702 703 /* 704 * Systems which offer a virtual console must use that 705 * as a fallback whenever the fb doesn't support tem. 706 * Such systems cannot render characters to the screen 707 * using OBP. 708 */ 709 if (!sp->cons_tem_supported) { 710 char *path; 711 712 if (plat_virtual_console_path(&path) >= 0) { 713 sp->cons_stdin_is_kbd = 0; 714 sp->cons_stdout_is_fb = 0; 715 sp->cons_stdin_path = path; 716 sp->cons_stdout_path = path; 717 sp->cons_fb_path = plat_fbpath(); 718 719 cmn_err(CE_WARN, 720 "%s doesn't support terminal emulation " 721 "mode; switching to virtual console.", 722 sp->cons_fb_path); 723 } 724 } 725 #endif /* _HAVE_TEM_FIRMWARE */ 726 } else { 727 sp->cons_fb_path = plat_fbpath(); 728 #ifdef _HAVE_TEM_FIRMWARE 729 sp->cons_tem_supported = consconfig_tem_supported(sp); 730 #endif /* _HAVE_TEM_FIRMWARE */ 731 } 732 733 sp->cons_li = ldi_ident_from_anon(); 734 735 /* Save the pointer for retrieval by the dacf functions */ 736 rval = space_store("consconfig", (uintptr_t)sp); 737 ASSERT(rval == 0); 738 739 return (sp); 740 } 741 742 static int 743 consconfig_relink_wc(cons_state_t *sp, ldi_handle_t new_lh, int *muxid) 744 { 745 int err, rval; 746 ldi_handle_t wc_lh; 747 dev_t wc_dev; 748 749 ASSERT(muxid != NULL); 750 751 /* 752 * NOTE: we could be in a dacf callback context right now. normally 753 * it's not legal to call any ldi_open_*() function from this context 754 * because we're currently holding device tree locks and if the 755 * ldi_open_*() call could try to acquire other device tree locks 756 * (to attach the device we're trying to open.) if this happens then 757 * we could deadlock. To avoid this situation, during initialization 758 * we made sure to grab a hold on the dip of the device we plan to 759 * open so that it can never be detached. Then we use 760 * ldi_open_by_dev() to actually open the device since it will see 761 * that the device is already attached and held and instead of 762 * acquire any locks it will only increase the reference count 763 * on the device. 764 */ 765 wc_dev = sp->cons_wc_vp->v_rdev; 766 err = ldi_open_by_dev(&wc_dev, OTYP_CHR, FREAD|FWRITE|FNOCTTY, 767 kcred, &wc_lh, sp->cons_li); 768 ASSERT(wc_dev == sp->cons_wc_vp->v_rdev); 769 if (err) { 770 cmn_err(CE_WARN, "consconfig_relink_wc: " 771 "unable to open wc device"); 772 return (err); 773 } 774 775 if (new_lh != NULL) { 776 DPRINTF(DPRINT_L0, "linking stream under wc\n"); 777 778 err = ldi_ioctl(wc_lh, I_PLINK, (uintptr_t)new_lh, 779 FKIOCTL, kcred, muxid); 780 if (err != 0) { 781 cmn_err(CE_WARN, "consconfig_relink_wc: " 782 "wc link failed, error %d", err); 783 } 784 } else { 785 DPRINTF(DPRINT_L0, "unlinking stream from under wc\n"); 786 787 err = ldi_ioctl(wc_lh, I_PUNLINK, *muxid, 788 FKIOCTL, kcred, &rval); 789 if (err != 0) { 790 cmn_err(CE_WARN, "consconfig_relink_wc: " 791 "wc unlink failed, error %d", err); 792 } else { 793 *muxid = -1; 794 } 795 } 796 797 (void) ldi_close(wc_lh, FREAD|FWRITE, kcred); 798 return (err); 799 } 800 801 static void 802 cons_build_upper_layer(cons_state_t *sp) 803 { 804 ldi_handle_t wc_lh; 805 struct strioctl strioc; 806 int rval; 807 dev_t dev; 808 dev_t wc_dev; 809 810 /* 811 * Build the wc->conskbd portion of the keyboard console stream. 812 * Even if no keyboard is attached to the system, the upper 813 * layer of the stream will be built. If the user attaches 814 * a keyboard after the system is booted, the keyboard driver 815 * and module will be linked under conskbd. 816 * 817 * Errors are generally ignored here because conskbd and wc 818 * are pseudo drivers and should be present on the system. 819 */ 820 821 /* open the console keyboard device. will never be closed */ 822 if (ldi_open_by_name(CONSKBD_PATH, FREAD|FWRITE|FNOCTTY, 823 kcred, &sp->conskbd_lh, sp->cons_li) != 0) { 824 panic("consconfig: unable to open conskbd device"); 825 /*NOTREACHED*/ 826 } 827 828 DPRINTF(DPRINT_L0, "conskbd_lh = %p\n", sp->conskbd_lh); 829 830 /* open the console mouse device. will never be closed */ 831 if (ldi_open_by_name(CONSMS_PATH, FREAD|FWRITE|FNOCTTY, 832 kcred, &sp->consms_lh, sp->cons_li) != 0) { 833 panic("consconfig: unable to open consms device"); 834 /*NOTREACHED*/ 835 } 836 837 DPRINTF(DPRINT_L0, "consms_lh = %p\n", sp->consms_lh); 838 839 /* 840 * Get a vnode for the wc device and then grab a hold on the 841 * device dip so it can never detach. We need to do this now 842 * because later we'll have to open the wc device in a context 843 * were it isn't safe to acquire any device tree locks (ie, during 844 * a dacf callback.) 845 */ 846 sp->cons_wc_vp = i_consconfig_createvp(WC_PATH); 847 if (sp->cons_wc_vp == NULL) 848 panic("consconfig: unable to find wc device"); 849 850 if (e_ddi_hold_devi_by_dev(sp->cons_wc_vp->v_rdev, 0) == NULL) 851 panic("consconfig: unable to hold wc device"); 852 853 /* 854 * Build the wc->conskbd portion of the keyboard console stream. 855 * Even if no keyboard is attached to the system, the upper 856 * layer of the stream will be built. If the user attaches 857 * a keyboard after the system is booted, the keyboard driver 858 * and module will be linked under conskbd. 859 * 860 * The act of linking conskbd under wc will cause wc to 861 * query the lower layers about their polled I/O routines 862 * using CONSOPENPOLLEDIO. This will fail on this link because 863 * there is not a physical keyboard linked under conskbd. 864 * 865 * Since conskbd and wc are pseudo drivers, errors are 866 * generally ignored when linking and unlinking them. 867 */ 868 (void) consconfig_relink_wc(sp, sp->conskbd_lh, &sp->conskbd_muxid); 869 870 /* 871 * Get a vnode for the redirection device. (It has the 872 * connection to the workstation console device wired into it, 873 * so that it's not necessary to establish the connection 874 * here. If the redirection device is ever generalized to 875 * handle multiple client devices, it won't be able to 876 * establish the connection itself, and we'll have to do it 877 * here.) 878 */ 879 wsconsvp = i_consconfig_createvp(IWSCN_PATH); 880 if (wsconsvp == NULL) { 881 panic("consconfig: unable to find iwscn device"); 882 /*NOTREACHED*/ 883 } 884 885 if (cons_tem_disable) 886 return; 887 888 if (sp->cons_fb_path == NULL) { 889 #if defined(__x86) 890 if (sp->cons_stdout_is_fb) 891 cmn_err(CE_WARN, "consconfig: no screen found"); 892 #endif 893 return; 894 } 895 896 /* make sure the frame buffer device exists */ 897 dev = ddi_pathname_to_dev_t(sp->cons_fb_path); 898 if (dev == NODEV) { 899 cmn_err(CE_WARN, "consconfig: " 900 "cannot find driver for screen device %s", 901 sp->cons_fb_path); 902 return; 903 } 904 905 #ifdef _HAVE_TEM_FIRMWARE 906 /* 907 * If the underlying fb device doesn't support terminal emulation, 908 * we don't want to open the wc device (below) because it depends 909 * on features which aren't available (polled mode io). 910 */ 911 if (!sp->cons_tem_supported) 912 return; 913 #endif /* _HAVE_TEM_FIRMWARE */ 914 915 /* tell wc to open the frame buffer device */ 916 wc_dev = sp->cons_wc_vp->v_rdev; 917 if (ldi_open_by_dev(&wc_dev, OTYP_CHR, FREAD|FWRITE|FNOCTTY, kcred, 918 &wc_lh, sp->cons_li)) { 919 cmn_err(CE_PANIC, "cons_build_upper_layer: " 920 "unable to open wc device"); 921 return; 922 } 923 ASSERT(wc_dev == sp->cons_wc_vp->v_rdev); 924 925 strioc.ic_cmd = WC_OPEN_FB; 926 strioc.ic_timout = INFTIM; 927 strioc.ic_len = strlen(sp->cons_fb_path) + 1; 928 strioc.ic_dp = sp->cons_fb_path; 929 930 if (ldi_ioctl(wc_lh, I_STR, (intptr_t)&strioc, 931 FKIOCTL, kcred, &rval) == 0) 932 consmode = CONS_KFB; 933 else 934 cmn_err(CE_WARN, 935 "consconfig: terminal emulator failed to initialize"); 936 (void) ldi_close(wc_lh, FREAD|FWRITE, kcred); 937 } 938 939 static void 940 consconfig_load_drivers(cons_state_t *sp) 941 { 942 /* 943 * Calling ddi_pathname_to_dev_t causes the drivers to be loaded. 944 * The attaching of the drivers will cause the creation of the 945 * keyboard and mouse minor nodes, which will in turn trigger the 946 * dacf framework to call the keyboard and mouse configuration 947 * tasks. See PSARC/1998/212 for more details about the dacf 948 * framework. 949 * 950 * on sparc, when the console is ttya, zs0 is stdin/stdout, and zs1 951 * is kb/mouse. zs0 must be attached before zs1. The zs driver 952 * is written this way and the hardware may depend on this, too. 953 * It would be better to enforce this by attaching zs in sibling 954 * order with a driver property, such as ddi-attachall. 955 */ 956 if (sp->cons_stdin_path != NULL) 957 stdindev = ddi_pathname_to_dev_t(sp->cons_stdin_path); 958 if (stdindev == NODEV) { 959 DPRINTF(DPRINT_L0, 960 "!fail to attach stdin: %s\n", sp->cons_stdin_path); 961 } 962 if (sp->cons_stdout_path != NULL) 963 stdoutdev = ddi_pathname_to_dev_t(sp->cons_stdout_path); 964 if (sp->cons_keyboard_path != NULL) 965 kbddev = ddi_pathname_to_dev_t(sp->cons_keyboard_path); 966 if (sp->cons_mouse_path != NULL) 967 mousedev = ddi_pathname_to_dev_t(sp->cons_mouse_path); 968 969 /* 970 * On x86, make sure the fb driver is loaded even if we don't use it 971 * for the console. This will ensure that we create a /dev/fb link 972 * which is required to start Xorg. 973 */ 974 #if defined(__x86) 975 if (sp->cons_fb_path != NULL) 976 fbdev = ddi_pathname_to_dev_t(sp->cons_fb_path); 977 #endif 978 979 DPRINTF(DPRINT_L0, "stdindev %lx, stdoutdev %lx, kbddev %lx, " 980 "mousedev %lx\n", stdindev, stdoutdev, kbddev, mousedev); 981 } 982 983 static void 984 consconfig_init_framebuffer(cons_state_t *sp) 985 { 986 if (!sp->cons_stdout_is_fb) 987 return; 988 989 DPRINTF(DPRINT_L0, "stdout is framebuffer\n"); 990 ASSERT(strcmp(sp->cons_fb_path, sp->cons_stdout_path) == 0); 991 992 /* 993 * Console output is a framebuffer. 994 * Find the framebuffer driver if we can, and make 995 * ourselves a shadow vnode to track it with. 996 */ 997 fbdev = stdoutdev; 998 if (fbdev == NODEV) { 999 DPRINTF(DPRINT_L3, 1000 "Can't find driver for console framebuffer\n"); 1001 } else { 1002 /* stdoutdev is valid, of fbvp should exist */ 1003 fbvp = i_consconfig_createvp(sp->cons_stdout_path); 1004 if (fbvp == NULL) { 1005 panic("consconfig_load_drivers: " 1006 "unable to find frame buffer device"); 1007 /*NOTREACHED*/ 1008 } 1009 ASSERT(fbvp->v_rdev == fbdev); 1010 1011 /* console device is never released */ 1012 fbdip = e_ddi_hold_devi_by_dev(fbdev, 0); 1013 } 1014 pm_cfb_setup(sp->cons_stdout_path); 1015 } 1016 1017 /* 1018 * consconfig_prepare_dev: 1019 * Flush the stream, push "pushmod" onto the stream. 1020 * for keyboard, issue the KIOCTRANSABLE ioctl, and 1021 * possible enable abort. 1022 */ 1023 static void 1024 consconfig_prepare_dev( 1025 ldi_handle_t new_lh, 1026 const char *pushmod, 1027 int kbdtranslatable, 1028 int input_type, 1029 int dev_type) 1030 { 1031 int err, rval; 1032 1033 /* send a flush down the stream to the keyboard driver */ 1034 (void) ldi_ioctl(new_lh, I_FLUSH, (intptr_t)FLUSHRW, 1035 FKIOCTL, kcred, &rval); 1036 1037 if (pushmod) { 1038 err = ldi_ioctl(new_lh, I_PUSH, (intptr_t)pushmod, 1039 FKIOCTL, kcred, &rval); 1040 if (err) { 1041 cmn_err(CE_WARN, "consconfig_prepare_dev: " 1042 "can't push streams module \"%s\", error %d", 1043 pushmod, err); 1044 } 1045 } 1046 1047 if (dev_type == CONS_MS) 1048 return; 1049 1050 ASSERT(dev_type == CONS_KBD); 1051 1052 err = ldi_ioctl(new_lh, KIOCTRANSABLE, 1053 (intptr_t)&kbdtranslatable, FKIOCTL, kcred, &rval); 1054 if (err) { 1055 cmn_err(CE_WARN, "consconfig_prepare_dev: " 1056 "KIOCTRANSABLE failed, error: %d", err); 1057 } 1058 1059 /* 1060 * During boot, dynamic_console_config() will call the 1061 * function to enable abort on the console. If the 1062 * keyboard is hotplugged after boot, check to see if 1063 * the keyboard is the console input. If it is 1064 * enable abort on it. 1065 */ 1066 if (input_type == CONSOLE_LOCAL) 1067 (void) consconfig_kbd_abort_enable(new_lh); 1068 } 1069 1070 /* 1071 * consconfig_relink_conskbd: 1072 * If new_lh is not NULL it should represent a driver with a 1073 * keyboard module pushed on top of it. The driver is then linked 1074 * underneath conskbd. the resulting stream will be 1075 * wc->conskbd->"new_lh driver". 1076 * 1077 * If new_lh is NULL, then an unlink operation is done on conskbd 1078 * that attempts to unlink the stream specified by *muxid. 1079 * the resulting stream will be wc->conskbd. 1080 */ 1081 static int 1082 consconfig_relink_conskbd(cons_state_t *sp, ldi_handle_t new_lh, int *muxid) 1083 { 1084 int err, rval; 1085 int conskbd_relink = 0; 1086 1087 ASSERT(muxid != NULL); 1088 1089 DPRINTF(DPRINT_L0, "consconfig_relink_conskbd: " 1090 "conskbd_lh = %p, new_lh = %p, muxid = %x\n", 1091 sp->conskbd_lh, new_lh, *muxid); 1092 1093 /* 1094 * If conskbd is linked under wc then temporarily unlink it 1095 * from under wc so that the new_lh stream may be linked under 1096 * conskbd. This has to be done because streams are built bottom 1097 * up and linking a stream under conskbd isn't allowed when 1098 * conskbd is linked under wc. 1099 */ 1100 if (sp->conskbd_muxid != -1) { 1101 DPRINTF(DPRINT_L0, "unlinking conskbd from under wc\n"); 1102 conskbd_relink = 1; 1103 err = consconfig_relink_wc(sp, NULL, &sp->conskbd_muxid); 1104 if (err) { 1105 cmn_err(CE_WARN, "consconfig_relink_conskbd: " 1106 "wc unlink failed, error %d", err); 1107 return (err); 1108 } 1109 } 1110 1111 if (new_lh != NULL) { 1112 DPRINTF(DPRINT_L0, "linking keyboard under conskbd\n"); 1113 1114 /* Link the stream represented by new_lh under conskbd */ 1115 err = ldi_ioctl(sp->conskbd_lh, I_PLINK, (uintptr_t)new_lh, 1116 FKIOCTL, kcred, muxid); 1117 if (err != 0) { 1118 cmn_err(CE_WARN, "consconfig_relink_conskbd: " 1119 "conskbd link failed, error %d", err); 1120 goto relink_failed; 1121 } 1122 } else { 1123 DPRINTF(DPRINT_L0, "unlinking keyboard from under conskbd\n"); 1124 1125 /* 1126 * This will cause the keyboard driver to be closed, 1127 * all modules to be popped, and the keyboard vnode released. 1128 */ 1129 err = ldi_ioctl(sp->conskbd_lh, I_PUNLINK, *muxid, 1130 FKIOCTL, kcred, &rval); 1131 if (err != 0) { 1132 cmn_err(CE_WARN, "consconfig_relink_conskbd: " 1133 "conskbd unlink failed, error %d", err); 1134 goto relink_failed; 1135 } else { 1136 *muxid = -1; 1137 } 1138 1139 consconfig_check_phys_kbd(sp); 1140 } 1141 1142 if (!conskbd_relink) 1143 return (err); 1144 1145 /* 1146 * Link consbkd back under wc. 1147 * 1148 * The act of linking conskbd back under wc will cause wc 1149 * to query the lower lower layers about their polled I/O 1150 * routines. This time the request will succeed because there 1151 * is a physical keyboard linked under conskbd. 1152 */ 1153 DPRINTF(DPRINT_L0, "re-linking conskbd under wc\n"); 1154 err = consconfig_relink_wc(sp, sp->conskbd_lh, &sp->conskbd_muxid); 1155 if (err) { 1156 cmn_err(CE_WARN, "consconfig_relink_conskbd: " 1157 "wc link failed, error %d", err); 1158 } 1159 return (err); 1160 1161 relink_failed: 1162 if (!conskbd_relink) 1163 return (err); 1164 1165 /* something went wrong, try to reconnect conskbd back under wc */ 1166 DPRINTF(DPRINT_L0, "re-linking conskbd under wc\n"); 1167 (void) consconfig_relink_wc(sp, sp->conskbd_lh, &sp->conskbd_muxid); 1168 return (err); 1169 } 1170 1171 /* 1172 * consconfig_relink_consms: 1173 * If new_lh is not NULL it should represent a driver with a 1174 * mouse module pushed on top of it. The driver is then linked 1175 * underneath consms. the resulting stream will be 1176 * consms->"new_lh driver". 1177 * 1178 * If new_lh is NULL, then an unlink operation is done on consms 1179 * that attempts to unlink the stream specified by *muxid. 1180 */ 1181 static int 1182 consconfig_relink_consms(cons_state_t *sp, ldi_handle_t new_lh, int *muxid) 1183 { 1184 int err, rval; 1185 1186 DPRINTF(DPRINT_L0, "consconfig_relink_consms: " 1187 "consms_lh = %p, new_lh = %p, muxid = %x\n", 1188 (void *)sp->consms_lh, (void *)new_lh, *muxid); 1189 1190 if (new_lh != NULL) { 1191 DPRINTF(DPRINT_L0, "linking mouse under consms\n"); 1192 1193 /* Link ms/usbms stream underneath consms multiplexor. */ 1194 err = ldi_ioctl(sp->consms_lh, I_PLINK, (uintptr_t)new_lh, 1195 FKIOCTL, kcred, muxid); 1196 if (err != 0) { 1197 cmn_err(CE_WARN, "consconfig_relink_consms: " 1198 "mouse link failed, error %d", err); 1199 } 1200 } else { 1201 DPRINTF(DPRINT_L0, "unlinking mouse from under consms\n"); 1202 1203 /* Tear down the mouse stream */ 1204 err = ldi_ioctl(sp->consms_lh, I_PUNLINK, *muxid, 1205 FKIOCTL, kcred, &rval); 1206 if (err != 0) { 1207 cmn_err(CE_WARN, "consconfig_relink_consms: " 1208 "mouse unlink failed, error %d", err); 1209 } else { 1210 *muxid = -1; 1211 } 1212 } 1213 return (err); 1214 } 1215 1216 static int 1217 cons_get_input_type(cons_state_t *sp) 1218 { 1219 int type; 1220 1221 /* 1222 * Now that we know what all the devices are, we can figure out 1223 * what kind of console we have. 1224 */ 1225 if (sp->cons_stdin_is_kbd) { 1226 /* Stdin is from the system keyboard */ 1227 type = CONSOLE_LOCAL; 1228 } else if ((stdindev != NODEV) && (stdindev == stdoutdev)) { 1229 /* 1230 * A reliable indicator that we are doing a remote console 1231 * is that stdin and stdout are the same. 1232 * This is probably a tip line. 1233 */ 1234 type = CONSOLE_TIP; 1235 } else { 1236 type = CONSOLE_SERIAL_KEYBOARD; 1237 } 1238 1239 return (type); 1240 } 1241 1242 static void 1243 consconfig_init_input(cons_state_t *sp) 1244 { 1245 ldi_handle_t new_lh; 1246 dev_t cons_final_dev; 1247 int err; 1248 1249 cons_final_dev = NODEV; 1250 1251 switch (sp->cons_input_type) { 1252 case CONSOLE_LOCAL: 1253 DPRINTF(DPRINT_L0, "stdin is keyboard\n"); 1254 1255 /* 1256 * The machine is allowed to boot without a keyboard. 1257 * If a user attaches a keyboard later, the keyboard 1258 * will be hooked into the console stream with the dacf 1259 * functions. 1260 * 1261 * The only drivers that look at kbbdev are the 1262 * serial drivers, which looks at kbdev to see if 1263 * they should allow abort on a break. In the absence 1264 * of keyboard, the serial drivers won't be attached 1265 * for any keyboard instance. 1266 */ 1267 if (kbddev == NODEV) { 1268 /* 1269 * If there is a problem with the keyboard 1270 * during the driver loading, then the polled 1271 * input won't get setup properly if polled 1272 * input is needed. This means that if the 1273 * keyboard is hotplugged, the keyboard would 1274 * work normally, but going down to the 1275 * debugger would not work if polled input is 1276 * required. This field is set here. The next 1277 * time a keyboard is plugged in, the field is 1278 * checked in order to give the next keyboard a 1279 * chance at being registered for console 1280 * input. 1281 * 1282 * Although this code will rarely be needed, 1283 * USB keyboards can be flaky, so this code 1284 * will be useful on the occasion that the 1285 * keyboard doesn't enumerate when the drivers 1286 * are loaded. 1287 */ 1288 DPRINTF(DPRINT_L2, "Error with console keyboard\n"); 1289 sp->cons_keyboard_problem = B_TRUE; 1290 } 1291 stdindev = kbddev; 1292 cons_final_dev = sp->cons_wc_vp->v_rdev; 1293 break; 1294 1295 case CONSOLE_TIP: 1296 DPRINTF(DPRINT_L0, "console input is tty (%s)\n", 1297 sp->cons_stdin_path); 1298 1299 /* 1300 * Console device drivers must be able to output 1301 * after being closed. 1302 */ 1303 rconsvp = i_consconfig_createvp(sp->cons_stdin_path); 1304 if (rconsvp == NULL) { 1305 panic("consconfig_init_input: " 1306 "unable to find stdin device (%s)", 1307 sp->cons_stdin_path); 1308 /*NOTREACHED*/ 1309 } 1310 rconsdev = rconsvp->v_rdev; 1311 1312 ASSERT(rconsdev == stdindev); 1313 1314 cons_final_dev = rconsdev; 1315 break; 1316 1317 case CONSOLE_SERIAL_KEYBOARD: 1318 DPRINTF(DPRINT_L0, "stdin is serial keyboard\n"); 1319 1320 /* 1321 * Non-keyboard input device, but not rconsdev. 1322 * This is known as the "serial keyboard" case - the 1323 * most likely use is someone has a keyboard attached 1324 * to a serial port (tip) and still has output on a 1325 * framebuffer. 1326 * 1327 * In this case, the serial driver must be linked 1328 * directly beneath wc. Since conskbd was linked 1329 * underneath wc above, first we unlink conskbd. 1330 */ 1331 (void) consconfig_relink_wc(sp, NULL, &sp->conskbd_muxid); 1332 sp->conskbd_muxid = -1; 1333 1334 /* 1335 * Open the serial keyboard, configure it, 1336 * and link it underneath wc. 1337 */ 1338 err = ldi_open_by_name(sp->cons_stdin_path, 1339 FREAD|FWRITE|FNOCTTY, kcred, &new_lh, sp->cons_li); 1340 if (err == 0) { 1341 struct termios termios; 1342 int rval; 1343 int stdin_muxid; 1344 1345 consconfig_prepare_dev(new_lh, 1346 "kb", TR_CANNOT, sp->cons_input_type, CONS_KBD); 1347 1348 /* Re-set baud rate */ 1349 (void) ldi_ioctl(new_lh, TCGETS, (intptr_t)&termios, 1350 FKIOCTL, kcred, &rval); 1351 1352 /* Set baud rate */ 1353 if (consconfig_setmodes(stdindev, &termios) == 0) { 1354 err = ldi_ioctl(new_lh, 1355 TCSETSF, (intptr_t)&termios, 1356 FKIOCTL, kcred, &rval); 1357 if (err) { 1358 cmn_err(CE_WARN, 1359 "consconfig_init_input: " 1360 "TCSETSF failed, error %d", err); 1361 } 1362 } 1363 1364 /* 1365 * Now link the serial keyboard direcly under wc 1366 * we don't save the returned muxid because we 1367 * don't support changing/hotplugging the console 1368 * keyboard when it is a serial keyboard. 1369 */ 1370 (void) consconfig_relink_wc(sp, new_lh, &stdin_muxid); 1371 1372 (void) ldi_close(new_lh, FREAD|FWRITE, kcred); 1373 } 1374 1375 cons_final_dev = sp->cons_wc_vp->v_rdev; 1376 break; 1377 1378 default: 1379 panic("consconfig_init_input: " 1380 "unsupported console input/output combination"); 1381 /*NOTREACHED*/ 1382 } 1383 1384 /* 1385 * Use the redirection device/workstation console pair as the "real" 1386 * console if the latter hasn't already been set. 1387 * The workstation console driver needs to see rwsconsvp, but 1388 * all other access should be through the redirecting driver. 1389 */ 1390 if (rconsvp == NULL) { 1391 consconfig_dprintf(DPRINT_L0, "setup redirection driver\n"); 1392 rconsvp = wsconsvp; 1393 rconsdev = wsconsvp->v_rdev; 1394 } 1395 1396 ASSERT(cons_final_dev != NODEV); 1397 1398 err = ldi_open_by_dev(&cons_final_dev, OTYP_CHR, FREAD|FWRITE|FNOCTTY, 1399 kcred, &new_lh, sp->cons_li); 1400 if (err) { 1401 panic("consconfig_init_input: " 1402 "unable to open console device"); 1403 /*NOTREACHED*/ 1404 } 1405 1406 /* Enable abort on the console */ 1407 (void) consconfig_kbd_abort_enable(new_lh); 1408 1409 /* Now we must close it to make console logins happy */ 1410 (void) ldi_close(new_lh, FREAD|FWRITE, kcred); 1411 1412 /* Set up polled input if it is supported by the console device */ 1413 if (plat_use_polled_debug()) { 1414 /* 1415 * In the debug case, register the keyboard polled entry 1416 * points, but don't throw the switch in the debugger. This 1417 * allows the polled entry points to be checked by hand 1418 */ 1419 consconfig_setup_polledio(sp, sp->cons_wc_vp->v_rdev); 1420 } else { 1421 consconfig_setup_polledio(sp, cons_final_dev); 1422 } 1423 1424 kadb_uses_kernel(); 1425 } 1426 1427 /* 1428 * This function kicks off the console configuration. 1429 * Configure keyboard and mouse. Main entry here. 1430 */ 1431 void 1432 dynamic_console_config(void) 1433 { 1434 /* initialize space.c globals */ 1435 stdindev = NODEV; 1436 mousedev = NODEV; 1437 kbddev = NODEV; 1438 fbdev = NODEV; 1439 fbvp = NULL; 1440 fbdip = NULL; 1441 wsconsvp = NULL; 1442 rwsconsvp = NULL; 1443 rwsconsdev = NODEV; 1444 rconsvp = NULL; 1445 rconsdev = NODEV; 1446 1447 /* Initialize cons_state_t structure and console device paths */ 1448 consconfig_sp = consconfig_state_init(); 1449 ASSERT(consconfig_sp); 1450 1451 /* Build upper layer of console stream */ 1452 cons_build_upper_layer(consconfig_sp); 1453 1454 /* 1455 * Load keyboard/mouse drivers. The dacf routines will 1456 * plumb the devices into the console stream 1457 * 1458 * At the conclusion of the ddi_pathname_to_dev_t calls, the keyboard 1459 * and mouse drivers are linked into their respective console 1460 * streams if the pathnames are valid. 1461 */ 1462 consconfig_load_drivers(consconfig_sp); 1463 consconfig_sp->cons_input_type = cons_get_input_type(consconfig_sp); 1464 1465 /* 1466 * This is legacy special case code for the "cool" virtual console 1467 * for the Starfire project. Starfire has a dummy "ssp-serial" 1468 * node in the OBP device tree and cvc is a pseudo driver. 1469 */ 1470 if (consconfig_sp->cons_stdout_path != NULL && stdindev == NODEV && 1471 strstr(consconfig_sp->cons_stdout_path, "ssp-serial")) { 1472 /* 1473 * Setup the virtual console driver for Starfire 1474 * Note that console I/O will still go through prom for now 1475 * (notice we don't open the driver here). The cvc driver 1476 * will be activated when /dev/console is opened by init. 1477 * During that time, a cvcd daemon will be started that 1478 * will open the cvcredirection driver to facilitate 1479 * the redirection of console I/O from cvc to cvcd. 1480 */ 1481 rconsvp = i_consconfig_createvp(CVC_PATH); 1482 if (rconsvp == NULL) 1483 return; 1484 rconsdev = rconsvp->v_rdev; 1485 return; 1486 } 1487 1488 rwsconsvp = consconfig_sp->cons_wc_vp; 1489 rwsconsdev = consconfig_sp->cons_wc_vp->v_rdev; 1490 1491 1492 /* initialize framebuffer, console input, and redirection device */ 1493 consconfig_init_framebuffer(consconfig_sp); 1494 consconfig_init_input(consconfig_sp); 1495 1496 DPRINTF(DPRINT_L0, 1497 "mousedev %lx, kbddev %lx, fbdev %lx, rconsdev %lx\n", 1498 mousedev, kbddev, fbdev, rconsdev); 1499 1500 flush_usb_serial_buf(); 1501 } 1502 1503 1504 /* 1505 * Start of DACF interfaces 1506 */ 1507 1508 /* 1509 * Do the real job for keyboard/mouse auto-configuration. 1510 */ 1511 static int 1512 do_config(cons_state_t *sp, cons_prop_t *prop) 1513 { 1514 ldi_handle_t lh; 1515 dev_t dev; 1516 int error; 1517 1518 ASSERT((prop->cp_type == CONS_KBD) || (prop->cp_type == CONS_MS)); 1519 1520 dev = prop->cp_dev; 1521 error = ldi_open_by_dev(&dev, OTYP_CHR, 1522 FREAD|FWRITE|FNOCTTY, kcred, &lh, sp->cons_li); 1523 if (error) { 1524 return (DACF_FAILURE); 1525 } 1526 ASSERT(dev == prop->cp_dev); /* clone not supported */ 1527 1528 /* 1529 * Prepare the new keyboard/mouse driver 1530 * to be linked under conskbd/consms. 1531 */ 1532 consconfig_prepare_dev(lh, prop->cp_pushmod, TR_CAN, 1533 sp->cons_input_type, prop->cp_type); 1534 1535 if (prop->cp_type == CONS_KBD) { 1536 /* 1537 * Tell the physical keyboard driver to send 1538 * the abort sequences up to the virtual keyboard 1539 * driver so that STOP and A (or F1 and A) 1540 * can be applied to different keyboards. 1541 */ 1542 (void) consconfig_kbd_abort_disable(lh); 1543 1544 /* Link the stream underneath conskbd */ 1545 error = consconfig_relink_conskbd(sp, lh, &prop->cp_muxid); 1546 } else { 1547 /* Link the stream underneath consms */ 1548 error = consconfig_relink_consms(sp, lh, &prop->cp_muxid); 1549 } 1550 1551 /* 1552 * At this point, the stream is: 1553 * for keyboard: wc->conskbd->["pushmod"->"kbd_vp driver"] 1554 * for mouse: consms->["module_name"->]"mouse_avp driver" 1555 */ 1556 1557 /* Close the driver stream, it will stay linked under conskbd */ 1558 (void) ldi_close(lh, FREAD|FWRITE, kcred); 1559 1560 if (error) { 1561 return (DACF_FAILURE); 1562 } 1563 1564 return (DACF_SUCCESS); 1565 } 1566 1567 static int 1568 do_unconfig(cons_state_t *sp, cons_prop_t *prop) 1569 { 1570 ASSERT((prop->cp_type == CONS_KBD) || (prop->cp_type == CONS_MS)); 1571 1572 if (prop->cp_type == CONS_KBD) 1573 return (consconfig_relink_conskbd(sp, NULL, &prop->cp_muxid)); 1574 else 1575 return (consconfig_relink_consms(sp, NULL, &prop->cp_muxid)); 1576 } 1577 1578 static int 1579 kb_ms_config(dacf_infohdl_t minor_hdl, dacf_arghdl_t arg_hdl, int type) 1580 { 1581 major_t major; 1582 minor_t minor; 1583 dev_t dev; 1584 dev_info_t *dip; 1585 cons_state_t *sp; 1586 cons_prop_t *prop; 1587 const char *pushmod; 1588 1589 /* 1590 * Retrieve the state information 1591 * Some platforms may use the old-style "consconfig" to configure 1592 * console stream modules but may also support devices that happen 1593 * to match a rule in /etc/dacf.conf. This will cause a problem 1594 * since the console state structure will not be initialized. 1595 * In that case, these entry points should silently fail and 1596 * permit console to be plumbed later in boot. 1597 */ 1598 if ((sp = (cons_state_t *)space_fetch("consconfig")) == NULL) 1599 return (DACF_FAILURE); 1600 1601 dip = dacf_devinfo_node(minor_hdl); 1602 major = ddi_driver_major(dip); 1603 ASSERT(major != DDI_MAJOR_T_NONE); 1604 minor = dacf_minor_number(minor_hdl); 1605 dev = makedevice(major, minor); 1606 ASSERT(dev != NODEV); 1607 1608 DPRINTF(DPRINT_L0, "driver name = \"%s\", dev = 0x%lx, major = 0x%x\n", 1609 (char *)dacf_driver_name(minor_hdl), dev, major); 1610 1611 /* Access to the global variables is synchronized */ 1612 mutex_enter(&sp->cons_lock); 1613 1614 /* 1615 * Check if the keyboard/mouse has already configured. 1616 */ 1617 if (consconfig_find_dev(sp, dev) != NULL) { 1618 mutex_exit(&sp->cons_lock); 1619 return (DACF_SUCCESS); 1620 } 1621 1622 prop = kmem_zalloc(sizeof (cons_prop_t), KM_SLEEP); 1623 1624 /* Config the new keyboard/mouse device */ 1625 prop->cp_dev = dev; 1626 1627 pushmod = dacf_get_arg(arg_hdl, "pushmod"); 1628 prop->cp_pushmod = i_ddi_strdup((char *)pushmod, KM_SLEEP); 1629 1630 prop->cp_type = type; 1631 if (do_config(sp, prop) != DACF_SUCCESS) { 1632 /* 1633 * The keyboard/mouse node failed to open. 1634 * Set the major and minor numbers to 0 so 1635 * kb_unconfig/ms_unconfig won't unconfigure 1636 * this node if it is detached. 1637 */ 1638 mutex_exit(&sp->cons_lock); 1639 consconfig_free_prop(prop); 1640 return (DACF_FAILURE); 1641 } 1642 1643 consconfig_add_dev(sp, prop); 1644 1645 /* 1646 * See if there was a problem with the console keyboard during boot. 1647 * If so, try to register polled input for this keyboard. 1648 */ 1649 if ((type == CONS_KBD) && (sp->cons_keyboard_problem)) { 1650 consconfig_setup_polledio(sp, sp->cons_wc_vp->v_rdev); 1651 sp->cons_keyboard_problem = B_FALSE; 1652 } 1653 1654 /* Prevent autodetach due to memory pressure */ 1655 (void) ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1); 1656 1657 mutex_exit(&sp->cons_lock); 1658 1659 return (DACF_SUCCESS); 1660 } 1661 1662 static int 1663 kb_ms_unconfig(dacf_infohdl_t minor_hdl, dacf_arghdl_t arg_hdl) 1664 { 1665 _NOTE(ARGUNUSED(arg_hdl)) 1666 1667 major_t major; 1668 minor_t minor; 1669 dev_t dev; 1670 dev_info_t *dip; 1671 cons_state_t *sp; 1672 cons_prop_t *prop; 1673 1674 /* 1675 * Retrieve the state information 1676 * So if there isn't a state available, then this entry point just 1677 * returns. See note in kb_config(). 1678 */ 1679 if ((sp = (cons_state_t *)space_fetch("consconfig")) == NULL) 1680 return (DACF_SUCCESS); 1681 1682 dip = dacf_devinfo_node(minor_hdl); 1683 major = ddi_driver_major(dip); 1684 ASSERT(major != DDI_MAJOR_T_NONE); 1685 minor = dacf_minor_number(minor_hdl); 1686 dev = makedevice(major, minor); 1687 ASSERT(dev != NODEV); 1688 1689 /* 1690 * Check if the keyboard/mouse that is being detached 1691 * is the console keyboard/mouse or not. 1692 */ 1693 mutex_enter(&sp->cons_lock); 1694 if ((prop = consconfig_find_dev(sp, dev)) == NULL) { 1695 mutex_exit(&sp->cons_lock); 1696 return (DACF_SUCCESS); 1697 } 1698 1699 /* 1700 * This dev may be opened physically and then hotplugged out. 1701 */ 1702 if (prop->cp_muxid != -1) { 1703 (void) do_unconfig(sp, prop); 1704 consconfig_rem_dev(sp, dev); 1705 } 1706 1707 mutex_exit(&sp->cons_lock); 1708 1709 return (DACF_SUCCESS); 1710 } 1711 1712 /* 1713 * This is the post-attach / pre-detach action function for the keyboard 1714 * and mouse. This function is associated with a node type in /etc/dacf.conf. 1715 */ 1716 static int 1717 kb_config(dacf_infohdl_t minor_hdl, dacf_arghdl_t arg_hdl, int flags) 1718 { 1719 _NOTE(ARGUNUSED(flags)) 1720 1721 return (kb_ms_config(minor_hdl, arg_hdl, CONS_KBD)); 1722 } 1723 1724 static int 1725 ms_config(dacf_infohdl_t minor_hdl, dacf_arghdl_t arg_hdl, int flags) 1726 { 1727 _NOTE(ARGUNUSED(flags)) 1728 1729 return (kb_ms_config(minor_hdl, arg_hdl, CONS_MS)); 1730 } 1731 1732 static int 1733 kb_unconfig(dacf_infohdl_t minor_hdl, dacf_arghdl_t arg_hdl, int flags) 1734 { 1735 _NOTE(ARGUNUSED(flags)) 1736 1737 return (kb_ms_unconfig(minor_hdl, arg_hdl)); 1738 } 1739 1740 static int 1741 ms_unconfig(dacf_infohdl_t minor_hdl, dacf_arghdl_t arg_hdl, int flags) 1742 { 1743 _NOTE(ARGUNUSED(flags)) 1744 1745 return (kb_ms_unconfig(minor_hdl, arg_hdl)); 1746 } 1747 1748 /* 1749 * consconfig_link and consconfig_unlink are provided to support 1750 * direct access to physical keyboard/mouse underlying conskbd/ 1751 * consms. 1752 * When the keyboard/mouse is opened physically via its device 1753 * file, it will be unlinked from the virtual one, and when it 1754 * is closed physically, it will be linked back under the virtual 1755 * one. 1756 */ 1757 void 1758 consconfig_link(major_t major, minor_t minor) 1759 { 1760 char buf[MAXPATHLEN]; 1761 dev_t dev; 1762 cons_state_t *sp; 1763 cons_prop_t *prop; 1764 1765 if ((sp = (cons_state_t *)space_fetch("consconfig")) == NULL) 1766 return; 1767 1768 dev = makedevice(major, minor); 1769 ASSERT(dev != NODEV); 1770 1771 mutex_enter(&sp->cons_lock); 1772 if ((prop = consconfig_find_dev(sp, dev)) == NULL) { 1773 mutex_exit(&sp->cons_lock); 1774 return; 1775 } 1776 1777 if (do_config(sp, prop) != DACF_SUCCESS) { 1778 (void) ddi_dev_pathname(dev, 0, buf); 1779 if (prop->cp_type == CONS_KBD) 1780 cmn_err(CE_WARN, "Failed to relink the keyboard " 1781 "(%s) underneath virtual keyboard", buf); 1782 else 1783 cmn_err(CE_WARN, "Failed to relink the mouse " 1784 "(%s) underneath virtual mouse", buf); 1785 consconfig_rem_dev(sp, dev); 1786 } 1787 1788 mutex_exit(&sp->cons_lock); 1789 } 1790 1791 1792 int 1793 consconfig_unlink(major_t major, minor_t minor) 1794 { 1795 dev_t dev; 1796 cons_state_t *sp; 1797 cons_prop_t *prop; 1798 int error; 1799 1800 if ((sp = (cons_state_t *)space_fetch("consconfig")) == NULL) 1801 return (DACF_SUCCESS); 1802 1803 dev = makedevice(major, minor); 1804 ASSERT(dev != NODEV); 1805 1806 mutex_enter(&sp->cons_lock); 1807 if ((prop = consconfig_find_dev(sp, dev)) == NULL) { 1808 mutex_exit(&sp->cons_lock); 1809 return (DACF_FAILURE); 1810 } 1811 1812 error = do_unconfig(sp, prop); 1813 1814 /* 1815 * Keep this dev on the list, for this dev is still online. 1816 */ 1817 mutex_exit(&sp->cons_lock); 1818 1819 return (error); 1820 } 1821 1822 /* 1823 * Routine to set baud rate, bits-per-char, parity and stop bits 1824 * on the console line when necessary. 1825 */ 1826 static int 1827 consconfig_setmodes(dev_t dev, struct termios *termiosp) 1828 { 1829 char buf[MAXPATHLEN]; 1830 int len = MAXPATHLEN; 1831 char name[16]; 1832 int ppos, i; 1833 char *path; 1834 dev_t tdev; 1835 1836 /* 1837 * First, search for a devalias which matches this dev_t. 1838 * Try all of ttya through ttyz until no such alias 1839 */ 1840 (void) strcpy(name, "ttya"); 1841 for (i = 0; i < ('z'-'a'); i++) { 1842 name[3] = 'a' + i; /* increment device name */ 1843 path = get_alias(name, buf); 1844 if (path == NULL) 1845 return (1); 1846 1847 tdev = ddi_pathname_to_dev_t(path); 1848 if (tdev == dev) 1849 break; /* Exit loop if found */ 1850 } 1851 1852 if (i >= ('z'-'a')) 1853 return (1); /* If we didn't find it, return */ 1854 1855 /* 1856 * Now that we know which "tty" this corresponds to, retrieve 1857 * the "ttya-mode" options property, which tells us how to configure 1858 * the line. 1859 */ 1860 (void) strcpy(name, "ttya-mode"); /* name of option we want */ 1861 name[3] = 'a' + i; /* Adjust to correct line */ 1862 1863 if (ddi_getlongprop_buf(DDI_DEV_T_ANY, ddi_root_node(), 0, name, 1864 buf, &len) != DDI_PROP_SUCCESS) 1865 return (1); /* if no such option, just return */ 1866 1867 /* 1868 * The IEEE 1275 standard specifies that /aliases string property 1869 * values should be null-terminated. Unfortunatly the reality 1870 * is that most aren't and the OBP can't easily be modified to 1871 * add null termination to these strings. So we'll add the 1872 * null termination here. If the string already contains a 1873 * null termination character then that's ok too because we'll 1874 * just be adding a second one. 1875 */ 1876 buf[len] = '\0'; 1877 1878 /* Clear out options we will be setting */ 1879 termiosp->c_cflag &= 1880 ~(CSIZE | CBAUD | CBAUDEXT | PARODD | PARENB | CSTOPB); 1881 1882 /* 1883 * Now, parse the string. Wish I could use sscanf(). 1884 * Format 9600,8,n,1,- 1885 * baud rate, bits-per-char, parity, stop-bits, ignored 1886 */ 1887 for (ppos = 0; ppos < (MAXPATHLEN-8); ppos++) { /* Find first comma */ 1888 if ((buf[ppos] == 0) || (buf[ppos] == ',')) 1889 break; 1890 } 1891 1892 if (buf[ppos] != ',') { 1893 cmn_err(CE_WARN, "consconfig_setmodes: " 1894 "invalid mode string %s", buf); 1895 return (1); 1896 } 1897 1898 for (i = 0; i < MAX_SPEEDS; i++) { 1899 if (strncmp(buf, speedtab[i].name, ppos) == 0) 1900 break; 1901 } 1902 1903 if (i >= MAX_SPEEDS) { 1904 cmn_err(CE_WARN, 1905 "consconfig_setmodes: unrecognized speed in %s", buf); 1906 return (1); 1907 } 1908 1909 /* Found the baud rate, set it */ 1910 termiosp->c_cflag |= speedtab[i].code & CBAUD; 1911 if (speedtab[i].code > 16) /* cfsetospeed! */ 1912 termiosp->c_cflag |= CBAUDEXT; 1913 1914 /* Set bits per character */ 1915 switch (buf[ppos+1]) { 1916 case '8': 1917 termiosp->c_cflag |= CS8; 1918 break; 1919 case '7': 1920 termiosp->c_cflag |= CS7; 1921 break; 1922 default: 1923 cmn_err(CE_WARN, 1924 "consconfig_setmodes: illegal bits-per-char %s", buf); 1925 return (1); 1926 } 1927 1928 /* Set parity */ 1929 switch (buf[ppos+3]) { 1930 case 'o': 1931 termiosp->c_cflag |= PARENB | PARODD; 1932 break; 1933 case 'e': 1934 termiosp->c_cflag |= PARENB; /* enabled, not odd */ 1935 break; 1936 case 'n': 1937 break; /* not enabled. */ 1938 default: 1939 cmn_err(CE_WARN, "consconfig_setmodes: illegal parity %s", buf); 1940 return (1); 1941 } 1942 1943 /* Set stop bits */ 1944 switch (buf[ppos+5]) { 1945 case '1': 1946 break; /* No extra stop bit */ 1947 case '2': 1948 termiosp->c_cflag |= CSTOPB; /* 1 extra stop bit */ 1949 break; 1950 default: 1951 cmn_err(CE_WARN, "consconfig_setmodes: " 1952 "illegal stop bits %s", buf); 1953 return (1); 1954 } 1955 1956 return (0); 1957 } 1958 1959 /* 1960 * Check to see if underlying keyboard devices are still online, 1961 * if any one is offline now, unlink it. 1962 */ 1963 static void 1964 consconfig_check_phys_kbd(cons_state_t *sp) 1965 { 1966 ldi_handle_t kb_lh; 1967 cons_prop_t *prop; 1968 int error; 1969 int rval; 1970 1971 for (prop = sp->cons_km_prop; prop; prop = prop->cp_next) { 1972 if ((prop->cp_type != CONS_KBD) || (prop->cp_muxid == -1)) 1973 continue; 1974 1975 error = ldi_open_by_dev(&prop->cp_dev, OTYP_CHR, 1976 FREAD|FWRITE|FNOCTTY, kcred, &kb_lh, sp->cons_li); 1977 1978 if (error) { 1979 (void) ldi_ioctl(sp->conskbd_lh, I_PUNLINK, 1980 prop->cp_muxid, FKIOCTL, kcred, &rval); 1981 prop->cp_dev = NODEV; 1982 } else { 1983 (void) ldi_close(kb_lh, FREAD|FWRITE, kcred); 1984 } 1985 } 1986 1987 /* 1988 * Remove all disconnected keyboards, 1989 * whose dev is turned into NODEV above. 1990 */ 1991 consconfig_rem_dev(sp, NODEV); 1992 } 1993 1994 /* 1995 * Remove devices according to dev, which may be NODEV 1996 */ 1997 static void 1998 consconfig_rem_dev(cons_state_t *sp, dev_t dev) 1999 { 2000 cons_prop_t *prop; 2001 cons_prop_t *prev_prop; 2002 cons_prop_t *tmp_prop; 2003 cons_prop_t *head_prop; 2004 2005 head_prop = NULL; 2006 prev_prop = NULL; 2007 for (prop = sp->cons_km_prop; prop != NULL; ) { 2008 if (prop->cp_dev == dev) { 2009 tmp_prop = prop->cp_next; 2010 consconfig_free_prop(prop); 2011 prop = tmp_prop; 2012 if (prev_prop) 2013 prev_prop->cp_next = prop; 2014 } else { 2015 if (head_prop == NULL) 2016 head_prop = prop; 2017 prev_prop = prop; 2018 prop = prop->cp_next; 2019 } 2020 } 2021 sp->cons_km_prop = head_prop; 2022 } 2023 2024 /* 2025 * Add a dev according to prop 2026 */ 2027 static void 2028 consconfig_add_dev(cons_state_t *sp, cons_prop_t *prop) 2029 { 2030 prop->cp_next = sp->cons_km_prop; 2031 sp->cons_km_prop = prop; 2032 } 2033 2034 /* 2035 * Find a device from our list according to dev 2036 */ 2037 static cons_prop_t * 2038 consconfig_find_dev(cons_state_t *sp, dev_t dev) 2039 { 2040 cons_prop_t *prop; 2041 2042 for (prop = sp->cons_km_prop; prop; prop = prop->cp_next) { 2043 if (prop->cp_dev == dev) 2044 break; 2045 } 2046 2047 return (prop); 2048 } 2049 2050 /* 2051 * Free a cons prop associated with a keyboard or mouse 2052 */ 2053 static void 2054 consconfig_free_prop(cons_prop_t *prop) 2055 { 2056 if (prop->cp_pushmod) 2057 kmem_free(prop->cp_pushmod, strlen(prop->cp_pushmod) + 1); 2058 kmem_free(prop, sizeof (cons_prop_t)); 2059 } 2060 2061 /* 2062 * Boot code can't print to usb serial device. The early boot message 2063 * is saved in a buffer at address indicated by "usb-serial-buf". 2064 * This function flushes the message to the USB serial line 2065 */ 2066 static void 2067 flush_usb_serial_buf(void) 2068 { 2069 int rval; 2070 vnode_t *vp; 2071 uint_t usbser_buf; 2072 char *kc, *bc, *usbser_kern_buf; 2073 2074 usbser_buf = ddi_prop_get_int(DDI_DEV_T_ANY, ddi_root_node(), 2075 DDI_PROP_DONTPASS, "usb-serial-buf", 0); 2076 2077 if (usbser_buf == 0) 2078 return; 2079 2080 /* 2081 * After consconfig() and before userland opens /dev/sysmsg, 2082 * console I/O is goes to polled I/O entry points. 2083 * 2084 * If usb-serial doesn't implement polled I/O, we need 2085 * to open /dev/console now to get kernel console I/O to work. 2086 * We also push ttcompat and ldterm explicitly to get the 2087 * correct output format (autopush isn't set up yet). We 2088 * ignore push errors because they are non-fatal. 2089 * Note that opening /dev/console causes rconsvp to be 2090 * opened as well. 2091 */ 2092 if (cons_polledio == NULL) { 2093 if (vn_open("/dev/console", UIO_SYSSPACE, FWRITE | FNOCTTY, 2094 0, &vp, 0, 0) != 0) 2095 return; 2096 2097 if (rconsvp) { 2098 (void) strioctl(rconsvp, __I_PUSH_NOCTTY, 2099 (intptr_t)"ldterm", FKIOCTL, K_TO_K, kcred, &rval); 2100 (void) strioctl(rconsvp, __I_PUSH_NOCTTY, 2101 (intptr_t)"ttcompat", FKIOCTL, K_TO_K, 2102 kcred, &rval); 2103 } 2104 } 2105 2106 /* 2107 * Copy message to a kernel buffer. Various kernel routines 2108 * expect buffer to be above kernelbase 2109 */ 2110 kc = usbser_kern_buf = (char *)kmem_zalloc(MMU_PAGESIZE, KM_SLEEP); 2111 bc = (char *)(uintptr_t)usbser_buf; 2112 while (*kc++ = *bc++) 2113 ; 2114 console_printf("%s", usbser_kern_buf); 2115 2116 kmem_free(usbser_kern_buf, MMU_PAGESIZE); 2117 } 2118 2119 boolean_t 2120 consconfig_console_is_tipline(void) 2121 { 2122 cons_state_t *sp; 2123 2124 if ((sp = (cons_state_t *)space_fetch("consconfig")) == NULL) 2125 return (B_FALSE); 2126 2127 if (sp->cons_input_type == CONSOLE_TIP) 2128 return (B_TRUE); 2129 2130 return (B_FALSE); 2131 } 2132