From 2945c302daefa047d645941bbb1185d51a713f0d Mon Sep 17 00:00:00 2001 From: KATO Takenori Date: Thu, 20 Jan 2000 15:16:49 +0000 Subject: [PATCH] Synced with the sc driver in the sys/dev/syscons directory. Submitted by: yokota --- sys/conf/files.pc98 | 4 + sys/pc98/cbus/sc_machdep.h | 24 - sys/pc98/cbus/scgdcrndr.c | 9 +- sys/pc98/cbus/scterm-sck.c | 1093 ++++++++++++++++++++++++ sys/pc98/cbus/syscons_cbus.c | 18 +- sys/pc98/pc98/sc_machdep.h | 24 - sys/pc98/pc98/scgdcrndr.c | 9 +- sys/pc98/pc98/scterm-sck.c | 1093 ++++++++++++++++++++++++ sys/pc98/pc98/syscons.c | 1535 +++++++--------------------------- sys/pc98/pc98/syscons_pc98.c | 18 +- 10 files changed, 2531 insertions(+), 1296 deletions(-) create mode 100644 sys/pc98/cbus/scterm-sck.c create mode 100644 sys/pc98/pc98/scterm-sck.c diff --git a/sys/conf/files.pc98 b/sys/conf/files.pc98 index e470be5a1c58..706d4f59d1f7 100644 --- a/sys/conf/files.pc98 +++ b/sys/conf/files.pc98 @@ -315,8 +315,12 @@ pc98/pc98/syscons_pc98.c optional sc dev/syscons/schistory.c optional sc dev/syscons/scmouse.c optional sc pc98/pc98/scgdcrndr.c optional sc +dev/syscons/scterm.c optional sc +dev/syscons/scterm-dumb.c optional sc +pc98/pc98/scterm-sck.c optional sc dev/syscons/scvidctl.c optional sc pc98/pc98/scvtbpc98.c optional sc +dev/syscons/sysmouse.c optional sc i386/isa/tw.c optional tw pc98/pc98/wd.c optional wdc pc98/pc98/wd.c optional wd diff --git a/sys/pc98/cbus/sc_machdep.h b/sys/pc98/cbus/sc_machdep.h index be8419f2df02..038f018f6840 100644 --- a/sys/pc98/cbus/sc_machdep.h +++ b/sys/pc98/cbus/sc_machdep.h @@ -58,28 +58,4 @@ #define ISFONTAVAIL(af) ((af) & V_ADP_FONT) #define ISPALAVAIL(af) ((af) & V_ADP_PALETTE) -#ifdef KANJI - -#define IS_KTYPE_ASCII_or_HANKAKU(A) (!((A) & 0xee)) -#define IS_KTYPE_KANA(A) ((A) & 0x11) -#define KTYPE_MASK_CTRL(A) ((A) &= 0xF0) - -#define _SCR_MD_STAT_DECLARED_ -typedef struct { - u_char kanji_1st_char; - u_char kanji_type; -#define KTYPE_ASCII 0 /* ASCII */ -#define KTYPE_KANA 1 /* HANKAKU */ -#define KTYPE_JKANA 0x10 /* JIS HANKAKU */ -#define KTYPE_7JIS 0x20 /* JIS */ -#define KTYPE_SJIS 2 /* Shift JIS */ -#define KTYPE_UJIS 4 /* UJIS */ -#define KTYPE_SUKANA 3 /* Shift JIS or UJIS HANKAKU */ -#define KTYPE_SUJIS 6 /* SHift JIS or UJIS */ -#define KTYPE_KANIN 0x80 /* Kanji Invoke sequence */ -#define KTYPE_ASCIN 0x40 /* ASCII Invoke sequence */ -} scr_md_stat_t; - -#endif /* KANJI */ - #endif /* !_PC98_PC98_SC_MACHDEP_H_ */ diff --git a/sys/pc98/cbus/scgdcrndr.c b/sys/pc98/cbus/scgdcrndr.c index df4d0eed356a..22a6d5d672c0 100644 --- a/sys/pc98/cbus/scgdcrndr.c +++ b/sys/pc98/cbus/scgdcrndr.c @@ -37,7 +37,6 @@ #include #include -#include #include #include @@ -63,6 +62,8 @@ static vr_draw_border_t gdc_grborder; static void gdc_nop(scr_stat *scp, ...); +static struct linker_set gdc_set; + static sc_rndr_sw_t txtrndrsw = { gdc_txtclear, gdc_txtborder, @@ -73,7 +74,7 @@ static sc_rndr_sw_t txtrndrsw = { (vr_set_mouse_t *)gdc_nop, gdc_txtmouse, }; -RENDERER(gdc, 0, txtrndrsw); +RENDERER(gdc, 0, txtrndrsw, gdc_set); #ifndef SC_NO_MODE_CHANGE static sc_rndr_sw_t grrndrsw = { @@ -86,9 +87,11 @@ static sc_rndr_sw_t grrndrsw = { (vr_set_mouse_t *)gdc_nop, (vr_draw_mouse_t *)gdc_nop, }; -RENDERER(gdc, GRAPHICS_MODE, grrndrsw); +RENDERER(gdc, GRAPHICS_MODE, grrndrsw, gdc_set); #endif /* SC_NO_MODE_CHANGE */ +RENDERER_MODULE(gdc, gdc_set); + static void gdc_nop(scr_stat *scp, ...) { diff --git a/sys/pc98/cbus/scterm-sck.c b/sys/pc98/cbus/scterm-sck.c new file mode 100644 index 000000000000..57b959d244d4 --- /dev/null +++ b/sys/pc98/cbus/scterm-sck.c @@ -0,0 +1,1093 @@ +/*- + * Copyright (c) 1999 FreeBSD(98) Porting Team. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer as + * the first lines of this file unmodified. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#include "sc.h" +#include "opt_syscons.h" + +#if NSC > 0 + +#include +#include +#include +#include + +#include + +#include +#include + +#ifndef SC_DUMB_TERMINAL + +#define MAX_ESC_PAR 5 + +#ifdef KANJI +#define IS_KTYPE_ASCII_or_HANKAKU(A) (!((A) & 0xee)) +#define IS_KTYPE_KANA(A) ((A) & 0x11) +#define KTYPE_MASK_CTRL(A) ((A) &= 0xF0) +#endif /* KANJI */ + +/* attribute flags */ +typedef struct { + u_short fg; /* foreground color */ + u_short bg; /* background color */ +} color_t; + +typedef struct { + int flags; +#define SCTERM_BUSY (1 << 0) + int esc; + int num_param; + int last_param; + int param[MAX_ESC_PAR]; + int saved_xpos; + int saved_ypos; + +#ifdef KANJI + u_char kanji_1st_char; + u_char kanji_type; +#define KTYPE_ASCII 0 /* ASCII */ +#define KTYPE_KANA 1 /* HANKAKU */ +#define KTYPE_JKANA 0x10 /* JIS HANKAKU */ +#define KTYPE_7JIS 0x20 /* JIS */ +#define KTYPE_SJIS 2 /* Shift JIS */ +#define KTYPE_UJIS 4 /* UJIS */ +#define KTYPE_SUKANA 3 /* Shift JIS or UJIS HANKAKU */ +#define KTYPE_SUJIS 6 /* SHift JIS or UJIS */ +#define KTYPE_KANIN 0x80 /* Kanji Invoke sequence */ +#define KTYPE_ASCIN 0x40 /* ASCII Invoke sequence */ +#endif /* KANJI */ + + int attr_mask; /* current logical attr mask */ +#define NORMAL_ATTR 0x00 +#define BLINK_ATTR 0x01 +#define BOLD_ATTR 0x02 +#define UNDERLINE_ATTR 0x04 +#define REVERSE_ATTR 0x08 +#define FG_CHANGED 0x10 +#define BG_CHANGED 0x20 + int cur_attr; /* current hardware attr word */ + color_t cur_color; /* current hardware color */ + color_t std_color; /* normal hardware color */ + color_t rev_color; /* reverse hardware color */ + color_t dflt_std_color; /* default normal color */ + color_t dflt_rev_color; /* default reverse color */ +} term_stat; + +static sc_term_init_t scterm_init; +static sc_term_term_t scterm_term; +static sc_term_puts_t scterm_puts; +static sc_term_ioctl_t scterm_ioctl; +static sc_term_reset_t scterm_reset; +static sc_term_default_attr_t scterm_default_attr; +static sc_term_clear_t scterm_clear; +static sc_term_notify_t scterm_notify; +static sc_term_input_t scterm_input; + +static sc_term_sw_t sc_term_sc = { + { NULL, NULL }, + "sck", /* emulator name */ + "syscons kanji terminal", /* description */ + "*", /* matching renderer, any :-) */ + sizeof(term_stat), /* softc size */ + 0, + scterm_init, + scterm_term, + scterm_puts, + scterm_ioctl, + scterm_reset, + scterm_default_attr, + scterm_clear, + scterm_notify, + scterm_input, +}; + +SCTERM_MODULE(sc, sc_term_sc); + +static term_stat reserved_term_stat; +static int default_kanji = UJIS; +static void scterm_scan_esc(scr_stat *scp, term_stat *tcp, + u_char c); +static int mask2attr(term_stat *tcp); +static u_char iskanji1(u_char mode, u_char c); +static u_char iskanji2(u_char mode, u_char c); +static u_short kanji_convert(u_char mode, u_char h, u_char l); + +static int +scterm_init(scr_stat *scp, void **softc, int code) +{ + term_stat *tcp; + + if (*softc == NULL) { + if (reserved_term_stat.flags & SCTERM_BUSY) + return EINVAL; + *softc = &reserved_term_stat; + } + tcp = *softc; + + switch (code) { + case SC_TE_COLD_INIT: + bzero(tcp, sizeof(*tcp)); + tcp->flags = SCTERM_BUSY; + tcp->esc = 0; + tcp->saved_xpos = -1; + tcp->saved_ypos = -1; + +#ifdef KANJI + tcp->kanji_1st_char = 0; + tcp->kanji_type = KTYPE_ASCII; +#endif + + tcp->attr_mask = NORMAL_ATTR; + /* XXX */ + tcp->dflt_std_color.fg = SC_NORM_ATTR & 0x0f; + tcp->dflt_std_color.bg = (SC_NORM_ATTR >> 4) & 0x0f; + tcp->dflt_rev_color.fg = SC_NORM_REV_ATTR & 0x0f; + tcp->dflt_rev_color.bg = (SC_NORM_REV_ATTR >> 4) & 0x0f; + tcp->std_color = tcp->dflt_std_color; + tcp->rev_color = tcp->dflt_rev_color; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); + ++sc_term_sc.te_refcount; + break; + + case SC_TE_WARM_INIT: + tcp->esc = 0; + tcp->saved_xpos = -1; + tcp->saved_ypos = -1; + tcp->std_color = tcp->dflt_std_color; + tcp->rev_color = tcp->dflt_rev_color; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); + break; + } + + return 0; +} + +static int +scterm_term(scr_stat *scp, void **softc) +{ + if (*softc == &reserved_term_stat) { + *softc = NULL; + bzero(&reserved_term_stat, sizeof(reserved_term_stat)); + } + --sc_term_sc.te_refcount; + return 0; +} + +static void +scterm_scan_esc(scr_stat *scp, term_stat *tcp, u_char c) +{ + static u_char ansi_col[16] = { + FG_BLACK, FG_RED, FG_GREEN, FG_BROWN, + FG_BLUE, FG_MAGENTA, FG_CYAN, FG_LIGHTGREY, + FG_DARKGREY, FG_LIGHTRED, FG_LIGHTGREEN, FG_YELLOW, + FG_LIGHTBLUE, FG_LIGHTMAGENTA, FG_LIGHTCYAN, FG_WHITE + }; + sc_softc_t *sc; + int i, n; + + i = n = 0; + sc = scp->sc; + if (tcp->esc == 1) { /* seen ESC */ + switch (c) { + + case '7': /* Save cursor position */ + tcp->saved_xpos = scp->xpos; + tcp->saved_ypos = scp->ypos; + break; + + case '8': /* Restore saved cursor position */ + if (tcp->saved_xpos >= 0 && tcp->saved_ypos >= 0) + sc_move_cursor(scp, tcp->saved_xpos, tcp->saved_ypos); + break; + + case '[': /* Start ESC [ sequence */ + tcp->esc = 2; + tcp->last_param = -1; + for (i = tcp->num_param; i < MAX_ESC_PAR; i++) + tcp->param[i] = 1; + tcp->num_param = 0; + return; + +#ifdef KANJI + case '$': /* Kanji Invoke sequence */ + tcp->kanji_type = KTYPE_KANIN; + return; +#endif + + case 'M': /* Move cursor up 1 line, scroll if at top */ + sc_term_up_scroll(scp, 1, sc->scr_map[0x20], tcp->cur_attr, 0, 0); + break; +#if notyet + case 'Q': + tcp->esc = 4; + return; +#endif + case 'c': /* Clear screen & home */ + sc_clear_screen(scp); + break; + + case '(': /* iso-2022: designate 94 character set to G0 */ +#ifdef KANJI + tcp->kanji_type = KTYPE_ASCIN; +#else + tcp->esc = 5; +#endif + return; + } + } + else if (tcp->esc == 2) { /* seen ESC [ */ + if (c >= '0' && c <= '9') { + if (tcp->num_param < MAX_ESC_PAR) { + if (tcp->last_param != tcp->num_param) { + tcp->last_param = tcp->num_param; + tcp->param[tcp->num_param] = 0; + } else { + tcp->param[tcp->num_param] *= 10; + } + tcp->param[tcp->num_param] += c - '0'; + return; + } + } + tcp->num_param = tcp->last_param + 1; + switch (c) { + + case ';': + if (tcp->num_param < MAX_ESC_PAR) + return; + break; + + case '=': + tcp->esc = 3; + tcp->last_param = -1; + for (i = tcp->num_param; i < MAX_ESC_PAR; i++) + tcp->param[i] = 1; + tcp->num_param = 0; + return; + + case 'A': /* up n rows */ + sc_term_up(scp, tcp->param[0], 0); + break; + + case 'B': /* down n rows */ + sc_term_down(scp, tcp->param[0], 0); + break; + + case 'C': /* right n columns */ + sc_term_right(scp, tcp->param[0]); + break; + + case 'D': /* left n columns */ + sc_term_left(scp, tcp->param[0]); + break; + + case 'E': /* cursor to start of line n lines down */ + n = tcp->param[0]; if (n < 1) n = 1; + sc_move_cursor(scp, 0, scp->ypos + n); + break; + + case 'F': /* cursor to start of line n lines up */ + n = tcp->param[0]; if (n < 1) n = 1; + sc_move_cursor(scp, 0, scp->ypos - n); + break; + + case 'f': /* Cursor move */ + case 'H': + if (tcp->num_param == 0) + sc_move_cursor(scp, 0, 0); + else if (tcp->num_param == 2) + sc_move_cursor(scp, tcp->param[1] - 1, tcp->param[0] - 1); + break; + + case 'J': /* Clear all or part of display */ + if (tcp->num_param == 0) + n = 0; + else + n = tcp->param[0]; + sc_term_clr_eos(scp, n, sc->scr_map[0x20], tcp->cur_attr); + break; + + case 'K': /* Clear all or part of line */ + if (tcp->num_param == 0) + n = 0; + else + n = tcp->param[0]; + sc_term_clr_eol(scp, n, sc->scr_map[0x20], tcp->cur_attr); + break; + + case 'L': /* Insert n lines */ + sc_term_ins_line(scp, scp->ypos, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr, 0); + break; + + case 'M': /* Delete n lines */ + sc_term_del_line(scp, scp->ypos, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr, 0); + break; + + case 'P': /* Delete n chars */ + sc_term_del_char(scp, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr); + break; + + case '@': /* Insert n chars */ + sc_term_ins_char(scp, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr); + break; + + case 'S': /* scroll up n lines */ + sc_term_del_line(scp, 0, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr, 0); + break; + + case 'T': /* scroll down n lines */ + sc_term_ins_line(scp, 0, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr, 0); + break; + + case 'X': /* erase n characters in line */ + n = tcp->param[0]; if (n < 1) n = 1; + if (n > scp->xsize - scp->xpos) + n = scp->xsize - scp->xpos; + sc_vtb_erase(&scp->vtb, scp->cursor_pos, n, + sc->scr_map[0x20], tcp->cur_attr); + mark_for_update(scp, scp->cursor_pos); + mark_for_update(scp, scp->cursor_pos + n - 1); + break; + + case 'Z': /* move n tabs backwards */ + sc_term_backtab(scp, tcp->param[0]); + break; + + case '`': /* move cursor to column n */ + sc_term_col(scp, tcp->param[0]); + break; + + case 'a': /* move cursor n columns to the right */ + sc_term_right(scp, tcp->param[0]); + break; + + case 'd': /* move cursor to row n */ + sc_term_row(scp, tcp->param[0]); + break; + + case 'e': /* move cursor n rows down */ + sc_term_down(scp, tcp->param[0], 0); + break; + + case 'm': /* change attribute */ + if (tcp->num_param == 0) { + tcp->attr_mask = NORMAL_ATTR; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); + break; + } + for (i = 0; i < tcp->num_param; i++) { + switch (n = tcp->param[i]) { + case 0: /* back to normal */ + tcp->attr_mask = NORMAL_ATTR; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); + break; + case 1: /* bold */ + tcp->attr_mask |= BOLD_ATTR; + tcp->cur_attr = mask2attr(tcp); + break; + case 4: /* underline */ + tcp->attr_mask |= UNDERLINE_ATTR; + tcp->cur_attr = mask2attr(tcp); + break; + case 5: /* blink */ + tcp->attr_mask |= BLINK_ATTR; + tcp->cur_attr = mask2attr(tcp); + break; + case 7: /* reverse video */ + tcp->attr_mask |= REVERSE_ATTR; + tcp->cur_attr = mask2attr(tcp); + break; + case 30: case 31: /* set fg color */ + case 32: case 33: case 34: + case 35: case 36: case 37: + tcp->attr_mask |= FG_CHANGED; + tcp->cur_color.fg = ansi_col[n - 30]; + tcp->cur_attr = mask2attr(tcp); + break; + case 40: case 41: /* set bg color */ + case 42: case 43: case 44: + case 45: case 46: case 47: + tcp->attr_mask |= BG_CHANGED; + tcp->cur_color.bg = ansi_col[n - 40]; + tcp->cur_attr = mask2attr(tcp); + break; + } + } + break; + + case 's': /* Save cursor position */ + tcp->saved_xpos = scp->xpos; + tcp->saved_ypos = scp->ypos; + break; + + case 'u': /* Restore saved cursor position */ + if (tcp->saved_xpos >= 0 && tcp->saved_ypos >= 0) + sc_move_cursor(scp, tcp->saved_xpos, tcp->saved_ypos); + break; + + case 'x': + if (tcp->num_param == 0) + n = 0; + else + n = tcp->param[0]; + switch (n) { + case 0: /* reset attributes */ + tcp->attr_mask = NORMAL_ATTR; + tcp->cur_color = tcp->std_color = tcp->dflt_std_color; + tcp->rev_color = tcp->dflt_rev_color; + tcp->cur_attr = mask2attr(tcp); + break; + case 1: /* set ansi background */ + tcp->attr_mask &= ~BG_CHANGED; + tcp->cur_color.bg = tcp->std_color.bg = + ansi_col[tcp->param[1] & 0x0f]; + tcp->cur_attr = mask2attr(tcp); + break; + case 2: /* set ansi foreground */ + tcp->attr_mask &= ~FG_CHANGED; + tcp->cur_color.fg = tcp->std_color.fg = + ansi_col[tcp->param[1] & 0x0f]; + tcp->cur_attr = mask2attr(tcp); + break; + case 3: /* set ansi attribute directly */ + tcp->attr_mask &= ~(FG_CHANGED | BG_CHANGED); + tcp->cur_color.fg = tcp->std_color.fg = + tcp->param[1] & 0x0f; + tcp->cur_color.bg = tcp->std_color.bg = + (tcp->param[1] >> 4) & 0x0f; + tcp->cur_attr = mask2attr(tcp); + break; + case 5: /* set ansi reverse video background */ + tcp->rev_color.bg = ansi_col[tcp->param[1] & 0x0f]; + tcp->cur_attr = mask2attr(tcp); + break; + case 6: /* set ansi reverse video foreground */ + tcp->rev_color.fg = ansi_col[tcp->param[1] & 0x0f]; + tcp->cur_attr = mask2attr(tcp); + break; + case 7: /* set ansi reverse video directly */ + tcp->rev_color.fg = tcp->param[1] & 0x0f; + tcp->rev_color.bg = (tcp->param[1] >> 4) & 0x0f; + tcp->cur_attr = mask2attr(tcp); + break; + } + break; + + case 'z': /* switch to (virtual) console n */ + if (tcp->num_param == 1) + sc_switch_scr(sc, tcp->param[0]); + break; + } + } + else if (tcp->esc == 3) { /* seen ESC [0-9]+ = */ + if (c >= '0' && c <= '9') { + if (tcp->num_param < MAX_ESC_PAR) { + if (tcp->last_param != tcp->num_param) { + tcp->last_param = tcp->num_param; + tcp->param[tcp->num_param] = 0; + } else { + tcp->param[tcp->num_param] *= 10; + } + tcp->param[tcp->num_param] += c - '0'; + return; + } + } + tcp->num_param = tcp->last_param + 1; + switch (c) { + + case ';': + if (tcp->num_param < MAX_ESC_PAR) + return; + break; + + case 'A': /* set display border color */ + if (tcp->num_param == 1) { + scp->border=tcp->param[0] & 0xff; + if (scp == sc->cur_scp) + sc_set_border(scp, scp->border); + } + break; + + case 'B': /* set bell pitch and duration */ + if (tcp->num_param == 2) { + scp->bell_pitch = tcp->param[0]; + scp->bell_duration = tcp->param[1]; + } + break; + + case 'C': /* set cursor type & shape */ + if (!ISGRAPHSC(sc->cur_scp)) + sc_remove_cursor_image(sc->cur_scp); + if (tcp->num_param == 1) { + if (tcp->param[0] & 0x01) + sc->flags |= SC_BLINK_CURSOR; + else + sc->flags &= ~SC_BLINK_CURSOR; + if (tcp->param[0] & 0x02) + sc->flags |= SC_CHAR_CURSOR; + else + sc->flags &= ~SC_CHAR_CURSOR; + } else if (tcp->num_param == 2) { + sc->cursor_base = scp->font_size + - (tcp->param[1] & 0x1F) - 1; + sc->cursor_height = (tcp->param[1] & 0x1F) + - (tcp->param[0] & 0x1F) + 1; + } + /* + * The cursor shape is global property; all virtual consoles + * are affected. Update the cursor in the current console... + */ + if (!ISGRAPHSC(sc->cur_scp)) { + i = spltty(); + sc_set_cursor_image(sc->cur_scp); + sc_draw_cursor_image(sc->cur_scp); + splx(i); + } + break; + + case 'F': /* set ansi foreground */ + if (tcp->num_param == 1) { + tcp->attr_mask &= ~FG_CHANGED; + tcp->cur_color.fg = tcp->std_color.fg = tcp->param[0] & 0x0f; + tcp->cur_attr = mask2attr(tcp); + } + break; + + case 'G': /* set ansi background */ + if (tcp->num_param == 1) { + tcp->attr_mask &= ~BG_CHANGED; + tcp->cur_color.bg = tcp->std_color.bg = tcp->param[0] & 0x0f; + tcp->cur_attr = mask2attr(tcp); + } + break; + + case 'H': /* set ansi reverse video foreground */ + if (tcp->num_param == 1) { + tcp->rev_color.fg = tcp->param[0] & 0x0f; + tcp->cur_attr = mask2attr(tcp); + } + break; + + case 'I': /* set ansi reverse video background */ + if (tcp->num_param == 1) { + tcp->rev_color.bg = tcp->param[0] & 0x0f; + tcp->cur_attr = mask2attr(tcp); + } + break; + } + } +#if notyet + else if (tcp->esc == 4) { /* seen ESC Q */ + /* to be filled */ + } +#endif + else if (tcp->esc == 5) { /* seen ESC ( */ + switch (c) { + case 'B': /* iso-2022: desginate ASCII into G0 */ + break; + /* other items to be filled */ + default: + break; + } + } + tcp->esc = 0; +} + +static void +scterm_puts(scr_stat *scp, u_char *buf, int len) +{ + term_stat *tcp = scp->ts; + u_char *ptr = buf; +#ifdef KANJI + u_short kanji_code; +#endif + +outloop: + scp->sc->write_in_progress++; + + if (tcp->esc) { + scterm_scan_esc(scp, tcp, *ptr++); + len--; + } + else if (PRINTABLE(*ptr)) { /* Print only printables */ + vm_offset_t p; + u_char *map; + int attr; + int i; +#ifdef KANJI + u_char c; +#else + int cnt; +#endif + + p = sc_vtb_pointer(&scp->vtb, scp->cursor_pos); + map = scp->sc->scr_map; + attr = tcp->cur_attr; + +#ifdef KANJI + c = *ptr; + if (tcp->kanji_1st_char == 0) { + tcp->kanji_type = iskanji1(tcp->kanji_type, c); + if (!IS_KTYPE_ASCII_or_HANKAKU(tcp->kanji_type)) { + /* not Ascii & not HANKAKU */ + tcp->kanji_1st_char = c; + goto kanji_end; + } else { + tcp->kanji_1st_char = 0; + } + } else { + if ((tcp->kanji_type = iskanji2(tcp->kanji_type, c)) & 0xee) { + /* print kanji on TEXT VRAM */ + kanji_code = kanji_convert(tcp->kanji_type, c, tcp->kanji_1st_char); + mark_for_update(scp, scp->cursor_pos); + for (i=0; i<2; i++){ + /* *cursor_pos = (kanji_code | (i*0x80)); */ + p = sc_vtb_putchar(&scp->vtb, p, + kanji_code | ((i == 0) ? 0x00 : 0x80), + attr); + ++scp->cursor_pos; + if (++scp->xpos >= scp->xsize) { + scp->xpos = 0; + scp->ypos++; + } + } + mark_for_update(scp, scp->cursor_pos - 1); + KTYPE_MASK_CTRL(tcp->kanji_type); + tcp->kanji_1st_char = 0; + goto kanji_end; + } else { + tcp->kanji_1st_char = 0; + } + } + if (IS_KTYPE_KANA(tcp->kanji_type)) + c |= 0x80; + KTYPE_MASK_CTRL(tcp->kanji_type); + sc_vtb_putchar(&scp->vtb, p, map[c], attr); + mark_for_update(scp, scp->cursor_pos); + mark_for_update(scp, scp->cursor_pos); + ++scp->cursor_pos; + ++scp->xpos; +kanji_end: + ++ptr; + --len; +#else /* !KANJI */ + cnt = imin(len, scp->xsize - scp->xpos); + i = cnt; + do { + /* + * gcc-2.6.3 generates poor (un)sign extension code. Casting the + * pointers in the following to volatile should have no effect, + * but in fact speeds up this inner loop from 26 to 18 cycles + * (+ cache misses) on i486's. + */ +#define UCVP(ucp) ((u_char volatile *)(ucp)) + p = sc_vtb_putchar(&scp->vtb, p, UCVP(map)[*UCVP(ptr)], attr); + ++ptr; + --i; + } while (i > 0 && PRINTABLE(*ptr)); + + len -= cnt - i; + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos += cnt - i; + mark_for_update(scp, scp->cursor_pos - 1); + scp->xpos += cnt - i; +#endif /* !KANJI */ + + if (scp->xpos >= scp->xsize) { + scp->xpos = 0; + scp->ypos++; + } + } + else { + switch (*ptr) { + case 0x07: + sc_bell(scp, scp->bell_pitch, scp->bell_duration); + break; + + case 0x08: /* non-destructive backspace */ + if (scp->cursor_pos > 0) { + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos--; + mark_for_update(scp, scp->cursor_pos); + if (scp->xpos > 0) + scp->xpos--; + else { + scp->xpos += scp->xsize - 1; + scp->ypos--; + } + } + break; + + case 0x09: /* non-destructive tab */ + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos += (8 - scp->xpos % 8u); + scp->xpos += (8 - scp->xpos % 8u); + if (scp->xpos >= scp->xsize) { + scp->xpos = 0; + scp->ypos++; + scp->cursor_pos = scp->xsize * scp->ypos; + } + mark_for_update(scp, scp->cursor_pos); + break; + + case 0x0a: /* newline, same pos */ + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos += scp->xsize; + mark_for_update(scp, scp->cursor_pos); + scp->ypos++; + break; + + case 0x0c: /* form feed, clears screen */ + sc_clear_screen(scp); + break; + + case 0x0d: /* return, return to pos 0 */ + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos -= scp->xpos; + mark_for_update(scp, scp->cursor_pos); + scp->xpos = 0; + break; + +#ifdef PC98 + case 0x0e: /* ^N */ + tcp->kanji_type = KTYPE_JKANA; + tcp->esc = 0; + tcp->kanji_1st_char = 0; + break; + + case 0x0f: /* ^O */ + tcp->kanji_type = KTYPE_ASCII; + tcp->esc = 0; + tcp->kanji_1st_char = 0; + break; +#endif /* PC98 */ + + case 0x1b: /* start escape sequence */ + tcp->esc = 1; + tcp->num_param = 0; + break; + } + ptr++; len--; + } + + sc_term_gen_scroll(scp, scp->sc->scr_map[0x20], tcp->cur_attr); + + scp->sc->write_in_progress--; + if (len) + goto outloop; +} + +static int +scterm_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data, + int flag, struct proc *p) +{ + term_stat *tcp = scp->ts; + vid_info_t *vi; + + switch (cmd) { + case GIO_ATTR: /* get current attributes */ + /* FIXME: */ + *(int*)data = (tcp->cur_attr >> 8) & 0xff; + return 0; + case CONS_GETINFO: /* get current (virtual) console info */ + vi = (vid_info_t *)data; + if (vi->size != sizeof(struct vid_info)) + return EINVAL; + vi->mv_norm.fore = tcp->std_color.fg; + vi->mv_norm.back = tcp->std_color.bg; + vi->mv_rev.fore = tcp->rev_color.fg; + vi->mv_rev.back = tcp->rev_color.bg; + /* + * The other fields are filled by the upper routine. XXX + */ + return ENOIOCTL; + } + return ENOIOCTL; +} + +static int +scterm_reset(scr_stat *scp, int code) +{ + /* FIXME */ + return 0; +} + +static void +scterm_default_attr(scr_stat *scp, int color, int rev_color) +{ + term_stat *tcp = scp->ts; + + tcp->dflt_std_color.fg = color & 0x0f; + tcp->dflt_std_color.bg = (color >> 4) & 0x0f; + tcp->dflt_rev_color.fg = rev_color & 0x0f; + tcp->dflt_rev_color.bg = (rev_color >> 4) & 0x0f; + tcp->std_color = tcp->dflt_std_color; + tcp->rev_color = tcp->dflt_rev_color; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); +} + +static void +scterm_clear(scr_stat *scp) +{ + term_stat *tcp = scp->ts; + + sc_move_cursor(scp, 0, 0); + sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], tcp->cur_attr); + mark_all(scp); +} + +static void +scterm_notify(scr_stat *scp, int event) +{ + switch (event) { + case SC_TE_NOTIFY_VTSWITCH_IN: + break; + case SC_TE_NOTIFY_VTSWITCH_OUT: + break; + } +} + +static int +scterm_input(scr_stat *scp, int c, struct tty *tp) +{ + return FALSE; +} + +/* + * Calculate hardware attributes word using logical attributes mask and + * hardware colors + */ + +/* FIXME */ +static int +mask2attr(term_stat *tcp) +{ + int attr, mask = tcp->attr_mask; + + if (mask & REVERSE_ATTR) { + attr = ((mask & FG_CHANGED) ? + tcp->cur_color.bg : tcp->rev_color.fg) | + (((mask & BG_CHANGED) ? + tcp->cur_color.fg : tcp->rev_color.bg) << 4); + } else + attr = tcp->cur_color.fg | (tcp->cur_color.bg << 4); + + /* XXX: underline mapping for Hercules adapter can be better */ + if (mask & (BOLD_ATTR | UNDERLINE_ATTR)) + attr ^= 0x08; + if (mask & BLINK_ATTR) + attr ^= 0x80; + + return (attr << 8); +} + +#ifdef KANJI +static u_char +iskanji1(u_char mode, u_char c) +{ + if ((mode == KTYPE_7JIS) && (c >= 0x21) && (c <= 0x7e)) { + /* JIS */ + default_kanji = UJIS; + return KTYPE_7JIS; + } + + if ((mode == KTYPE_JKANA) && (c >= 0x21) && (c <= 0x5f)) { + /* JIS HANKAKU */ + default_kanji = UJIS; + return KTYPE_JKANA; + } + +#if 1 + if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { + /* UJIS */ + return KTYPE_UJIS; + } +#endif + + if ((c >= 0x81) && (c <= 0x9f) && (c != 0x8e)) { + /* SJIS */ + default_kanji = SJIS; + return KTYPE_SJIS; + } + + if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == SJIS)) { + /* SJIS HANKAKU */ + return KTYPE_KANA; + } + +#if 0 + if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { + /* UJIS */ + return KTYPE_UJIS; + } +#endif + + if ((c >= 0xf0) && (c <= 0xfe)) { + /* UJIS */ + default_kanji = UJIS; + return KTYPE_UJIS; + } + + if ((c >= 0xe0) && (c <= 0xef)) { + /* SJIS or UJIS */ + return KTYPE_SUJIS; + } + + if (c == 0x8e) { + /* SJIS or UJIS HANKAKU */ + return KTYPE_SUKANA; + } + + return KTYPE_ASCII; +} + +static u_char +iskanji2(u_char mode, u_char c) +{ + switch (mode) { + case KTYPE_7JIS: + if ((c >= 0x21) && (c <= 0x7e)) { + /* JIS */ + return KTYPE_7JIS; + } + break; + case KTYPE_SJIS: + if ((c >= 0x40) && (c <= 0xfc) && (c != 0x7f)) { + /* SJIS */ + return KTYPE_SJIS; + } + break; + case KTYPE_UJIS: + if ((c >= 0xa1) && (c <= 0xfe)) { + /* UJIS */ + return KTYPE_UJIS; + } + break; + case KTYPE_SUKANA: + if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { + /* UJIS HANKAKU */ + return KTYPE_KANA; + } + if ((c >= 0x40) && (c <= 0xfc) && (c != 0x7f)) { + /* SJIS */ + default_kanji = SJIS; + return KTYPE_SJIS; + } + break; + case KTYPE_SUJIS: + if ((c >= 0x40) && (c <= 0xa0) && (c != 0x7f)) { + /* SJIS */ + default_kanji = SJIS; + return KTYPE_SJIS; + } + if ((c == 0xfd) || (c == 0xfe)) { + /* UJIS */ + default_kanji = UJIS; + return KTYPE_UJIS; + } + if ((c >= 0xa1) && (c <= 0xfc)) { + if (default_kanji == SJIS) + return KTYPE_SJIS; + if (default_kanji == UJIS) + return KTYPE_UJIS; + } + break; + } + return KTYPE_ASCII; +} + +/* + * JIS X0208-83 keisen conversion table + */ +static u_short keiConv[32] = { + 0x240c, 0x260c, 0x300c, 0x340c, 0x3c0c, 0x380c, 0x400c, 0x500c, + 0x480c, 0x580c, 0x600c, 0x250c, 0x270c, 0x330c, 0x370c, 0x3f0c, + 0x3b0c, 0x470c, 0x570c, 0x4f0c, 0x5f0c, 0x6f0c, 0x440c, 0x530c, + 0x4c0c, 0x5b0c, 0x630c, 0x410c, 0x540c, 0x490c, 0x5c0c, 0x660c +}; + +static u_short +kanji_convert(u_char mode, u_char h, u_char l) +{ + u_short tmp, high, low, c; + high = (u_short) h; + low = (u_short) l; + + switch (mode) { + case KTYPE_SJIS: /* SHIFT JIS */ + if (low >= 0xe0) { + low -= 0x40; + } + low = (low - 0x81) * 2 + 0x21; + if (high > 0x7f) { + high--; + } + if (high > 0x9d) { + low++; + high -= 0x9e - 0x21; + } else { + high -= 0x40 - 0x21; + } + high &= 0x7F; + low &= 0x7F; + tmp = ((high << 8) | low) - 0x20; + break; + case KTYPE_7JIS: /* JIS */ + case KTYPE_UJIS: /* UJIS */ + high &= 0x7F; + low &= 0x7F; + tmp = ((high << 8) | low) - 0x20; + break; + default: + tmp = 0; + break; + } + + /* keisen */ + c = ((tmp & 0xff) << 8) | (tmp >> 8); + /* 0x2821 .. 0x2840 */ + if (0x0821 <= c && c <= 0x0840) + tmp = keiConv[c - 0x0821]; + + return (tmp); +} +#endif /* KANJI */ + +#endif /* SC_DUMB_TERMINAL */ + +#endif /* NSC > 0 */ diff --git a/sys/pc98/cbus/syscons_cbus.c b/sys/pc98/cbus/syscons_cbus.c index 514aaca9ab59..d4f5bd1541d4 100644 --- a/sys/pc98/cbus/syscons_cbus.c +++ b/sys/pc98/cbus/syscons_cbus.c @@ -69,7 +69,7 @@ static driver_t sc_driver = { sizeof(sc_softc_t), }; -static sc_softc_t main_softc = { 0, 0, 0, -1, NULL, -1, NULL, }; +static sc_softc_t main_softc; static int scprobe(device_t dev) @@ -109,17 +109,17 @@ sc_softc_t return NULL; if (flags & SC_KERNEL_CONSOLE) { /* FIXME: clear if it is wired to another unit! */ - main_softc.unit = unit; - return &main_softc; + sc = &main_softc; } else { sc = (sc_softc_t *)device_get_softc(devclass_get_device(sc_devclass, unit)); - if (!(sc->flags & SC_INIT_DONE)) { - sc->unit = unit; - sc->keyboard = -1; - sc->adapter = -1; - } - return sc; } + sc->unit = unit; + if (!(sc->flags & SC_INIT_DONE)) { + sc->keyboard = -1; + sc->adapter = -1; + sc->mouse_char = SC_MOUSE_CHAR; + } + return sc; } sc_softc_t diff --git a/sys/pc98/pc98/sc_machdep.h b/sys/pc98/pc98/sc_machdep.h index be8419f2df02..038f018f6840 100644 --- a/sys/pc98/pc98/sc_machdep.h +++ b/sys/pc98/pc98/sc_machdep.h @@ -58,28 +58,4 @@ #define ISFONTAVAIL(af) ((af) & V_ADP_FONT) #define ISPALAVAIL(af) ((af) & V_ADP_PALETTE) -#ifdef KANJI - -#define IS_KTYPE_ASCII_or_HANKAKU(A) (!((A) & 0xee)) -#define IS_KTYPE_KANA(A) ((A) & 0x11) -#define KTYPE_MASK_CTRL(A) ((A) &= 0xF0) - -#define _SCR_MD_STAT_DECLARED_ -typedef struct { - u_char kanji_1st_char; - u_char kanji_type; -#define KTYPE_ASCII 0 /* ASCII */ -#define KTYPE_KANA 1 /* HANKAKU */ -#define KTYPE_JKANA 0x10 /* JIS HANKAKU */ -#define KTYPE_7JIS 0x20 /* JIS */ -#define KTYPE_SJIS 2 /* Shift JIS */ -#define KTYPE_UJIS 4 /* UJIS */ -#define KTYPE_SUKANA 3 /* Shift JIS or UJIS HANKAKU */ -#define KTYPE_SUJIS 6 /* SHift JIS or UJIS */ -#define KTYPE_KANIN 0x80 /* Kanji Invoke sequence */ -#define KTYPE_ASCIN 0x40 /* ASCII Invoke sequence */ -} scr_md_stat_t; - -#endif /* KANJI */ - #endif /* !_PC98_PC98_SC_MACHDEP_H_ */ diff --git a/sys/pc98/pc98/scgdcrndr.c b/sys/pc98/pc98/scgdcrndr.c index df4d0eed356a..22a6d5d672c0 100644 --- a/sys/pc98/pc98/scgdcrndr.c +++ b/sys/pc98/pc98/scgdcrndr.c @@ -37,7 +37,6 @@ #include #include -#include #include #include @@ -63,6 +62,8 @@ static vr_draw_border_t gdc_grborder; static void gdc_nop(scr_stat *scp, ...); +static struct linker_set gdc_set; + static sc_rndr_sw_t txtrndrsw = { gdc_txtclear, gdc_txtborder, @@ -73,7 +74,7 @@ static sc_rndr_sw_t txtrndrsw = { (vr_set_mouse_t *)gdc_nop, gdc_txtmouse, }; -RENDERER(gdc, 0, txtrndrsw); +RENDERER(gdc, 0, txtrndrsw, gdc_set); #ifndef SC_NO_MODE_CHANGE static sc_rndr_sw_t grrndrsw = { @@ -86,9 +87,11 @@ static sc_rndr_sw_t grrndrsw = { (vr_set_mouse_t *)gdc_nop, (vr_draw_mouse_t *)gdc_nop, }; -RENDERER(gdc, GRAPHICS_MODE, grrndrsw); +RENDERER(gdc, GRAPHICS_MODE, grrndrsw, gdc_set); #endif /* SC_NO_MODE_CHANGE */ +RENDERER_MODULE(gdc, gdc_set); + static void gdc_nop(scr_stat *scp, ...) { diff --git a/sys/pc98/pc98/scterm-sck.c b/sys/pc98/pc98/scterm-sck.c new file mode 100644 index 000000000000..57b959d244d4 --- /dev/null +++ b/sys/pc98/pc98/scterm-sck.c @@ -0,0 +1,1093 @@ +/*- + * Copyright (c) 1999 FreeBSD(98) Porting Team. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer as + * the first lines of this file unmodified. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#include "sc.h" +#include "opt_syscons.h" + +#if NSC > 0 + +#include +#include +#include +#include + +#include + +#include +#include + +#ifndef SC_DUMB_TERMINAL + +#define MAX_ESC_PAR 5 + +#ifdef KANJI +#define IS_KTYPE_ASCII_or_HANKAKU(A) (!((A) & 0xee)) +#define IS_KTYPE_KANA(A) ((A) & 0x11) +#define KTYPE_MASK_CTRL(A) ((A) &= 0xF0) +#endif /* KANJI */ + +/* attribute flags */ +typedef struct { + u_short fg; /* foreground color */ + u_short bg; /* background color */ +} color_t; + +typedef struct { + int flags; +#define SCTERM_BUSY (1 << 0) + int esc; + int num_param; + int last_param; + int param[MAX_ESC_PAR]; + int saved_xpos; + int saved_ypos; + +#ifdef KANJI + u_char kanji_1st_char; + u_char kanji_type; +#define KTYPE_ASCII 0 /* ASCII */ +#define KTYPE_KANA 1 /* HANKAKU */ +#define KTYPE_JKANA 0x10 /* JIS HANKAKU */ +#define KTYPE_7JIS 0x20 /* JIS */ +#define KTYPE_SJIS 2 /* Shift JIS */ +#define KTYPE_UJIS 4 /* UJIS */ +#define KTYPE_SUKANA 3 /* Shift JIS or UJIS HANKAKU */ +#define KTYPE_SUJIS 6 /* SHift JIS or UJIS */ +#define KTYPE_KANIN 0x80 /* Kanji Invoke sequence */ +#define KTYPE_ASCIN 0x40 /* ASCII Invoke sequence */ +#endif /* KANJI */ + + int attr_mask; /* current logical attr mask */ +#define NORMAL_ATTR 0x00 +#define BLINK_ATTR 0x01 +#define BOLD_ATTR 0x02 +#define UNDERLINE_ATTR 0x04 +#define REVERSE_ATTR 0x08 +#define FG_CHANGED 0x10 +#define BG_CHANGED 0x20 + int cur_attr; /* current hardware attr word */ + color_t cur_color; /* current hardware color */ + color_t std_color; /* normal hardware color */ + color_t rev_color; /* reverse hardware color */ + color_t dflt_std_color; /* default normal color */ + color_t dflt_rev_color; /* default reverse color */ +} term_stat; + +static sc_term_init_t scterm_init; +static sc_term_term_t scterm_term; +static sc_term_puts_t scterm_puts; +static sc_term_ioctl_t scterm_ioctl; +static sc_term_reset_t scterm_reset; +static sc_term_default_attr_t scterm_default_attr; +static sc_term_clear_t scterm_clear; +static sc_term_notify_t scterm_notify; +static sc_term_input_t scterm_input; + +static sc_term_sw_t sc_term_sc = { + { NULL, NULL }, + "sck", /* emulator name */ + "syscons kanji terminal", /* description */ + "*", /* matching renderer, any :-) */ + sizeof(term_stat), /* softc size */ + 0, + scterm_init, + scterm_term, + scterm_puts, + scterm_ioctl, + scterm_reset, + scterm_default_attr, + scterm_clear, + scterm_notify, + scterm_input, +}; + +SCTERM_MODULE(sc, sc_term_sc); + +static term_stat reserved_term_stat; +static int default_kanji = UJIS; +static void scterm_scan_esc(scr_stat *scp, term_stat *tcp, + u_char c); +static int mask2attr(term_stat *tcp); +static u_char iskanji1(u_char mode, u_char c); +static u_char iskanji2(u_char mode, u_char c); +static u_short kanji_convert(u_char mode, u_char h, u_char l); + +static int +scterm_init(scr_stat *scp, void **softc, int code) +{ + term_stat *tcp; + + if (*softc == NULL) { + if (reserved_term_stat.flags & SCTERM_BUSY) + return EINVAL; + *softc = &reserved_term_stat; + } + tcp = *softc; + + switch (code) { + case SC_TE_COLD_INIT: + bzero(tcp, sizeof(*tcp)); + tcp->flags = SCTERM_BUSY; + tcp->esc = 0; + tcp->saved_xpos = -1; + tcp->saved_ypos = -1; + +#ifdef KANJI + tcp->kanji_1st_char = 0; + tcp->kanji_type = KTYPE_ASCII; +#endif + + tcp->attr_mask = NORMAL_ATTR; + /* XXX */ + tcp->dflt_std_color.fg = SC_NORM_ATTR & 0x0f; + tcp->dflt_std_color.bg = (SC_NORM_ATTR >> 4) & 0x0f; + tcp->dflt_rev_color.fg = SC_NORM_REV_ATTR & 0x0f; + tcp->dflt_rev_color.bg = (SC_NORM_REV_ATTR >> 4) & 0x0f; + tcp->std_color = tcp->dflt_std_color; + tcp->rev_color = tcp->dflt_rev_color; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); + ++sc_term_sc.te_refcount; + break; + + case SC_TE_WARM_INIT: + tcp->esc = 0; + tcp->saved_xpos = -1; + tcp->saved_ypos = -1; + tcp->std_color = tcp->dflt_std_color; + tcp->rev_color = tcp->dflt_rev_color; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); + break; + } + + return 0; +} + +static int +scterm_term(scr_stat *scp, void **softc) +{ + if (*softc == &reserved_term_stat) { + *softc = NULL; + bzero(&reserved_term_stat, sizeof(reserved_term_stat)); + } + --sc_term_sc.te_refcount; + return 0; +} + +static void +scterm_scan_esc(scr_stat *scp, term_stat *tcp, u_char c) +{ + static u_char ansi_col[16] = { + FG_BLACK, FG_RED, FG_GREEN, FG_BROWN, + FG_BLUE, FG_MAGENTA, FG_CYAN, FG_LIGHTGREY, + FG_DARKGREY, FG_LIGHTRED, FG_LIGHTGREEN, FG_YELLOW, + FG_LIGHTBLUE, FG_LIGHTMAGENTA, FG_LIGHTCYAN, FG_WHITE + }; + sc_softc_t *sc; + int i, n; + + i = n = 0; + sc = scp->sc; + if (tcp->esc == 1) { /* seen ESC */ + switch (c) { + + case '7': /* Save cursor position */ + tcp->saved_xpos = scp->xpos; + tcp->saved_ypos = scp->ypos; + break; + + case '8': /* Restore saved cursor position */ + if (tcp->saved_xpos >= 0 && tcp->saved_ypos >= 0) + sc_move_cursor(scp, tcp->saved_xpos, tcp->saved_ypos); + break; + + case '[': /* Start ESC [ sequence */ + tcp->esc = 2; + tcp->last_param = -1; + for (i = tcp->num_param; i < MAX_ESC_PAR; i++) + tcp->param[i] = 1; + tcp->num_param = 0; + return; + +#ifdef KANJI + case '$': /* Kanji Invoke sequence */ + tcp->kanji_type = KTYPE_KANIN; + return; +#endif + + case 'M': /* Move cursor up 1 line, scroll if at top */ + sc_term_up_scroll(scp, 1, sc->scr_map[0x20], tcp->cur_attr, 0, 0); + break; +#if notyet + case 'Q': + tcp->esc = 4; + return; +#endif + case 'c': /* Clear screen & home */ + sc_clear_screen(scp); + break; + + case '(': /* iso-2022: designate 94 character set to G0 */ +#ifdef KANJI + tcp->kanji_type = KTYPE_ASCIN; +#else + tcp->esc = 5; +#endif + return; + } + } + else if (tcp->esc == 2) { /* seen ESC [ */ + if (c >= '0' && c <= '9') { + if (tcp->num_param < MAX_ESC_PAR) { + if (tcp->last_param != tcp->num_param) { + tcp->last_param = tcp->num_param; + tcp->param[tcp->num_param] = 0; + } else { + tcp->param[tcp->num_param] *= 10; + } + tcp->param[tcp->num_param] += c - '0'; + return; + } + } + tcp->num_param = tcp->last_param + 1; + switch (c) { + + case ';': + if (tcp->num_param < MAX_ESC_PAR) + return; + break; + + case '=': + tcp->esc = 3; + tcp->last_param = -1; + for (i = tcp->num_param; i < MAX_ESC_PAR; i++) + tcp->param[i] = 1; + tcp->num_param = 0; + return; + + case 'A': /* up n rows */ + sc_term_up(scp, tcp->param[0], 0); + break; + + case 'B': /* down n rows */ + sc_term_down(scp, tcp->param[0], 0); + break; + + case 'C': /* right n columns */ + sc_term_right(scp, tcp->param[0]); + break; + + case 'D': /* left n columns */ + sc_term_left(scp, tcp->param[0]); + break; + + case 'E': /* cursor to start of line n lines down */ + n = tcp->param[0]; if (n < 1) n = 1; + sc_move_cursor(scp, 0, scp->ypos + n); + break; + + case 'F': /* cursor to start of line n lines up */ + n = tcp->param[0]; if (n < 1) n = 1; + sc_move_cursor(scp, 0, scp->ypos - n); + break; + + case 'f': /* Cursor move */ + case 'H': + if (tcp->num_param == 0) + sc_move_cursor(scp, 0, 0); + else if (tcp->num_param == 2) + sc_move_cursor(scp, tcp->param[1] - 1, tcp->param[0] - 1); + break; + + case 'J': /* Clear all or part of display */ + if (tcp->num_param == 0) + n = 0; + else + n = tcp->param[0]; + sc_term_clr_eos(scp, n, sc->scr_map[0x20], tcp->cur_attr); + break; + + case 'K': /* Clear all or part of line */ + if (tcp->num_param == 0) + n = 0; + else + n = tcp->param[0]; + sc_term_clr_eol(scp, n, sc->scr_map[0x20], tcp->cur_attr); + break; + + case 'L': /* Insert n lines */ + sc_term_ins_line(scp, scp->ypos, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr, 0); + break; + + case 'M': /* Delete n lines */ + sc_term_del_line(scp, scp->ypos, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr, 0); + break; + + case 'P': /* Delete n chars */ + sc_term_del_char(scp, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr); + break; + + case '@': /* Insert n chars */ + sc_term_ins_char(scp, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr); + break; + + case 'S': /* scroll up n lines */ + sc_term_del_line(scp, 0, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr, 0); + break; + + case 'T': /* scroll down n lines */ + sc_term_ins_line(scp, 0, tcp->param[0], + sc->scr_map[0x20], tcp->cur_attr, 0); + break; + + case 'X': /* erase n characters in line */ + n = tcp->param[0]; if (n < 1) n = 1; + if (n > scp->xsize - scp->xpos) + n = scp->xsize - scp->xpos; + sc_vtb_erase(&scp->vtb, scp->cursor_pos, n, + sc->scr_map[0x20], tcp->cur_attr); + mark_for_update(scp, scp->cursor_pos); + mark_for_update(scp, scp->cursor_pos + n - 1); + break; + + case 'Z': /* move n tabs backwards */ + sc_term_backtab(scp, tcp->param[0]); + break; + + case '`': /* move cursor to column n */ + sc_term_col(scp, tcp->param[0]); + break; + + case 'a': /* move cursor n columns to the right */ + sc_term_right(scp, tcp->param[0]); + break; + + case 'd': /* move cursor to row n */ + sc_term_row(scp, tcp->param[0]); + break; + + case 'e': /* move cursor n rows down */ + sc_term_down(scp, tcp->param[0], 0); + break; + + case 'm': /* change attribute */ + if (tcp->num_param == 0) { + tcp->attr_mask = NORMAL_ATTR; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); + break; + } + for (i = 0; i < tcp->num_param; i++) { + switch (n = tcp->param[i]) { + case 0: /* back to normal */ + tcp->attr_mask = NORMAL_ATTR; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); + break; + case 1: /* bold */ + tcp->attr_mask |= BOLD_ATTR; + tcp->cur_attr = mask2attr(tcp); + break; + case 4: /* underline */ + tcp->attr_mask |= UNDERLINE_ATTR; + tcp->cur_attr = mask2attr(tcp); + break; + case 5: /* blink */ + tcp->attr_mask |= BLINK_ATTR; + tcp->cur_attr = mask2attr(tcp); + break; + case 7: /* reverse video */ + tcp->attr_mask |= REVERSE_ATTR; + tcp->cur_attr = mask2attr(tcp); + break; + case 30: case 31: /* set fg color */ + case 32: case 33: case 34: + case 35: case 36: case 37: + tcp->attr_mask |= FG_CHANGED; + tcp->cur_color.fg = ansi_col[n - 30]; + tcp->cur_attr = mask2attr(tcp); + break; + case 40: case 41: /* set bg color */ + case 42: case 43: case 44: + case 45: case 46: case 47: + tcp->attr_mask |= BG_CHANGED; + tcp->cur_color.bg = ansi_col[n - 40]; + tcp->cur_attr = mask2attr(tcp); + break; + } + } + break; + + case 's': /* Save cursor position */ + tcp->saved_xpos = scp->xpos; + tcp->saved_ypos = scp->ypos; + break; + + case 'u': /* Restore saved cursor position */ + if (tcp->saved_xpos >= 0 && tcp->saved_ypos >= 0) + sc_move_cursor(scp, tcp->saved_xpos, tcp->saved_ypos); + break; + + case 'x': + if (tcp->num_param == 0) + n = 0; + else + n = tcp->param[0]; + switch (n) { + case 0: /* reset attributes */ + tcp->attr_mask = NORMAL_ATTR; + tcp->cur_color = tcp->std_color = tcp->dflt_std_color; + tcp->rev_color = tcp->dflt_rev_color; + tcp->cur_attr = mask2attr(tcp); + break; + case 1: /* set ansi background */ + tcp->attr_mask &= ~BG_CHANGED; + tcp->cur_color.bg = tcp->std_color.bg = + ansi_col[tcp->param[1] & 0x0f]; + tcp->cur_attr = mask2attr(tcp); + break; + case 2: /* set ansi foreground */ + tcp->attr_mask &= ~FG_CHANGED; + tcp->cur_color.fg = tcp->std_color.fg = + ansi_col[tcp->param[1] & 0x0f]; + tcp->cur_attr = mask2attr(tcp); + break; + case 3: /* set ansi attribute directly */ + tcp->attr_mask &= ~(FG_CHANGED | BG_CHANGED); + tcp->cur_color.fg = tcp->std_color.fg = + tcp->param[1] & 0x0f; + tcp->cur_color.bg = tcp->std_color.bg = + (tcp->param[1] >> 4) & 0x0f; + tcp->cur_attr = mask2attr(tcp); + break; + case 5: /* set ansi reverse video background */ + tcp->rev_color.bg = ansi_col[tcp->param[1] & 0x0f]; + tcp->cur_attr = mask2attr(tcp); + break; + case 6: /* set ansi reverse video foreground */ + tcp->rev_color.fg = ansi_col[tcp->param[1] & 0x0f]; + tcp->cur_attr = mask2attr(tcp); + break; + case 7: /* set ansi reverse video directly */ + tcp->rev_color.fg = tcp->param[1] & 0x0f; + tcp->rev_color.bg = (tcp->param[1] >> 4) & 0x0f; + tcp->cur_attr = mask2attr(tcp); + break; + } + break; + + case 'z': /* switch to (virtual) console n */ + if (tcp->num_param == 1) + sc_switch_scr(sc, tcp->param[0]); + break; + } + } + else if (tcp->esc == 3) { /* seen ESC [0-9]+ = */ + if (c >= '0' && c <= '9') { + if (tcp->num_param < MAX_ESC_PAR) { + if (tcp->last_param != tcp->num_param) { + tcp->last_param = tcp->num_param; + tcp->param[tcp->num_param] = 0; + } else { + tcp->param[tcp->num_param] *= 10; + } + tcp->param[tcp->num_param] += c - '0'; + return; + } + } + tcp->num_param = tcp->last_param + 1; + switch (c) { + + case ';': + if (tcp->num_param < MAX_ESC_PAR) + return; + break; + + case 'A': /* set display border color */ + if (tcp->num_param == 1) { + scp->border=tcp->param[0] & 0xff; + if (scp == sc->cur_scp) + sc_set_border(scp, scp->border); + } + break; + + case 'B': /* set bell pitch and duration */ + if (tcp->num_param == 2) { + scp->bell_pitch = tcp->param[0]; + scp->bell_duration = tcp->param[1]; + } + break; + + case 'C': /* set cursor type & shape */ + if (!ISGRAPHSC(sc->cur_scp)) + sc_remove_cursor_image(sc->cur_scp); + if (tcp->num_param == 1) { + if (tcp->param[0] & 0x01) + sc->flags |= SC_BLINK_CURSOR; + else + sc->flags &= ~SC_BLINK_CURSOR; + if (tcp->param[0] & 0x02) + sc->flags |= SC_CHAR_CURSOR; + else + sc->flags &= ~SC_CHAR_CURSOR; + } else if (tcp->num_param == 2) { + sc->cursor_base = scp->font_size + - (tcp->param[1] & 0x1F) - 1; + sc->cursor_height = (tcp->param[1] & 0x1F) + - (tcp->param[0] & 0x1F) + 1; + } + /* + * The cursor shape is global property; all virtual consoles + * are affected. Update the cursor in the current console... + */ + if (!ISGRAPHSC(sc->cur_scp)) { + i = spltty(); + sc_set_cursor_image(sc->cur_scp); + sc_draw_cursor_image(sc->cur_scp); + splx(i); + } + break; + + case 'F': /* set ansi foreground */ + if (tcp->num_param == 1) { + tcp->attr_mask &= ~FG_CHANGED; + tcp->cur_color.fg = tcp->std_color.fg = tcp->param[0] & 0x0f; + tcp->cur_attr = mask2attr(tcp); + } + break; + + case 'G': /* set ansi background */ + if (tcp->num_param == 1) { + tcp->attr_mask &= ~BG_CHANGED; + tcp->cur_color.bg = tcp->std_color.bg = tcp->param[0] & 0x0f; + tcp->cur_attr = mask2attr(tcp); + } + break; + + case 'H': /* set ansi reverse video foreground */ + if (tcp->num_param == 1) { + tcp->rev_color.fg = tcp->param[0] & 0x0f; + tcp->cur_attr = mask2attr(tcp); + } + break; + + case 'I': /* set ansi reverse video background */ + if (tcp->num_param == 1) { + tcp->rev_color.bg = tcp->param[0] & 0x0f; + tcp->cur_attr = mask2attr(tcp); + } + break; + } + } +#if notyet + else if (tcp->esc == 4) { /* seen ESC Q */ + /* to be filled */ + } +#endif + else if (tcp->esc == 5) { /* seen ESC ( */ + switch (c) { + case 'B': /* iso-2022: desginate ASCII into G0 */ + break; + /* other items to be filled */ + default: + break; + } + } + tcp->esc = 0; +} + +static void +scterm_puts(scr_stat *scp, u_char *buf, int len) +{ + term_stat *tcp = scp->ts; + u_char *ptr = buf; +#ifdef KANJI + u_short kanji_code; +#endif + +outloop: + scp->sc->write_in_progress++; + + if (tcp->esc) { + scterm_scan_esc(scp, tcp, *ptr++); + len--; + } + else if (PRINTABLE(*ptr)) { /* Print only printables */ + vm_offset_t p; + u_char *map; + int attr; + int i; +#ifdef KANJI + u_char c; +#else + int cnt; +#endif + + p = sc_vtb_pointer(&scp->vtb, scp->cursor_pos); + map = scp->sc->scr_map; + attr = tcp->cur_attr; + +#ifdef KANJI + c = *ptr; + if (tcp->kanji_1st_char == 0) { + tcp->kanji_type = iskanji1(tcp->kanji_type, c); + if (!IS_KTYPE_ASCII_or_HANKAKU(tcp->kanji_type)) { + /* not Ascii & not HANKAKU */ + tcp->kanji_1st_char = c; + goto kanji_end; + } else { + tcp->kanji_1st_char = 0; + } + } else { + if ((tcp->kanji_type = iskanji2(tcp->kanji_type, c)) & 0xee) { + /* print kanji on TEXT VRAM */ + kanji_code = kanji_convert(tcp->kanji_type, c, tcp->kanji_1st_char); + mark_for_update(scp, scp->cursor_pos); + for (i=0; i<2; i++){ + /* *cursor_pos = (kanji_code | (i*0x80)); */ + p = sc_vtb_putchar(&scp->vtb, p, + kanji_code | ((i == 0) ? 0x00 : 0x80), + attr); + ++scp->cursor_pos; + if (++scp->xpos >= scp->xsize) { + scp->xpos = 0; + scp->ypos++; + } + } + mark_for_update(scp, scp->cursor_pos - 1); + KTYPE_MASK_CTRL(tcp->kanji_type); + tcp->kanji_1st_char = 0; + goto kanji_end; + } else { + tcp->kanji_1st_char = 0; + } + } + if (IS_KTYPE_KANA(tcp->kanji_type)) + c |= 0x80; + KTYPE_MASK_CTRL(tcp->kanji_type); + sc_vtb_putchar(&scp->vtb, p, map[c], attr); + mark_for_update(scp, scp->cursor_pos); + mark_for_update(scp, scp->cursor_pos); + ++scp->cursor_pos; + ++scp->xpos; +kanji_end: + ++ptr; + --len; +#else /* !KANJI */ + cnt = imin(len, scp->xsize - scp->xpos); + i = cnt; + do { + /* + * gcc-2.6.3 generates poor (un)sign extension code. Casting the + * pointers in the following to volatile should have no effect, + * but in fact speeds up this inner loop from 26 to 18 cycles + * (+ cache misses) on i486's. + */ +#define UCVP(ucp) ((u_char volatile *)(ucp)) + p = sc_vtb_putchar(&scp->vtb, p, UCVP(map)[*UCVP(ptr)], attr); + ++ptr; + --i; + } while (i > 0 && PRINTABLE(*ptr)); + + len -= cnt - i; + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos += cnt - i; + mark_for_update(scp, scp->cursor_pos - 1); + scp->xpos += cnt - i; +#endif /* !KANJI */ + + if (scp->xpos >= scp->xsize) { + scp->xpos = 0; + scp->ypos++; + } + } + else { + switch (*ptr) { + case 0x07: + sc_bell(scp, scp->bell_pitch, scp->bell_duration); + break; + + case 0x08: /* non-destructive backspace */ + if (scp->cursor_pos > 0) { + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos--; + mark_for_update(scp, scp->cursor_pos); + if (scp->xpos > 0) + scp->xpos--; + else { + scp->xpos += scp->xsize - 1; + scp->ypos--; + } + } + break; + + case 0x09: /* non-destructive tab */ + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos += (8 - scp->xpos % 8u); + scp->xpos += (8 - scp->xpos % 8u); + if (scp->xpos >= scp->xsize) { + scp->xpos = 0; + scp->ypos++; + scp->cursor_pos = scp->xsize * scp->ypos; + } + mark_for_update(scp, scp->cursor_pos); + break; + + case 0x0a: /* newline, same pos */ + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos += scp->xsize; + mark_for_update(scp, scp->cursor_pos); + scp->ypos++; + break; + + case 0x0c: /* form feed, clears screen */ + sc_clear_screen(scp); + break; + + case 0x0d: /* return, return to pos 0 */ + mark_for_update(scp, scp->cursor_pos); + scp->cursor_pos -= scp->xpos; + mark_for_update(scp, scp->cursor_pos); + scp->xpos = 0; + break; + +#ifdef PC98 + case 0x0e: /* ^N */ + tcp->kanji_type = KTYPE_JKANA; + tcp->esc = 0; + tcp->kanji_1st_char = 0; + break; + + case 0x0f: /* ^O */ + tcp->kanji_type = KTYPE_ASCII; + tcp->esc = 0; + tcp->kanji_1st_char = 0; + break; +#endif /* PC98 */ + + case 0x1b: /* start escape sequence */ + tcp->esc = 1; + tcp->num_param = 0; + break; + } + ptr++; len--; + } + + sc_term_gen_scroll(scp, scp->sc->scr_map[0x20], tcp->cur_attr); + + scp->sc->write_in_progress--; + if (len) + goto outloop; +} + +static int +scterm_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data, + int flag, struct proc *p) +{ + term_stat *tcp = scp->ts; + vid_info_t *vi; + + switch (cmd) { + case GIO_ATTR: /* get current attributes */ + /* FIXME: */ + *(int*)data = (tcp->cur_attr >> 8) & 0xff; + return 0; + case CONS_GETINFO: /* get current (virtual) console info */ + vi = (vid_info_t *)data; + if (vi->size != sizeof(struct vid_info)) + return EINVAL; + vi->mv_norm.fore = tcp->std_color.fg; + vi->mv_norm.back = tcp->std_color.bg; + vi->mv_rev.fore = tcp->rev_color.fg; + vi->mv_rev.back = tcp->rev_color.bg; + /* + * The other fields are filled by the upper routine. XXX + */ + return ENOIOCTL; + } + return ENOIOCTL; +} + +static int +scterm_reset(scr_stat *scp, int code) +{ + /* FIXME */ + return 0; +} + +static void +scterm_default_attr(scr_stat *scp, int color, int rev_color) +{ + term_stat *tcp = scp->ts; + + tcp->dflt_std_color.fg = color & 0x0f; + tcp->dflt_std_color.bg = (color >> 4) & 0x0f; + tcp->dflt_rev_color.fg = rev_color & 0x0f; + tcp->dflt_rev_color.bg = (rev_color >> 4) & 0x0f; + tcp->std_color = tcp->dflt_std_color; + tcp->rev_color = tcp->dflt_rev_color; + tcp->cur_color = tcp->std_color; + tcp->cur_attr = mask2attr(tcp); +} + +static void +scterm_clear(scr_stat *scp) +{ + term_stat *tcp = scp->ts; + + sc_move_cursor(scp, 0, 0); + sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], tcp->cur_attr); + mark_all(scp); +} + +static void +scterm_notify(scr_stat *scp, int event) +{ + switch (event) { + case SC_TE_NOTIFY_VTSWITCH_IN: + break; + case SC_TE_NOTIFY_VTSWITCH_OUT: + break; + } +} + +static int +scterm_input(scr_stat *scp, int c, struct tty *tp) +{ + return FALSE; +} + +/* + * Calculate hardware attributes word using logical attributes mask and + * hardware colors + */ + +/* FIXME */ +static int +mask2attr(term_stat *tcp) +{ + int attr, mask = tcp->attr_mask; + + if (mask & REVERSE_ATTR) { + attr = ((mask & FG_CHANGED) ? + tcp->cur_color.bg : tcp->rev_color.fg) | + (((mask & BG_CHANGED) ? + tcp->cur_color.fg : tcp->rev_color.bg) << 4); + } else + attr = tcp->cur_color.fg | (tcp->cur_color.bg << 4); + + /* XXX: underline mapping for Hercules adapter can be better */ + if (mask & (BOLD_ATTR | UNDERLINE_ATTR)) + attr ^= 0x08; + if (mask & BLINK_ATTR) + attr ^= 0x80; + + return (attr << 8); +} + +#ifdef KANJI +static u_char +iskanji1(u_char mode, u_char c) +{ + if ((mode == KTYPE_7JIS) && (c >= 0x21) && (c <= 0x7e)) { + /* JIS */ + default_kanji = UJIS; + return KTYPE_7JIS; + } + + if ((mode == KTYPE_JKANA) && (c >= 0x21) && (c <= 0x5f)) { + /* JIS HANKAKU */ + default_kanji = UJIS; + return KTYPE_JKANA; + } + +#if 1 + if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { + /* UJIS */ + return KTYPE_UJIS; + } +#endif + + if ((c >= 0x81) && (c <= 0x9f) && (c != 0x8e)) { + /* SJIS */ + default_kanji = SJIS; + return KTYPE_SJIS; + } + + if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == SJIS)) { + /* SJIS HANKAKU */ + return KTYPE_KANA; + } + +#if 0 + if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { + /* UJIS */ + return KTYPE_UJIS; + } +#endif + + if ((c >= 0xf0) && (c <= 0xfe)) { + /* UJIS */ + default_kanji = UJIS; + return KTYPE_UJIS; + } + + if ((c >= 0xe0) && (c <= 0xef)) { + /* SJIS or UJIS */ + return KTYPE_SUJIS; + } + + if (c == 0x8e) { + /* SJIS or UJIS HANKAKU */ + return KTYPE_SUKANA; + } + + return KTYPE_ASCII; +} + +static u_char +iskanji2(u_char mode, u_char c) +{ + switch (mode) { + case KTYPE_7JIS: + if ((c >= 0x21) && (c <= 0x7e)) { + /* JIS */ + return KTYPE_7JIS; + } + break; + case KTYPE_SJIS: + if ((c >= 0x40) && (c <= 0xfc) && (c != 0x7f)) { + /* SJIS */ + return KTYPE_SJIS; + } + break; + case KTYPE_UJIS: + if ((c >= 0xa1) && (c <= 0xfe)) { + /* UJIS */ + return KTYPE_UJIS; + } + break; + case KTYPE_SUKANA: + if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { + /* UJIS HANKAKU */ + return KTYPE_KANA; + } + if ((c >= 0x40) && (c <= 0xfc) && (c != 0x7f)) { + /* SJIS */ + default_kanji = SJIS; + return KTYPE_SJIS; + } + break; + case KTYPE_SUJIS: + if ((c >= 0x40) && (c <= 0xa0) && (c != 0x7f)) { + /* SJIS */ + default_kanji = SJIS; + return KTYPE_SJIS; + } + if ((c == 0xfd) || (c == 0xfe)) { + /* UJIS */ + default_kanji = UJIS; + return KTYPE_UJIS; + } + if ((c >= 0xa1) && (c <= 0xfc)) { + if (default_kanji == SJIS) + return KTYPE_SJIS; + if (default_kanji == UJIS) + return KTYPE_UJIS; + } + break; + } + return KTYPE_ASCII; +} + +/* + * JIS X0208-83 keisen conversion table + */ +static u_short keiConv[32] = { + 0x240c, 0x260c, 0x300c, 0x340c, 0x3c0c, 0x380c, 0x400c, 0x500c, + 0x480c, 0x580c, 0x600c, 0x250c, 0x270c, 0x330c, 0x370c, 0x3f0c, + 0x3b0c, 0x470c, 0x570c, 0x4f0c, 0x5f0c, 0x6f0c, 0x440c, 0x530c, + 0x4c0c, 0x5b0c, 0x630c, 0x410c, 0x540c, 0x490c, 0x5c0c, 0x660c +}; + +static u_short +kanji_convert(u_char mode, u_char h, u_char l) +{ + u_short tmp, high, low, c; + high = (u_short) h; + low = (u_short) l; + + switch (mode) { + case KTYPE_SJIS: /* SHIFT JIS */ + if (low >= 0xe0) { + low -= 0x40; + } + low = (low - 0x81) * 2 + 0x21; + if (high > 0x7f) { + high--; + } + if (high > 0x9d) { + low++; + high -= 0x9e - 0x21; + } else { + high -= 0x40 - 0x21; + } + high &= 0x7F; + low &= 0x7F; + tmp = ((high << 8) | low) - 0x20; + break; + case KTYPE_7JIS: /* JIS */ + case KTYPE_UJIS: /* UJIS */ + high &= 0x7F; + low &= 0x7F; + tmp = ((high << 8) | low) - 0x20; + break; + default: + tmp = 0; + break; + } + + /* keisen */ + c = ((tmp & 0xff) << 8) | (tmp >> 8); + /* 0x2821 .. 0x2840 */ + if (0x0821 <= c && c <= 0x0840) + tmp = keiConv[c - 0x0821]; + + return (tmp); +} +#endif /* KANJI */ + +#endif /* SC_DUMB_TERMINAL */ + +#endif /* NSC > 0 */ diff --git a/sys/pc98/pc98/syscons.c b/sys/pc98/pc98/syscons.c index d2dcaaec1f67..caf35cccd2b2 100644 --- a/sys/pc98/pc98/syscons.c +++ b/sys/pc98/pc98/syscons.c @@ -72,24 +72,25 @@ #define KEYCODE_BS 0x0e /* "<-- Backspace" key, XXX */ +typedef struct default_attr { + int std_color; /* normal hardware color */ + int rev_color; /* reverse hardware color */ +} default_attr; + static default_attr user_default = { - SC_NORM_ATTR << 8, - SC_NORM_REV_ATTR << 8, + SC_NORM_ATTR, + SC_NORM_REV_ATTR, }; static default_attr kernel_default = { - SC_KERNEL_CONS_ATTR << 8, - SC_KERNEL_CONS_REV_ATTR << 8, + SC_KERNEL_CONS_ATTR, + SC_KERNEL_CONS_REV_ATTR, }; static int sc_console_unit = -1; static scr_stat *sc_console; static struct tty *sc_console_tty; -#ifndef SC_NO_SYSMOUSE -static struct tty *sc_mouse_tty; -#endif -static term_stat kernel_console; -static default_attr *current_default; +static void *kernel_console_ts; static char init_done = COLD; static char shutdown_in_progress = FALSE; @@ -98,11 +99,13 @@ static char sc_malloc = FALSE; static int saver_mode = CONS_LKM_SAVER; /* LKM/user saver */ static int run_scrn_saver = FALSE; /* should run the saver? */ static long scrn_blank_time = 0; /* screen saver timeout value */ +#if NSPLASH > 0 static int scrn_blanked; /* # of blanked screen */ static int sticky_splash = FALSE; static void none_saver(sc_softc_t *sc, int blank) { } static void (*current_saver)(sc_softc_t *, int) = none_saver; +#endif #if !defined(SC_NO_FONT_LOADING) && defined(SC_DFLT_FONT) #include "font.h" @@ -116,13 +119,8 @@ static int enable_panic_key; SYSCTL_INT(_machdep, OID_AUTO, enable_panic_key, CTLFLAG_RW, &enable_panic_key, 0, ""); -#define SC_MOUSE 128 #define SC_CONSOLECTL 255 -#ifdef PC98 -static u_char default_kanji = UJIS; -#endif - #define VIRTUAL_TTY(sc, x) (SC_DEV((sc), (x))->si_tty) static int debugger; @@ -135,9 +133,10 @@ static int scdevtounit(dev_t dev); static kbd_callback_func_t sckbdevent; static int scparam(struct tty *tp, struct termios *t); static void scstart(struct tty *tp); -static void scmousestart(struct tty *tp); static void scinit(int unit, int flags); +#if __i386__ static void scterm(int unit, int flags); +#endif static void scshutdown(void *arg, int howto); static u_int scgetc(sc_softc_t *sc, u_int flags); #define SCGETC_CN 1 @@ -164,23 +163,15 @@ static int wait_scrn_saver_stop(sc_softc_t *sc); #define scsplash_stick(stick) #endif /* NSPLASH */ -static int switch_scr(sc_softc_t *sc, u_int next_scr); static int do_switch_scr(sc_softc_t *sc, int s); static int vt_proc_alive(scr_stat *scp); static int signal_vt_rel(scr_stat *scp); static int signal_vt_acq(scr_stat *scp); static void exchange_scr(sc_softc_t *sc); -static void scan_esc(scr_stat *scp, u_char c); -static void ansi_put(scr_stat *scp, u_char *buf, int len); -static void draw_cursor_image(scr_stat *scp); -static void remove_cursor_image(scr_stat *scp); static void update_cursor_image(scr_stat *scp); -static void move_crsr(scr_stat *scp, int x, int y); -static int mask2attr(struct term_stat *term); static int save_kbd_state(scr_stat *scp); static int update_kbd_state(scr_stat *scp, int state, int mask); static int update_kbd_leds(scr_stat *scp, int which); -static void do_bell(scr_stat *scp, int pitch, int duration); static timeout_t blink_screen; #define CDEV_MAJOR 12 @@ -296,12 +287,33 @@ sc_attach_unit(int unit, int flags) int vc; dev_t dev; - scmeminit(NULL); /* XXX */ - flags &= ~SC_KERNEL_CONSOLE; - if (sc_console_unit == unit) + + if (sc_console_unit == unit) { + /* + * If this unit is being used as the system console, we need to + * adjust some variables and buffers before and after scinit(). + */ + /* assert(sc_console != NULL) */ flags |= SC_KERNEL_CONSOLE; - scinit(unit, flags); + scmeminit(NULL); + + scinit(unit, flags); + + if (sc_console->tsw->te_size > 0) { + /* assert(sc_console->ts != NULL); */ + kernel_console_ts = sc_console->ts; + sc_console->ts = malloc(sc_console->tsw->te_size, + M_DEVBUF, M_WAITOK); + bcopy(kernel_console_ts, sc_console->ts, sc_console->tsw->te_size); + (*sc_console->tsw->te_default_attr)(sc_console, + user_default.std_color, + user_default.rev_color); + } + } else { + scinit(unit, flags); + } + sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE); sc->config = flags; scp = SC_STAT(sc->dev[0]); @@ -344,7 +356,10 @@ sc_attach_unit(int unit, int flags) if (sc->adapter >= 0) printf(" fb%d", sc->adapter); if (sc->keyboard >= 0) - printf(" kbd%d", sc->keyboard); + printf(", kbd%d", sc->keyboard); + if (scp->tsw) + printf(", terminal emulator: %s (%s)", + scp->tsw->te_name, scp->tsw->te_desc); printf("\n"); } @@ -364,12 +379,6 @@ sc_attach_unit(int unit, int flags) */ } -#ifndef SC_NO_SYSMOUSE - dev = make_dev(&sc_cdevsw, SC_MOUSE, - UID_ROOT, GID_WHEEL, 0600, "sysmouse"); - dev->si_tty = sc_mouse_tty = ttymalloc(sc_mouse_tty); - /* sysmouse doesn't have scr_stat */ -#endif /* SC_NO_SYSMOUSE */ dev = make_dev(&sc_cdevsw, SC_CONSOLECTL, UID_ROOT, GID_WHEEL, 0600, "consolectl"); dev->si_tty = sc_console_tty = ttymalloc(sc_console_tty); @@ -390,7 +399,7 @@ scmeminit(void *arg) * various buffers for the kernel console. */ - if (sc_console_unit < 0) + if (sc_console_unit < 0) /* sc_console == NULL */ return; /* copy the temporary buffer to the final buffer */ @@ -430,8 +439,6 @@ scdevtounit(dev_t dev) if (vty == SC_CONSOLECTL) return ((sc_console != NULL) ? sc_console->sc->unit : -1); - else if (vty == SC_MOUSE) - return -1; else if ((vty < 0) || (vty >= MAXCONS*sc_max_unit())) return -1; else @@ -451,17 +458,12 @@ scopen(dev_t dev, int flag, int mode, struct proc *p) DPRINTF(5, ("scopen: dev:%d,%d, unit:%d, vty:%d\n", major(dev), minor(dev), unit, SC_VTY(dev))); - /* sc == NULL, if SC_VTY(dev) == SC_MOUSE */ sc = sc_get_softc(unit, (sc_console_unit == unit) ? SC_KERNEL_CONSOLE : 0); -#ifndef SC_NO_SYSMOUSE - if ((SC_VTY(dev) != SC_MOUSE) && (sc == NULL)) -#else if (sc == NULL) -#endif return ENXIO; tp = dev->si_tty = ttymalloc(dev->si_tty); - tp->t_oproc = (SC_VTY(dev) == SC_MOUSE) ? scmousestart : scstart; + tp->t_oproc = scstart; tp->t_param = scparam; tp->t_stop = nottystop; tp->t_dev = dev; @@ -481,10 +483,6 @@ scopen(dev_t dev, int flag, int mode, struct proc *p) tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; scparam(tp, &tp->t_termios); (*linesw[tp->t_line].l_modem)(tp, 1); -#ifndef SC_NO_SYSMOUSE - if (SC_VTY(dev) == SC_MOUSE) - sc_mouse_set_level(0); /* XXX */ -#endif } else if (tp->t_state & TS_XCLUDE && suser(p)) @@ -492,19 +490,17 @@ scopen(dev_t dev, int flag, int mode, struct proc *p) error = (*linesw[tp->t_line].l_open)(dev, tp); - if (SC_VTY(dev) != SC_MOUSE) { - /* assert(sc != NULL) */ - scp = SC_STAT(dev); - if (scp == NULL) { - scp = SC_STAT(dev) = alloc_scp(sc, SC_VTY(dev)); - if (ISGRAPHSC(scp)) - sc_set_pixel_mode(scp, NULL, COL, ROW, 16); - } - if (!tp->t_winsize.ws_col && !tp->t_winsize.ws_row) { - tp->t_winsize.ws_col = scp->xsize; - tp->t_winsize.ws_row = scp->ysize; - } + scp = SC_STAT(dev); + if (scp == NULL) { + scp = SC_STAT(dev) = alloc_scp(sc, SC_VTY(dev)); + if (ISGRAPHSC(scp)) + sc_set_pixel_mode(scp, NULL, COL, ROW, 16); } + if (!tp->t_winsize.ws_col && !tp->t_winsize.ws_row) { + tp->t_winsize.ws_col = scp->xsize; + tp->t_winsize.ws_row = scp->ysize; + } + return error; } @@ -512,10 +508,10 @@ int scclose(dev_t dev, int flag, int mode, struct proc *p) { struct tty *tp = dev->si_tty; - struct scr_stat *scp; + scr_stat *scp; int s; - if ((SC_VTY(dev) != SC_CONSOLECTL) && (SC_VTY(dev) != SC_MOUSE)) { + if (SC_VTY(dev) != SC_CONSOLECTL) { scp = SC_STAT(tp->t_dev); /* were we in the middle of the VT switching process? */ DPRINTF(5, ("sc%d: scclose(), ", scp->sc->unit)); @@ -544,6 +540,7 @@ scclose(dev_t dev, int flag, int mode, struct proc *p) sc_vtb_destroy(&scp->vtb); sc_vtb_destroy(&scp->scr); sc_free_history_buffer(scp, scp->ysize); + SC_STAT(dev) = NULL; free(scp, M_DEVBUF); } #else @@ -566,9 +563,8 @@ scclose(dev_t dev, int flag, int mode, struct proc *p) int scread(dev_t dev, struct uio *uio, int flag) { - sc_touch_scrn_saver(); - return(ttyread(dev, uio, flag)); + return ttyread(dev, uio, flag); } static int @@ -588,6 +584,7 @@ sckbdevent(keyboard_t *thiskbd, int event, void *arg) break; case KBDIO_UNLOADING: sc->kbd = NULL; + sc->keyboard = -1; kbd_release(thiskbd, (void *)&sc->keyboard); return 0; default: @@ -608,6 +605,9 @@ sckbdevent(keyboard_t *thiskbd, int event, void *arg) || !(cur_tty->t_state & TS_ISOPEN)) continue; + if ((*sc->cur_scp->tsw->te_input)(sc->cur_scp, c, cur_tty)) + continue; + switch (KEYFLAGS(c)) { case 0x0000: /* normal key */ (*linesw[cur_tty->t_line].l_rint)(KEYCHAR(c), cur_tty); @@ -683,15 +683,6 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) error = sc_mouse_ioctl(tp, cmd, data, flag, p); if (error != ENOIOCTL) return error; - if (SC_VTY(dev) == SC_MOUSE) { - error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); - if (error != ENOIOCTL) - return error; - error = ttioctl(tp, cmd, data, flag); - if (error != ENOIOCTL) - return error; - return ENOTTY; - } #endif scp = SC_STAT(tp->t_dev); @@ -699,11 +690,17 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) /* scp is sc_console, if SC_VTY(dev) == SC_CONSOLECTL. */ sc = scp->sc; + if (scp->tsw) { + error = (*scp->tsw->te_ioctl)(scp, tp, cmd, data, flag, p); + if (error != ENOIOCTL) + return error; + } + switch (cmd) { /* process console hardware related ioctl's */ case GIO_ATTR: /* get current attributes */ - *(int*)data = (scp->term.cur_attr >> 8) & 0xFF; - return 0; + /* this ioctl is not processed here, but in the terminal emulator */ + return ENOTTY; case GIO_COLOR: /* is this a color console ? */ *(int *)data = (sc->adp->va_flags & V_ADP_COLOR) ? 1 : 0; @@ -720,7 +717,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) case CONS_CURSORTYPE: /* set cursor type blink/noblink */ if (!ISGRAPHSC(sc->cur_scp)) - remove_cursor_image(sc->cur_scp); + sc_remove_cursor_image(sc->cur_scp); if ((*(int*)data) & 0x01) sc->flags |= SC_BLINK_CURSOR; else @@ -736,7 +733,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) if (!ISGRAPHSC(sc->cur_scp)) { s = spltty(); sc_set_cursor_image(sc->cur_scp); - draw_cursor_image(sc->cur_scp); + sc_draw_cursor_image(sc->cur_scp); splx(s); } return 0; @@ -761,10 +758,14 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) ptr->mv_row = scp->ypos; ptr->mv_csz = scp->xsize; ptr->mv_rsz = scp->ysize; - ptr->mv_norm.fore = (scp->term.std_color & 0x0f00)>>8; - ptr->mv_norm.back = (scp->term.std_color & 0xf000)>>12; - ptr->mv_rev.fore = (scp->term.rev_color & 0x0f00)>>8; - ptr->mv_rev.back = (scp->term.rev_color & 0xf000)>>12; + /* + * The following fields are filled by the terminal emulator. XXX + * + * ptr->mv_norm.fore + * ptr->mv_norm.back + * ptr->mv_rev.fore + * ptr->mv_rev.back + */ ptr->mv_grfc.fore = 0; /* not supported */ ptr->mv_grfc.back = 0; /* not supported */ ptr->mv_ovscan = scp->border; @@ -957,7 +958,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) s = spltty(); sc_clean_up(sc->cur_scp); splx(s); - return switch_scr(sc, *(int *)data - 1); + return sc_switch_scr(sc, *(int *)data - 1); case VT_WAITACTIVE: /* wait for switch to occur */ if ((*(int *)data >= sc->first_vty + sc->vtys) @@ -1057,10 +1058,10 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) case KDMKTONE: /* sound the bell */ if (*(int*)data) - do_bell(scp, (*(int*)data)&0xffff, + sc_bell(scp, (*(int*)data)&0xffff, (((*(int*)data)>>16)&0xffff)*hz/1000); else - do_bell(scp, scp->bell_pitch, scp->bell_duration); + sc_bell(scp, scp->bell_pitch, scp->bell_duration); return 0; case KIOCSOUND: /* make tone (*data) hz */ @@ -1143,6 +1144,37 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) splx(s); return error; + case CONS_GETTERM: /* get the current terminal emulator info */ + { + sc_term_sw_t *sw; + + if (((term_info_t *)data)->ti_index == 0) { + sw = scp->tsw; + } else { + sw = sc_term_match_by_number(((term_info_t *)data)->ti_index); + } + if (sw != NULL) { + strncpy(((term_info_t *)data)->ti_name, sw->te_name, + sizeof(((term_info_t *)data)->ti_name)); + strncpy(((term_info_t *)data)->ti_desc, sw->te_desc, + sizeof(((term_info_t *)data)->ti_desc)); + ((term_info_t *)data)->ti_flags = 0; + return 0; + } else { + ((term_info_t *)data)->ti_name[0] = '\0'; + ((term_info_t *)data)->ti_desc[0] = '\0'; + ((term_info_t *)data)->ti_flags = 0; + return EINVAL; + } + } + + case CONS_SETTERM: /* set the current terminal emulator */ + s = spltty(); + error = sc_init_emulator(scp, ((term_info_t *)data)->ti_name); + /* FIXME: what if scp == sc_console! XXX */ + splx(s); + return error; + case GIO_SCRNMAP: /* get output translation table */ bcopy(&sc->scr_map, data, sizeof(sc->scr_map)); return 0; @@ -1178,7 +1210,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) * Don't load if the current font size is not 8x8. */ if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size < 14)) - copy_font(sc->cur_scp, LOAD, 8, sc->font_8); + sc_load_font(sc->cur_scp, 0, 8, sc->font_8, 0, 256); return 0; case GIO_FONT8x8: /* get 8x8 dot font */ @@ -1204,7 +1236,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size >= 14) && (sc->cur_scp->font_size < 16)) - copy_font(sc->cur_scp, LOAD, 14, sc->font_14); + sc_load_font(sc->cur_scp, 0, 14, sc->font_14, 0, 256); return 0; case GIO_FONT8x14: /* get 8x14 dot font */ @@ -1228,7 +1260,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) * Don't load if the current font size is not 8x16. */ if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size >= 16)) - copy_font(sc->cur_scp, LOAD, 16, sc->font_16); + sc_load_font(sc->cur_scp, 0, 16, sc->font_16, 0, 256); return 0; case GIO_FONT8x16: /* get 8x16 dot font */ @@ -1279,7 +1311,7 @@ scstart(struct tty *tp) while (rbp->c_cc) { len = q_to_b(rbp, buf, PCBURST); splx(s); - ansi_put(scp, buf, len); + sc_puts(scp, buf, len); s = spltty(); } tp->t_state &= ~TS_BUSY; @@ -1288,26 +1320,6 @@ scstart(struct tty *tp) splx(s); } -static void -scmousestart(struct tty *tp) -{ - struct clist *rbp; - int s; - u_char buf[PCBURST]; - - s = spltty(); - if (!(tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))) { - tp->t_state |= TS_BUSY; - rbp = &tp->t_outq; - while (rbp->c_cc) { - q_to_b(rbp, buf, PCBURST); - } - tp->t_state &= ~TS_BUSY; - ttwwakeup(tp); - } - splx(s); -} - static void sccnprobe(struct consdev *cp) { @@ -1380,8 +1392,6 @@ sccnterm(struct consdev *cp) #ifdef __alpha__ -extern struct consdev *cn_tab; - void sccnattach(void) { @@ -1417,7 +1427,10 @@ sccnputc(dev_t dev, int c) { u_char buf[1]; scr_stat *scp = sc_console; - term_stat save = scp->term; + void *save; +#ifndef SC_NO_HISTORY + struct tty *tp; +#endif /* !SC_NO_HISTORY */ int s; /* assert(sc_console != NULL) */ @@ -1431,19 +1444,20 @@ sccnputc(dev_t dev, int c) sc_remove_cutmarking(scp); scp->status &= ~BUFFER_SAVED; scp->status |= CURSOR_ENABLED; - draw_cursor_image(scp); + sc_draw_cursor_image(scp); } - scstart(VIRTUAL_TTY(scp->sc, scp->index)); + tp = VIRTUAL_TTY(scp->sc, scp->index); + if (tp->t_state & TS_ISOPEN) + scstart(tp); } #endif /* !SC_NO_HISTORY */ - scp->term = kernel_console; - current_default = &kernel_default; + save = scp->ts; + if (kernel_console_ts != NULL) + scp->ts = kernel_console_ts; buf[0] = c; - ansi_put(scp, buf, 1); - kernel_console = scp->term; - current_default = &user_default; - scp->term = save; + sc_puts(scp, buf, 1); + scp->ts = save; s = spltty(); /* block sckbdevent and scrn_timer */ sccnupdate(scp); @@ -1476,7 +1490,7 @@ sccndbctl(dev_t dev, int on) if (!cold && sc_console->sc->cur_scp->smode.mode == VT_AUTO && sc_console->smode.mode == VT_AUTO) - switch_scr(sc_console->sc, sc_console->index); + sc_switch_scr(sc_console->sc, sc_console->index); } if (on) ++debugger; @@ -1779,15 +1793,15 @@ scrn_update(scr_stat *scp, int show_cursor) /* do we need to remove old cursor image ? */ if (scp->cursor_oldpos < scp->start || scp->cursor_oldpos > scp->end) { - remove_cursor_image(scp); + sc_remove_cursor_image(scp); } scp->cursor_oldpos = scp->cursor_pos; - draw_cursor_image(scp); + sc_draw_cursor_image(scp); } else { /* cursor didn't move, has it been overwritten ? */ if (scp->cursor_pos >= scp->start && scp->cursor_pos <= scp->end) { - draw_cursor_image(scp); + sc_draw_cursor_image(scp); } else { /* if its a blinking cursor, we may have to update it */ if (scp->sc->flags & SC_BLINK_CURSOR) @@ -1955,7 +1969,7 @@ set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border) /* assert(scp == scp->sc->cur_scp) */ s = spltty(); if (!ISGRAPHSC(scp)) - remove_cursor_image(scp); + sc_remove_cursor_image(scp); scp->splash_save_mode = scp->mode; scp->splash_save_status = scp->status & (GRAPHICS_MODE | PIXEL_MODE); scp->status &= ~(GRAPHICS_MODE | PIXEL_MODE); @@ -1973,7 +1987,7 @@ set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border) if (pal != NULL) load_palette(scp->sc->adp, pal); #endif - set_border(scp, border); + sc_set_border(scp, border); return 0; } else { s = spltty(); @@ -2002,7 +2016,7 @@ restore_scrn_saver_mode(scr_stat *scp, int changemode) scp->sc->flags &= ~SC_SCRN_BLANKED; if (!changemode) { if (!ISGRAPHSC(scp)) - draw_cursor_image(scp); + sc_draw_cursor_image(scp); --scrn_blanked; splx(s); return 0; @@ -2033,7 +2047,7 @@ stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int)) mark_all(sc->cur_scp); if (sc->delayed_next_scr) - switch_scr(sc, sc->delayed_next_scr - 1); + sc_switch_scr(sc, sc->delayed_next_scr - 1); wakeup((caddr_t)&scrn_blanked); } @@ -2064,23 +2078,13 @@ sc_touch_scrn_saver(void) run_scrn_saver = FALSE; } -void -sc_clear_screen(scr_stat *scp) -{ - move_crsr(scp, 0, 0); - scp->cursor_oldpos = scp->cursor_pos; - sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], scp->term.cur_color); - mark_all(scp); - sc_remove_cutmarking(scp); -} - -static int -switch_scr(sc_softc_t *sc, u_int next_scr) +int +sc_switch_scr(sc_softc_t *sc, u_int next_scr) { struct tty *tp; int s; - DPRINTF(5, ("sc0: switch_scr() %d ", next_scr + 1)); + DPRINTF(5, ("sc0: sc_switch_scr() %d ", next_scr + 1)); /* delay switch if the screen is blanked or being updated */ if ((sc->flags & SC_SCRN_BLANKED) || sc->write_in_progress @@ -2188,7 +2192,7 @@ switch_scr(sc_softc_t *sc, u_int next_scr) if ((next_scr < sc->first_vty) || (next_scr >= sc->first_vty + sc->vtys) || sc->switch_in_progress) { splx(s); - do_bell(sc->cur_scp, bios_value.bell_pitch, BELL_DURATION); + sc_bell(sc->cur_scp, bios_value.bell_pitch, BELL_DURATION); DPRINTF(5, ("error 1\n")); return EINVAL; } @@ -2204,7 +2208,7 @@ switch_scr(sc_softc_t *sc, u_int next_scr) && (sc->cur_scp->smode.mode == VT_AUTO) && ISGRAPHSC(sc->cur_scp)) { splx(s); - do_bell(sc->cur_scp, bios_value.bell_pitch, BELL_DURATION); + sc_bell(sc->cur_scp, bios_value.bell_pitch, BELL_DURATION); DPRINTF(5, ("error, graphics mode\n")); return EINVAL; } @@ -2218,7 +2222,7 @@ switch_scr(sc_softc_t *sc, u_int next_scr) tp = VIRTUAL_TTY(sc, next_scr); if ((tp == NULL) || !(tp->t_state & TS_ISOPEN)) { splx(s); - do_bell(sc->cur_scp, bios_value.bell_pitch, BELL_DURATION); + sc_bell(sc->cur_scp, bios_value.bell_pitch, BELL_DURATION); DPRINTF(5, ("error 2, requested vty isn't open!\n")); return EINVAL; } @@ -2334,7 +2338,7 @@ exchange_scr(sc_softc_t *sc) scr_stat *scp; /* save the current state of video and keyboard */ - move_crsr(sc->old_scp, sc->old_scp->xpos, sc->old_scp->ypos); + sc_move_cursor(sc->old_scp, sc->old_scp->xpos, sc->old_scp->ypos); if (sc->old_scp->kbd_mode == K_XLATE) save_kbd_state(sc->old_scp); @@ -2349,14 +2353,14 @@ exchange_scr(sc_softc_t *sc) else sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize, (void *)sc->adp->va_window, FALSE); - move_crsr(scp, scp->xpos, scp->ypos); + sc_move_cursor(scp, scp->xpos, scp->ypos); if (!ISGRAPHSC(scp)) sc_set_cursor_image(scp); #ifndef SC_NO_PALETTE_LOADING if (ISGRAPHSC(sc->old_scp)) load_palette(sc->adp, sc->palette); #endif - set_border(scp, scp->border); + sc_set_border(scp, scp->border); /* set up the keyboard for the new screen */ if (sc->old_scp->kbd_mode != scp->kbd_mode) @@ -2366,950 +2370,24 @@ exchange_scr(sc_softc_t *sc) mark_all(scp); } -static void -scan_esc(scr_stat *scp, u_char c) +void +sc_puts(scr_stat *scp, u_char *buf, int len) { - static u_char ansi_col[16] = - {0, 4, 2, 6, 1, 5, 3, 7, 8, 12, 10, 14, 9, 13, 11, 15}; - sc_softc_t *sc; - int i, n; - int count; - - sc = scp->sc; - if (scp->term.esc == 1) { /* seen ESC */ -#ifdef KANJI - switch (scp->md.kanji_type) { - case KTYPE_KANIN: /* Kanji Invoke sequence */ - switch (c) { - case 'B': - case '@': - scp->md.kanji_type = KTYPE_7JIS; - scp->term.esc = 0; - scp->md.kanji_1st_char = 0; - return; - default: - scp->md.kanji_type = KTYPE_ASCII; - scp->term.esc = 0; - break; - } - break; - case KTYPE_ASCIN: /* Ascii Invoke sequence */ - switch (c) { - case 'J': - case 'B': - case 'H': - scp->md.kanji_type = KTYPE_ASCII; - scp->term.esc = 0; - scp->md.kanji_1st_char = 0; - return; - case 'I': - scp->md.kanji_type = KTYPE_JKANA; - scp->term.esc = 0; - scp->md.kanji_1st_char = 0; - return; - default: - scp->md.kanji_type = KTYPE_ASCII; - scp->term.esc = 0; - break; - } - break; - default: - break; - } -#endif /* KANJI */ - switch (c) { - - case '7': /* Save cursor position */ - scp->saved_xpos = scp->xpos; - scp->saved_ypos = scp->ypos; - break; - - case '8': /* Restore saved cursor position */ - if (scp->saved_xpos >= 0 && scp->saved_ypos >= 0) - move_crsr(scp, scp->saved_xpos, scp->saved_ypos); - break; - - case '[': /* Start ESC [ sequence */ - scp->term.esc = 2; - scp->term.last_param = -1; - for (i = scp->term.num_param; i < MAX_ESC_PAR; i++) - scp->term.param[i] = 1; - scp->term.num_param = 0; - return; - -#ifdef KANJI - case '$': /* Kanji Invoke sequence */ - scp->md.kanji_type = KTYPE_KANIN; - return; -#endif - - case 'M': /* Move cursor up 1 line, scroll if at top */ - if (scp->ypos > 0) - move_crsr(scp, scp->xpos, scp->ypos - 1); - else { - sc_vtb_ins(&scp->vtb, 0, scp->xsize, - sc->scr_map[0x20], scp->term.cur_color); - mark_all(scp); - } - break; -#if notyet - case 'Q': - scp->term.esc = 4; - return; -#endif - case 'c': /* Clear screen & home */ - sc_clear_screen(scp); - break; - - case '(': /* iso-2022: designate 94 character set to G0 */ -#ifdef KANJI - scp->md.kanji_type = KTYPE_ASCIN; -#else - scp->term.esc = 5; -#endif - return; - } - } - else if (scp->term.esc == 2) { /* seen ESC [ */ - if (c >= '0' && c <= '9') { - if (scp->term.num_param < MAX_ESC_PAR) { - if (scp->term.last_param != scp->term.num_param) { - scp->term.last_param = scp->term.num_param; - scp->term.param[scp->term.num_param] = 0; - } - else - scp->term.param[scp->term.num_param] *= 10; - scp->term.param[scp->term.num_param] += c - '0'; - return; - } - } - scp->term.num_param = scp->term.last_param + 1; - switch (c) { - - case ';': - if (scp->term.num_param < MAX_ESC_PAR) - return; - break; - - case '=': - scp->term.esc = 3; - scp->term.last_param = -1; - for (i = scp->term.num_param; i < MAX_ESC_PAR; i++) - scp->term.param[i] = 1; - scp->term.num_param = 0; - return; - - case 'A': /* up n rows */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, scp->xpos, scp->ypos - n); - break; - - case 'B': /* down n rows */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, scp->xpos, scp->ypos + n); - break; - - case 'C': /* right n columns */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, scp->xpos + n, scp->ypos); - break; - - case 'D': /* left n columns */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, scp->xpos - n, scp->ypos); - break; - - case 'E': /* cursor to start of line n lines down */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, 0, scp->ypos + n); - break; - - case 'F': /* cursor to start of line n lines up */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, 0, scp->ypos - n); - break; - - case 'f': /* Cursor move */ - case 'H': - if (scp->term.num_param == 0) - move_crsr(scp, 0, 0); - else if (scp->term.num_param == 2) - move_crsr(scp, scp->term.param[1] - 1, scp->term.param[0] - 1); - break; - - case 'J': /* Clear all or part of display */ - if (scp->term.num_param == 0) - n = 0; - else - n = scp->term.param[0]; - switch (n) { - case 0: /* clear form cursor to end of display */ - sc_vtb_erase(&scp->vtb, scp->cursor_pos, - scp->xsize * scp->ysize - scp->cursor_pos, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->cursor_pos); - mark_for_update(scp, scp->xsize * scp->ysize - 1); - sc_remove_cutmarking(scp); - break; - case 1: /* clear from beginning of display to cursor */ - sc_vtb_erase(&scp->vtb, 0, scp->cursor_pos, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, 0); - mark_for_update(scp, scp->cursor_pos); - sc_remove_cutmarking(scp); - break; - case 2: /* clear entire display */ - sc_vtb_clear(&scp->vtb, sc->scr_map[0x20], scp->term.cur_color); - mark_all(scp); - sc_remove_cutmarking(scp); - break; - } - break; - - case 'K': /* Clear all or part of line */ - if (scp->term.num_param == 0) - n = 0; - else - n = scp->term.param[0]; - switch (n) { - case 0: /* clear form cursor to end of line */ - sc_vtb_erase(&scp->vtb, scp->cursor_pos, - scp->xsize - scp->xpos, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->cursor_pos); - mark_for_update(scp, scp->cursor_pos + - scp->xsize - 1 - scp->xpos); - break; - case 1: /* clear from beginning of line to cursor */ - sc_vtb_erase(&scp->vtb, scp->cursor_pos - scp->xpos, - scp->xpos + 1, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->ypos * scp->xsize); - mark_for_update(scp, scp->cursor_pos); - break; - case 2: /* clear entire line */ - sc_vtb_erase(&scp->vtb, scp->cursor_pos - scp->xpos, - scp->xsize, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->ypos * scp->xsize); - mark_for_update(scp, (scp->ypos + 1) * scp->xsize - 1); - break; - } - break; - - case 'L': /* Insert n lines */ - n = scp->term.param[0]; if (n < 1) n = 1; - if (n > scp->ysize - scp->ypos) - n = scp->ysize - scp->ypos; - sc_vtb_ins(&scp->vtb, scp->ypos * scp->xsize, n * scp->xsize, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->ypos * scp->xsize); - mark_for_update(scp, scp->xsize * scp->ysize - 1); - break; - - case 'M': /* Delete n lines */ - n = scp->term.param[0]; if (n < 1) n = 1; - if (n > scp->ysize - scp->ypos) - n = scp->ysize - scp->ypos; - sc_vtb_delete(&scp->vtb, scp->ypos * scp->xsize, n * scp->xsize, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->ypos * scp->xsize); - mark_for_update(scp, scp->xsize * scp->ysize - 1); - break; - - case 'P': /* Delete n chars */ - n = scp->term.param[0]; if (n < 1) n = 1; - if (n > scp->xsize - scp->xpos) - n = scp->xsize - scp->xpos; - count = scp->xsize - (scp->xpos + n); - sc_vtb_move(&scp->vtb, scp->cursor_pos + n, scp->cursor_pos, count); - sc_vtb_erase(&scp->vtb, scp->cursor_pos + count, n, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->cursor_pos); - mark_for_update(scp, scp->cursor_pos + n + count - 1); - break; - - case '@': /* Insert n chars */ - n = scp->term.param[0]; if (n < 1) n = 1; - if (n > scp->xsize - scp->xpos) - n = scp->xsize - scp->xpos; - count = scp->xsize - (scp->xpos + n); - sc_vtb_move(&scp->vtb, scp->cursor_pos, scp->cursor_pos + n, count); - sc_vtb_erase(&scp->vtb, scp->cursor_pos, n, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->cursor_pos); - mark_for_update(scp, scp->cursor_pos + n + count - 1); - break; - - case 'S': /* scroll up n lines */ - n = scp->term.param[0]; if (n < 1) n = 1; - if (n > scp->ysize) - n = scp->ysize; - sc_vtb_delete(&scp->vtb, 0, n * scp->xsize, - sc->scr_map[0x20], scp->term.cur_color); - mark_all(scp); - break; - - case 'T': /* scroll down n lines */ - n = scp->term.param[0]; if (n < 1) n = 1; - if (n > scp->ysize) - n = scp->ysize; - sc_vtb_ins(&scp->vtb, 0, n * scp->xsize, - sc->scr_map[0x20], scp->term.cur_color); - mark_all(scp); - break; - - case 'X': /* erase n characters in line */ - n = scp->term.param[0]; if (n < 1) n = 1; - if (n > scp->xsize - scp->xpos) - n = scp->xsize - scp->xpos; - sc_vtb_erase(&scp->vtb, scp->cursor_pos, n, - sc->scr_map[0x20], scp->term.cur_color); - mark_for_update(scp, scp->cursor_pos); - mark_for_update(scp, scp->cursor_pos + n - 1); - break; - - case 'Z': /* move n tabs backwards */ - n = scp->term.param[0]; if (n < 1) n = 1; - if ((i = scp->xpos & 0xf8) == scp->xpos) - i -= 8*n; - else - i -= 8*(n-1); - if (i < 0) - i = 0; - move_crsr(scp, i, scp->ypos); - break; - - case '`': /* move cursor to column n */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, n - 1, scp->ypos); - break; - - case 'a': /* move cursor n columns to the right */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, scp->xpos + n, scp->ypos); - break; - - case 'd': /* move cursor to row n */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, scp->xpos, n - 1); - break; - - case 'e': /* move cursor n rows down */ - n = scp->term.param[0]; if (n < 1) n = 1; - move_crsr(scp, scp->xpos, scp->ypos + n); - break; - - case 'm': /* change attribute */ - if (scp->term.num_param == 0) { - scp->term.attr_mask = NORMAL_ATTR; - scp->term.cur_attr = - scp->term.cur_color = scp->term.std_color; - break; - } - for (i = 0; i < scp->term.num_param; i++) { - switch (n = scp->term.param[i]) { - case 0: /* back to normal */ - scp->term.attr_mask = NORMAL_ATTR; - scp->term.cur_attr = - scp->term.cur_color = scp->term.std_color; - break; - case 1: /* bold */ - scp->term.attr_mask |= BOLD_ATTR; - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 4: /* underline */ - scp->term.attr_mask |= UNDERLINE_ATTR; - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 5: /* blink */ - scp->term.attr_mask |= BLINK_ATTR; - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 7: /* reverse video */ - scp->term.attr_mask |= REVERSE_ATTR; - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 30: case 31: /* set fg color */ - case 32: case 33: case 34: - case 35: case 36: case 37: - scp->term.attr_mask |= FOREGROUND_CHANGED; - scp->term.cur_color = - (scp->term.cur_color&0xF000) | (ansi_col[(n-30)&7]<<8); - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 40: case 41: /* set bg color */ - case 42: case 43: case 44: - case 45: case 46: case 47: - scp->term.attr_mask |= BACKGROUND_CHANGED; - scp->term.cur_color = - (scp->term.cur_color&0x0F00) | (ansi_col[(n-40)&7]<<12); - scp->term.cur_attr = mask2attr(&scp->term); - break; - } - } - break; - - case 's': /* Save cursor position */ - scp->saved_xpos = scp->xpos; - scp->saved_ypos = scp->ypos; - break; - - case 'u': /* Restore saved cursor position */ - if (scp->saved_xpos >= 0 && scp->saved_ypos >= 0) - move_crsr(scp, scp->saved_xpos, scp->saved_ypos); - break; - - case 'x': - if (scp->term.num_param == 0) - n = 0; - else - n = scp->term.param[0]; - switch (n) { - case 0: /* reset attributes */ - scp->term.attr_mask = NORMAL_ATTR; - scp->term.cur_attr = - scp->term.cur_color = scp->term.std_color = - current_default->std_color; - scp->term.rev_color = current_default->rev_color; - break; - case 1: /* set ansi background */ - scp->term.attr_mask &= ~BACKGROUND_CHANGED; - scp->term.cur_color = scp->term.std_color = - (scp->term.std_color & 0x0F00) | - (ansi_col[(scp->term.param[1])&0x0F]<<12); - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 2: /* set ansi foreground */ - scp->term.attr_mask &= ~FOREGROUND_CHANGED; - scp->term.cur_color = scp->term.std_color = - (scp->term.std_color & 0xF000) | - (ansi_col[(scp->term.param[1])&0x0F]<<8); - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 3: /* set ansi attribute directly */ - scp->term.attr_mask &= ~(FOREGROUND_CHANGED|BACKGROUND_CHANGED); - scp->term.cur_color = scp->term.std_color = - (scp->term.param[1]&0xFF)<<8; - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 5: /* set ansi reverse video background */ - scp->term.rev_color = - (scp->term.rev_color & 0x0F00) | - (ansi_col[(scp->term.param[1])&0x0F]<<12); - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 6: /* set ansi reverse video foreground */ - scp->term.rev_color = - (scp->term.rev_color & 0xF000) | - (ansi_col[(scp->term.param[1])&0x0F]<<8); - scp->term.cur_attr = mask2attr(&scp->term); - break; - case 7: /* set ansi reverse video directly */ - scp->term.rev_color = - (scp->term.param[1]&0xFF)<<8; - scp->term.cur_attr = mask2attr(&scp->term); - break; - } - break; - - case 'z': /* switch to (virtual) console n */ - if (scp->term.num_param == 1) - switch_scr(sc, scp->term.param[0]); - break; - } - } - else if (scp->term.esc == 3) { /* seen ESC [0-9]+ = */ - if (c >= '0' && c <= '9') { - if (scp->term.num_param < MAX_ESC_PAR) { - if (scp->term.last_param != scp->term.num_param) { - scp->term.last_param = scp->term.num_param; - scp->term.param[scp->term.num_param] = 0; - } - else - scp->term.param[scp->term.num_param] *= 10; - scp->term.param[scp->term.num_param] += c - '0'; - return; - } - } - scp->term.num_param = scp->term.last_param + 1; - switch (c) { - - case ';': - if (scp->term.num_param < MAX_ESC_PAR) - return; - break; - - case 'A': /* set display border color */ - if (scp->term.num_param == 1) { - scp->border=scp->term.param[0] & 0xff; - if (scp == sc->cur_scp) - set_border(scp, scp->border); - } - break; - - case 'B': /* set bell pitch and duration */ - if (scp->term.num_param == 2) { - scp->bell_pitch = scp->term.param[0]; - scp->bell_duration = scp->term.param[1]; - } - break; - - case 'C': /* set cursor type & shape */ - if (!ISGRAPHSC(sc->cur_scp)) - remove_cursor_image(sc->cur_scp); - if (scp->term.num_param == 1) { - if (scp->term.param[0] & 0x01) - sc->flags |= SC_BLINK_CURSOR; - else - sc->flags &= ~SC_BLINK_CURSOR; - if (scp->term.param[0] & 0x02) - sc->flags |= SC_CHAR_CURSOR; - else - sc->flags &= ~SC_CHAR_CURSOR; - } - else if (scp->term.num_param == 2) { - sc->cursor_base = scp->font_size - - (scp->term.param[1] & 0x1F) - 1; - sc->cursor_height = (scp->term.param[1] & 0x1F) - - (scp->term.param[0] & 0x1F) + 1; - } - /* - * The cursor shape is global property; all virtual consoles - * are affected. Update the cursor in the current console... - */ - if (!ISGRAPHSC(sc->cur_scp)) { - i = spltty(); - sc_set_cursor_image(sc->cur_scp); - draw_cursor_image(sc->cur_scp); - splx(i); - } - break; - - case 'F': /* set ansi foreground */ - if (scp->term.num_param == 1) { - scp->term.attr_mask &= ~FOREGROUND_CHANGED; - scp->term.cur_color = scp->term.std_color = - (scp->term.std_color & 0xF000) - | ((scp->term.param[0] & 0x0F) << 8); - scp->term.cur_attr = mask2attr(&scp->term); - } - break; - - case 'G': /* set ansi background */ - if (scp->term.num_param == 1) { - scp->term.attr_mask &= ~BACKGROUND_CHANGED; - scp->term.cur_color = scp->term.std_color = - (scp->term.std_color & 0x0F00) - | ((scp->term.param[0] & 0x0F) << 12); - scp->term.cur_attr = mask2attr(&scp->term); - } - break; - - case 'H': /* set ansi reverse video foreground */ - if (scp->term.num_param == 1) { - scp->term.rev_color = - (scp->term.rev_color & 0xF000) - | ((scp->term.param[0] & 0x0F) << 8); - scp->term.cur_attr = mask2attr(&scp->term); - } - break; - - case 'I': /* set ansi reverse video background */ - if (scp->term.num_param == 1) { - scp->term.rev_color = - (scp->term.rev_color & 0x0F00) - | ((scp->term.param[0] & 0x0F) << 12); - scp->term.cur_attr = mask2attr(&scp->term); - } - break; - } - } -#if notyet - else if (scp->term.esc == 4) { /* seen ESC Q */ - /* to be filled */ - } -#endif - else if (scp->term.esc == 5) { /* seen ESC ( */ - switch (c) { - case 'B': /* iso-2022: desginate ASCII into G0 */ - break; - /* other items to be filled */ - default: - break; - } - } - scp->term.esc = 0; -} - -#ifdef KANJI -static u_char iskanji1(u_char mode, u_char c) -{ - if ((mode == KTYPE_7JIS) && (c >= 0x21) && (c <= 0x7e)) { - /* JIS */ - default_kanji = UJIS; - return KTYPE_7JIS; - } - - if ((mode == KTYPE_JKANA) && (c >= 0x21) && (c <= 0x5f)) { - /* JIS HANKAKU */ - default_kanji = UJIS; - return KTYPE_JKANA; - } - -#if 1 - if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { - /* UJIS */ - return KTYPE_UJIS; - } -#endif - - if ((c >= 0x81) && (c <= 0x9f) && (c != 0x8e)) { - /* SJIS */ - default_kanji = SJIS; - return KTYPE_SJIS; - } - - if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == SJIS)) { - /* SJIS HANKAKU */ - return KTYPE_KANA; - } - -#if 0 - if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { - /* UJIS */ - return KTYPE_UJIS; - } -#endif - - if ((c >= 0xf0) && (c <= 0xfe)) { - /* UJIS */ - default_kanji = UJIS; - return KTYPE_UJIS; - } - - if ((c >= 0xe0) && (c <= 0xef)) { - /* SJIS or UJIS */ - return KTYPE_SUJIS; - } - - if (c == 0x8e) { - /* SJIS or UJIS HANKAKU */ - return KTYPE_SUKANA; - } - - return KTYPE_ASCII; -} - -static u_char iskanji2(u_char mode, u_char c) -{ - switch (mode) { - case KTYPE_7JIS: - if ((c >= 0x21) && (c <= 0x7e)) { - /* JIS */ - return KTYPE_7JIS; - } - break; - case KTYPE_SJIS: - if ((c >= 0x40) && (c <= 0xfc) && (c != 0x7f)) { - /* SJIS */ - return KTYPE_SJIS; - } - break; - case KTYPE_UJIS: - if ((c >= 0xa1) && (c <= 0xfe)) { - /* UJIS */ - return KTYPE_UJIS; - } - break; - case KTYPE_SUKANA: - if ((c >= 0xa1) && (c <= 0xdf) && (default_kanji == UJIS)) { - /* UJIS HANKAKU */ - return KTYPE_KANA; - } - if ((c >= 0x40) && (c <= 0xfc) && (c != 0x7f)) { - /* SJIS */ - default_kanji = SJIS; - return KTYPE_SJIS; - } - break; - case KTYPE_SUJIS: - if ((c >= 0x40) && (c <= 0xa0) && (c != 0x7f)) { - /* SJIS */ - default_kanji = SJIS; - return KTYPE_SJIS; - } - if ((c == 0xfd) || (c == 0xfe)) { - /* UJIS */ - default_kanji = UJIS; - return KTYPE_UJIS; - } - if ((c >= 0xa1) && (c <= 0xfc)) { - if (default_kanji == SJIS) - return KTYPE_SJIS; - if (default_kanji == UJIS) - return KTYPE_UJIS; - } - break; - } - return KTYPE_ASCII; -} - -/* - * JIS X0208-83 keisen conversion table - */ -static u_short keiConv[32] = { - 0x240c, 0x260c, 0x300c, 0x340c, 0x3c0c, 0x380c, 0x400c, 0x500c, - 0x480c, 0x580c, 0x600c, 0x250c, 0x270c, 0x330c, 0x370c, 0x3f0c, - 0x3b0c, 0x470c, 0x570c, 0x4f0c, 0x5f0c, 0x6f0c, 0x440c, 0x530c, - 0x4c0c, 0x5b0c, 0x630c, 0x410c, 0x540c, 0x490c, 0x5c0c, 0x660c -}; - - -static u_short kanji_convert(u_char mode, u_char h, u_char l) -{ - u_short tmp, high, low, c; - high = (u_short) h; - low = (u_short) l; - - switch (mode) { - case KTYPE_SJIS: /* SHIFT JIS */ - if (low >= 0xe0) { - low -= 0x40; - } - low = (low - 0x81) * 2 + 0x21; - if (high > 0x7f) { - high--; - } - if (high > 0x9d) { - low++; - high -= 0x9e - 0x21; - } else { - high -= 0x40 - 0x21; - } - high &= 0x7F; - low &= 0x7F; - tmp = ((high << 8) | low) - 0x20; - break; - case KTYPE_7JIS: /* JIS */ - case KTYPE_UJIS: /* UJIS */ - high &= 0x7F; - low &= 0x7F; - tmp = ((high << 8) | low) - 0x20; - break; - default: - tmp = 0; - break; - } - - /* keisen */ - c = ((tmp & 0xff) << 8) | (tmp >> 8); - /* 0x2821 .. 0x2840 */ - if (0x0821 <= c && c <= 0x0840) - tmp = keiConv[c - 0x0821]; - - return (tmp); -} -#endif /* KANJI */ - -static void -ansi_put(scr_stat *scp, u_char *buf, int len) -{ - u_char *ptr = buf; -#ifdef KANJI - u_short kanji_code; -#endif - +#if NSPLASH > 0 /* make screensaver happy */ if (!sticky_splash && scp == scp->sc->cur_scp) run_scrn_saver = FALSE; - -outloop: - scp->sc->write_in_progress++; - if (scp->term.esc) { - scan_esc(scp, *ptr++); - len--; - } - else if (PRINTABLE(*ptr)) { /* Print only printables */ - vm_offset_t p; - u_char *map; - int attr; - int i; -#ifdef KANJI - u_char c; -#else - int cnt; #endif - p = sc_vtb_pointer(&scp->vtb, scp->cursor_pos); - map = scp->sc->scr_map; - attr = scp->term.cur_attr; + if (scp->tsw) + (*scp->tsw->te_puts)(scp, buf, len); -#ifdef KANJI - c = *ptr; - if (scp->md.kanji_1st_char == 0) { - scp->md.kanji_type = iskanji1(scp->md.kanji_type, c); - if (!IS_KTYPE_ASCII_or_HANKAKU(scp->md.kanji_type)) { - /* not Ascii & not HANKAKU */ - scp->md.kanji_1st_char = c; - goto kanji_end; - } else { - scp->md.kanji_1st_char = 0; - } - } else { - if ((scp->md.kanji_type = iskanji2(scp->md.kanji_type, c)) & 0xee) { - /* print kanji on TEXT VRAM */ - kanji_code = kanji_convert(scp->md.kanji_type, c, scp->md.kanji_1st_char); - mark_for_update(scp, scp->cursor_pos); - for (i=0; i<2; i++){ - /* *cursor_pos = (kanji_code | (i*0x80)); */ - p = sc_vtb_putchar(&scp->vtb, p, - kanji_code | ((i == 0) ? 0x00 : 0x80), - attr); - ++scp->cursor_pos; - if (++scp->xpos >= scp->xsize) { - scp->xpos = 0; - scp->ypos++; - } - } - mark_for_update(scp, scp->cursor_pos - 1); - KTYPE_MASK_CTRL(scp->md.kanji_type); - scp->md.kanji_1st_char = 0; - goto kanji_end; - } else { - scp->md.kanji_1st_char = 0; - } - } - if (IS_KTYPE_KANA(scp->md.kanji_type)) - c |= 0x80; - KTYPE_MASK_CTRL(scp->md.kanji_type); - sc_vtb_putchar(&scp->vtb, p, map[c], attr); - mark_for_update(scp, scp->cursor_pos); - mark_for_update(scp, scp->cursor_pos); - ++scp->cursor_pos; - ++scp->xpos; -kanji_end: - ++ptr; - --len; -#else /* !KANJI */ - cnt = (len <= scp->xsize - scp->xpos) ? len : (scp->xsize - scp->xpos); - i = cnt; - do { - /* - * gcc-2.6.3 generates poor (un)sign extension code. Casting the - * pointers in the following to volatile should have no effect, - * but in fact speeds up this inner loop from 26 to 18 cycles - * (+ cache misses) on i486's. - */ -#define UCVP(ucp) ((u_char volatile *)(ucp)) - p = sc_vtb_putchar(&scp->vtb, p, UCVP(map)[*UCVP(ptr)], attr); - ++ptr; - --i; - } while (i > 0 && PRINTABLE(*ptr)); - len -= cnt - i; - mark_for_update(scp, scp->cursor_pos); - scp->cursor_pos += cnt - i; - mark_for_update(scp, scp->cursor_pos - 1); - scp->xpos += cnt - i; -#endif /* KANJI */ - - if (scp->xpos >= scp->xsize) { - scp->xpos = 0; - scp->ypos++; - } - } - else { - switch(*ptr) { - case 0x07: - do_bell(scp, scp->bell_pitch, scp->bell_duration); - break; - - case 0x08: /* non-destructive backspace */ - if (scp->cursor_pos > 0) { - mark_for_update(scp, scp->cursor_pos); - scp->cursor_pos--; - mark_for_update(scp, scp->cursor_pos); - if (scp->xpos > 0) - scp->xpos--; - else { - scp->xpos += scp->xsize - 1; - scp->ypos--; - } - } - break; - - case 0x09: /* non-destructive tab */ - mark_for_update(scp, scp->cursor_pos); - scp->cursor_pos += (8 - scp->xpos % 8u); - if ((scp->xpos += (8 - scp->xpos % 8u)) >= scp->xsize) { - scp->xpos = 0; - scp->ypos++; - scp->cursor_pos = scp->xsize * scp->ypos; - } - mark_for_update(scp, scp->cursor_pos); - break; - - case 0x0a: /* newline, same pos */ - mark_for_update(scp, scp->cursor_pos); - scp->cursor_pos += scp->xsize; - mark_for_update(scp, scp->cursor_pos); - scp->ypos++; - break; - - case 0x0c: /* form feed, clears screen */ - sc_clear_screen(scp); - break; - - case 0x0d: /* return, return to pos 0 */ - mark_for_update(scp, scp->cursor_pos); - scp->cursor_pos -= scp->xpos; - mark_for_update(scp, scp->cursor_pos); - scp->xpos = 0; - break; - -#ifdef PC98 - case 0x0e: /* ^N */ - scp->md.kanji_type = KTYPE_JKANA; - scp->term.esc = 0; - scp->md.kanji_1st_char = 0; - break; - - case 0x0f: /* ^O */ - scp->md.kanji_type = KTYPE_ASCII; - scp->term.esc = 0; - scp->md.kanji_1st_char = 0; - break; -#endif /* PC98 */ - - case 0x1b: /* start escape sequence */ - scp->term.esc = 1; - scp->term.num_param = 0; - break; - } - ptr++; len--; - } - /* do we have to scroll ?? */ - if (scp->cursor_pos >= scp->ysize * scp->xsize) { - sc_remove_cutmarking(scp); -#ifndef SC_NO_HISTORY - if (scp->history != NULL) - sc_hist_save_one_line(scp, 0); -#endif - sc_vtb_delete(&scp->vtb, 0, scp->xsize, - scp->sc->scr_map[0x20], scp->term.cur_color); - scp->cursor_pos -= scp->xsize; - scp->ypos--; - mark_all(scp); - } - scp->sc->write_in_progress--; - if (len) - goto outloop; if (scp->sc->delayed_next_scr) - switch_scr(scp->sc, scp->sc->delayed_next_scr - 1); + sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1); } -static void -draw_cursor_image(scr_stat *scp) +void +sc_draw_cursor_image(scr_stat *scp) { /* assert(scp == scp->sc->cur_scp); */ ++scp->sc->videoio_in_progress; @@ -3319,8 +2397,8 @@ draw_cursor_image(scr_stat *scp) --scp->sc->videoio_in_progress; } -static void -remove_cursor_image(scr_stat *scp) +void +sc_remove_cursor_image(scr_stat *scp) { /* assert(scp == scp->sc->cur_scp); */ ++scp->sc->videoio_in_progress; @@ -3372,22 +2450,6 @@ sc_set_cursor_image(scr_stat *scp) --scp->sc->videoio_in_progress; } -static void -move_crsr(scr_stat *scp, int x, int y) -{ - if (x < 0) - x = 0; - if (y < 0) - y = 0; - if (x >= scp->xsize) - x = scp->xsize-1; - if (y >= scp->ysize) - y = scp->ysize-1; - scp->xpos = x; - scp->ypos = y; - scp->cursor_pos = scp->ypos * scp->xsize + scp->xpos; -} - static void scinit(int unit, int flags) { @@ -3420,17 +2482,8 @@ scinit(int unit, int flags) int i; /* one time initialization */ - if (init_done == COLD) { + if (init_done == COLD) sc_get_bios_values(&bios_value); - current_default = &user_default; - /* kernel console attributes */ - kernel_console.esc = 0; - kernel_console.attr_mask = NORMAL_ATTR; - kernel_console.cur_attr = - kernel_console.cur_color = kernel_console.std_color = - kernel_default.std_color; - kernel_console.rev_color = kernel_default.rev_color; - } init_done = WARM; /* @@ -3450,8 +2503,8 @@ scinit(int unit, int flags) i = kbd_release(sc->kbd, (void *)&sc->keyboard); DPRINTF(5, ("sc%d: kbd_release returned %d\n", unit, i)); if (sc->kbd != NULL) { - DPRINTF(5, ("sc%d: kbd != NULL!, index:%d, minor:%d, flags:0x%x\n", - unit, sc->kbd->kb_index, sc->kbd->kb_minor, sc->kbd->kb_flags)); + DPRINTF(5, ("sc%d: kbd != NULL!, index:%d, unit:%d, flags:0x%x\n", + unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags)); } sc->kbd = NULL; } @@ -3463,8 +2516,8 @@ scinit(int unit, int flags) DPRINTF(1, ("sc%d: keyboard %d\n", unit, sc->keyboard)); sc->kbd = kbd_get_keyboard(sc->keyboard); if (sc->kbd != NULL) { - DPRINTF(1, ("sc%d: kbd index:%d, minor:%d, flags:0x%x\n", - unit, sc->kbd->kb_index, sc->kbd->kb_minor, sc->kbd->kb_flags)); + DPRINTF(1, ("sc%d: kbd index:%d, unit:%d, flags:0x%x\n", + unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags)); } if (!(sc->flags & SC_INIT_DONE) || (adp != sc->adp)) { @@ -3490,7 +2543,7 @@ scinit(int unit, int flags) /* set up the first console */ sc->first_vty = unit*MAXCONS; - sc->vtys = MAXCONS; + sc->vtys = MAXCONS; /* XXX: should be configurable */ if (flags & SC_KERNEL_CONSOLE) { sc->dev = main_devs; sc->dev[0] = makedev(CDEV_MAJOR, unit*MAXCONS); @@ -3500,6 +2553,11 @@ scinit(int unit, int flags) init_scp(sc, sc->first_vty, scp); sc_vtb_init(&scp->vtb, VTB_MEMORY, scp->xsize, scp->ysize, (void *)sc_buffer, FALSE); + if (sc_init_emulator(scp, SC_DFLT_TERM)) + sc_init_emulator(scp, "*"); + (*scp->tsw->te_default_attr)(scp, + kernel_default.std_color, + kernel_default.rev_color); } else { /* assert(sc_malloc) */ sc->dev = malloc(sizeof(dev_t)*sc->vtys, M_DEVBUF, M_WAITOK); @@ -3534,7 +2592,7 @@ scinit(int unit, int flags) sc->cursor_height = imin(i, scp->font_size); if (!ISGRAPHSC(scp)) { sc_set_cursor_image(scp); - draw_cursor_image(scp); + sc_draw_cursor_image(scp); } /* save font and palette */ @@ -3547,29 +2605,26 @@ scinit(int unit, int flags) bcopy(dflt_font_16, sc->font_16, sizeof(dflt_font_16)); sc->fonts_loaded = FONT_16 | FONT_14 | FONT_8; if (scp->font_size < 14) { - copy_font(scp, LOAD, 8, sc->font_8); - sc->fonts_loaded = FONT_8; + sc_load_font(scp, 0, 8, sc->font_8, 0, 256); } else if (scp->font_size >= 16) { - copy_font(scp, LOAD, 16, sc->font_16); - sc->fonts_loaded = FONT_16; + sc_load_font(scp, 0, 16, sc->font_16, 0, 256); } else { - copy_font(scp, LOAD, 14, sc->font_14); - sc->fonts_loaded = FONT_14; + sc_load_font(scp, 0, 14, sc->font_14, 0, 256); } #else /* !SC_DFLT_FONT */ if (scp->font_size < 14) { - copy_font(scp, SAVE, 8, sc->font_8); + sc_save_font(scp, 0, 8, sc->font_8, 0, 256); sc->fonts_loaded = FONT_8; } else if (scp->font_size >= 16) { - copy_font(scp, SAVE, 16, sc->font_16); + sc_save_font(scp, 0, 16, sc->font_16, 0, 256); sc->fonts_loaded = FONT_16; } else { - copy_font(scp, SAVE, 14, sc->font_14); + sc_save_font(scp, 0, 14, sc->font_14, 0, 256); sc->fonts_loaded = FONT_14; } #endif /* SC_DFLT_FONT */ /* FONT KLUDGE: always use the font page #0. XXX */ - (*vidsw[sc->adapter]->show_font)(sc->adp, 0); + sc_show_font(scp, 0); } #endif /* !SC_NO_FONT_LOADING */ @@ -3600,10 +2655,12 @@ scinit(int unit, int flags) sc->flags |= SC_INIT_DONE; } +#if __i386__ static void scterm(int unit, int flags) { sc_softc_t *sc; + scr_stat *scp; sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE); if (sc == NULL) @@ -3623,6 +2680,13 @@ scterm(int unit, int flags) if (sc->adapter >= 0) vid_release(sc->adp, &sc->adapter); + /* stop the terminal emulator, if any */ + scp = SC_STAT(sc->dev[0]); + if (scp->tsw) + (*scp->tsw->te_term)(scp, &scp->ts); + if (scp->ts != NULL) + free(scp->ts, M_DEVBUF); + /* clear the structure */ if (!(flags & SC_KERNEL_CONSOLE)) { /* XXX: We need delete_dev() for this */ @@ -3642,6 +2706,7 @@ scterm(int unit, int flags) sc->keyboard = -1; sc->adapter = -1; } +#endif static void scshutdown(void *arg, int howto) @@ -3652,14 +2717,16 @@ scshutdown(void *arg, int howto) if (!cold && sc_console && sc_console->sc->cur_scp->smode.mode == VT_AUTO && sc_console->smode.mode == VT_AUTO) - switch_scr(sc_console->sc, sc_console->index); + sc_switch_scr(sc_console->sc, sc_console->index); shutdown_in_progress = TRUE; } int sc_clean_up(scr_stat *scp) { +#if NSPLASH > 0 int error; +#endif /* NSPLASH */ sc_touch_scrn_saver(); #if NSPLASH > 0 @@ -3676,7 +2743,6 @@ sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard) { sc_vtb_t new; sc_vtb_t old; - int s; old = scp->vtb; sc_vtb_init(&new, VTB_MEMORY, scp->xsize, scp->ysize, NULL, wait); @@ -3690,11 +2756,7 @@ sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard) sc_vtb_copy(&old, 0, &new, 0, scp->xsize*scp->ysize); scp->vtb = new; } else { - /* clear the screen and move the text cursor to the top-left position */ - s = splhigh(); scp->vtb = new; - sc_clear_screen(scp); - splx(s); sc_vtb_destroy(&old); } @@ -3715,6 +2777,8 @@ static scr_stat init_scp(sc, vty, scp); sc_alloc_scr_buffer(scp, TRUE, TRUE); + if (sc_init_emulator(scp, SC_DFLT_TERM)) + sc_init_emulator(scp, "*"); #ifndef SC_NO_SYSMOUSE if (ISMOUSEAVAIL(sc->adp->va_flags)) @@ -3725,7 +2789,6 @@ static scr_stat sc_alloc_history_buffer(scp, 0, 0, TRUE); #endif - sc_clear_screen(scp); return scp; } @@ -3734,6 +2797,8 @@ init_scp(sc_softc_t *sc, int vty, scr_stat *scp) { video_info_t info; + bzero(scp, sizeof(*scp)); + scp->index = vty; scp->sc = sc; scp->status = 0; @@ -3745,7 +2810,7 @@ init_scp(sc_softc_t *sc, int vty, scr_stat *scp) scp->ypixel = info.vi_height; scp->xsize = info.vi_width/8; scp->ysize = info.vi_height/info.vi_cheight; - scp->font_size = FONT_NONE; + scp->font_size = 0; scp->font = NULL; } else { scp->xsize = info.vi_width; @@ -3779,15 +2844,11 @@ init_scp(sc_softc_t *sc, int vty, scr_stat *scp) sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, 0, 0, NULL, FALSE); scp->xoff = scp->yoff = 0; scp->xpos = scp->ypos = 0; - scp->saved_xpos = scp->saved_ypos = -1; scp->start = scp->xsize * scp->ysize - 1; scp->end = 0; - scp->term.esc = 0; - scp->term.attr_mask = NORMAL_ATTR; - scp->term.cur_attr = - scp->term.cur_color = scp->term.std_color = - current_default->std_color; - scp->term.rev_color = current_default->rev_color; + scp->tsw = NULL; + scp->ts = NULL; + scp->rndr = NULL; scp->border = BG_BLACK; scp->cursor_base = sc->cursor_base; scp->cursor_height = imin(sc->cursor_height, scp->font_size); @@ -3809,14 +2870,64 @@ init_scp(sc_softc_t *sc, int vty, scr_stat *scp) scp->history = NULL; scp->history_pos = 0; scp->history_size = 0; -#ifdef KANJI - scp->md.kanji_1st_char = 0; - scp->md.kanji_type = KTYPE_ASCII; -#endif +} - /* what if the following call fails... XXX */ - scp->rndr = sc_render_match(scp, scp->sc->adp, - scp->status & (GRAPHICS_MODE | PIXEL_MODE)); +int +sc_init_emulator(scr_stat *scp, char *name) +{ + sc_term_sw_t *sw; + sc_rndr_sw_t *rndr; + void *p; + int error; + + if (name == NULL) /* if no name is given, use the current emulator */ + sw = scp->tsw; + else /* ...otherwise find the named emulator */ + sw = sc_term_match(name); + if (sw == NULL) + return EINVAL; + + rndr = NULL; + if (strcmp(sw->te_renderer, "*") != 0) { + rndr = sc_render_match(scp, sw->te_renderer, + scp->status & (GRAPHICS_MODE | PIXEL_MODE)); + } + if (rndr == NULL) { + rndr = sc_render_match(scp, scp->sc->adp->va_name, + scp->status & (GRAPHICS_MODE | PIXEL_MODE)); + if (rndr == NULL) + return ENODEV; + } + + if (sw == scp->tsw) { + error = (*sw->te_init)(scp, &scp->ts, SC_TE_WARM_INIT); + scp->rndr = rndr; + sc_clear_screen(scp); + /* assert(error == 0); */ + return error; + } + + if (sc_malloc && (sw->te_size > 0)) + p = malloc(sw->te_size, M_DEVBUF, M_NOWAIT); + else + p = NULL; + error = (*sw->te_init)(scp, &p, SC_TE_COLD_INIT); + if (error) + return error; + + if (scp->tsw) + (*scp->tsw->te_term)(scp, &scp->ts); + if (scp->ts != NULL) + free(scp->ts, M_DEVBUF); + scp->tsw = sw; + scp->ts = p; + scp->rndr = rndr; + + /* XXX */ + (*sw->te_default_attr)(scp, user_default.std_color, user_default.rev_color); + sc_clear_screen(scp); + + return 0; } /* @@ -3829,6 +2940,9 @@ static u_int scgetc(sc_softc_t *sc, u_int flags) { scr_stat *scp; +#ifndef SC_NO_HISTORY + struct tty *tp; +#endif u_int c; int this_scr; int f; @@ -3849,7 +2963,7 @@ next_code: c = kbd_read_char(sc->kbd, !(flags & SCGETC_NONBLOCK)); if (c == ERRKEY) { if (!(flags & SCGETC_CN)) - do_bell(scp, bios_value.bell_pitch, BELL_DURATION); + sc_bell(scp, bios_value.bell_pitch, BELL_DURATION); } else if (c == NOKEY) return c; else @@ -3873,7 +2987,7 @@ next_code: if (!ISGRAPHSC(scp) && scp->history && scp->status & SLKED) { scp->status &= ~CURSOR_ENABLED; - remove_cursor_image(scp); + sc_remove_cursor_image(scp); #ifndef SC_NO_HISTORY if (!(scp->status & BUFFER_SAVED)) { @@ -3896,14 +3010,14 @@ next_code: sc_remove_cutmarking(scp); if (sc_hist_up_line(scp)) if (!(flags & SCGETC_CN)) - do_bell(scp, bios_value.bell_pitch, BELL_DURATION); + sc_bell(scp, bios_value.bell_pitch, BELL_DURATION); goto next_code; case SPCLKEY | FKEY | F(58): /* down arrow key */ sc_remove_cutmarking(scp); if (sc_hist_down_line(scp)) if (!(flags & SCGETC_CN)) - do_bell(scp, bios_value.bell_pitch, BELL_DURATION); + sc_bell(scp, bios_value.bell_pitch, BELL_DURATION); goto next_code; case SPCLKEY | FKEY | F(51): /* page up key */ @@ -3911,7 +3025,7 @@ next_code: for (i=0; iysize; i++) if (sc_hist_up_line(scp)) { if (!(flags & SCGETC_CN)) - do_bell(scp, bios_value.bell_pitch, BELL_DURATION); + sc_bell(scp, bios_value.bell_pitch, BELL_DURATION); break; } goto next_code; @@ -3921,7 +3035,7 @@ next_code: for (i=0; iysize; i++) if (sc_hist_down_line(scp)) { if (!(flags & SCGETC_CN)) - do_bell(scp, bios_value.bell_pitch, BELL_DURATION); + sc_bell(scp, bios_value.bell_pitch, BELL_DURATION); break; } goto next_code; @@ -3957,10 +3071,12 @@ next_code: sc_remove_cutmarking(scp); scp->status &= ~BUFFER_SAVED; scp->status |= CURSOR_ENABLED; - draw_cursor_image(scp); + sc_draw_cursor_image(scp); } + tp = VIRTUAL_TTY(sc, scp->index); + if (tp->t_state & TS_ISOPEN) + scstart(tp); #endif - scstart(VIRTUAL_TTY(sc, scp->index)); } } break; @@ -4044,7 +3160,7 @@ next_code: i = (i + 1)%sc->vtys) { struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i); if (tp && tp->t_state & TS_ISOPEN) { - switch_scr(scp->sc, sc->first_vty + i); + sc_switch_scr(scp->sc, sc->first_vty + i); break; } } @@ -4057,7 +3173,7 @@ next_code: i = (i + sc->vtys - 1)%sc->vtys) { struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i); if (tp && tp->t_state & TS_ISOPEN) { - switch_scr(scp->sc, sc->first_vty + i); + sc_switch_scr(scp->sc, sc->first_vty + i); break; } } @@ -4065,7 +3181,7 @@ next_code: default: if (KEYCHAR(c) >= F_SCR && KEYCHAR(c) <= L_SCR) { - switch_scr(scp->sc, sc->first_vty + KEYCHAR(c) - F_SCR); + sc_switch_scr(scp->sc, sc->first_vty + KEYCHAR(c) - F_SCR); break; } /* assert(c & FKEY) */ @@ -4089,43 +3205,12 @@ scmmap(dev_t dev, vm_offset_t offset, int nprot) { scr_stat *scp; - if (SC_VTY(dev) == SC_MOUSE) - return -1; scp = SC_STAT(dev); if (scp != scp->sc->cur_scp) return -1; return (*vidsw[scp->sc->adapter]->mmap)(scp->sc->adp, offset, nprot); } -/* - * Calculate hardware attributes word using logical attributes mask and - * hardware colors - */ - -static int -mask2attr(struct term_stat *term) -{ - int attr, mask = term->attr_mask; - - if (mask & REVERSE_ATTR) { - attr = ((mask & FOREGROUND_CHANGED) ? - ((term->cur_color & 0xF000) >> 4) : - (term->rev_color & 0x0F00)) | - ((mask & BACKGROUND_CHANGED) ? - ((term->cur_color & 0x0F00) << 4) : - (term->rev_color & 0xF000)); - } else - attr = term->cur_color; - - /* XXX: underline mapping for Hercules adapter can be better */ - if (mask & (BOLD_ATTR | UNDERLINE_ATTR)) - attr ^= 0x0800; - if (mask & BLINK_ATTR) - attr ^= 0x8000; - - return attr; -} - static int save_kbd_state(scr_stat *scp) { @@ -4212,13 +3297,13 @@ set_mode(scr_stat *scp) if (!(scp->status & PIXEL_MODE) && ISFONTAVAIL(scp->sc->adp->va_flags)) { if (scp->font_size < 14) { if (scp->sc->fonts_loaded & FONT_8) - copy_font(scp, LOAD, 8, scp->sc->font_8); + sc_load_font(scp, 0, 8, scp->sc->font_8, 0, 256); } else if (scp->font_size >= 16) { if (scp->sc->fonts_loaded & FONT_16) - copy_font(scp, LOAD, 16, scp->sc->font_16); + sc_load_font(scp, 0, 16, scp->sc->font_16, 0, 256); } else { if (scp->sc->fonts_loaded & FONT_14) - copy_font(scp, LOAD, 14, scp->sc->font_14); + sc_load_font(scp, 0, 14, scp->sc->font_14, 0, 256); } /* * FONT KLUDGE: @@ -4227,20 +3312,20 @@ set_mode(scr_stat *scp) * Somehow we cannot show the font in other font pages on * some video cards... XXX */ - (*vidsw[scp->sc->adapter]->show_font)(scp->sc->adp, 0); + sc_show_font(scp, 0); } mark_all(scp); } #endif /* !SC_NO_FONT_LOADING */ - set_border(scp, scp->border); + sc_set_border(scp, scp->border); sc_set_cursor_image(scp); return 0; } void -set_border(scr_stat *scp, int color) +sc_set_border(scr_stat *scp, int color) { ++scp->sc->videoio_in_progress; (*scp->rndr->draw_border)(scp, color); @@ -4249,36 +3334,36 @@ set_border(scr_stat *scp, int color) #ifndef SC_NO_FONT_LOADING void -copy_font(scr_stat *scp, int operation, int font_size, u_char *buf) +sc_load_font(scr_stat *scp, int page, int size, u_char *buf, + int base, int count) { - /* - * FONT KLUDGE: - * This is an interim kludge to display correct font. - * Always use the font page #0 on the video plane 2. - * Somehow we cannot show the font in other font pages on - * some video cards... XXX - */ - scp->sc->font_loading_in_progress = TRUE; - if (operation == LOAD) { - (*vidsw[scp->sc->adapter]->load_font)(scp->sc->adp, 0, font_size, - buf, 0, 256); - } else if (operation == SAVE) { - (*vidsw[scp->sc->adapter]->save_font)(scp->sc->adp, 0, font_size, - buf, 0, 256); - } - scp->sc->font_loading_in_progress = FALSE; + sc_softc_t *sc; + + sc = scp->sc; + sc->font_loading_in_progress = TRUE; + (*vidsw[sc->adapter]->load_font)(sc->adp, page, size, buf, base, count); + sc->font_loading_in_progress = FALSE; +} + +void +sc_save_font(scr_stat *scp, int page, int size, u_char *buf, + int base, int count) +{ + sc_softc_t *sc; + + sc = scp->sc; + sc->font_loading_in_progress = TRUE; + (*vidsw[sc->adapter]->save_font)(sc->adp, page, size, buf, base, count); + sc->font_loading_in_progress = FALSE; +} + +void +sc_show_font(scr_stat *scp, int page) +{ + (*vidsw[scp->sc->adapter]->show_font)(scp->sc->adp, page); } #endif /* !SC_NO_FONT_LOADING */ -#ifndef SC_NO_SYSMOUSE -struct tty -*sc_get_mouse_tty(void) -{ - return sc_mouse_tty; -} -#endif /* !SC_NO_SYSMOUSE */ - -#ifndef SC_NO_CUTPASTE void sc_paste(scr_stat *scp, u_char *p, int count) { @@ -4294,10 +3379,9 @@ sc_paste(scr_stat *scp, u_char *p, int count) (*linesw[tp->t_line].l_rint)(rmap[*p++], tp); } } -#endif /* SC_NO_CUTPASTE */ -static void -do_bell(scr_stat *scp, int pitch, int duration) +void +sc_bell(scr_stat *scp, int pitch, int duration) { if (cold || shutdown_in_progress) return; @@ -4323,13 +3407,16 @@ static void blink_screen(void *arg) { scr_stat *scp = arg; + struct tty *tp; if (ISGRAPHSC(scp) || (scp->sc->blink_in_progress <= 1)) { scp->sc->blink_in_progress = 0; mark_all(scp); - scstart(VIRTUAL_TTY(scp->sc, scp->index)); + tp = VIRTUAL_TTY(scp->sc, scp->index); + if (tp->t_state & TS_ISOPEN) + scstart(tp); if (scp->sc->delayed_next_scr) - switch_scr(scp->sc, scp->sc->delayed_next_scr - 1); + sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1); } else { (*scp->rndr->draw)(scp, 0, scp->xsize*scp->ysize, diff --git a/sys/pc98/pc98/syscons_pc98.c b/sys/pc98/pc98/syscons_pc98.c index 514aaca9ab59..d4f5bd1541d4 100644 --- a/sys/pc98/pc98/syscons_pc98.c +++ b/sys/pc98/pc98/syscons_pc98.c @@ -69,7 +69,7 @@ static driver_t sc_driver = { sizeof(sc_softc_t), }; -static sc_softc_t main_softc = { 0, 0, 0, -1, NULL, -1, NULL, }; +static sc_softc_t main_softc; static int scprobe(device_t dev) @@ -109,17 +109,17 @@ sc_softc_t return NULL; if (flags & SC_KERNEL_CONSOLE) { /* FIXME: clear if it is wired to another unit! */ - main_softc.unit = unit; - return &main_softc; + sc = &main_softc; } else { sc = (sc_softc_t *)device_get_softc(devclass_get_device(sc_devclass, unit)); - if (!(sc->flags & SC_INIT_DONE)) { - sc->unit = unit; - sc->keyboard = -1; - sc->adapter = -1; - } - return sc; } + sc->unit = unit; + if (!(sc->flags & SC_INIT_DONE)) { + sc->keyboard = -1; + sc->adapter = -1; + sc->mouse_char = SC_MOUSE_CHAR; + } + return sc; } sc_softc_t