1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * ANSI terminal emulator module; parse ANSI X3.64 escape sequences and
29 * the like.
30 *
31 * How Virtual Terminal Emulator Works:
32 *
33 * Every virtual terminal is associated with a tem_vt_state structure
34 * and maintains a virtual screen buffer in tvs_screen_buf, which contains
35 * all the characters which should be shown on the physical screen when
36 * the terminal is activated. There are also two other buffers, tvs_fg_buf
37 * and tvs_bg_buf, which track the foreground and background colors of the
38 * on screen characters
39 *
40 * Data written to a virtual terminal is composed of characters which
41 * should be displayed on the screen when this virtual terminal is
42 * activated, fg/bg colors of these characters, and other control
43 * information (escape sequence, etc).
44 *
45 * When data is passed to a virtual terminal it first is parsed for
46 * control information by tem_safe_parse(). Subsequently the character
47 * and color data are written to tvs_screen_buf, tvs_fg_buf, and
48 * tvs_bg_buf. They are saved in these buffers in order to refresh
49 * the screen when this terminal is activated. If the terminal is
50 * currently active, the data (characters and colors) are also written
51 * to the physical screen by invoking a callback function,
52 * tem_safe_text_callbacks() or tem_safe_pix_callbacks().
53 *
54 * When rendering data to the framebuffer, if the framebuffer is in
55 * VIS_PIXEL mode, the character data will first be converted to pixel
56 * data using tem_safe_pix_bit2pix(), and then the pixels get displayed
57 * on the physical screen. We only store the character and color data in
58 * tem_vt_state since the bit2pix conversion only happens when actually
59 * rendering to the physical framebuffer.
60 */
61
62
63 #include <sys/types.h>
64 #include <sys/file.h>
65 #include <sys/conf.h>
66 #include <sys/errno.h>
67 #include <sys/open.h>
68 #include <sys/cred.h>
69 #include <sys/kmem.h>
70 #include <sys/ascii.h>
71 #include <sys/consdev.h>
72 #include <sys/font.h>
73 #include <sys/fbio.h>
74 #include <sys/conf.h>
75 #include <sys/modctl.h>
76 #include <sys/strsubr.h>
77 #include <sys/stat.h>
78 #include <sys/visual_io.h>
79 #include <sys/mutex.h>
80 #include <sys/param.h>
81 #include <sys/debug.h>
82 #include <sys/cmn_err.h>
83 #include <sys/console.h>
84 #include <sys/ddi.h>
85 #include <sys/sunddi.h>
86 #include <sys/sunldi.h>
87 #include <sys/tem_impl.h>
88 #ifdef _HAVE_TEM_FIRMWARE
89 #include <sys/promif.h>
90 #endif /* _HAVE_TEM_FIRMWARE */
91 #include <sys/consplat.h>
92 #include <sys/kd.h>
93 #include <sys/sysmacros.h>
94 #include <sys/note.h>
95 #include <sys/t_lock.h>
96
97 /* Terminal emulator internal helper functions */
98 static void tems_setup_terminal(struct vis_devinit *, size_t, size_t);
99 static void tems_modechange_callback(struct vis_modechg_arg *,
100 struct vis_devinit *);
101
102 static void tems_reset_colormap(cred_t *, enum called_from);
103
104 static void tem_free_buf(struct tem_vt_state *);
105 static void tem_internal_init(struct tem_vt_state *, cred_t *, boolean_t,
106 boolean_t);
107 static void tems_get_initial_color(tem_color_t *pcolor);
108
109 /*
110 * Globals
111 */
112 static ldi_ident_t term_li = NULL;
113 tem_state_t tems; /* common term info */
114 _NOTE(MUTEX_PROTECTS_DATA(tems.ts_lock, tems))
115
116 extern struct mod_ops mod_miscops;
117
118 static struct modlmisc modlmisc = {
119 &mod_miscops, /* modops */
120 "ANSI Terminal Emulator", /* name */
121 };
122
123 static struct modlinkage modlinkage = {
124 MODREV_1, { (void *)&modlmisc, NULL }
125 };
126
127 int
128 _init(void)
129 {
130 int ret;
131 ret = mod_install(&modlinkage);
132 if (ret != 0)
133 return (ret);
134 ret = ldi_ident_from_mod(&modlinkage, &term_li);
135 if (ret != 0) {
136 (void) mod_remove(&modlinkage);
137 return (ret);
138 }
139
140 mutex_init(&tems.ts_lock, (char *)NULL, MUTEX_DRIVER, NULL);
141 list_create(&tems.ts_list, sizeof (struct tem_vt_state),
142 offsetof(struct tem_vt_state, tvs_list_node));
143 tems.ts_active = NULL;
144
145 return (0);
146 }
147
148 int
149 _fini()
150 {
151 int ret;
152
153 ret = mod_remove(&modlinkage);
154 if (ret == 0) {
155 ldi_ident_release(term_li);
156 term_li = NULL;
157 }
158 return (ret);
159 }
160
161 int
162 _info(struct modinfo *modinfop)
163 {
164 return (mod_info(&modlinkage, modinfop));
165 }
166
167 static void
168 tem_add(struct tem_vt_state *tem)
169 {
170 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock));
171
172 list_insert_head(&tems.ts_list, tem);
173 }
174
175 static void
176 tem_rm(struct tem_vt_state *tem)
177 {
178 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock));
179
180 list_remove(&tems.ts_list, tem);
181 }
182
183 /*
184 * This is the main entry point to the module. It handles output requests
185 * during normal system operation, when (e.g.) mutexes are available.
186 */
187 void
188 tem_write(tem_vt_state_t tem_arg, uchar_t *buf, ssize_t len, cred_t *credp)
189 {
190 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg;
191
192 mutex_enter(&tems.ts_lock);
193 mutex_enter(&tem->tvs_lock);
194
195 if (!tem->tvs_initialized) {
196 mutex_exit(&tem->tvs_lock);
197 mutex_exit(&tems.ts_lock);
198 return;
199 }
200
201 tem_safe_check_first_time(tem, credp, CALLED_FROM_NORMAL);
202 tem_safe_terminal_emulate(tem, buf, len, credp, CALLED_FROM_NORMAL);
203
204 mutex_exit(&tem->tvs_lock);
205 mutex_exit(&tems.ts_lock);
206 }
207
208 static void
209 tem_internal_init(struct tem_vt_state *ptem, cred_t *credp,
210 boolean_t init_color, boolean_t clear_screen)
211 {
212 unsigned i, j, width, height;
213 text_attr_t attr;
214 text_color_t fg;
215 text_color_t bg;
216
217 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&ptem->tvs_lock));
218
219 if (tems.ts_display_mode == VIS_PIXEL) {
220 ptem->tvs_pix_data_size = tems.ts_pix_data_size;
221 ptem->tvs_pix_data =
222 kmem_alloc(ptem->tvs_pix_data_size, KM_SLEEP);
223 }
224
225 ptem->tvs_outbuf_size = tems.ts_c_dimension.width *
226 sizeof (*ptem->tvs_outbuf);
227 ptem->tvs_outbuf = kmem_alloc(ptem->tvs_outbuf_size, KM_SLEEP);
228
229 width = tems.ts_c_dimension.width;
230 height = tems.ts_c_dimension.height;
231 ptem->tvs_screen_history_size = height;
232
233 ptem->tvs_screen_buf_size = width * ptem->tvs_screen_history_size *
234 sizeof (*ptem->tvs_screen_buf);
235 ptem->tvs_screen_buf = kmem_alloc(ptem->tvs_screen_buf_size, KM_SLEEP);
236 ptem->tvs_screen_rows = kmem_alloc(ptem->tvs_screen_history_size *
237 sizeof (term_char_t *), KM_SLEEP);
238
239 tem_safe_reset_display(ptem, credp, CALLED_FROM_NORMAL,
240 clear_screen, init_color);
241
242 ptem->tvs_utf8_left = 0;
243 ptem->tvs_utf8_partial = 0;
244
245 /* Get default attributes and fill up the screen buffer. */
246 tem_safe_get_attr(ptem, &fg, &bg, &attr, TEM_ATTR_SCREEN_REVERSE);
247 for (i = 0; i < ptem->tvs_screen_history_size; i++) {
248 ptem->tvs_screen_rows[i] = &ptem->tvs_screen_buf[i * width];
249
250 for (j = 0; j < width; j++) {
251 ptem->tvs_screen_rows[i][j].tc_fg_color = fg;
252 ptem->tvs_screen_rows[i][j].tc_bg_color = bg;
253 ptem->tvs_screen_rows[i][j].tc_char =
254 TEM_ATTR(attr) | ' ';
255
256 }
257 }
258
259 ptem->tvs_initialized = B_TRUE;
260 }
261
262 int
263 tem_initialized(tem_vt_state_t tem_arg)
264 {
265 struct tem_vt_state *ptem = (struct tem_vt_state *)tem_arg;
266 int ret;
267
268 mutex_enter(&ptem->tvs_lock);
269 ret = ptem->tvs_initialized == B_TRUE? 1 : 0;
270 mutex_exit(&ptem->tvs_lock);
271
272 return (ret);
273 }
274
275 tem_vt_state_t
276 tem_init(cred_t *credp)
277 {
278 struct tem_vt_state *ptem;
279
280 ptem = kmem_zalloc(sizeof (struct tem_vt_state), KM_SLEEP);
281 mutex_init(&ptem->tvs_lock, (char *)NULL, MUTEX_DRIVER, NULL);
282
283 mutex_enter(&tems.ts_lock);
284 mutex_enter(&ptem->tvs_lock);
285
286 ptem->tvs_isactive = B_FALSE;
287 ptem->tvs_fbmode = KD_TEXT;
288
289 /*
290 * A tem is regarded as initialized only after tem_internal_init(),
291 * will be set at the end of tem_internal_init().
292 */
293 ptem->tvs_initialized = B_FALSE;
294
295
296 if (!tems.ts_initialized) {
297 /*
298 * Only happens during early console configuration.
299 */
300 tem_add(ptem);
301 mutex_exit(&ptem->tvs_lock);
302 mutex_exit(&tems.ts_lock);
303 return ((tem_vt_state_t)ptem);
304 }
305
306 tem_internal_init(ptem, credp, B_TRUE, B_FALSE);
307 tem_add(ptem);
308 mutex_exit(&ptem->tvs_lock);
309 mutex_exit(&tems.ts_lock);
310
311 return ((tem_vt_state_t)ptem);
312 }
313
314 /*
315 * re-init the tem after video mode has changed and tems_info has
316 * been re-inited. The lock is already held.
317 */
318 static void
319 tem_reinit(struct tem_vt_state *tem, boolean_t reset_display)
320 {
321 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock));
322
323 tem_free_buf(tem); /* only free virtual buffers */
324
325 /* reserve color */
326 tem_internal_init(tem, kcred, B_FALSE, reset_display);
327 }
328
329 static void
330 tem_free_buf(struct tem_vt_state *tem)
331 {
332 ASSERT(tem != NULL && MUTEX_HELD(&tem->tvs_lock));
333
334 if (tem->tvs_outbuf != NULL)
335 kmem_free(tem->tvs_outbuf, tem->tvs_outbuf_size);
336 if (tem->tvs_pix_data != NULL)
337 kmem_free(tem->tvs_pix_data, tem->tvs_pix_data_size);
338 if (tem->tvs_screen_buf != NULL)
339 kmem_free(tem->tvs_screen_buf, tem->tvs_screen_buf_size);
340 if (tem->tvs_screen_rows != NULL) {
341 kmem_free(tem->tvs_screen_rows, tem->tvs_screen_history_size *
342 sizeof (term_char_t *));
343 }
344 }
345
346 void
347 tem_destroy(tem_vt_state_t tem_arg, cred_t *credp)
348 {
349 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg;
350
351 mutex_enter(&tems.ts_lock);
352 mutex_enter(&tem->tvs_lock);
353
354 if (tem->tvs_isactive && tem->tvs_fbmode == KD_TEXT)
355 tem_safe_blank_screen(tem, credp, CALLED_FROM_NORMAL);
356
357 tem_free_buf(tem);
358 tem_rm(tem);
359
360 if (tems.ts_active == tem)
361 tems.ts_active = NULL;
362
363 mutex_exit(&tem->tvs_lock);
364 mutex_exit(&tems.ts_lock);
365
366 kmem_free(tem, sizeof (struct tem_vt_state));
367 }
368
369 static int
370 tems_failed(cred_t *credp, boolean_t finish_ioctl)
371 {
372 int lyr_rval;
373
374 ASSERT(MUTEX_HELD(&tems.ts_lock));
375
376 if (finish_ioctl)
377 (void) ldi_ioctl(tems.ts_hdl, VIS_DEVFINI, 0,
378 FWRITE|FKIOCTL, credp, &lyr_rval);
379
380 (void) ldi_close(tems.ts_hdl, NULL, credp);
381 tems.ts_hdl = NULL;
382 return (ENXIO);
383 }
384
385 /*
386 * only called once during boot
387 */
388 int
389 tem_info_init(char *pathname, cred_t *credp)
390 {
391 int lyr_rval, ret;
392 struct vis_devinit temargs;
393 char *pathbuf;
394 size_t height = 0;
395 size_t width = 0;
396 struct tem_vt_state *p;
397
398 mutex_enter(&tems.ts_lock);
399
400 if (tems.ts_initialized) {
401 mutex_exit(&tems.ts_lock);
402 return (0);
403 }
404
405 /*
406 * Open the layered device using the devfs physical device name
407 * after adding the /devices prefix.
408 */
409 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
410 (void) strcpy(pathbuf, "/devices");
411 if (i_ddi_prompath_to_devfspath(pathname,
412 pathbuf + strlen("/devices")) != DDI_SUCCESS) {
413 cmn_err(CE_WARN, "terminal-emulator: path conversion error");
414 kmem_free(pathbuf, MAXPATHLEN);
415
416 mutex_exit(&tems.ts_lock);
417 return (ENXIO);
418 }
419 if (ldi_open_by_name(pathbuf, FWRITE, credp,
420 &tems.ts_hdl, term_li) != 0) {
421 cmn_err(CE_WARN, "terminal-emulator: device path open error");
422 kmem_free(pathbuf, MAXPATHLEN);
423
424 mutex_exit(&tems.ts_lock);
425 return (ENXIO);
426 }
427 kmem_free(pathbuf, MAXPATHLEN);
428
429 temargs.modechg_cb = (vis_modechg_cb_t)tems_modechange_callback;
430 temargs.modechg_arg = NULL;
431
432 /*
433 * Initialize the console and get the device parameters
434 */
435 if (ldi_ioctl(tems.ts_hdl, VIS_DEVINIT,
436 (intptr_t)&temargs, FWRITE|FKIOCTL, credp, &lyr_rval) != 0) {
437 cmn_err(CE_WARN, "terminal emulator: Compatible fb not found");
438 ret = tems_failed(credp, B_FALSE);
439 mutex_exit(&tems.ts_lock);
440 return (ret);
441 }
442
443 /* Make sure the fb driver and terminal emulator versions match */
444 if (temargs.version != VIS_CONS_REV) {
445 cmn_err(CE_WARN,
446 "terminal emulator: VIS_CONS_REV %d (see sys/visual_io.h) "
447 "of console fb driver not supported", temargs.version);
448 ret = tems_failed(credp, B_TRUE);
449 mutex_exit(&tems.ts_lock);
450 return (ret);
451 }
452
453 if ((tems.ts_fb_polledio = temargs.polledio) == NULL) {
454 cmn_err(CE_WARN, "terminal emulator: fb doesn't support polled "
455 "I/O");
456 ret = tems_failed(credp, B_TRUE);
457 mutex_exit(&tems.ts_lock);
458 return (ret);
459 }
460
461 /* other sanity checks */
462 if (!((temargs.depth == 4) || (temargs.depth == 8) ||
463 (temargs.depth == 15) || (temargs.depth == 16) ||
464 (temargs.depth == 24) || (temargs.depth == 32))) {
465 cmn_err(CE_WARN, "terminal emulator: unsupported depth");
466 ret = tems_failed(credp, B_TRUE);
467 mutex_exit(&tems.ts_lock);
468 return (ret);
469 }
470
471 if ((temargs.mode != VIS_TEXT) && (temargs.mode != VIS_PIXEL)) {
472 cmn_err(CE_WARN, "terminal emulator: unsupported mode");
473 ret = tems_failed(credp, B_TRUE);
474 mutex_exit(&tems.ts_lock);
475 return (ret);
476 }
477
478 if ((temargs.mode == VIS_PIXEL) && plat_stdout_is_framebuffer())
479 plat_tem_get_prom_size(&height, &width);
480
481 /*
482 * Initialize the common terminal emulator info
483 */
484 tems_setup_terminal(&temargs, height, width);
485
486 tems_reset_colormap(credp, CALLED_FROM_NORMAL);
487 tems_get_initial_color(&tems.ts_init_color);
488
489 tems.ts_initialized = 1; /* initialization flag */
490
491 for (p = list_head(&tems.ts_list); p != NULL;
492 p = list_next(&tems.ts_list, p)) {
493 mutex_enter(&p->tvs_lock);
494 tem_internal_init(p, credp, B_TRUE, B_FALSE);
495 if (temargs.mode == VIS_PIXEL)
496 tem_pix_align(p, credp, CALLED_FROM_NORMAL);
497 mutex_exit(&p->tvs_lock);
498 }
499
500 mutex_exit(&tems.ts_lock);
501 return (0);
502 }
503
504 #define TEMS_DEPTH_DIFF 0x01
505 #define TEMS_DIMENSION_DIFF 0x02
506
507 static uchar_t
508 tems_check_videomode(struct vis_devinit *tp)
509 {
510 uchar_t result = 0;
511
512 if (tems.ts_pdepth != tp->depth)
513 result |= TEMS_DEPTH_DIFF;
514
515 if (tp->mode == VIS_TEXT) {
516 if (tems.ts_c_dimension.width != tp->width ||
517 tems.ts_c_dimension.height != tp->height)
518 result |= TEMS_DIMENSION_DIFF;
519 } else {
520 if (tems.ts_p_dimension.width != tp->width ||
521 tems.ts_p_dimension.height != tp->height)
522 result |= TEMS_DIMENSION_DIFF;
523 }
524
525 return (result);
526 }
527
528 static void
529 tems_setup_terminal(struct vis_devinit *tp, size_t height, size_t width)
530 {
531 bitmap_data_t *font_data;
532 int i;
533 int old_blank_buf_size = tems.ts_c_dimension.width *
534 sizeof (*tems.ts_blank_line);
535
536 ASSERT(MUTEX_HELD(&tems.ts_lock));
537
538 tems.ts_pdepth = tp->depth;
539 tems.ts_linebytes = tp->linebytes;
540 tems.ts_display_mode = tp->mode;
541 tems.ts_color_map = tp->color_map;
542
543 switch (tp->mode) {
544 case VIS_TEXT:
545 tems.ts_p_dimension.width = 0;
546 tems.ts_p_dimension.height = 0;
547 tems.ts_c_dimension.width = tp->width;
548 tems.ts_c_dimension.height = tp->height;
549 tems.ts_callbacks = &tem_safe_text_callbacks;
550
551 break;
552
553 case VIS_PIXEL:
554 /*
555 * First check to see if the user has specified a screen size.
556 * If so, use those values. Else use 34x80 as the default.
557 */
558 if (width == 0) {
559 width = TEM_DEFAULT_COLS;
560 height = TEM_DEFAULT_ROWS;
561 }
562 tems.ts_c_dimension.height = (screen_size_t)height;
563 tems.ts_c_dimension.width = (screen_size_t)width;
564
565 tems.ts_p_dimension.height = tp->height;
566 tems.ts_p_dimension.width = tp->width;
567
568 tems.ts_callbacks = &tem_safe_pix_callbacks;
569
570 /*
571 * set_font() will select a appropriate sized font for
572 * the number of rows and columns selected. If we don't
573 * have a font that will fit, then it will use the
574 * default builtin font and adjust the rows and columns
575 * to fit on the screen.
576 */
577 font_data = set_font(&tems.ts_c_dimension.height,
578 &tems.ts_c_dimension.width,
579 tems.ts_p_dimension.height,
580 tems.ts_p_dimension.width);
581
582 for (i = 0; i < VFNT_MAPS; i++) {
583 tems.ts_font.vf_map[i] =
584 font_data->font->vf_map[i];
585 tems.ts_font.vf_map_count[i] =
586 font_data->font->vf_map_count[i];
587 }
588 tems.ts_font.vf_bytes = font_data->font->vf_bytes;
589 tems.ts_font.vf_width = font_data->font->vf_width;
590 tems.ts_font.vf_height = font_data->font->vf_height;
591
592 tems.ts_p_offset.y = (tems.ts_p_dimension.height -
593 (tems.ts_c_dimension.height * tems.ts_font.vf_height)) / 2;
594 tems.ts_p_offset.x = (tems.ts_p_dimension.width -
595 (tems.ts_c_dimension.width * tems.ts_font.vf_width)) / 2;
596
597 tems.ts_pix_data_size =
598 tems.ts_font.vf_width * tems.ts_font.vf_height;
599
600 tems.ts_pix_data_size *= 4;
601
602 tems.ts_pdepth = tp->depth;
603
604 break;
605 }
606
607 /* Now virtual cls also uses the blank_line buffer */
608 if (tems.ts_blank_line)
609 kmem_free(tems.ts_blank_line, old_blank_buf_size);
610
611 tems.ts_blank_line = kmem_alloc(tems.ts_c_dimension.width *
612 sizeof (*tems.ts_blank_line), KM_SLEEP);
613 }
614
615 /*
616 * This is a callback function that we register with the frame
617 * buffer driver layered underneath. It gets invoked from
618 * the underlying frame buffer driver to reconfigure the terminal
619 * emulator to a new screen size and depth in conjunction with
620 * framebuffer videomode changes.
621 * Here we keep the foreground/background color and attributes,
622 * which may be different with the initial settings, so that
623 * the color won't change while the framebuffer videomode changes.
624 * And we also reset the kernel terminal emulator and clear the
625 * whole screen.
626 */
627 /* ARGSUSED */
628 void
629 tems_modechange_callback(struct vis_modechg_arg *arg,
630 struct vis_devinit *devinit)
631 {
632 uchar_t diff;
633 struct tem_vt_state *p;
634 tem_modechg_cb_t cb;
635 tem_modechg_cb_arg_t cb_arg;
636
637 ASSERT(!(list_is_empty(&tems.ts_list)));
638
639 mutex_enter(&tems.ts_lock);
640
641 /*
642 * currently only for pixel mode
643 */
644 diff = tems_check_videomode(devinit);
645 if (diff == 0) {
646 mutex_exit(&tems.ts_lock);
647 return;
648 }
649
650 diff = diff & TEMS_DIMENSION_DIFF;
651
652 if (diff == 0) {
653 /*
654 * Only need to reinit the active tem.
655 */
656 struct tem_vt_state *active = tems.ts_active;
657 tems.ts_pdepth = devinit->depth;
658
659 mutex_enter(&active->tvs_lock);
660 ASSERT(active->tvs_isactive);
661 tem_reinit(active, B_TRUE);
662 mutex_exit(&active->tvs_lock);
663
664 mutex_exit(&tems.ts_lock);
665 return;
666 }
667
668 tems_setup_terminal(devinit, tems.ts_c_dimension.height,
669 tems.ts_c_dimension.width);
670
671 for (p = list_head(&tems.ts_list); p != NULL;
672 p = list_next(&tems.ts_list, p)) {
673 mutex_enter(&p->tvs_lock);
674 tem_reinit(p, p->tvs_isactive);
675 mutex_exit(&p->tvs_lock);
676 }
677
678
679 if (tems.ts_modechg_cb == NULL) {
680 mutex_exit(&tems.ts_lock);
681 return;
682 }
683
684 cb = tems.ts_modechg_cb;
685 cb_arg = tems.ts_modechg_arg;
686
687 /*
688 * Release the lock while doing callback.
689 */
690 mutex_exit(&tems.ts_lock);
691 cb(cb_arg);
692 }
693
694 /*
695 * This function is used to clear entire screen via the underlying framebuffer
696 * driver.
697 */
698 int
699 tems_cls_layered(struct vis_consclear *pda,
700 cred_t *credp)
701 {
702 int rval;
703
704 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCLEAR,
705 (intptr_t)pda, FKIOCTL, credp, &rval);
706 return (rval);
707 }
708
709 /*
710 * This function is used to display a rectangular blit of data
711 * of a given size and location via the underlying framebuffer driver.
712 * The blit can be as small as a pixel or as large as the screen.
713 */
714 void
715 tems_display_layered(struct vis_consdisplay *pda,
716 cred_t *credp)
717 {
718 int rval;
719
720 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSDISPLAY,
721 (intptr_t)pda, FKIOCTL, credp, &rval);
722 }
723
724 /*
725 * This function is used to invoke a block copy operation in the
726 * underlying framebuffer driver. Rectangle copies are how scrolling
727 * is implemented, as well as horizontal text shifting escape seqs.
728 * such as from vi when deleting characters and words.
729 */
730 void
731 tems_copy_layered(struct vis_conscopy *pma,
732 cred_t *credp)
733 {
734 int rval;
735
736 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCOPY,
737 (intptr_t)pma, FKIOCTL, credp, &rval);
738 }
739
740 /*
741 * This function is used to show or hide a rectangluar monochrom
742 * pixel inverting, text block cursor via the underlying framebuffer.
743 */
744 void
745 tems_cursor_layered(struct vis_conscursor *pca,
746 cred_t *credp)
747 {
748 int rval;
749
750 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCURSOR,
751 (intptr_t)pca, FKIOCTL, credp, &rval);
752 }
753
754 static void
755 tem_kdsetmode(int mode, cred_t *credp)
756 {
757 int rval;
758
759 (void) ldi_ioctl(tems.ts_hdl, KDSETMODE,
760 (intptr_t)mode, FKIOCTL, credp, &rval);
761
762 }
763
764 static void
765 tems_reset_colormap(cred_t *credp, enum called_from called_from)
766 {
767 struct vis_cmap cm;
768 int rval;
769
770 if (called_from == CALLED_FROM_STANDALONE)
771 return;
772
773 switch (tems.ts_pdepth) {
774 case 8:
775 cm.index = 0;
776 cm.count = 16;
777 /* 8-bits (1/3 of TrueColor 24) */
778 cm.red = (uint8_t *)cmap4_to_24.red;
779 /* 8-bits (1/3 of TrueColor 24) */
780 cm.blue = (uint8_t *)cmap4_to_24.blue;
781 /* 8-bits (1/3 of TrueColor 24) */
782 cm.green = (uint8_t *)cmap4_to_24.green;
783 (void) ldi_ioctl(tems.ts_hdl, VIS_PUTCMAP, (intptr_t)&cm,
784 FKIOCTL, credp, &rval);
785 break;
786 }
787 }
788
789 void
790 tem_get_size(ushort_t *r, ushort_t *c, ushort_t *x, ushort_t *y)
791 {
792 mutex_enter(&tems.ts_lock);
793 *r = (ushort_t)tems.ts_c_dimension.height;
794 *c = (ushort_t)tems.ts_c_dimension.width;
795 *x = (ushort_t)tems.ts_p_dimension.width;
796 *y = (ushort_t)tems.ts_p_dimension.height;
797 mutex_exit(&tems.ts_lock);
798 }
799
800 void
801 tem_register_modechg_cb(tem_modechg_cb_t func, tem_modechg_cb_arg_t arg)
802 {
803 mutex_enter(&tems.ts_lock);
804
805 tems.ts_modechg_cb = func;
806 tems.ts_modechg_arg = arg;
807
808 mutex_exit(&tems.ts_lock);
809 }
810
811 /*
812 * This function is to scroll up the OBP output, which has
813 * different screen height and width with our kernel console.
814 */
815 static void
816 tem_prom_scroll_up(struct tem_vt_state *tem, int nrows, cred_t *credp,
817 enum called_from called_from)
818 {
819 struct vis_conscopy ma;
820 int ncols, width;
821
822 /* copy */
823 ma.s_row = nrows * tems.ts_font.vf_height;
824 ma.e_row = tems.ts_p_dimension.height - 1;
825 ma.t_row = 0;
826
827 ma.s_col = 0;
828 ma.e_col = tems.ts_p_dimension.width - 1;
829 ma.t_col = 0;
830
831 tems_safe_copy(&ma, credp, called_from);
832
833 /* clear */
834 width = tems.ts_font.vf_width;
835 ncols = (tems.ts_p_dimension.width + (width - 1))/ width;
836
837 tem_safe_pix_cls_range(tem, 0, nrows, tems.ts_p_offset.y,
838 0, ncols, 0, B_TRUE, credp, called_from);
839 }
840
841 #define PROM_DEFAULT_FONT_HEIGHT 22
842 #define PROM_DEFAULT_WINDOW_TOP 0x8a
843
844 /*
845 * This function is to compute the starting row of the console, according to
846 * PROM cursor's position. Here we have to take different fonts into account.
847 */
848 static int
849 tem_adjust_row(struct tem_vt_state *tem, int prom_row, cred_t *credp,
850 enum called_from called_from)
851 {
852 int tem_row;
853 int tem_y;
854 int prom_charheight = 0;
855 int prom_window_top = 0;
856 int scroll_up_lines;
857
858 plat_tem_get_prom_font_size(&prom_charheight, &prom_window_top);
859 if (prom_charheight == 0)
860 prom_charheight = PROM_DEFAULT_FONT_HEIGHT;
861 if (prom_window_top == 0)
862 prom_window_top = PROM_DEFAULT_WINDOW_TOP;
863
864 tem_y = (prom_row + 1) * prom_charheight + prom_window_top -
865 tems.ts_p_offset.y;
866 tem_row = (tem_y + tems.ts_font.vf_height - 1) /
867 tems.ts_font.vf_height - 1;
868
869 if (tem_row < 0) {
870 tem_row = 0;
871 } else if (tem_row >= (tems.ts_c_dimension.height - 1)) {
872 /*
873 * Scroll up the prom outputs if the PROM cursor's position is
874 * below our tem's lower boundary.
875 */
876 scroll_up_lines = tem_row -
877 (tems.ts_c_dimension.height - 1);
878 tem_prom_scroll_up(tem, scroll_up_lines, credp, called_from);
879 tem_row = tems.ts_c_dimension.height - 1;
880 }
881
882 return (tem_row);
883 }
884
885 void
886 tem_pix_align(struct tem_vt_state *tem, cred_t *credp,
887 enum called_from called_from)
888 {
889 uint32_t row = 0;
890 uint32_t col = 0;
891
892 if (plat_stdout_is_framebuffer()) {
893 plat_tem_hide_prom_cursor();
894
895 /*
896 * We are getting the current cursor position in pixel
897 * mode so that we don't over-write the console output
898 * during boot.
899 */
900 plat_tem_get_prom_pos(&row, &col);
901
902 /*
903 * Adjust the row if necessary when the font of our
904 * kernel console tem is different with that of prom
905 * tem.
906 */
907 row = tem_adjust_row(tem, row, credp, called_from);
908
909 /* first line of our kernel console output */
910 tem->tvs_first_line = row + 1;
911
912 /* re-set and align cusror position */
913 tem->tvs_s_cursor.row = tem->tvs_c_cursor.row =
914 (screen_pos_t)row;
915 tem->tvs_s_cursor.col = tem->tvs_c_cursor.col = 0;
916 } else {
917 tem_safe_reset_display(tem, credp, called_from, B_TRUE, B_TRUE);
918 }
919 }
920
921 static void
922 tems_get_inverses(boolean_t *p_inverse, boolean_t *p_inverse_screen)
923 {
924 int i_inverse = 0;
925 int i_inverse_screen = 0;
926
927 plat_tem_get_inverses(&i_inverse, &i_inverse_screen);
928
929 *p_inverse = (i_inverse == 0) ? B_FALSE : B_TRUE;
930 *p_inverse_screen = (i_inverse_screen == 0) ? B_FALSE : B_TRUE;
931 }
932
933 /*
934 * Get the foreground/background color and attributes from the initial
935 * PROM, so that our kernel console can keep the same visual behaviour.
936 */
937 static void
938 tems_get_initial_color(tem_color_t *pcolor)
939 {
940 boolean_t inverse, inverse_screen;
941 unsigned short flags = 0;
942
943 pcolor->fg_color = DEFAULT_ANSI_FOREGROUND;
944 pcolor->bg_color = DEFAULT_ANSI_BACKGROUND;
945 #ifndef _HAVE_TEM_FIRMWARE
946 plat_tem_get_colors(&pcolor->fg_color, &pcolor->bg_color);
947 #endif
948
949 tems_get_inverses(&inverse, &inverse_screen);
950 if (inverse)
951 flags |= TEM_ATTR_REVERSE;
952 if (inverse_screen)
953 flags |= TEM_ATTR_SCREEN_REVERSE;
954
955 if (flags != 0) {
956 /*
957 * If either reverse flag is set, the screen is in
958 * white-on-black mode. We set the bold flag to
959 * improve readability.
960 */
961 flags |= TEM_ATTR_BOLD;
962 } else {
963 /*
964 * Otherwise, the screen is in black-on-white mode.
965 * The SPARC PROM console, which starts in this mode,
966 * uses the bright white background colour so we
967 * match it here.
968 */
969 if (pcolor->bg_color == ANSI_COLOR_WHITE)
970 flags |= TEM_ATTR_BRIGHT_BG;
971 }
972
973 pcolor->a_flags = flags;
974 }
975
976 uchar_t
977 tem_get_fbmode(tem_vt_state_t tem_arg)
978 {
979 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg;
980
981 uchar_t fbmode;
982
983 mutex_enter(&tem->tvs_lock);
984 fbmode = tem->tvs_fbmode;
985 mutex_exit(&tem->tvs_lock);
986
987 return (fbmode);
988 }
989
990 void
991 tem_set_fbmode(tem_vt_state_t tem_arg, uchar_t fbmode, cred_t *credp)
992 {
993 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg;
994
995 mutex_enter(&tems.ts_lock);
996 mutex_enter(&tem->tvs_lock);
997
998 if (fbmode == tem->tvs_fbmode) {
999 mutex_exit(&tem->tvs_lock);
1000 mutex_exit(&tems.ts_lock);
1001 return;
1002 }
1003
1004 tem->tvs_fbmode = fbmode;
1005
1006 if (tem->tvs_isactive) {
1007 tem_kdsetmode(tem->tvs_fbmode, credp);
1008 if (fbmode == KD_TEXT)
1009 tem_safe_unblank_screen(tem, credp, CALLED_FROM_NORMAL);
1010 }
1011
1012 mutex_exit(&tem->tvs_lock);
1013 mutex_exit(&tems.ts_lock);
1014 }
1015
1016 void
1017 tem_activate(tem_vt_state_t tem_arg, boolean_t unblank, cred_t *credp)
1018 {
1019 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg;
1020
1021 mutex_enter(&tems.ts_lock);
1022 tems.ts_active = tem;
1023
1024 mutex_enter(&tem->tvs_lock);
1025 tem->tvs_isactive = B_TRUE;
1026
1027 tem_kdsetmode(tem->tvs_fbmode, credp);
1028
1029 if (unblank)
1030 tem_safe_unblank_screen(tem, credp, CALLED_FROM_NORMAL);
1031
1032 mutex_exit(&tem->tvs_lock);
1033 mutex_exit(&tems.ts_lock);
1034 }
1035
1036 void
1037 tem_switch(tem_vt_state_t tem_arg1, tem_vt_state_t tem_arg2, cred_t *credp)
1038 {
1039 struct tem_vt_state *cur = (struct tem_vt_state *)tem_arg1;
1040 struct tem_vt_state *tobe = (struct tem_vt_state *)tem_arg2;
1041
1042 mutex_enter(&tems.ts_lock);
1043 mutex_enter(&tobe->tvs_lock);
1044 mutex_enter(&cur->tvs_lock);
1045
1046 tems.ts_active = tobe;
1047 cur->tvs_isactive = B_FALSE;
1048 tobe->tvs_isactive = B_TRUE;
1049
1050 mutex_exit(&cur->tvs_lock);
1051
1052 if (cur->tvs_fbmode != tobe->tvs_fbmode)
1053 tem_kdsetmode(tobe->tvs_fbmode, credp);
1054
1055 if (tobe->tvs_fbmode == KD_TEXT)
1056 tem_safe_unblank_screen(tobe, credp, CALLED_FROM_NORMAL);
1057
1058 mutex_exit(&tobe->tvs_lock);
1059 mutex_exit(&tems.ts_lock);
1060 }