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 (c) 1987, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2019 Toomas Soome <tsoome@me.com> 25 * Copyright 2019 Joyent, Inc. 26 */ 27 28 /* 29 * "Workstation console" multiplexor driver for Sun. 30 * 31 * Sends output to the primary frame buffer using the PROM monitor; 32 * gets input from a stream linked below us that is the "keyboard 33 * driver", below which is linked the primary keyboard. 34 */ 35 36 /* 37 * Locking Policy: 38 * This module has a D_MTPERMOD inner perimeter which means STREAMS 39 * only allows one thread to enter this module through STREAMS entry 40 * points each time -- open() close() put() srv() qtimeout(). 41 * So for the most time we do not need locking in this module, but with 42 * the following exceptions: 43 * 44 * - wc shares three global variables (wc_dip, vc_active_console, 45 * vc_cons_user, vc_avl_root) with virtual console devname part 46 * (fs/dev/sdev_vtops.c) which get compiled into genunix. 47 * 48 * - wc_modechg_cb() is a callback function which will triggered when 49 * framebuffer display mode is changed. 50 * 51 * - vt_send_hotkeys() is triggered by timeout() which is not STREAMS MT 52 * safe. 53 * 54 * Based on the fact that virtual console devname part and wc_modechg_cb() 55 * only do read access to the above mentioned shared four global variables, 56 * It is safe to do locking this way: 57 * 1) all read access to the four global variables in THIS WC MODULE do not 58 * need locking; 59 * 2) all write access to the four global variables in THIS WC MODULE must 60 * hold vc_lock; 61 * 3) any access to the four global variables in either DEVNAME PART or the 62 * CALLBACK must hold vc_lock; 63 * 4) other global variables which are only shared in this wc module and only 64 * accessible through STREAMS entry points such as "vc_last_console", 65 * "vc_inuse_max_minor", "vc_target_console" and "vc_waitactive_list" 66 * do not need explict locking. 67 * 68 * wc_modechg_cb() does read access to vc_state_t::vc_flags, 69 * vc_state_t::vc_state_lock is used to protect concurrently accesses to 70 * vc_state_t::vc_flags which may happen from both through STREAMS entry 71 * points and wc_modechg_cb(). 72 * Since wc_modechg_cb() only does read access to vc_state_t::vc_flags, 73 * The other parts of wc module (except wc_modechg_cb()) only has to hold 74 * vc_state_t::vc_flags when writing to vc_state_t::vc_flags. 75 * 76 * vt_send_hotkeys() could access vt_pending_vtno at the same time with 77 * the rest of wc module, vt_pending_vtno_lock is used to protect 78 * vt_pending_vtno. 79 * 80 * Lock order: vc_lock -> vc_state_t::vc_state_lock. 81 * No overlap between vc_lock and vt_pending_vtno_lock. 82 */ 83 84 #include <sys/types.h> 85 #include <sys/param.h> 86 #include <sys/signal.h> 87 #include <sys/cred.h> 88 #include <sys/vnode.h> 89 #include <sys/termios.h> 90 #include <sys/termio.h> 91 #include <sys/ttold.h> 92 #include <sys/stropts.h> 93 #include <sys/stream.h> 94 #include <sys/strsun.h> 95 #include <sys/tty.h> 96 #include <sys/buf.h> 97 #include <sys/uio.h> 98 #include <sys/stat.h> 99 #include <sys/sysmacros.h> 100 #include <sys/errno.h> 101 #include <sys/proc.h> 102 #include <sys/procset.h> 103 #include <sys/fault.h> 104 #include <sys/siginfo.h> 105 #include <sys/debug.h> 106 #include <sys/session.h> 107 #include <sys/kmem.h> 108 #include <sys/cpuvar.h> 109 #include <sys/kbio.h> 110 #include <sys/strredir.h> 111 #include <sys/fs/snode.h> 112 #include <sys/consdev.h> 113 #include <sys/conf.h> 114 #include <sys/cmn_err.h> 115 #include <sys/console.h> 116 #include <sys/promif.h> 117 #include <sys/note.h> 118 #include <sys/polled_io.h> 119 #include <sys/systm.h> 120 #include <sys/ddi.h> 121 #include <sys/sunddi.h> 122 #include <sys/sunndi.h> 123 #include <sys/esunddi.h> 124 #include <sys/sunldi.h> 125 #include <sys/debug.h> 126 #include <sys/console.h> 127 #include <sys/ddi_impldefs.h> 128 #include <sys/policy.h> 129 #include <sys/modctl.h> 130 #include <sys/tem.h> 131 #include <sys/wscons.h> 132 #include <sys/vt_impl.h> 133 134 /* streams stuff */ 135 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", copyreq)) 136 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", copyresp)) 137 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", datab)) 138 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", iocblk)) 139 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", msgb)) 140 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", queue)) 141 142 #define MINLINES 10 143 #define MAXLINES 48 144 #define LOSCREENLINES 34 145 #define HISCREENLINES 48 146 147 #define MINCOLS 10 148 #define MAXCOLS 120 149 #define LOSCREENCOLS 80 150 #define HISCREENCOLS 120 151 152 struct wscons_state { 153 dev_t wc_dev; /* major/minor for this device */ 154 #ifdef _HAVE_TEM_FIRMWARE 155 int wc_defer_output; /* set if output device is "slow" */ 156 #endif /* _HAVE_TEM_FIRMWARE */ 157 queue_t *wc_kbdqueue; /* "console keyboard" device queue */ 158 /* below us */ 159 cons_polledio_t wc_polledio; /* polled I/O function pointers */ 160 cons_polledio_t *wc_kb_polledio; /* keyboard's polledio */ 161 unsigned int wc_kb_getpolledio_id; /* id for kb CONSOPENPOLLEDIO */ 162 queue_t *wc_pending_wq; 163 mblk_t *wc_pending_link; /* I_PLINK pending for kb polledio */ 164 } wscons; 165 166 /* 167 * This module has a D_MTPERMOD inner perimeter, so we don't need to protect 168 * the variables only shared within this module 169 */ 170 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", wscons)) 171 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", wscons_state)) 172 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vt_stat)) 173 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vc_waitactive_msg)) 174 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", tty_common)) 175 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vt_mode)) 176 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vt_dispinfo)) 177 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", winsize)) 178 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", vc_last_console)) 179 180 #ifdef _HAVE_TEM_FIRMWARE 181 ssize_t wc_cons_wrtvec(promif_redir_arg_t arg, uchar_t *s, size_t n); 182 #endif /* _HAVE_TEM_FIRMWARE */ 183 184 static int wcopen(queue_t *, dev_t *, int, int, cred_t *); 185 static int wcclose(queue_t *, int, cred_t *); 186 static int wcuwsrv(queue_t *); 187 static int wcuwput(queue_t *, mblk_t *); 188 static int wclrput(queue_t *, mblk_t *); 189 190 static struct module_info wcm_info = { 191 0, 192 "wc", 193 0, 194 INFPSZ, 195 2048, 196 128 197 }; 198 199 static struct qinit wcurinit = { 200 putq, 201 NULL, 202 wcopen, 203 wcclose, 204 NULL, 205 &wcm_info, 206 NULL 207 }; 208 209 static struct qinit wcuwinit = { 210 wcuwput, 211 wcuwsrv, 212 wcopen, 213 wcclose, 214 NULL, 215 &wcm_info, 216 NULL 217 }; 218 219 static struct qinit wclrinit = { 220 wclrput, 221 NULL, 222 NULL, 223 NULL, 224 NULL, 225 &wcm_info, 226 NULL 227 }; 228 229 /* 230 * We always putnext directly to the underlying queue. 231 */ 232 static struct qinit wclwinit = { 233 NULL, 234 NULL, 235 NULL, 236 NULL, 237 NULL, 238 &wcm_info, 239 NULL 240 }; 241 242 static struct streamtab wcinfo = { 243 &wcurinit, 244 &wcuwinit, 245 &wclrinit, 246 &wclwinit, 247 }; 248 249 static int wc_info(dev_info_t *, ddi_info_cmd_t, void *, void **result); 250 static int wc_attach(dev_info_t *, ddi_attach_cmd_t); 251 252 DDI_DEFINE_STREAM_OPS(wc_ops, nulldev, nulldev, wc_attach, nodev, nodev, 253 wc_info, D_MTPERMOD | D_MP, &wcinfo, ddi_quiesce_not_supported); 254 255 static void wcreioctl(void *); 256 static void wcioctl(queue_t *, mblk_t *); 257 #ifdef _HAVE_TEM_FIRMWARE 258 static void wcopoll(void *); 259 #endif /* _HAVE_TEM_FIRMWARE */ 260 static void wcrstrt(void *); 261 static void wc_open_kb_polledio(struct wscons_state *wc, queue_t *q, 262 mblk_t *mp); 263 static void wc_close_kb_polledio(struct wscons_state *wc, queue_t *q, 264 mblk_t *mp); 265 static void wc_polled_putchar(cons_polledio_arg_t arg, 266 unsigned char c); 267 static boolean_t wc_polled_ischar(cons_polledio_arg_t arg); 268 static int wc_polled_getchar(cons_polledio_arg_t arg); 269 static void wc_polled_enter(cons_polledio_arg_t arg); 270 static void wc_polled_exit(cons_polledio_arg_t arg); 271 void wc_get_size(vc_state_t *pvc); 272 static void wc_modechg_cb(tem_modechg_cb_arg_t arg); 273 static tem_vt_state_t wc_get_screen_tem(vc_state_t *); 274 275 static struct dev_ops wc_ops; 276 277 /* 278 * Debug printing 279 */ 280 #ifndef DPRINTF 281 #ifdef DEBUG 282 /*PRINTFLIKE1*/ 283 static void wc_dprintf(const char *fmt, ...) __KPRINTFLIKE(1); 284 #define DPRINTF(l, m, args) \ 285 (((l) >= wc_errlevel) && ((m) & wc_errmask) ? \ 286 wc_dprintf args : \ 287 (void) 0) 288 /* 289 * Severity levels for printing 290 */ 291 #define PRINT_L0 0 /* print every message */ 292 #define PRINT_L1 1 /* debug */ 293 #define PRINT_L2 2 /* quiet */ 294 295 /* 296 * Masks 297 */ 298 #define PRINT_MASK_ALL 0xFFFFFFFFU 299 uint_t wc_errmask = PRINT_MASK_ALL; 300 uint_t wc_errlevel = PRINT_L2; 301 302 #else 303 #define DPRINTF(l, m, args) /* NOTHING */ 304 #endif 305 #endif 306 307 /* 308 * Module linkage information for the kernel. 309 */ 310 static struct modldrv modldrv = { 311 &mod_driverops, /* Type of module. This one is a pseudo driver */ 312 "Workstation multiplexer Driver 'wc'", 313 &wc_ops, /* driver ops */ 314 }; 315 316 static struct modlinkage modlinkage = { 317 MODREV_1, 318 &modldrv, 319 NULL 320 }; 321 322 int 323 _init(void) 324 { 325 int rc; 326 if ((rc = mod_install(&modlinkage)) == 0) 327 vt_init(); 328 return (rc); 329 } 330 331 int 332 _fini(void) 333 { 334 return (mod_remove(&modlinkage)); 335 } 336 337 int 338 _info(struct modinfo *modinfop) 339 { 340 return (mod_info(&modlinkage, modinfop)); 341 } 342 343 /*ARGSUSED*/ 344 static int 345 wc_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 346 { 347 /* create minor node for workstation hard console */ 348 if (ddi_create_minor_node(devi, "wscons", S_IFCHR, 349 0, DDI_PSEUDO, 0) == DDI_FAILURE) { 350 ddi_remove_minor_node(devi, NULL); 351 return (DDI_FAILURE); 352 } 353 354 mutex_enter(&vc_lock); 355 356 wc_dip = devi; 357 358 bzero(&(wscons.wc_polledio), sizeof (wscons.wc_polledio)); 359 360 vt_resize(VC_DEFAULT_COUNT); 361 362 mutex_exit(&vc_lock); 363 364 return (DDI_SUCCESS); 365 } 366 367 /* ARGSUSED */ 368 static int 369 wc_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 370 void **result) 371 { 372 int error; 373 374 switch (infocmd) { 375 case DDI_INFO_DEVT2DEVINFO: 376 if (wc_dip == NULL) { 377 error = DDI_FAILURE; 378 } else { 379 *result = (void *) wc_dip; 380 error = DDI_SUCCESS; 381 } 382 break; 383 case DDI_INFO_DEVT2INSTANCE: 384 *result = (void *)0; 385 error = DDI_SUCCESS; 386 break; 387 default: 388 error = DDI_FAILURE; 389 } 390 return (error); 391 } 392 393 static void 394 wc_init_polledio(void) 395 { 396 static boolean_t polledio_inited = B_FALSE; 397 _NOTE(SCHEME_PROTECTS_DATA("D_MTPERMOD protected data", 398 polledio_inited)) 399 400 if (polledio_inited) 401 return; 402 403 polledio_inited = B_TRUE; 404 405 /* 406 * Initialize the parts of the polled I/O struct that 407 * are common to both input and output modes, but which 408 * don't flag to the upper layers, which if any of the 409 * two modes are available. We don't know at this point 410 * if system is configured CONS_KFB, but we will when 411 * consconfig_dacf asks us with CONSOPENPOLLED I/O. 412 */ 413 bzero(&(wscons.wc_polledio), sizeof (wscons.wc_polledio)); 414 wscons.wc_polledio.cons_polledio_version = 415 CONSPOLLEDIO_V0; 416 wscons.wc_polledio.cons_polledio_argument = 417 (cons_polledio_arg_t)&wscons; 418 wscons.wc_polledio.cons_polledio_enter = 419 wc_polled_enter; 420 wscons.wc_polledio.cons_polledio_exit = 421 wc_polled_exit; 422 423 #ifdef _HAVE_TEM_FIRMWARE 424 /* 425 * If we're talking directly to a framebuffer, we assume 426 * that it's a "slow" device, so that rendering should 427 * be deferred to a timeout or softcall so that we write 428 * a bunch of characters at once. 429 */ 430 wscons.wc_defer_output = prom_stdout_is_framebuffer(); 431 #endif /* _HAVE_TEM_FIRMWARE */ 432 } 433 434 /*ARGSUSED*/ 435 static int 436 wcopen(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *crp) 437 { 438 int minor; 439 440 wc_init_polledio(); 441 minor = (int)getminor(*devp); 442 return (vt_open(minor, q, crp)); 443 } 444 445 /*ARGSUSED*/ 446 static int 447 wcclose(queue_t *q, int flag, cred_t *crp) 448 { 449 vc_state_t *pvc = (vc_state_t *)q->q_ptr; 450 451 qprocsoff(q); 452 453 mutex_enter(&vc_lock); 454 455 /* 456 * If we are closing the VT node which 457 * /dev/vt/console_user points to, revert 458 * /dev/vt/console to /dev/console 459 */ 460 if (vc_cons_user == pvc->vc_minor) 461 vc_cons_user = VT_MINOR_INVALID; 462 463 if (pvc->vc_minor == 0 || pvc->vc_minor == vc_active_console) { 464 465 /* 466 * If we lose the system console, 467 * no any other active consoles. 468 */ 469 if (pvc->vc_minor == 0 && pvc->vc_minor == vc_active_console) { 470 vc_active_console = VT_MINOR_INVALID; 471 vc_last_console = VT_MINOR_INVALID; 472 } 473 474 /* 475 * just clean for our primary console 476 * and active console 477 */ 478 mutex_enter(&pvc->vc_state_lock); 479 vt_clean(q, pvc); 480 mutex_exit(&pvc->vc_state_lock); 481 482 mutex_exit(&vc_lock); 483 484 return (0); 485 } 486 vt_close(q, pvc, crp); 487 488 mutex_exit(&vc_lock); 489 490 return (0); 491 } 492 493 /* 494 * Service procedure for upper write queue. 495 * We need to have service procedure to make sure the keyboard events 496 * are queued up for screen output and are not dependant on the screen 497 * updates. 498 */ 499 static int 500 wcuwsrv(queue_t *q) 501 { 502 vc_state_t *pvc = (vc_state_t *)q->q_ptr; 503 tem_vt_state_t ptem = NULL; 504 mblk_t *mp; 505 ssize_t cc; 506 507 while ((mp = getq(q)) != NULL) { 508 /* 509 * If we're waiting for something to happen (delay timeout to 510 * expire, current transmission to finish, output to be 511 * restarted, output to finish draining), don't grab anything 512 * new. 513 */ 514 if (pvc->vc_flags & (WCS_DELAY|WCS_BUSY|WCS_STOPPED)) { 515 (void) putbq(q, mp); 516 return (0); 517 } 518 519 switch (mp->b_datap->db_type) { 520 default: /* drop unknown type */ 521 freemsg(mp); 522 continue; 523 524 case M_IOCTL: 525 wcioctl(q, mp); 526 continue; 527 528 case M_DELAY: 529 /* 530 * Arrange for "wcrstrt" to be called when the 531 * delay expires; it will turn WCS_DELAY off. 532 */ 533 if (pvc->vc_timeoutid != 0) 534 (void) quntimeout(q, pvc->vc_timeoutid); 535 pvc->vc_timeoutid = qtimeout(q, wcrstrt, pvc, 536 (clock_t)(*(unsigned char *)mp->b_rptr + 6)); 537 538 mutex_enter(&pvc->vc_state_lock); 539 pvc->vc_flags |= WCS_DELAY; 540 mutex_exit(&pvc->vc_state_lock); 541 542 freemsg(mp); 543 continue; 544 545 case M_DATA: 546 break; 547 } 548 549 if ((cc = mp->b_wptr - mp->b_rptr) == 0) { 550 freemsg(mp); 551 continue; 552 } 553 554 #ifdef _HAVE_TEM_FIRMWARE 555 if (consmode == CONS_KFB) { 556 #endif /* _HAVE_TEM_FIRMWARE */ 557 ptem = wc_get_screen_tem(pvc); 558 559 if (ptem == NULL) { 560 freemsg(mp); 561 continue; 562 } 563 564 for (mblk_t *nbp = mp; nbp != NULL; nbp = nbp->b_cont) { 565 cc = nbp->b_wptr - nbp->b_rptr; 566 567 if (cc <= 0) 568 continue; 569 570 tem_write(ptem, nbp->b_rptr, cc, kcred); 571 } 572 freemsg(mp); 573 #ifdef _HAVE_TEM_FIRMWARE 574 continue; 575 } 576 577 /* consmode = CONS_FW */ 578 if (pvc->vc_minor != 0) { 579 freemsg(mp); 580 continue; 581 } 582 583 /* 584 * Direct output to the frame buffer if this device 585 * is not the "hardware" console. 586 */ 587 if (wscons.wc_defer_output) { 588 mutex_enter(&pvc->vc_state_lock); 589 pvc->vc_flags |= WCS_BUSY; 590 mutex_exit(&pvc->vc_state_lock); 591 592 pvc->vc_pendc = -1; 593 594 for (mblk_t *nbp = mp; nbp != NULL; nbp = nbp->b_cont) { 595 cc = nbp->b_wptr - nbp->b_rptr; 596 597 if (cc <= 0) 598 continue; 599 600 console_puts((const char *)nbp->b_rptr, cc); 601 } 602 freemsg(mp); 603 mutex_enter(&pvc->vc_state_lock); 604 pvc->vc_flags &= ~WCS_BUSY; 605 mutex_exit(&pvc->vc_state_lock); 606 continue; 607 } 608 for (boolean_t done = B_FALSE; done != B_TRUE; ) { 609 int c; 610 611 c = *mp->b_rptr++; 612 cc--; 613 if (prom_mayput((char)c) != 0) { 614 615 mutex_enter(&pvc->vc_state_lock); 616 pvc->vc_flags |= WCS_BUSY; 617 mutex_exit(&pvc->vc_state_lock); 618 619 pvc->vc_pendc = c; 620 if (pvc->vc_timeoutid != 0) 621 (void) quntimeout(q, 622 pvc->vc_timeoutid); 623 pvc->vc_timeoutid = qtimeout(q, wcopoll, 624 pvc, 1); 625 if (mp != NULL) { 626 /* not done with this message yet */ 627 (void) putbq(q, mp); 628 return (0); 629 } 630 break; 631 } 632 while (cc <= 0) { 633 mblk_t *nbp = mp; 634 mp = mp->b_cont; 635 freeb(nbp); 636 if (mp == NULL) { 637 done = B_TRUE; 638 break; 639 } 640 /* LINTED E_PTRDIFF_OVERFLOW */ 641 cc = mp->b_wptr - mp->b_rptr; 642 } 643 } 644 #endif /* _HAVE_TEM_FIRMWARE */ 645 } 646 return (0); 647 } 648 649 /* 650 * Put procedure for upper write queue. 651 * Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here; 652 * queue up M_BREAK, M_DELAY, and M_DATA messages for processing by 653 * the service routine. Discard everything else. 654 */ 655 static int 656 wcuwput(queue_t *q, mblk_t *mp) 657 { 658 vc_state_t *pvc = (vc_state_t *)q->q_ptr; 659 660 switch (mp->b_datap->db_type) { 661 662 case M_STOP: 663 mutex_enter(&pvc->vc_state_lock); 664 pvc->vc_flags |= WCS_STOPPED; 665 mutex_exit(&pvc->vc_state_lock); 666 667 freemsg(mp); 668 break; 669 670 case M_START: 671 mutex_enter(&pvc->vc_state_lock); 672 pvc->vc_flags &= ~WCS_STOPPED; 673 mutex_exit(&pvc->vc_state_lock); 674 675 qenable(q); 676 freemsg(mp); 677 break; 678 679 case M_IOCTL: { 680 struct iocblk *iocp; 681 struct linkblk *linkp; 682 683 iocp = (struct iocblk *)(void *)mp->b_rptr; 684 switch (iocp->ioc_cmd) { 685 686 case I_LINK: /* stupid, but permitted */ 687 case I_PLINK: 688 if (wscons.wc_kbdqueue != NULL) { 689 /* somebody already linked */ 690 miocnak(q, mp, 0, EINVAL); 691 return (0); 692 } 693 linkp = (struct linkblk *)(void *)mp->b_cont->b_rptr; 694 wscons.wc_kbdqueue = WR(linkp->l_qbot); 695 mp->b_datap->db_type = M_IOCACK; 696 iocp->ioc_count = 0; 697 wc_open_kb_polledio(&wscons, q, mp); 698 break; 699 700 case I_UNLINK: /* stupid, but permitted */ 701 case I_PUNLINK: 702 linkp = (struct linkblk *)(void *)mp->b_cont->b_rptr; 703 if (wscons.wc_kbdqueue != WR(linkp->l_qbot)) { 704 /* not us */ 705 miocnak(q, mp, 0, EINVAL); 706 return (0); 707 } 708 709 mp->b_datap->db_type = M_IOCACK; 710 iocp->ioc_count = 0; 711 wc_close_kb_polledio(&wscons, q, mp); 712 break; 713 714 case TCSETSW: 715 case TCSETSF: 716 case TCSETAW: 717 case TCSETAF: 718 case TCSBRK: 719 /* 720 * The changes do not take effect until all 721 * output queued before them is drained. 722 * Put this message on the queue, so that 723 * "wcuwsrv" will see it when it's done 724 * with the output before it. 725 */ 726 if (putq(q, mp) == 0) 727 freemsg(mp); 728 break; 729 730 case CONSSETABORTENABLE: 731 case CONSGETABORTENABLE: 732 case KIOCSDIRECT: 733 if (wscons.wc_kbdqueue != NULL) { 734 wscons.wc_pending_wq = q; 735 (void) putnext(wscons.wc_kbdqueue, mp); 736 break; 737 } 738 /* fall through */ 739 740 default: 741 /* 742 * Do it now. 743 */ 744 wcioctl(q, mp); 745 break; 746 } 747 break; 748 } 749 750 case M_FLUSH: 751 if (*mp->b_rptr & FLUSHW) { 752 /* 753 * Flush our write queue. 754 */ 755 flushq(q, FLUSHDATA); /* XXX doesn't flush M_DELAY */ 756 *mp->b_rptr &= ~FLUSHW; /* it has been flushed */ 757 } 758 if (*mp->b_rptr & FLUSHR) { 759 flushq(RD(q), FLUSHDATA); 760 qreply(q, mp); /* give the read queues a crack at it */ 761 } else 762 freemsg(mp); 763 break; 764 765 case M_BREAK: 766 /* 767 * Ignore these, as they make no sense. 768 */ 769 freemsg(mp); 770 break; 771 772 case M_DELAY: 773 case M_DATA: 774 /* 775 * Queue the message up to be transmitted. 776 */ 777 if (putq(q, mp) == 0) 778 freemsg(mp); 779 break; 780 781 case M_IOCDATA: 782 vt_miocdata(q, mp); 783 break; 784 785 default: 786 /* 787 * "No, I don't want a subscription to Chain Store Age, 788 * thank you anyway." 789 */ 790 freemsg(mp); 791 break; 792 } 793 794 return (0); 795 } 796 797 /* 798 * Retry an "ioctl", now that "qbufcall" claims we may be able to allocate 799 * the buffer we need. 800 */ 801 /*ARGSUSED*/ 802 static void 803 wcreioctl(void *arg) 804 { 805 vc_state_t *pvc = (vc_state_t *)arg; 806 queue_t *q; 807 mblk_t *mp; 808 809 pvc->vc_bufcallid = 0; 810 q = pvc->vc_ttycommon.t_writeq; 811 if ((mp = pvc->vc_ttycommon.t_iocpending) != NULL) { 812 /* not pending any more */ 813 pvc->vc_ttycommon.t_iocpending = NULL; 814 wcioctl(q, mp); 815 } 816 } 817 818 static int 819 wc_getterm(mblk_t *mp) 820 { 821 char *term; 822 intptr_t arg; 823 int flag = ((struct iocblk *)(void *)mp->b_rptr)->ioc_flag; 824 825 STRUCT_DECL(cons_getterm, wcterm); 826 STRUCT_INIT(wcterm, flag); 827 828 arg = *((intptr_t *)(void *)mp->b_cont->b_rptr); 829 830 if (ddi_copyin((void *)arg, STRUCT_BUF(wcterm), 831 STRUCT_SIZE(wcterm), flag) != 0) { 832 return (EFAULT); 833 } 834 835 if (consmode == CONS_FW) { 836 /* PROM terminal emulator */ 837 term = "sun"; 838 } else { 839 /* Kernel terminal emulator */ 840 ASSERT(consmode == CONS_KFB); 841 term = "sun-color"; 842 } 843 844 if (STRUCT_FGET(wcterm, cn_term_len) < 845 strlen(term) + 1) { 846 return (EOVERFLOW); 847 } 848 849 if (ddi_copyout(term, 850 STRUCT_FGETP(wcterm, cn_term_type), 851 strlen(term) + 1, flag) != 0) { 852 return (EFAULT); 853 } 854 855 return (0); 856 } 857 858 /* 859 * Process an "ioctl" message sent down to us. 860 */ 861 static void 862 wcioctl(queue_t *q, mblk_t *mp) 863 { 864 vc_state_t *pvc = (vc_state_t *)q->q_ptr; 865 struct iocblk *iocp; 866 size_t datasize; 867 int error; 868 long len; 869 870 iocp = (struct iocblk *)(void *)mp->b_rptr; 871 872 if ((iocp->ioc_cmd & VTIOC) == VTIOC || 873 (iocp->ioc_cmd & KDIOC) == KDIOC) { 874 vt_ioctl(q, mp); 875 return; 876 } 877 878 switch (iocp->ioc_cmd) { 879 case TIOCSWINSZ: 880 /* 881 * Ignore all attempts to set the screen size; the 882 * value in the EEPROM is guaranteed (modulo PROM bugs) 883 * to be the value used by the PROM monitor code, so it 884 * is by definition correct. Many programs (e.g., 885 * "login" and "tset") will attempt to reset the size 886 * to (0, 0) or (34, 80), neither of which is 887 * necessarily correct. 888 * We just ACK the message, so as not to disturb 889 * programs that set the sizes. 890 */ 891 iocp->ioc_count = 0; /* no data returned */ 892 mp->b_datap->db_type = M_IOCACK; 893 qreply(q, mp); 894 return; 895 896 case CONSOPENPOLLEDIO: 897 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 898 ("wcioctl: CONSOPENPOLLEDIO\n")); 899 900 error = miocpullup(mp, sizeof (struct cons_polledio *)); 901 if (error != 0) { 902 miocnak(q, mp, 0, error); 903 return; 904 } 905 906 /* 907 * We are given an appropriate-sized data block, 908 * and return a pointer to our structure in it. 909 */ 910 if (consmode == CONS_KFB) 911 wscons.wc_polledio.cons_polledio_putchar = 912 wc_polled_putchar; 913 *(struct cons_polledio **)(void *)mp->b_cont->b_rptr = 914 &wscons.wc_polledio; 915 916 mp->b_datap->db_type = M_IOCACK; 917 918 qreply(q, mp); 919 break; 920 921 case CONS_GETTERM: 922 if ((error = wc_getterm(mp)) != 0) 923 miocnak(q, mp, 0, error); 924 else 925 miocack(q, mp, 0, 0); 926 return; 927 928 case WC_OPEN_FB: 929 /* 930 * Start out pessimistic, so that we can just jump to 931 * the reply to bail out. 932 */ 933 mp->b_datap->db_type = M_IOCNAK; 934 935 /* 936 * First test: really, this should be done only from 937 * inside the kernel. Unfortunately, that information 938 * doesn't seem to be available in a streams ioctl, 939 * so restrict it to root only. (Perhaps we could check 940 * for ioc_cr == kcred.) 941 */ 942 if ((iocp->ioc_error = secpolicy_console(iocp->ioc_cr)) != 0) 943 goto open_fail; 944 945 /* 946 * Some miscellaneous checks... 947 */ 948 iocp->ioc_error = EINVAL; 949 950 /* 951 * If we don't have exactly one continuation block, fail. 952 */ 953 if (mp->b_cont == NULL || 954 mp->b_cont->b_cont != NULL) 955 goto open_fail; 956 957 /* 958 * If there's no null terminator in the string, fail. 959 */ 960 /* LINTED E_PTRDIFF_OVERFLOW */ 961 len = mp->b_cont->b_wptr - mp->b_cont->b_rptr; 962 if (memchr(mp->b_cont->b_rptr, 0, len) == NULL) 963 goto open_fail; 964 965 /* 966 * NOTE: should eventually get default 967 * dimensions from a property, e.g. screen-#rows. 968 */ 969 iocp->ioc_error = tem_info_init((char *)mp->b_cont->b_rptr, 970 iocp->ioc_cr); 971 /* 972 * Of course, if the terminal emulator initialization 973 * failed, fail. 974 */ 975 if (iocp->ioc_error != 0) 976 goto open_fail; 977 978 #ifdef _HAVE_TEM_FIRMWARE 979 if (prom_stdout_is_framebuffer()) { 980 /* 981 * Drivers in the console stream may emit additional 982 * messages before we are ready. This causes text 983 * overwrite on the screen. So we set the redirection 984 * here. It is safe because the ioctl in consconfig_dacf 985 * will succeed and consmode will be set to CONS_KFB. 986 */ 987 prom_set_stdout_redirect(wc_cons_wrtvec, 988 (promif_redir_arg_t)NULL); 989 990 } 991 #endif /* _HAVE_TEM_FIRMWARE */ 992 993 tem_register_modechg_cb(wc_modechg_cb, 994 (tem_modechg_cb_arg_t)&wscons); 995 996 /* 997 * ... and succeed. 998 */ 999 mp->b_datap->db_type = M_IOCACK; 1000 1001 open_fail: 1002 qreply(q, mp); 1003 break; 1004 1005 case WC_CLOSE_FB: 1006 /* 1007 * There's nothing that can call this, so it's not 1008 * really implemented. 1009 */ 1010 mp->b_datap->db_type = M_IOCNAK; 1011 /* 1012 * However, if it were implemented, it would clearly 1013 * be root-only. 1014 */ 1015 if ((iocp->ioc_error = secpolicy_console(iocp->ioc_cr)) != 0) 1016 goto close_fail; 1017 1018 iocp->ioc_error = EINVAL; 1019 1020 close_fail: 1021 qreply(q, mp); 1022 break; 1023 1024 default: 1025 1026 /* 1027 * The only way in which "ttycommon_ioctl" can fail is 1028 * if the "ioctl" requires a response containing data 1029 * to be returned to the user, and no mblk could be 1030 * allocated for the data. No such "ioctl" alters our 1031 * state. Thus, we always go ahead and do any 1032 * state-changes the "ioctl" calls for. If we couldn't 1033 * allocate the data, "ttycommon_ioctl" has stashed the 1034 * "ioctl" away safely, so we just call "qbufcall" to 1035 * request that we be called back when we stand a 1036 * better chance of allocating the data. 1037 */ 1038 datasize = ttycommon_ioctl(&pvc->vc_ttycommon, q, mp, &error); 1039 if (datasize != 0) { 1040 if (pvc->vc_bufcallid != 0) 1041 qunbufcall(q, pvc->vc_bufcallid); 1042 pvc->vc_bufcallid = qbufcall(q, datasize, BPRI_HI, 1043 wcreioctl, pvc); 1044 return; 1045 } 1046 1047 if (error < 0) { 1048 if (iocp->ioc_cmd == TCSBRK) 1049 error = 0; 1050 else 1051 error = EINVAL; 1052 } 1053 if (error != 0) { 1054 iocp->ioc_error = error; 1055 mp->b_datap->db_type = M_IOCNAK; 1056 } 1057 qreply(q, mp); 1058 break; 1059 } 1060 } 1061 1062 /* 1063 * This function gets the polled I/O structures from the lower 1064 * keyboard driver. If any initialization or resource allocation 1065 * needs to be done by the lower driver, it will be done when 1066 * the lower driver services this message. 1067 */ 1068 static void 1069 wc_open_kb_polledio(struct wscons_state *wscons, queue_t *q, mblk_t *mp) 1070 { 1071 mblk_t *mp2; 1072 struct iocblk *iocp; 1073 1074 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 1075 ("wc_open_kb_polledio: sending CONSOPENPOLLEDIO\n")); 1076 1077 mp2 = mkiocb(CONSOPENPOLLEDIO); 1078 1079 if (mp2 == NULL) { 1080 /* 1081 * If we can't get an mblk, then wait for it. 1082 */ 1083 goto nomem; 1084 } 1085 1086 mp2->b_cont = allocb(sizeof (struct cons_polledio *), BPRI_HI); 1087 1088 if (mp2->b_cont == NULL) { 1089 /* 1090 * If we can't get an mblk, then wait for it, and release 1091 * the mblk that we have already allocated. 1092 */ 1093 freemsg(mp2); 1094 goto nomem; 1095 } 1096 1097 iocp = (struct iocblk *)(void *)mp2->b_rptr; 1098 1099 iocp->ioc_count = sizeof (struct cons_polledio *); 1100 mp2->b_cont->b_wptr = mp2->b_cont->b_rptr + 1101 sizeof (struct cons_polledio *); 1102 1103 wscons->wc_pending_wq = q; 1104 wscons->wc_pending_link = mp; 1105 wscons->wc_kb_getpolledio_id = iocp->ioc_id; 1106 1107 putnext(wscons->wc_kbdqueue, mp2); 1108 1109 return; 1110 1111 nomem: 1112 iocp = (struct iocblk *)(void *)mp->b_rptr; 1113 iocp->ioc_error = ENOMEM; 1114 mp->b_datap->db_type = M_IOCNAK; 1115 qreply(q, mp); 1116 } 1117 1118 /* 1119 * This function releases the polled I/O structures from the lower 1120 * keyboard driver. If any de-initialization needs to be done, or 1121 * any resources need to be released, it will be done when the lower 1122 * driver services this message. 1123 */ 1124 static void 1125 wc_close_kb_polledio(struct wscons_state *wscons, queue_t *q, mblk_t *mp) 1126 { 1127 mblk_t *mp2; 1128 struct iocblk *iocp; 1129 1130 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 1131 ("wc_close_kb_polledio: sending CONSCLOSEPOLLEDIO\n")); 1132 1133 mp2 = mkiocb(CONSCLOSEPOLLEDIO); 1134 1135 if (mp2 == NULL) { 1136 /* 1137 * If we can't get an mblk, then wait for it. 1138 */ 1139 goto nomem; 1140 } 1141 1142 mp2->b_cont = allocb(sizeof (struct cons_polledio *), BPRI_HI); 1143 1144 if (mp2->b_cont == NULL) { 1145 /* 1146 * If we can't get an mblk, then wait for it, and release 1147 * the mblk that we have already allocated. 1148 */ 1149 freemsg(mp2); 1150 1151 goto nomem; 1152 } 1153 1154 iocp = (struct iocblk *)(void *)mp2->b_rptr; 1155 1156 iocp->ioc_count = 0; 1157 1158 wscons->wc_pending_wq = q; 1159 wscons->wc_pending_link = mp; 1160 wscons->wc_kb_getpolledio_id = iocp->ioc_id; 1161 1162 putnext(wscons->wc_kbdqueue, mp2); 1163 1164 return; 1165 1166 nomem: 1167 iocp = (struct iocblk *)(void *)mp->b_rptr; 1168 iocp->ioc_error = ENOMEM; 1169 mp->b_datap->db_type = M_IOCNAK; 1170 qreply(q, mp); 1171 } 1172 1173 #ifdef _HAVE_TEM_FIRMWARE 1174 /* ARGSUSED */ 1175 static void 1176 wcopoll(void *arg) 1177 { 1178 vc_state_t *pvc = (vc_state_t *)arg; 1179 queue_t *q; 1180 1181 q = pvc->vc_ttycommon.t_writeq; 1182 pvc->vc_timeoutid = 0; 1183 1184 mutex_enter(&pvc->vc_state_lock); 1185 1186 /* See if we can continue output */ 1187 if ((pvc->vc_flags & WCS_BUSY) && pvc->vc_pendc != -1) { 1188 if (prom_mayput((char)pvc->vc_pendc) == 0) { 1189 pvc->vc_pendc = -1; 1190 pvc->vc_flags &= ~WCS_BUSY; 1191 if (!(pvc->vc_flags&(WCS_DELAY|WCS_STOPPED))) 1192 qenable(q); 1193 } else 1194 pvc->vc_timeoutid = qtimeout(q, wcopoll, pvc, 1); 1195 } 1196 1197 mutex_exit(&pvc->vc_state_lock); 1198 } 1199 #endif /* _HAVE_TEM_FIRMWARE */ 1200 1201 /* 1202 * Restart output on the console after a timeout. 1203 */ 1204 /* ARGSUSED */ 1205 static void 1206 wcrstrt(void *arg) 1207 { 1208 vc_state_t *pvc = (vc_state_t *)arg; 1209 1210 ASSERT(pvc->vc_ttycommon.t_writeq != NULL); 1211 1212 mutex_enter(&pvc->vc_state_lock); 1213 pvc->vc_flags &= ~WCS_DELAY; 1214 mutex_exit(&pvc->vc_state_lock); 1215 1216 qenable(pvc->vc_ttycommon.t_writeq); 1217 } 1218 1219 /* 1220 * get screen terminal for current output 1221 */ 1222 static tem_vt_state_t 1223 wc_get_screen_tem(vc_state_t *pvc) 1224 { 1225 if (!tem_initialized(pvc->vc_tem) || 1226 tem_get_fbmode(pvc->vc_tem) != KD_TEXT) 1227 return (NULL); 1228 1229 return (pvc->vc_tem); 1230 } 1231 1232 /* 1233 * Put procedure for lower read queue. 1234 * Pass everything up to queue above "upper half". 1235 */ 1236 static int 1237 wclrput(queue_t *q, mblk_t *mp) 1238 { 1239 vc_state_t *pvc; 1240 queue_t *upq; 1241 struct iocblk *iocp; 1242 1243 pvc = vt_minor2vc(VT_ACTIVE); 1244 1245 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 1246 ("wclrput: wclrput type = 0x%x\n", mp->b_datap->db_type)); 1247 1248 switch (mp->b_datap->db_type) { 1249 1250 case M_FLUSH: 1251 if (*mp->b_rptr == FLUSHW || *mp->b_rptr == FLUSHRW) { 1252 /* 1253 * Flush our write queue. 1254 */ 1255 /* XXX doesn't flush M_DELAY */ 1256 flushq(WR(q), FLUSHDATA); 1257 *mp->b_rptr = FLUSHR; /* it has been flushed */ 1258 } 1259 if (*mp->b_rptr == FLUSHR || *mp->b_rptr == FLUSHRW) { 1260 flushq(q, FLUSHDATA); 1261 *mp->b_rptr = FLUSHW; /* it has been flushed */ 1262 qreply(q, mp); /* give the read queues a crack at it */ 1263 } else 1264 freemsg(mp); 1265 break; 1266 1267 case M_DATA: 1268 if (consmode == CONS_KFB && vt_check_hotkeys(mp)) { 1269 freemsg(mp); 1270 break; 1271 } 1272 1273 if ((upq = pvc->vc_ttycommon.t_readq) != NULL) { 1274 if (!canput(upq->q_next)) { 1275 ttycommon_qfull(&pvc->vc_ttycommon, upq); 1276 qenable(WR(upq)); 1277 freemsg(mp); 1278 } else { 1279 putnext(upq, mp); 1280 } 1281 } else 1282 freemsg(mp); 1283 break; 1284 1285 case M_IOCACK: 1286 case M_IOCNAK: 1287 iocp = (struct iocblk *)(void *)mp->b_rptr; 1288 if (wscons.wc_pending_link != NULL && 1289 iocp->ioc_id == wscons.wc_kb_getpolledio_id) { 1290 switch (mp->b_datap->db_type) { 1291 1292 case M_IOCACK: 1293 switch (iocp->ioc_cmd) { 1294 1295 case CONSOPENPOLLEDIO: 1296 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 1297 ("wclrput: " 1298 "ACK CONSOPENPOLLEDIO\n")); 1299 wscons.wc_kb_polledio = 1300 *(struct cons_polledio **) 1301 (void *)mp->b_cont->b_rptr; 1302 wscons.wc_polledio. 1303 cons_polledio_getchar = 1304 wc_polled_getchar; 1305 wscons.wc_polledio. 1306 cons_polledio_ischar = 1307 wc_polled_ischar; 1308 break; 1309 1310 case CONSCLOSEPOLLEDIO: 1311 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 1312 ("wclrput: " 1313 "ACK CONSCLOSEPOLLEDIO\n")); 1314 wscons.wc_kb_polledio = NULL; 1315 wscons.wc_kbdqueue = NULL; 1316 wscons.wc_polledio. 1317 cons_polledio_getchar = NULL; 1318 wscons.wc_polledio. 1319 cons_polledio_ischar = NULL; 1320 break; 1321 default: 1322 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 1323 ("wclrput: " 1324 "ACK UNKNOWN\n")); 1325 } 1326 1327 break; 1328 case M_IOCNAK: 1329 /* 1330 * Keyboard may or may not support polled I/O. 1331 * This ioctl may have been rejected because 1332 * we only have the wc->conskbd chain built, 1333 * and the keyboard driver has not been linked 1334 * underneath conskbd yet. 1335 */ 1336 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 1337 ("wclrput: NAK\n")); 1338 1339 switch (iocp->ioc_cmd) { 1340 1341 case CONSCLOSEPOLLEDIO: 1342 wscons.wc_kb_polledio = NULL; 1343 wscons.wc_kbdqueue = NULL; 1344 wscons.wc_polledio. 1345 cons_polledio_getchar = NULL; 1346 wscons.wc_polledio. 1347 cons_polledio_ischar = NULL; 1348 break; 1349 } 1350 break; 1351 } 1352 1353 /* 1354 * Discard the response, replace it with the 1355 * pending response to the I_PLINK, then let it 1356 * flow upward. 1357 */ 1358 freemsg(mp); 1359 mp = wscons.wc_pending_link; 1360 wscons.wc_pending_link = NULL; 1361 wscons.wc_kb_getpolledio_id = 0; 1362 } 1363 /* FALLTHROUGH */ 1364 1365 default: /* inc M_ERROR, M_HANGUP, M_IOCACK, M_IOCNAK, ... */ 1366 if (wscons.wc_pending_wq != NULL) { 1367 qreply(wscons.wc_pending_wq, mp); 1368 wscons.wc_pending_wq = NULL; 1369 break; 1370 } 1371 1372 if ((upq = pvc->vc_ttycommon.t_readq) != NULL) { 1373 putnext(upq, mp); 1374 } else { 1375 DPRINTF(PRINT_L1, PRINT_MASK_ALL, 1376 ("wclrput: Message DISCARDED\n")); 1377 freemsg(mp); 1378 } 1379 break; 1380 } 1381 1382 return (0); 1383 } 1384 1385 #ifdef _HAVE_TEM_FIRMWARE 1386 /* 1387 * This routine exists so that prom_write() can redirect writes 1388 * to the framebuffer through the kernel terminal emulator, if 1389 * that configuration is selected during consconfig. 1390 * When the kernel terminal emulator is enabled, consconfig_dacf 1391 * sets up the PROM output redirect vector to enter this function. 1392 * During panic the console will already be powered up as part of 1393 * calling into the prom_*() layer. 1394 */ 1395 /* ARGSUSED */ 1396 ssize_t 1397 wc_cons_wrtvec(promif_redir_arg_t arg, uchar_t *s, size_t n) 1398 { 1399 vc_state_t *pvc; 1400 1401 pvc = vt_minor2vc(VT_ACTIVE); 1402 1403 if (pvc->vc_tem == NULL) 1404 return (0); 1405 1406 ASSERT(consmode == CONS_KFB); 1407 1408 if (panicstr) 1409 polled_io_cons_write(s, n); 1410 else 1411 (void) tem_write(pvc->vc_tem, s, n, kcred); 1412 1413 return (n); 1414 } 1415 #endif /* _HAVE_TEM_FIRMWARE */ 1416 1417 /* 1418 * These are for systems without OBP, and for devices that cannot be 1419 * shared between Solaris and the OBP. 1420 */ 1421 static void 1422 wc_polled_putchar(cons_polledio_arg_t arg, unsigned char c) 1423 { 1424 vc_state_t *pvc; 1425 1426 pvc = vt_minor2vc(VT_ACTIVE); 1427 1428 if (c == '\n') 1429 wc_polled_putchar(arg, '\r'); 1430 1431 if (pvc->vc_tem == NULL) { 1432 /* 1433 * We have no terminal emulator configured. We have no 1434 * recourse but to drop the output on the floor. 1435 */ 1436 return; 1437 } 1438 1439 tem_safe_polled_write(pvc->vc_tem, &c, 1); 1440 } 1441 1442 /* 1443 * These are for systems without OBP, and for devices that cannot be 1444 * shared between Solaris and the OBP. 1445 */ 1446 static int 1447 wc_polled_getchar(cons_polledio_arg_t arg) 1448 { 1449 struct wscons_state *wscons = (struct wscons_state *)arg; 1450 1451 if (wscons->wc_kb_polledio == NULL) { 1452 prom_printf("wscons: getchar with no keyboard support"); 1453 prom_printf("Halted..."); 1454 for (;;) 1455 /* HANG FOREVER */; 1456 } 1457 1458 return (wscons->wc_kb_polledio->cons_polledio_getchar( 1459 wscons->wc_kb_polledio->cons_polledio_argument)); 1460 } 1461 1462 static boolean_t 1463 wc_polled_ischar(cons_polledio_arg_t arg) 1464 { 1465 struct wscons_state *wscons = (struct wscons_state *)arg; 1466 1467 if (wscons->wc_kb_polledio == NULL) 1468 return (B_FALSE); 1469 1470 return (wscons->wc_kb_polledio->cons_polledio_ischar( 1471 wscons->wc_kb_polledio->cons_polledio_argument)); 1472 } 1473 1474 static void 1475 wc_polled_enter(cons_polledio_arg_t arg) 1476 { 1477 struct wscons_state *wscons = (struct wscons_state *)arg; 1478 1479 if (wscons->wc_kb_polledio == NULL) 1480 return; 1481 1482 if (wscons->wc_kb_polledio->cons_polledio_enter != NULL) { 1483 wscons->wc_kb_polledio->cons_polledio_enter( 1484 wscons->wc_kb_polledio->cons_polledio_argument); 1485 } 1486 } 1487 1488 static void 1489 wc_polled_exit(cons_polledio_arg_t arg) 1490 { 1491 struct wscons_state *wscons = (struct wscons_state *)arg; 1492 1493 if (wscons->wc_kb_polledio == NULL) 1494 return; 1495 1496 if (wscons->wc_kb_polledio->cons_polledio_exit != NULL) { 1497 wscons->wc_kb_polledio->cons_polledio_exit( 1498 wscons->wc_kb_polledio->cons_polledio_argument); 1499 } 1500 } 1501 1502 1503 #ifdef DEBUG 1504 static void 1505 wc_dprintf(const char *fmt, ...) 1506 { 1507 char buf[256]; 1508 va_list ap; 1509 1510 va_start(ap, fmt); 1511 (void) vsprintf(buf, fmt, ap); 1512 va_end(ap); 1513 1514 cmn_err(CE_WARN, "wc: %s", buf); 1515 } 1516 #endif 1517 1518 /*ARGSUSED*/ 1519 static void 1520 update_property(vc_state_t *pvc, char *name, ushort_t value) 1521 { 1522 char data[8]; 1523 1524 (void) snprintf(data, sizeof (data), "%u", value); 1525 1526 (void) ddi_prop_update_string(wscons.wc_dev, wc_dip, name, data); 1527 } 1528 1529 /* 1530 * Gets the number of text rows and columns and the 1531 * width and height (in pixels) of the console. 1532 */ 1533 void 1534 wc_get_size(vc_state_t *pvc) 1535 { 1536 struct winsize *t = &pvc->vc_ttycommon.t_size; 1537 ushort_t r = LOSCREENLINES, c = LOSCREENCOLS, x = 0, y = 0; 1538 1539 if (pvc->vc_tem != NULL) 1540 tem_get_size(&r, &c, &x, &y); 1541 #ifdef _HAVE_TEM_FIRMWARE 1542 else 1543 console_get_size(&r, &c, &x, &y); 1544 #endif /* _HAVE_TEM_FIRMWARE */ 1545 1546 mutex_enter(&pvc->vc_ttycommon.t_excl); 1547 t->ws_col = c; 1548 t->ws_row = r; 1549 t->ws_xpixel = x; 1550 t->ws_ypixel = y; 1551 mutex_exit(&pvc->vc_ttycommon.t_excl); 1552 1553 if (pvc->vc_minor != 0) 1554 return; 1555 1556 /* only for the wscons:0 */ 1557 update_property(pvc, "screen-#cols", c); 1558 update_property(pvc, "screen-#rows", r); 1559 update_property(pvc, "screen-width", x); 1560 update_property(pvc, "screen-height", y); 1561 } 1562 1563 /*ARGSUSED*/ 1564 static void 1565 wc_modechg_cb(tem_modechg_cb_arg_t arg) 1566 { 1567 minor_t index; 1568 vc_state_t *pvc; 1569 1570 mutex_enter(&vc_lock); 1571 for (index = 0; index < VC_INSTANCES_COUNT; index++) { 1572 pvc = vt_minor2vc(index); 1573 1574 mutex_enter(&pvc->vc_state_lock); 1575 1576 if ((pvc->vc_flags & WCS_ISOPEN) && 1577 (pvc->vc_flags & WCS_INIT)) 1578 wc_get_size(pvc); 1579 1580 mutex_exit(&pvc->vc_state_lock); 1581 } 1582 mutex_exit(&vc_lock); 1583 } 1584