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