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