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 * Copyright (c) 2012 Gary Mills
23 *
24 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 #include <sys/types.h>
29 #include <sys/systm.h>
30 #include <sys/archsystm.h>
31 #include <sys/boot_console.h>
32 #include <sys/panic.h>
33 #include <sys/ctype.h>
34 #if defined(__xpv)
35 #include <sys/hypervisor.h>
36 #endif /* __xpv */
37
38 #include "boot_serial.h"
39 #include "boot_vga.h"
40
41 #if defined(_BOOT)
42 #include <dboot/dboot_asm.h>
43 #include <dboot/dboot_xboot.h>
44 #else /* _BOOT */
45 #include <sys/bootconf.h>
46 #if defined(__xpv)
47 #include <sys/evtchn_impl.h>
48 #endif /* __xpv */
49 static char *defcons_buf;
50 static char *defcons_cur;
51 #endif /* _BOOT */
52
53 #if defined(__xpv)
54 extern void bcons_init_xen(char *);
55 extern void bcons_putchar_xen(int);
56 extern int bcons_getchar_xen(void);
57 extern int bcons_ischar_xen(void);
58 #endif /* __xpv */
59
60 static int cons_color = CONS_COLOR;
61 static int console = CONS_SCREEN_TEXT;
62 static int tty_num = 0;
63 static int tty_addr[] = {0x3f8, 0x2f8, 0x3e8, 0x2e8};
64 static char *boot_line;
65 static struct boot_env {
66 char *be_env; /* ends with double ascii nul */
67 size_t be_size; /* size of the environment, including nul */
68 } boot_env;
69
70 static int serial_ischar(void);
71 static int serial_getchar(void);
72 static void serial_putchar(int);
73 static void serial_adjust_prop(void);
74
75 #if !defined(_BOOT)
76 /* Set if the console or mode are expressed in the boot line */
77 static int console_set, console_mode_set;
78 #endif
79
80 #if defined(__xpv)
81 static int console_hypervisor_redirect = B_FALSE;
82 static int console_hypervisor_device = CONS_INVALID;
83 static int console_hypervisor_tty_num = 0;
84
85 /* Obtain the hypervisor console type */
86 int
87 console_hypervisor_dev_type(int *tnum)
88 {
89 if (tnum != NULL)
90 *tnum = console_hypervisor_tty_num;
91 return (console_hypervisor_device);
92 }
93 #endif /* __xpv */
94
95 /* Clear the screen and initialize VIDEO, XPOS and YPOS. */
96 void
97 clear_screen(void)
98 {
99 /*
100 * XXX should set vga mode so we don't depend on the
101 * state left by the boot loader. Note that we have to
102 * enable the cursor before clearing the screen since
103 * the cursor position is dependant upon the cursor
104 * skew, which is initialized by vga_cursor_display()
105 */
106 vga_cursor_display();
107 vga_clear(cons_color);
108 vga_setpos(0, 0);
109 }
110
111 /* Put the character C on the screen. */
112 static void
113 screen_putchar(int c)
114 {
115 int row, col;
116
117 vga_getpos(&row, &col);
118 switch (c) {
119 case '\t':
120 col += 8 - (col % 8);
121 if (col == VGA_TEXT_COLS)
122 col = 79;
123 vga_setpos(row, col);
124 break;
125
126 case '\r':
127 vga_setpos(row, 0);
128 break;
129
130 case '\b':
131 if (col > 0)
132 vga_setpos(row, col - 1);
133 break;
134
135 case '\n':
136 if (row < VGA_TEXT_ROWS - 1)
137 vga_setpos(row + 1, col);
138 else
139 vga_scroll(cons_color);
140 break;
141
142 default:
143 vga_drawc(c, cons_color);
144 if (col < VGA_TEXT_COLS -1)
145 vga_setpos(row, col + 1);
146 else if (row < VGA_TEXT_ROWS - 1)
147 vga_setpos(row + 1, 0);
148 else {
149 vga_setpos(row, 0);
150 vga_scroll(cons_color);
151 }
152 break;
153 }
154 }
155
156 static int port;
157
158 static void
159 serial_init(void)
160 {
161 port = tty_addr[tty_num];
162
163 outb(port + ISR, 0x20);
164 if (inb(port + ISR) & 0x20) {
165 /*
166 * 82510 chip is present
167 */
168 outb(port + DAT+7, 0x04); /* clear status */
169 outb(port + ISR, 0x40); /* set to bank 2 */
170 outb(port + MCR, 0x08); /* IMD */
171 outb(port + DAT, 0x21); /* FMD */
172 outb(port + ISR, 0x00); /* set to bank 0 */
173 } else {
174 /*
175 * set the UART in FIFO mode if it has FIFO buffers.
176 * use 16550 fifo reset sequence specified in NS
177 * application note. disable fifos until chip is
178 * initialized.
179 */
180 outb(port + FIFOR, 0x00); /* clear */
181 outb(port + FIFOR, FIFO_ON); /* enable */
182 outb(port + FIFOR, FIFO_ON|FIFORXFLSH); /* reset */
183 outb(port + FIFOR,
184 FIFO_ON|FIFODMA|FIFOTXFLSH|FIFORXFLSH|0x80);
185 if ((inb(port + ISR) & 0xc0) != 0xc0) {
186 /*
187 * no fifo buffers so disable fifos.
188 * this is true for 8250's
189 */
190 outb(port + FIFOR, 0x00);
191 }
192 }
193
194 /* disable interrupts */
195 outb(port + ICR, 0);
196
197 #if !defined(_BOOT)
198 if (IN_XPV_PANIC())
199 return;
200 #endif
201
202 /* adjust setting based on tty properties */
203 serial_adjust_prop();
204
205 #if defined(_BOOT)
206 /*
207 * Do a full reset to match console behavior.
208 * 0x1B + c - reset everything
209 */
210 serial_putchar(0x1B);
211 serial_putchar('c');
212 #endif
213 }
214
215 /* Advance str pointer past white space */
216 #define EAT_WHITE_SPACE(str) { \
217 while ((*str != '\0') && ISSPACE(*str)) \
218 str++; \
219 }
220
221 /*
222 * boot_line is set when we call here. Search it for the argument name,
223 * and if found, return a pointer to it.
224 */
225 static char *
226 find_boot_line_prop(const char *name)
227 {
228 char *ptr;
229 char *ret = NULL;
230 char end_char;
231 size_t len;
232
233 if (boot_line == NULL)
234 return (NULL);
235
236 len = strlen(name);
237
238 /*
239 * We have two nested loops here: the outer loop discards all options
240 * except -B, and the inner loop parses the -B options looking for
241 * the one we're interested in.
242 */
243 for (ptr = boot_line; *ptr != '\0'; ptr++) {
244 EAT_WHITE_SPACE(ptr);
245
246 if (*ptr == '-') {
247 ptr++;
248 while ((*ptr != '\0') && (*ptr != 'B') &&
249 !ISSPACE(*ptr))
250 ptr++;
251 if (*ptr == '\0')
252 goto out;
253 else if (*ptr != 'B')
254 continue;
255 } else {
256 while ((*ptr != '\0') && !ISSPACE(*ptr))
257 ptr++;
258 if (*ptr == '\0')
259 goto out;
260 continue;
261 }
262
263 do {
264 ptr++;
265 EAT_WHITE_SPACE(ptr);
266
267 if ((strncmp(ptr, name, len) == 0) &&
268 (ptr[len] == '=')) {
269 ptr += len + 1;
270 if ((*ptr == '\'') || (*ptr == '"')) {
271 ret = ptr + 1;
272 end_char = *ptr;
273 ptr++;
274 } else {
275 ret = ptr;
276 end_char = ',';
277 }
278 goto consume_property;
279 }
280
281 /*
282 * We have a property, and it's not the one we're
283 * interested in. Skip the property name. A name
284 * can end with '=', a comma, or white space.
285 */
286 while ((*ptr != '\0') && (*ptr != '=') &&
287 (*ptr != ',') && (!ISSPACE(*ptr)))
288 ptr++;
289
290 /*
291 * We only want to go through the rest of the inner
292 * loop if we have a comma. If we have a property
293 * name without a value, either continue or break.
294 */
295 if (*ptr == '\0')
296 goto out;
297 else if (*ptr == ',')
298 continue;
299 else if (ISSPACE(*ptr))
300 break;
301 ptr++;
302
303 /*
304 * Is the property quoted?
305 */
306 if ((*ptr == '\'') || (*ptr == '"')) {
307 end_char = *ptr;
308 ptr++;
309 } else {
310 /*
311 * Not quoted, so the string ends at a comma
312 * or at white space. Deal with white space
313 * later.
314 */
315 end_char = ',';
316 }
317
318 /*
319 * Now, we can ignore any characters until we find
320 * end_char.
321 */
322 consume_property:
323 for (; (*ptr != '\0') && (*ptr != end_char); ptr++) {
324 if ((end_char == ',') && ISSPACE(*ptr))
325 break;
326 }
327 if (*ptr && (*ptr != ',') && !ISSPACE(*ptr))
328 ptr++;
329 } while (*ptr == ',');
330 }
331 out:
332 return (ret);
333 }
334
335 /*
336 * Find prop from boot env module. The data in module is list of C strings
337 * name=value, the list is terminated by double nul.
338 */
339 static const char *
340 find_boot_env_prop(const char *name)
341 {
342 char *ptr;
343 size_t len;
344 uintptr_t size;
345
346 if (boot_env.be_env == NULL)
347 return (NULL);
348
349 ptr = boot_env.be_env;
350 len = strlen(name);
351
352 /*
353 * Make sure we have at least len + 2 bytes in the environment.
354 * We are looking for name=value\0 constructs, and the environment
355 * itself is terminated by '\0'.
356 */
357 if (boot_env.be_size < len + 2)
358 return (NULL);
359
360 do {
361 if ((strncmp(ptr, name, len) == 0) && (ptr[len] == '=')) {
362 ptr += len + 1;
363 return (ptr);
364 }
365 /* find the first '\0' */
366 while (*ptr != '\0') {
367 ptr++;
368 size = (uintptr_t)ptr - (uintptr_t)boot_env.be_env;
369 if (size > boot_env.be_size)
370 return (NULL);
371 }
372 ptr++;
373
374 /* If the remainder is shorter than name + 2, get out. */
375 size = (uintptr_t)ptr - (uintptr_t)boot_env.be_env;
376 if (boot_env.be_size - size < len + 2)
377 return (NULL);
378 } while (*ptr != '\0');
379 return (NULL);
380 }
381
382 /*
383 * Get prop value from either command line or boot environment.
384 * We always check kernel command line first, as this will keep the
385 * functionality and will allow user to override the values in environment.
386 */
387 const char *
388 find_boot_prop(const char *name)
389 {
390 const char *value = find_boot_line_prop(name);
391
392 if (value == NULL)
393 value = find_boot_env_prop(name);
394 return (value);
395 }
396
397 #define MATCHES(p, pat) \
398 (strncmp(p, pat, strlen(pat)) == 0 ? (p += strlen(pat), 1) : 0)
399
400 #define SKIP(p, c) \
401 while (*(p) != 0 && *p != (c)) \
402 ++(p); \
403 if (*(p) == (c)) \
404 ++(p);
405
406 /*
407 * find a tty mode property either from cmdline or from boot properties
408 */
409 static const char *
410 get_mode_value(char *name)
411 {
412 /*
413 * when specified on boot line it looks like "name" "="....
414 */
415 if (boot_line != NULL) {
416 return (find_boot_prop(name));
417 }
418
419 #if defined(_BOOT)
420 return (NULL);
421 #else
422 /*
423 * if we're running in the full kernel we check the bootenv.rc settings
424 */
425 {
426 static char propval[20];
427
428 propval[0] = 0;
429 if (do_bsys_getproplen(NULL, name) <= 0)
430 return (NULL);
431 (void) do_bsys_getprop(NULL, name, propval);
432 return (propval);
433 }
434 #endif
435 }
436
437 /*
438 * adjust serial port based on properties
439 * These come either from the cmdline or from boot properties.
440 */
441 static void
442 serial_adjust_prop(void)
443 {
444 char propname[20];
445 const char *propval;
446 const char *p;
447 ulong_t baud;
448 uchar_t lcr = 0;
449 uchar_t mcr = DTR | RTS;
450
451 (void) strcpy(propname, "ttyX-mode");
452 propname[3] = 'a' + tty_num;
453 propval = get_mode_value(propname);
454 if (propval == NULL)
455 propval = "9600,8,n,1,-";
456 #if !defined(_BOOT)
457 else
458 console_mode_set = 1;
459 #endif
460
461 /* property is of the form: "9600,8,n,1,-" */
462 p = propval;
463 if (MATCHES(p, "110,"))
464 baud = ASY110;
465 else if (MATCHES(p, "150,"))
466 baud = ASY150;
467 else if (MATCHES(p, "300,"))
468 baud = ASY300;
469 else if (MATCHES(p, "600,"))
470 baud = ASY600;
471 else if (MATCHES(p, "1200,"))
472 baud = ASY1200;
473 else if (MATCHES(p, "2400,"))
474 baud = ASY2400;
475 else if (MATCHES(p, "4800,"))
476 baud = ASY4800;
477 else if (MATCHES(p, "19200,"))
478 baud = ASY19200;
479 else if (MATCHES(p, "38400,"))
480 baud = ASY38400;
481 else if (MATCHES(p, "57600,"))
482 baud = ASY57600;
483 else if (MATCHES(p, "115200,"))
484 baud = ASY115200;
485 else {
486 baud = ASY9600;
487 SKIP(p, ',');
488 }
489 outb(port + LCR, DLAB);
490 outb(port + DAT + DLL, baud & 0xff);
491 outb(port + DAT + DLH, (baud >> 8) & 0xff);
492
493 switch (*p) {
494 case '5':
495 lcr |= BITS5;
496 ++p;
497 break;
498 case '6':
499 lcr |= BITS6;
500 ++p;
501 break;
502 case '7':
503 lcr |= BITS7;
504 ++p;
505 break;
506 case '8':
507 ++p;
508 default:
509 lcr |= BITS8;
510 break;
511 }
512
513 SKIP(p, ',');
514
515 switch (*p) {
516 case 'n':
517 lcr |= PARITY_NONE;
518 ++p;
519 break;
520 case 'o':
521 lcr |= PARITY_ODD;
522 ++p;
523 break;
524 case 'e':
525 ++p;
526 default:
527 lcr |= PARITY_EVEN;
528 break;
529 }
530
531
532 SKIP(p, ',');
533
534 switch (*p) {
535 case '1':
536 /* STOP1 is 0 */
537 ++p;
538 break;
539 default:
540 lcr |= STOP2;
541 break;
542 }
543 /* set parity bits */
544 outb(port + LCR, lcr);
545
546 (void) strcpy(propname, "ttyX-rts-dtr-off");
547 propname[3] = 'a' + tty_num;
548 propval = get_mode_value(propname);
549 if (propval == NULL)
550 propval = "false";
551 if (propval[0] != 'f' && propval[0] != 'F')
552 mcr = 0;
553 /* set modem control bits */
554 outb(port + MCR, mcr | OUT2);
555 }
556
557 /* Obtain the console type */
558 int
559 boot_console_type(int *tnum)
560 {
561 if (tnum != NULL)
562 *tnum = tty_num;
563 return (console);
564 }
565
566 /*
567 * A structure to map console names to values.
568 */
569 typedef struct {
570 char *name;
571 int value;
572 } console_value_t;
573
574 console_value_t console_devices[] = {
575 { "ttya", CONS_TTY }, /* 0 */
576 { "ttyb", CONS_TTY }, /* 1 */
577 { "ttyc", CONS_TTY }, /* 2 */
578 { "ttyd", CONS_TTY }, /* 3 */
579 { "text", CONS_SCREEN_TEXT },
580 { "graphics", CONS_SCREEN_GRAPHICS },
581 #if defined(__xpv)
582 { "hypervisor", CONS_HYPERVISOR },
583 #endif
584 #if !defined(_BOOT)
585 { "usb-serial", CONS_USBSER },
586 #endif
587 { NULL, CONS_INVALID }
588 };
589
590 static void
591 bcons_init_env(struct xboot_info *xbi)
592 {
593 uint32_t i;
594 struct boot_modules *modules;
595
596 modules = (struct boot_modules *)(uintptr_t)xbi->bi_modules;
597 for (i = 0; i < xbi->bi_module_cnt; i++) {
598 if (modules[i].bm_type == BMT_ENV)
599 break;
600 }
601 if (i == xbi->bi_module_cnt)
602 return;
603
604 boot_env.be_env = (char *)(uintptr_t)modules[i].bm_addr;
605 boot_env.be_size = modules[i].bm_size;
606 }
607
608 void
609 bcons_init(struct xboot_info *xbi)
610 {
611 console_value_t *consolep;
612 size_t len, cons_len;
613 const char *cons_str;
614 #if !defined(_BOOT)
615 static char console_text[] = "text";
616 extern int post_fastreboot;
617 #endif
618
619 /* Set up data to fetch properties from commad line and boot env. */
620 boot_line = (char *)(uintptr_t)xbi->bi_cmdline;
621 bcons_init_env(xbi);
622 console = CONS_INVALID;
623
624 #if defined(__xpv)
625 bcons_init_xen(boot_line);
626 #endif /* __xpv */
627
628 cons_str = find_boot_prop("console");
629 if (cons_str == NULL)
630 cons_str = find_boot_prop("output-device");
631
632 #if !defined(_BOOT)
633 if (post_fastreboot && strcmp(cons_str, "graphics") == 0)
634 cons_str = console_text;
635 #endif
636
637 /*
638 * Go through the console_devices array trying to match the string
639 * we were given. The string on the command line must end with
640 * a comma or white space.
641 */
642 if (cons_str != NULL) {
643 int n;
644
645 cons_len = strlen(cons_str);
646 for (n = 0; console_devices[n].name != NULL; n++) {
647 consolep = &console_devices[n];
648 len = strlen(consolep->name);
649 if ((len <= cons_len) && ((cons_str[len] == '\0') ||
650 (cons_str[len] == ',') || (cons_str[len] == '\'') ||
651 (cons_str[len] == '"') || ISSPACE(cons_str[len])) &&
652 (strncmp(cons_str, consolep->name, len) == 0)) {
653 console = consolep->value;
654 if (console == CONS_TTY)
655 tty_num = n;
656 break;
657 }
658 }
659 }
660
661 #if defined(__xpv)
662 /*
663 * domU's always use the hypervisor regardless of what
664 * the console variable may be set to.
665 */
666 if (!DOMAIN_IS_INITDOMAIN(xen_info)) {
667 console = CONS_HYPERVISOR;
668 console_hypervisor_redirect = B_TRUE;
669 }
670 #endif /* __xpv */
671
672 /*
673 * If no console device specified, default to text.
674 * Remember what was specified for second phase.
675 */
676 if (console == CONS_INVALID)
677 console = CONS_SCREEN_TEXT;
678 #if !defined(_BOOT)
679 else
680 console_set = 1;
681 #endif
682
683 #if defined(__xpv)
684 if (DOMAIN_IS_INITDOMAIN(xen_info)) {
685 switch (HYPERVISOR_console_io(CONSOLEIO_get_device, 0, NULL)) {
686 case XEN_CONSOLE_COM1:
687 case XEN_CONSOLE_COM2:
688 console_hypervisor_device = CONS_TTY;
689 console_hypervisor_tty_num = tty_num;
690 break;
691 case XEN_CONSOLE_VGA:
692 /*
693 * Currently xen doesn't really support
694 * keyboard/display console devices.
695 * What this setting means is that
696 * "vga=keep" has been enabled, which is
697 * more of a xen debugging tool that a
698 * true console mode. Hence, we're going
699 * to ignore this xen "console" setting.
700 */
701 /*FALLTHROUGH*/
702 default:
703 console_hypervisor_device = CONS_INVALID;
704 }
705 }
706
707 /*
708 * if the hypervisor is using the currently selected serial
709 * port then default to using the hypervisor as the console
710 * device.
711 */
712 if (console == console_hypervisor_device) {
713 console = CONS_HYPERVISOR;
714 console_hypervisor_redirect = B_TRUE;
715 }
716 #endif /* __xpv */
717
718 switch (console) {
719 case CONS_TTY:
720 serial_init();
721 break;
722
723 case CONS_HYPERVISOR:
724 break;
725
726 #if !defined(_BOOT)
727 case CONS_USBSER:
728 /*
729 * We can't do anything with the usb serial
730 * until we have memory management.
731 */
732 break;
733 #endif
734 case CONS_SCREEN_GRAPHICS:
735 kb_init();
736 break;
737 case CONS_SCREEN_TEXT:
738 default:
739 #if defined(_BOOT)
740 clear_screen(); /* clears the grub or xen screen */
741 #endif /* _BOOT */
742 kb_init();
743 break;
744 }
745 }
746
747 #if !defined(_BOOT)
748 /*
749 * 2nd part of console initialization.
750 * In the kernel (ie. fakebop), this can be used only to switch to
751 * using a serial port instead of screen based on the contents
752 * of the bootenv.rc file.
753 */
754 /*ARGSUSED*/
755 void
756 bcons_init2(char *inputdev, char *outputdev, char *consoledev)
757 {
758 int cons = CONS_INVALID;
759 int ttyn;
760 char *devnames[] = { consoledev, outputdev, inputdev, NULL };
761 console_value_t *consolep;
762 int i;
763 extern int post_fastreboot;
764
765 if (post_fastreboot && console == CONS_SCREEN_GRAPHICS)
766 console = CONS_SCREEN_TEXT;
767
768 if (console != CONS_USBSER && console != CONS_SCREEN_GRAPHICS) {
769 if (console_set) {
770 /*
771 * If the console was set on the command line,
772 * but the ttyX-mode was not, we only need to
773 * check bootenv.rc for that setting.
774 */
775 if ((!console_mode_set) && (console == CONS_TTY))
776 serial_init();
777 return;
778 }
779
780 for (i = 0; devnames[i] != NULL; i++) {
781 int n;
782
783 for (n = 0; console_devices[n].name != NULL; n++) {
784 consolep = &console_devices[n];
785 if (strcmp(devnames[i], consolep->name) == 0) {
786 cons = consolep->value;
787 if (cons == CONS_TTY)
788 ttyn = n;
789 }
790 }
791 if (cons != CONS_INVALID)
792 break;
793 }
794
795 #if defined(__xpv)
796 /*
797 * if the hypervisor is using the currently selected console
798 * device then default to using the hypervisor as the console
799 * device.
800 */
801 if (cons == console_hypervisor_device) {
802 cons = CONS_HYPERVISOR;
803 console_hypervisor_redirect = B_TRUE;
804 }
805 #endif /* __xpv */
806
807 if ((cons == CONS_INVALID) || (cons == console)) {
808 /*
809 * we're sticking with whatever the current setting is
810 */
811 return;
812 }
813
814 console = cons;
815 if (cons == CONS_TTY) {
816 tty_num = ttyn;
817 serial_init();
818 return;
819 }
820 } else {
821 /*
822 * USB serial and GRAPHICS console
823 * we just collect data into a buffer
824 */
825 extern void *defcons_init(size_t);
826 defcons_buf = defcons_cur = defcons_init(MMU_PAGESIZE);
827 }
828 }
829
830 #if defined(__xpv)
831 boolean_t
832 bcons_hypervisor_redirect(void)
833 {
834 return (console_hypervisor_redirect);
835 }
836
837 void
838 bcons_device_change(int new_console)
839 {
840 if (new_console < CONS_MIN || new_console > CONS_MAX)
841 return;
842
843 /*
844 * If we are asked to switch the console to the hypervisor, that
845 * really means to switch the console to whichever device the
846 * hypervisor is/was using.
847 */
848 if (new_console == CONS_HYPERVISOR)
849 new_console = console_hypervisor_device;
850
851 console = new_console;
852
853 if (new_console == CONS_TTY) {
854 tty_num = console_hypervisor_tty_num;
855 serial_init();
856 }
857 }
858 #endif /* __xpv */
859
860 static void
861 defcons_putchar(int c)
862 {
863 if (defcons_buf != NULL &&
864 defcons_cur + 1 - defcons_buf < MMU_PAGESIZE) {
865 *defcons_cur++ = c;
866 *defcons_cur = 0;
867 }
868 }
869 #endif /* _BOOT */
870
871 static void
872 serial_putchar(int c)
873 {
874 int checks = 10000;
875
876 while (((inb(port + LSR) & XHRE) == 0) && checks--)
877 ;
878 outb(port + DAT, (char)c);
879 }
880
881 static int
882 serial_getchar(void)
883 {
884 uchar_t lsr;
885
886 while (serial_ischar() == 0)
887 ;
888
889 lsr = inb(port + LSR);
890 if (lsr & (SERIAL_BREAK | SERIAL_FRAME |
891 SERIAL_PARITY | SERIAL_OVERRUN)) {
892 if (lsr & SERIAL_OVERRUN) {
893 return (inb(port + DAT));
894 } else {
895 /* Toss the garbage */
896 (void) inb(port + DAT);
897 return (0);
898 }
899 }
900 return (inb(port + DAT));
901 }
902
903 static int
904 serial_ischar(void)
905 {
906 return (inb(port + LSR) & RCA);
907 }
908
909 static void
910 _doputchar(int c)
911 {
912 switch (console) {
913 case CONS_TTY:
914 serial_putchar(c);
915 return;
916 case CONS_SCREEN_TEXT:
917 screen_putchar(c);
918 return;
919 case CONS_SCREEN_GRAPHICS:
920 #if !defined(_BOOT)
921 case CONS_USBSER:
922 defcons_putchar(c);
923 #endif /* _BOOT */
924 return;
925 }
926 }
927
928 void
929 bcons_putchar(int c)
930 {
931 static int bhcharpos = 0;
932
933 #if defined(__xpv)
934 if (!DOMAIN_IS_INITDOMAIN(xen_info) ||
935 console == CONS_HYPERVISOR) {
936 bcons_putchar_xen(c);
937 return;
938 }
939 #endif /* __xpv */
940
941 if (c == '\t') {
942 do {
943 _doputchar(' ');
944 } while (++bhcharpos % 8);
945 return;
946 } else if (c == '\n' || c == '\r') {
947 bhcharpos = 0;
948 _doputchar('\r');
949 _doputchar(c);
950 return;
951 } else if (c == '\b') {
952 if (bhcharpos)
953 bhcharpos--;
954 _doputchar(c);
955 return;
956 }
957
958 bhcharpos++;
959 _doputchar(c);
960 }
961
962 /*
963 * kernel character input functions
964 */
965 int
966 bcons_getchar(void)
967 {
968 #if defined(__xpv)
969 if (!DOMAIN_IS_INITDOMAIN(xen_info) ||
970 console == CONS_HYPERVISOR)
971 return (bcons_getchar_xen());
972 #endif /* __xpv */
973
974 switch (console) {
975 case CONS_TTY:
976 return (serial_getchar());
977 default:
978 return (kb_getchar());
979 }
980 }
981
982 #if !defined(_BOOT)
983
984 int
985 bcons_ischar(void)
986 {
987
988 #if defined(__xpv)
989 if (!DOMAIN_IS_INITDOMAIN(xen_info) ||
990 console == CONS_HYPERVISOR)
991 return (bcons_ischar_xen());
992 #endif /* __xpv */
993
994 switch (console) {
995 case CONS_TTY:
996 return (serial_ischar());
997 default:
998 return (kb_ischar());
999 }
1000 }
1001
1002 #endif /* _BOOT */