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