Print this page
NEX-16819 loader UEFI support
Includes work by Toomas Soome <tsoome@me.com>
Upstream commits:
loader: pxe receive cleanup
9475 libefi: Do not return only if ReceiveFilter
installboot: should support efi system partition
8931 boot1.efi: scan all display modes rather than
loader: spinconsole updates
loader: gfx experiment to try GOP Blt() function.
sha1 build test
loader: add sha1 hash calculation
common/sha1: update for loader build
loader: biosdisk rework
uts: 32-bit kernel FB needs mapping in low memory
uts: add diag-device
uts: boot console mirror with diag-device
uts: enable very early console on ttya
kmdb: add diag-device as input/output device
uts: test VGA memory exclusion from mapping
uts: clear boot mapping and protect boot pages test
uts: add dboot map debug printf
uts: need to release FB pages in release_bootstrap()
uts: add screenmap ioctl
uts: update sys/queue.h
loader: add illumos uts/common to include path
loader: tem/gfx font cleanup
loader: vbe checks
uts: gfx_private set KD_TEXT when KD_RESETTEXT is
uts: gfx 8-bit update
loader: gfx 8-bit fix
loader: always set media size from partition.
uts: MB2 support for 32-bit kernel
loader: x86 should have tem 80x25
uts: x86 should have tem 80x25
uts: font update
loader: font update
uts: tem attributes
loader: tem.c comment added
uts: use font module
loader: add font module
loader: build rules for new font setup
uts: gfx_private update for new font structure
uts: early boot update for new font structure
uts: font update
uts: font build rules update for new fonts
uts: tem update to new font structure
loader: module.c needs to include tem_impl.h
uts: gfx_private 8x16 font rework
uts: make font_lookup public
loader: font rework
uts: font rework
9259 libefi: efi_alloc_and_read should check for PMBR
uts: tem utf-8 support
loader: implement tem utf-8 support
loader: tem should be able to display UTF-8
7784 uts: console input should support utf-8
7796 uts: ldterm default to utf-8
uts: do not reset serial console
uts: set up colors even if tem is not console
uts: add type for early boot properties
uts: gfx_private experiment with drm and vga
uts: gfx_private should use setmode drm callback.
uts: identify FB types and set up gfx_private based
loader: replace gop and vesa with framebuffer
uts: boot needs simple tem to support mdb
uts: boot_keyboard should emit esc sequences for
uts: gfx_private FB showuld be written by line
kmdb: set terminal window size
uts: gfx_private needs to keep track of early boot FB
pnglite: move pnglite to usr/src/common
loader: gfx_fb
ficl-sys: add gfx primitives
loader: add illumos.png logo
ficl: add fb-putimage
loader: add png support
loader: add alpha blending for gfx_fb
loader: use term-drawrect for menu frame
ficl: add simple gfx words
uts: provide fb_info via fbgattr dev_specific array.
uts: gfx_private add alpha blending
uts: update sys/ascii.h
uts: tem OSC support (incomplete)
uts: implement env module support and use data from
uts: tem get colors from early boot data
loader: use crc32 from libstand (libz)
loader: optimize for size
loader: pass tem info to the environment
loader: import tem for loader console
loader: UEFI loader needs to set ISADIR based on
loader: need UEFI32 support
8918 loader.efi: add vesa edid support
uts: tem_safe_pix_clear_prom_output() should only
uts: tem_safe_pix_clear_entire_screen() should use
uts: tem_safe_check_first_time() should query cursor
uts: tem implement cls callback & visual_io v4
uts: gfx_vgatext use block cursor for vgatext
uts: gfx_private implement cls callback & visual_io
uts: gfx_private bitmap framebuffer implementation
uts: early start frame buffer console support
uts: font functions should check the input char
uts: font rendering should support 16/24/32bit depths
uts: use smallest font as fallback default.
uts: update terminal dimensions based on selected
7834 uts: vgatext should use gfx_private
uts: add spacing property to 8859-1.bdf
terminfo: add underline for sun-color
terminfo: sun-color has 16 colors
uts: add font load callback type
loader: do not repeat int13 calls with error 0x20 and
8905 loader: add skein/edonr support
8904 common/crypto: make skein and edonr loader
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Revert "NEX-16819 loader UEFI support"
This reverts commit ec06b9fc617b99234e538bf2e7e4d02a24993e0c.
Reverting due to failures in the zfs-tests and the sharefs-tests
NEX-16819 loader UEFI support
Includes work by Toomas Soome <tsoome@me.com>
Upstream commits:
loader: pxe receive cleanup
9475 libefi: Do not return only if ReceiveFilter
installboot: should support efi system partition
8931 boot1.efi: scan all display modes rather than
loader: spinconsole updates
loader: gfx experiment to try GOP Blt() function.
sha1 build test
loader: add sha1 hash calculation
common/sha1: update for loader build
loader: biosdisk rework
uts: 32-bit kernel FB needs mapping in low memory
uts: add diag-device
uts: boot console mirror with diag-device
uts: enable very early console on ttya
kmdb: add diag-device as input/output device
uts: test VGA memory exclusion from mapping
uts: clear boot mapping and protect boot pages test
uts: add dboot map debug printf
uts: need to release FB pages in release_bootstrap()
uts: add screenmap ioctl
uts: update sys/queue.h
loader: add illumos uts/common to include path
loader: tem/gfx font cleanup
loader: vbe checks
uts: gfx_private set KD_TEXT when KD_RESETTEXT is
uts: gfx 8-bit update
loader: gfx 8-bit fix
loader: always set media size from partition.
uts: MB2 support for 32-bit kernel
loader: x86 should have tem 80x25
uts: x86 should have tem 80x25
uts: font update
loader: font update
uts: tem attributes
loader: tem.c comment added
uts: use font module
loader: add font module
loader: build rules for new font setup
uts: gfx_private update for new font structure
uts: early boot update for new font structure
uts: font update
uts: font build rules update for new fonts
uts: tem update to new font structure
loader: module.c needs to include tem_impl.h
uts: gfx_private 8x16 font rework
uts: make font_lookup public
loader: font rework
uts: font rework
libefi: efi_alloc_and_read should check for PMBR
uts: tem utf-8 support
loader: implement tem utf-8 support
loader: tem should be able to display UTF-8
7784 uts: console input should support utf-8
7796 uts: ldterm default to utf-8
uts: do not reset serial console
uts: set up colors even if tem is not console
uts: add type for early boot properties
uts: gfx_private experiment with drm and vga
uts: gfx_private should use setmode drm callback.
uts: identify FB types and set up gfx_private based
loader: replace gop and vesa with framebuffer
uts: boot needs simple tem to support mdb
uts: boot_keyboard should emit esc sequences for
uts: gfx_private FB showuld be written by line
kmdb: set terminal window size
uts: gfx_private needs to keep track of early boot FB
pnglite: move pnglite to usr/src/common
loader: gfx_fb
ficl-sys: add gfx primitives
loader: add illumos.png logo
ficl: add fb-putimage
loader: add png support
loader: add alpha blending for gfx_fb
loader: use term-drawrect for menu frame
ficl: add simple gfx words
uts: provide fb_info via fbgattr dev_specific array.
uts: gfx_private add alpha blending
uts: update sys/ascii.h
uts: tem OSC support (incomplete)
uts: implement env module support and use data from
uts: tem get colors from early boot data
loader: use crc32 from libstand (libz)
loader: optimize for size
loader: pass tem info to the environment
loader: import tem for loader console
loader: UEFI loader needs to set ISADIR based on
loader: need UEFI32 support
8918 loader.efi: add vesa edid support
uts: tem_safe_pix_clear_prom_output() should only
uts: tem_safe_pix_clear_entire_screen() should use
uts: tem_safe_check_first_time() should query cursor
uts: tem implement cls callback & visual_io v4
uts: gfx_vgatext use block cursor for vgatext
uts: gfx_private implement cls callback & visual_io
uts: gfx_private bitmap framebuffer implementation
uts: early start frame buffer console support
uts: font functions should check the input char
uts: font rendering should support 16/24/32bit depths
uts: use smallest font as fallback default.
uts: update terminal dimensions based on selected
7834 uts: vgatext should use gfx_private
uts: add spacing property to 8859-1.bdf
terminfo: add underline for sun-color
terminfo: sun-color has 16 colors
uts: add font load callback type
loader: do not repeat int13 calls with error 0x20 and
8905 loader: add skein/edonr support
8904 common/crypto: make skein and edonr loader
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
*** 85,106 ****
&tem_safe_pix_cursor,
&tem_safe_pix_bit2pix,
&tem_safe_pix_cls
};
!
! static void tem_safe_control(struct tem_vt_state *, uchar_t,
cred_t *, enum called_from);
static void tem_safe_setparam(struct tem_vt_state *, int, int);
static void tem_safe_selgraph(struct tem_vt_state *);
! static void tem_safe_chkparam(struct tem_vt_state *, uchar_t,
cred_t *, enum called_from);
! static void tem_safe_getparams(struct tem_vt_state *, uchar_t,
cred_t *, enum called_from);
! static void tem_safe_outch(struct tem_vt_state *, uchar_t,
cred_t *, enum called_from);
! static void tem_safe_parse(struct tem_vt_state *, uchar_t,
cred_t *, enum called_from);
static void tem_safe_new_line(struct tem_vt_state *,
cred_t *, enum called_from);
static void tem_safe_cr(struct tem_vt_state *);
--- 85,105 ----
&tem_safe_pix_cursor,
&tem_safe_pix_bit2pix,
&tem_safe_pix_cls
};
! static void tem_safe_control(struct tem_vt_state *, tem_char_t,
cred_t *, enum called_from);
static void tem_safe_setparam(struct tem_vt_state *, int, int);
static void tem_safe_selgraph(struct tem_vt_state *);
! static void tem_safe_chkparam(struct tem_vt_state *, tem_char_t,
cred_t *, enum called_from);
! static void tem_safe_getparams(struct tem_vt_state *, tem_char_t,
cred_t *, enum called_from);
! static void tem_safe_outch(struct tem_vt_state *, tem_char_t,
cred_t *, enum called_from);
! static void tem_safe_parse(struct tem_vt_state *, tem_char_t,
cred_t *, enum called_from);
static void tem_safe_new_line(struct tem_vt_state *,
cred_t *, enum called_from);
static void tem_safe_cr(struct tem_vt_state *);
*** 135,178 ****
cred_t *, enum called_from);
static void tem_safe_bell(struct tem_vt_state *tem,
enum called_from called_from);
static void tem_safe_pix_clear_prom_output(struct tem_vt_state *tem,
cred_t *credp, enum called_from called_from);
static void tem_safe_virtual_cls(struct tem_vt_state *, int, screen_pos_t,
screen_pos_t);
static void tem_safe_virtual_display(struct tem_vt_state *,
! unsigned char *, int, screen_pos_t, screen_pos_t,
! text_color_t, text_color_t);
static void tem_safe_virtual_copy(struct tem_vt_state *, screen_pos_t,
screen_pos_t, screen_pos_t, screen_pos_t,
screen_pos_t, screen_pos_t);
static void tem_safe_align_cursor(struct tem_vt_state *tem);
! static void bit_to_pix4(struct tem_vt_state *tem, uchar_t c,
text_color_t fg_color, text_color_t bg_color);
! static void bit_to_pix8(struct tem_vt_state *tem, uchar_t c,
text_color_t fg_color, text_color_t bg_color);
! static void bit_to_pix24(struct tem_vt_state *tem, uchar_t c,
text_color_t fg_color, text_color_t bg_color);
- /* BEGIN CSTYLED */
- /* Bk Rd Gr Br Bl Mg Cy Wh */
- static text_color_t dim_xlate[] = { 1, 5, 3, 7, 2, 6, 4, 8 };
- static text_color_t brt_xlate[] = { 9, 13, 11, 15, 10, 14, 12, 0 };
- /* END CSTYLED */
-
-
- text_cmap_t cmap4_to_24 = {
- /* BEGIN CSTYLED */
- /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
- Wh+ Bk Bl Gr Cy Rd Mg Br Wh Bk+ Bl+ Gr+ Cy+ Rd+ Mg+ Yw */
- 0xff,0x00,0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x40,0x00,0x00,0x00,0xff,0xff,0xff,
- 0xff,0x00,0x00,0x80,0x80,0x00,0x00,0x80,0x80,0x40,0x00,0xff,0xff,0x00,0x00,0xff,
- 0xff,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x40,0xff,0x00,0xff,0x00,0xff,0x00
- /* END CSTYLED */
- };
-
#define PIX4TO32(pix4) (uint32_t)( \
cmap4_to_24.red[pix4] << 16 | \
cmap4_to_24.green[pix4] << 8 | \
cmap4_to_24.blue[pix4])
--- 134,164 ----
cred_t *, enum called_from);
static void tem_safe_bell(struct tem_vt_state *tem,
enum called_from called_from);
static void tem_safe_pix_clear_prom_output(struct tem_vt_state *tem,
cred_t *credp, enum called_from called_from);
+ static void tem_safe_get_color(text_color_t *, text_color_t *, term_char_t);
static void tem_safe_virtual_cls(struct tem_vt_state *, int, screen_pos_t,
screen_pos_t);
static void tem_safe_virtual_display(struct tem_vt_state *,
! term_char_t *, int, screen_pos_t, screen_pos_t);
static void tem_safe_virtual_copy(struct tem_vt_state *, screen_pos_t,
screen_pos_t, screen_pos_t, screen_pos_t,
screen_pos_t, screen_pos_t);
static void tem_safe_align_cursor(struct tem_vt_state *tem);
! static void bit_to_pix4(struct tem_vt_state *tem, tem_char_t c,
text_color_t fg_color, text_color_t bg_color);
! static void bit_to_pix8(struct tem_vt_state *tem, tem_char_t c,
text_color_t fg_color, text_color_t bg_color);
! static void bit_to_pix16(struct tem_vt_state *tem, tem_char_t c,
text_color_t fg_color, text_color_t bg_color);
+ static void bit_to_pix24(struct tem_vt_state *tem, tem_char_t c,
+ text_color_t fg_color, text_color_t bg_color);
+ static void bit_to_pix32(struct tem_vt_state *tem, tem_char_t c,
+ text_color_t fg_color, text_color_t bg_color);
#define PIX4TO32(pix4) (uint32_t)( \
cmap4_to_24.red[pix4] << 16 | \
cmap4_to_24.green[pix4] << 8 | \
cmap4_to_24.blue[pix4])
*** 180,192 ****
#define tem_safe_callback_display (*tems.ts_callbacks->tsc_display)
#define tem_safe_callback_copy (*tems.ts_callbacks->tsc_copy)
#define tem_safe_callback_cursor (*tems.ts_callbacks->tsc_cursor)
#define tem_safe_callback_cls (*tems.ts_callbacks->tsc_cls)
! #define tem_safe_callback_bit2pix(tem, c, fg, bg) { \
ASSERT(tems.ts_callbacks->tsc_bit2pix != NULL); \
! (void) (*tems.ts_callbacks->tsc_bit2pix)((tem), (c), (fg), (bg));\
}
void
tem_safe_check_first_time(
struct tem_vt_state *tem,
--- 166,178 ----
#define tem_safe_callback_display (*tems.ts_callbacks->tsc_display)
#define tem_safe_callback_copy (*tems.ts_callbacks->tsc_copy)
#define tem_safe_callback_cursor (*tems.ts_callbacks->tsc_cursor)
#define tem_safe_callback_cls (*tems.ts_callbacks->tsc_cls)
! #define tem_safe_callback_bit2pix(tem, c) { \
ASSERT(tems.ts_callbacks->tsc_bit2pix != NULL); \
! (void) (*tems.ts_callbacks->tsc_bit2pix)((tem), (c));\
}
void
tem_safe_check_first_time(
struct tem_vt_state *tem,
*** 206,219 ****
*/
if (!first_time)
return;
first_time = 0;
! if (tems.ts_display_mode == VIS_TEXT) {
tem_safe_text_cursor(tem, VIS_GET_CURSOR, credp, called_from);
tem_safe_align_cursor(tem);
- }
}
/*
* This entry point handles output requests from restricted contexts like
* kmdb, where services like mutexes are not available. This function
--- 192,206 ----
*/
if (!first_time)
return;
first_time = 0;
! if (tems.ts_display_mode == VIS_TEXT)
tem_safe_text_cursor(tem, VIS_GET_CURSOR, credp, called_from);
+ else
+ tem_safe_pix_cursor(tem, VIS_GET_CURSOR, credp, called_from);
tem_safe_align_cursor(tem);
}
/*
* This entry point handles output requests from restricted contexts like
* kmdb, where services like mutexes are not available. This function
*** 247,257 ****
/* Process partial UTF-8 sequence. */
static void
tem_safe_input_partial(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
! int i;
uint8_t c;
if (tem->tvs_utf8_left == 0)
return;
--- 234,244 ----
/* Process partial UTF-8 sequence. */
static void
tem_safe_input_partial(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
! unsigned i;
uint8_t c;
if (tem->tvs_utf8_left == 0)
return;
*** 342,354 ****
v = b & 0x1f; /* Two-byte sequence */
b = u & 0xff;
v = (v << 6) | (b & 0x3f);
}
- /* Use '?' as replacement if needed. */
- if (v > 0xff)
- v = '?';
tem_safe_parse(tem, v, credp, called_from);
tem->tvs_utf8_partial = 0;
}
return;
}
--- 329,338 ----
*** 444,454 ****
* send the appropriate control message or set state based on the
* value of the control character ch
*/
static void
! tem_safe_control(struct tem_vt_state *tem, uchar_t ch, cred_t *credp,
enum called_from called_from)
{
tem->tvs_state = A_STATE_START;
switch (ch) {
case A_BEL:
--- 428,438 ----
* send the appropriate control message or set state based on the
* value of the control character ch
*/
static void
! tem_safe_control(struct tem_vt_state *tem, tem_char_t ch, cred_t *credp,
enum called_from called_from)
{
tem->tvs_state = A_STATE_START;
switch (ch) {
case A_BEL:
*** 503,512 ****
--- 487,509 ----
tem->tvs_params[i] = -1;
tem->tvs_state = A_STATE_CSI;
}
break;
+ case A_OSC:
+ {
+ int i;
+ tem->tvs_curparam = 0;
+ tem->tvs_paramval = 0;
+ tem->tvs_gotparam = B_FALSE;
+ /* clear the parameters */
+ for (i = 0; i < TEM_MAXPARAMS; i++)
+ tem->tvs_params[i] = -1;
+ tem->tvs_state = A_STATE_OSC;
+ }
+ break;
+
case A_GS:
tem_safe_back_tab(tem, credp, called_from);
break;
default:
*** 563,572 ****
--- 560,572 ----
case 2: /* Faint Intense */
tem->tvs_flags &= ~TEM_ATTR_BOLD;
break;
+ case 4: /* Underline */
+ tem->tvs_flags |= TEM_ATTR_UNDERLINE;
+ break;
case 5: /* Blink */
tem->tvs_flags |= TEM_ATTR_BLINK;
break;
case 7: /* Reverse video */
*** 575,584 ****
--- 575,604 ----
} else {
tem->tvs_flags |= TEM_ATTR_REVERSE;
}
break;
+ case 22: /* Remove Bold */
+ tem->tvs_flags &= ~TEM_ATTR_BOLD;
+ break;
+
+ case 24: /* Remove Underline */
+ tem->tvs_flags &= ~TEM_ATTR_UNDERLINE;
+ break;
+
+ case 25: /* Remove Blink */
+ tem->tvs_flags &= ~TEM_ATTR_BLINK;
+ break;
+
+ case 27: /* Remove Reverse */
+ if (tem->tvs_flags & TEM_ATTR_SCREEN_REVERSE) {
+ tem->tvs_flags |= TEM_ATTR_REVERSE;
+ } else {
+ tem->tvs_flags &= ~TEM_ATTR_REVERSE;
+ }
+ break;
+
case 30: /* black (grey) foreground */
case 31: /* red (light red) foreground */
case 32: /* green (light green) foreground */
case 33: /* brown (yellow) foreground */
case 34: /* blue (light blue) foreground */
*** 661,671 ****
*
* General rule: This code does not validate the arguments passed.
* It assumes that the next lower level will do so.
*/
static void
! tem_safe_chkparam(struct tem_vt_state *tem, uchar_t ch, cred_t *credp,
enum called_from called_from)
{
int i;
int row;
int col;
--- 681,691 ----
*
* General rule: This code does not validate the arguments passed.
* It assumes that the next lower level will do so.
*/
static void
! tem_safe_chkparam(struct tem_vt_state *tem, tem_char_t ch, cred_t *credp,
enum called_from called_from)
{
int i;
int row;
int col;
*** 924,934 ****
/*
* Gather the parameters of an ANSI escape sequence
*/
static void
! tem_safe_getparams(struct tem_vt_state *tem, uchar_t ch,
cred_t *credp, enum called_from called_from)
{
ASSERT((called_from == CALLED_FROM_STANDALONE) ||
MUTEX_HELD(&tem->tvs_lock));
--- 944,954 ----
/*
* Gather the parameters of an ANSI escape sequence
*/
static void
! tem_safe_getparams(struct tem_vt_state *tem, tem_char_t ch,
cred_t *credp, enum called_from called_from)
{
ASSERT((called_from == CALLED_FROM_STANDALONE) ||
MUTEX_HELD(&tem->tvs_lock));
*** 959,983 ****
}
}
}
/*
* Add character to internal buffer.
* When its full, send it to the next layer.
*/
static void
! tem_safe_outch(struct tem_vt_state *tem, uchar_t ch,
cred_t *credp, enum called_from called_from)
{
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
/* buffer up the character until later */
!
! tem->tvs_outbuf[tem->tvs_outindex++] = ch;
tem->tvs_c_cursor.col++;
if (tem->tvs_c_cursor.col >= tems.ts_c_dimension.width) {
tem_safe_send_data(tem, credp, called_from);
tem_safe_new_line(tem, credp, called_from);
}
--- 979,1064 ----
}
}
}
/*
+ * Gather the OSC string.
+ * OSC Ps ; Pt ST
+ * OSC Ps ; Pt BEL
+ * Ps is number sequence identifying the function. We only support
+ * Ps = 4 and Ps = 104.
+ * Quite obviously this is nowhere close to be done;)
+ */
+ /* ARGSUSED */
+ static void
+ tem_safe_get_oscstring(struct tem_vt_state *tem, uchar_t ch,
+ cred_t *credp __unused, enum called_from called_from)
+ {
+ ASSERT((called_from == CALLED_FROM_STANDALONE) ||
+ MUTEX_HELD(&tem->tvs_lock));
+
+ /* Should we cancel? */
+ if (ch == A_CAN || ch == A_SUB || ch == A_ESC) {
+ tem->tvs_state = A_STATE_START;
+ return;
+ }
+
+ /* following two if statements will read in the numeric parameter */
+ if (ch >= '0' && ch <= '9') {
+ tem->tvs_paramval = ((tem->tvs_paramval * 10) + (ch - '0'));
+ tem->tvs_gotparam = B_TRUE; /* Remember got parameter */
+ return; /* Return immediately */
+ }
+
+ if (tem->tvs_gotparam && ch == ';') {
+ /* get the parameter value */
+ tem->tvs_params[tem->tvs_curparam] = tem->tvs_paramval;
+ tem->tvs_curparam++;
+ tem->tvs_gotparam = B_FALSE;
+ tem->tvs_paramval = 0;
+ }
+
+ if (tem->tvs_curparam == 0) {
+ /* bad sequence */
+ tem->tvs_state = A_STATE_START;
+ return;
+ }
+ if (tem->tvs_gotparam == B_FALSE && tem->tvs_curparam > 0) {
+ if (tem->tvs_params[0] != 4 && tem->tvs_params[0] != 104) {
+ /* make sure tvs_params will not get filled up */
+ tem->tvs_curparam = 1;
+ }
+ }
+ if (ch == A_ST || ch == A_BEL) {
+ /* done */
+ tem->tvs_state = A_STATE_START;
+ return;
+ }
+ }
+
+ /*
* Add character to internal buffer.
* When its full, send it to the next layer.
*/
static void
! tem_safe_outch(struct tem_vt_state *tem, tem_char_t ch,
cred_t *credp, enum called_from called_from)
{
+ text_color_t fg;
+ text_color_t bg;
+ text_attr_t attr;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
/* buffer up the character until later */
! tem_safe_get_attr(tem, &fg, &bg, &attr, TEM_ATTR_REVERSE);
! tem->tvs_outbuf[tem->tvs_outindex].tc_char = ch | TEM_ATTR(attr);
! tem->tvs_outbuf[tem->tvs_outindex].tc_fg_color = fg;
! tem->tvs_outbuf[tem->tvs_outindex].tc_bg_color = bg;
! tem->tvs_outindex++;
tem->tvs_c_cursor.col++;
if (tem->tvs_c_cursor.col >= tems.ts_c_dimension.width) {
tem_safe_send_data(tem, credp, called_from);
tem_safe_new_line(tem, credp, called_from);
}
*** 1052,1086 ****
static void
tem_safe_send_data(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
- text_color_t fg_color;
- text_color_t bg_color;
-
ASSERT((called_from == CALLED_FROM_STANDALONE) ||
MUTEX_HELD(&tem->tvs_lock));
if (tem->tvs_outindex == 0) {
tem_safe_align_cursor(tem);
return;
}
- tem_safe_get_color(tem, &fg_color, &bg_color, TEM_ATTR_REVERSE);
tem_safe_virtual_display(tem,
tem->tvs_outbuf, tem->tvs_outindex,
! tem->tvs_s_cursor.row, tem->tvs_s_cursor.col,
! fg_color, bg_color);
if (tem->tvs_isactive) {
/*
* Call the primitive to render this data.
*/
tem_safe_callback_display(tem,
tem->tvs_outbuf, tem->tvs_outindex,
tem->tvs_s_cursor.row, tem->tvs_s_cursor.col,
- fg_color, bg_color,
credp, called_from);
}
tem->tvs_outindex = 0;
--- 1133,1161 ----
static void
tem_safe_send_data(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
ASSERT((called_from == CALLED_FROM_STANDALONE) ||
MUTEX_HELD(&tem->tvs_lock));
if (tem->tvs_outindex == 0) {
tem_safe_align_cursor(tem);
return;
}
tem_safe_virtual_display(tem,
tem->tvs_outbuf, tem->tvs_outindex,
! tem->tvs_s_cursor.row, tem->tvs_s_cursor.col);
if (tem->tvs_isactive) {
/*
* Call the primitive to render this data.
*/
tem_safe_callback_display(tem,
tem->tvs_outbuf, tem->tvs_outindex,
tem->tvs_s_cursor.row, tem->tvs_s_cursor.col,
credp, called_from);
}
tem->tvs_outindex = 0;
*** 1104,1123 ****
* State machine parser based on the current state and character input
* major terminations are to control character or normal character
*/
static void
! tem_safe_parse(struct tem_vt_state *tem, uchar_t ch,
cred_t *credp, enum called_from called_from)
{
int i;
ASSERT((called_from == CALLED_FROM_STANDALONE) ||
MUTEX_HELD(&tem->tvs_lock));
if (tem->tvs_state == A_STATE_START) { /* Normal state? */
! if (ch == A_CSI || ch == A_ESC || ch < ' ') {
/* Control */
tem_safe_control(tem, ch, credp, called_from);
} else {
/* Display */
tem_safe_outch(tem, ch, credp, called_from);
--- 1179,1198 ----
* State machine parser based on the current state and character input
* major terminations are to control character or normal character
*/
static void
! tem_safe_parse(struct tem_vt_state *tem, tem_char_t ch,
cred_t *credp, enum called_from called_from)
{
int i;
ASSERT((called_from == CALLED_FROM_STANDALONE) ||
MUTEX_HELD(&tem->tvs_lock));
if (tem->tvs_state == A_STATE_START) { /* Normal state? */
! if (ch == A_CSI || ch == A_OSC || ch == A_ESC || ch < ' ') {
/* Control */
tem_safe_control(tem, ch, credp, called_from);
} else {
/* Display */
tem_safe_outch(tem, ch, credp, called_from);
*** 1125,1134 ****
--- 1200,1214 ----
return;
}
/* In <ESC> sequence */
if (tem->tvs_state != A_STATE_ESC) { /* Need to get parameters? */
+ if (tem->tvs_state == A_STATE_OSC) {
+ tem_safe_get_oscstring(tem, ch, credp, called_from);
+ return;
+ }
+
if (tem->tvs_state != A_STATE_CSI) {
tem_safe_getparams(tem, ch, credp, called_from);
return;
}
*** 1235,1244 ****
--- 1315,1332 ----
tem->tvs_gotparam = B_FALSE;
/* clear the parameters */
for (i = 0; i < TEM_MAXPARAMS; i++)
tem->tvs_params[i] = -1;
tem->tvs_state = A_STATE_CSI;
+ } else if (ch == ']') {
+ tem->tvs_curparam = 0;
+ tem->tvs_paramval = 0;
+ tem->tvs_gotparam = B_FALSE;
+ /* clear the parameters */
+ for (i = 0; i < TEM_MAXPARAMS; i++)
+ tem->tvs_params[i] = -1;
+ tem->tvs_state = A_STATE_OSC;
} else if (ch == 'Q') { /* <ESC>Q ? */
tem->tvs_state = A_STATE_START;
} else if (ch == 'C') { /* <ESC>C ? */
tem->tvs_state = A_STATE_START;
} else {
*** 1395,1423 ****
tem_safe_callback_cls(tem, count, row, col, credp, called_from);
}
/*ARGSUSED*/
void
! tem_safe_text_display(struct tem_vt_state *tem, uchar_t *string,
int count, screen_pos_t row, screen_pos_t col,
- text_color_t fg_color, text_color_t bg_color,
cred_t *credp, enum called_from called_from)
{
struct vis_consdisplay da;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! da.data = string;
! da.width = (screen_size_t)count;
da.row = row;
da.col = col;
! da.fg_color = fg_color;
! da.bg_color = bg_color;
!
tems_safe_display(&da, credp, called_from);
}
/*
* This function is used to blit a rectangular color image,
* unperturbed on the underlying framebuffer, to render
--- 1483,1514 ----
tem_safe_callback_cls(tem, count, row, col, credp, called_from);
}
/*ARGSUSED*/
void
! tem_safe_text_display(struct tem_vt_state *tem, term_char_t *string,
int count, screen_pos_t row, screen_pos_t col,
cred_t *credp, enum called_from called_from)
{
struct vis_consdisplay da;
+ int i;
+ tem_char_t c;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! da.data = (uint8_t *)&c;
! da.width = 1;
da.row = row;
da.col = col;
! for (i = 0; i < count; i++) {
! tem_safe_get_color(&da.fg_color, &da.bg_color, string[i]);
! c = TEM_CHAR(string[i].tc_char);
tems_safe_display(&da, credp, called_from);
+ da.col++;
+ }
}
/*
* This function is used to blit a rectangular color image,
* unperturbed on the underlying framebuffer, to render
*** 1449,1459 ****
mutex_exit(&tem->tvs_lock);
mutex_exit(&tems.ts_lock);
}
-
/*ARGSUSED*/
void
tem_safe_text_copy(struct tem_vt_state *tem,
screen_pos_t s_col, screen_pos_t s_row,
screen_pos_t e_col, screen_pos_t e_row,
--- 1540,1549 ----
*** 1478,1523 ****
void
tem_safe_text_cls(struct tem_vt_state *tem,
int count, screen_pos_t row, screen_pos_t col, cred_t *credp,
enum called_from called_from)
{
! struct vis_consdisplay da;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! da.data = tems.ts_blank_line;
! da.width = (screen_size_t)count;
! da.row = row;
! da.col = col;
!
! tem_safe_get_color(tem, &da.fg_color, &da.bg_color,
TEM_ATTR_SCREEN_REVERSE);
! tems_safe_display(&da, credp, called_from);
}
void
tem_safe_pix_display(struct tem_vt_state *tem,
! uchar_t *string, int count,
screen_pos_t row, screen_pos_t col,
- text_color_t fg_color, text_color_t bg_color,
cred_t *credp, enum called_from called_from)
{
struct vis_consdisplay da;
int i;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
da.data = (uchar_t *)tem->tvs_pix_data;
! da.width = tems.ts_font.width;
! da.height = tems.ts_font.height;
da.row = (row * da.height) + tems.ts_p_offset.y;
da.col = (col * da.width) + tems.ts_p_offset.x;
for (i = 0; i < count; i++) {
! tem_safe_callback_bit2pix(tem, string[i], fg_color, bg_color);
tems_safe_display(&da, credp, called_from);
da.col += da.width;
}
}
--- 1568,1619 ----
void
tem_safe_text_cls(struct tem_vt_state *tem,
int count, screen_pos_t row, screen_pos_t col, cred_t *credp,
enum called_from called_from)
{
! text_attr_t attr;
! term_char_t c;
! int i;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! tem_safe_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
TEM_ATTR_SCREEN_REVERSE);
! c.tc_char = TEM_ATTR(attr & ~TEM_ATTR_UNDERLINE) | ' ';
!
! if (count > tems.ts_c_dimension.width ||
! col + count > tems.ts_c_dimension.width)
! count = tems.ts_c_dimension.width - col;
!
! for (i = 0; i < count; i++)
! tems.ts_blank_line[i] = c;
!
! tem_safe_text_display(tem, tems.ts_blank_line, count, row, col,
! credp, called_from);
}
void
tem_safe_pix_display(struct tem_vt_state *tem,
! term_char_t *string, int count,
screen_pos_t row, screen_pos_t col,
cred_t *credp, enum called_from called_from)
{
struct vis_consdisplay da;
int i;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
da.data = (uchar_t *)tem->tvs_pix_data;
! da.width = (screen_size_t)tems.ts_font.vf_width;
! da.height = (screen_size_t)tems.ts_font.vf_height;
da.row = (row * da.height) + tems.ts_p_offset.y;
da.col = (col * da.width) + tems.ts_p_offset.x;
for (i = 0; i < count; i++) {
! tem_safe_callback_bit2pix(tem, string[i]);
tems_safe_display(&da, credp, called_from);
da.col += da.width;
}
}
*** 1546,1558 ****
*/
tem_safe_pix_clear_prom_output(tem, credp, called_from);
}
need_clear = B_FALSE;
! ma.s_row = s_row * tems.ts_font.height + tems.ts_p_offset.y;
! ma.e_row = (e_row + 1) * tems.ts_font.height + tems.ts_p_offset.y - 1;
! ma.t_row = t_row * tems.ts_font.height + tems.ts_p_offset.y;
/*
* Check if we're in process of clearing OBP's columns area,
* which only happens when term scrolls up a whole line.
*/
--- 1642,1655 ----
*/
tem_safe_pix_clear_prom_output(tem, credp, called_from);
}
need_clear = B_FALSE;
! ma.s_row = s_row * tems.ts_font.vf_height + tems.ts_p_offset.y;
! ma.e_row = (e_row + 1) * tems.ts_font.vf_height +
! tems.ts_p_offset.y - 1;
! ma.t_row = t_row * tems.ts_font.vf_height + tems.ts_p_offset.y;
/*
* Check if we're in process of clearing OBP's columns area,
* which only happens when term scrolls up a whole line.
*/
*** 1560,1578 ****
e_col == tems.ts_c_dimension.width - 1) {
/*
* We need to clear OBP's columns area outside our kernel
* console term. So that we set ma.e_col to entire row here.
*/
! ma.s_col = s_col * tems.ts_font.width;
ma.e_col = tems.ts_p_dimension.width - 1;
! ma.t_col = t_col * tems.ts_font.width;
} else {
! ma.s_col = s_col * tems.ts_font.width + tems.ts_p_offset.x;
! ma.e_col = (e_col + 1) * tems.ts_font.width +
tems.ts_p_offset.x - 1;
! ma.t_col = t_col * tems.ts_font.width + tems.ts_p_offset.x;
}
tems_safe_copy(&ma, credp, called_from);
if (tem->tvs_first_line > 0 && t_row < s_row) {
--- 1657,1675 ----
e_col == tems.ts_c_dimension.width - 1) {
/*
* We need to clear OBP's columns area outside our kernel
* console term. So that we set ma.e_col to entire row here.
*/
! ma.s_col = s_col * tems.ts_font.vf_width;
ma.e_col = tems.ts_p_dimension.width - 1;
! ma.t_col = t_col * tems.ts_font.vf_width;
} else {
! ma.s_col = s_col * tems.ts_font.vf_width + tems.ts_p_offset.x;
! ma.e_col = (e_col + 1) * tems.ts_font.vf_width +
tems.ts_p_offset.x - 1;
! ma.t_col = t_col * tems.ts_font.vf_width + tems.ts_p_offset.x;
}
tems_safe_copy(&ma, credp, called_from);
if (tem->tvs_first_line > 0 && t_row < s_row) {
*** 1585,1613 ****
}
}
void
! tem_safe_pix_bit2pix(struct tem_vt_state *tem, unsigned char c,
! unsigned char fg, unsigned char bg)
{
! void (*fp)(struct tem_vt_state *, unsigned char,
unsigned char, unsigned char);
switch (tems.ts_pdepth) {
case 4:
fp = bit_to_pix4;
break;
case 8:
fp = bit_to_pix8;
break;
case 24:
- case 32:
fp = bit_to_pix24;
}
! fp(tem, c, fg, bg);
}
/*
* This function only clears count of columns in one row
--- 1682,1720 ----
}
}
void
! tem_safe_pix_bit2pix(struct tem_vt_state *tem, term_char_t c)
{
! text_color_t fg, bg;
! void (*fp)(struct tem_vt_state *, tem_char_t,
unsigned char, unsigned char);
+ tem_safe_get_color(&fg, &bg, c);
switch (tems.ts_pdepth) {
case 4:
fp = bit_to_pix4;
break;
case 8:
fp = bit_to_pix8;
break;
+ case 15:
+ case 16:
+ fp = bit_to_pix16;
+ break;
case 24:
fp = bit_to_pix24;
+ break;
+ case 32:
+ fp = bit_to_pix32;
+ break;
+ default:
+ return;
}
! fp(tem, c.tc_char, fg, bg);
}
/*
* This function only clears count of columns in one row
*** 1649,1670 ****
*/
static void
tem_safe_pix_clear_prom_output(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
! int nrows, ncols, width, height;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! width = tems.ts_font.width;
! height = tems.ts_font.height;
! nrows = (tems.ts_p_offset.y + (height - 1))/ height;
ncols = (tems.ts_p_dimension.width + (width - 1))/ width;
! tem_safe_pix_cls_range(tem, 0, nrows, 0, 0, ncols, 0,
B_FALSE, credp, called_from);
}
/*
* clear the whole screen for pixel mode, just clear the
--- 1756,1779 ----
*/
static void
tem_safe_pix_clear_prom_output(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
! int nrows, ncols, width, height, offset;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! width = tems.ts_font.vf_width;
! height = tems.ts_font.vf_height;
! offset = tems.ts_p_offset.y % height;
! nrows = tems.ts_p_offset.y / height;
ncols = (tems.ts_p_dimension.width + (width - 1))/ width;
! if (nrows > 0)
! tem_safe_pix_cls_range(tem, 0, nrows, offset, 0, ncols, 0,
B_FALSE, credp, called_from);
}
/*
* clear the whole screen for pixel mode, just clear the
*** 1672,1694 ****
*/
void
tem_safe_pix_clear_entire_screen(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
int nrows, ncols, width, height;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! width = tems.ts_font.width;
! height = tems.ts_font.height;
nrows = (tems.ts_p_dimension.height + (height - 1))/ height;
ncols = (tems.ts_p_dimension.width + (width - 1))/ width;
! tem_safe_pix_cls_range(tem, 0, nrows, 0, 0, ncols, 0,
! B_FALSE, credp, called_from);
/*
* Since the whole screen is cleared, we don't need
* to clear OBP output later.
*/
--- 1781,1818 ----
*/
void
tem_safe_pix_clear_entire_screen(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
+ struct vis_consclear cl;
+ text_color_t fg_color;
+ text_color_t bg_color;
+ text_attr_t attr;
+ term_char_t c;
int nrows, ncols, width, height;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! /* call driver first, if error, clear terminal area */
! tem_safe_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
! TEM_ATTR_SCREEN_REVERSE);
! c.tc_char = TEM_ATTR(attr);
+ tem_safe_get_color(&fg_color, &bg_color, c);
+ cl.bg_color = bg_color;
+ if (tems_cls_layered(&cl, credp) == 0)
+ return;
+
+ width = tems.ts_font.vf_width;
+ height = tems.ts_font.vf_height;
+
nrows = (tems.ts_p_dimension.height + (height - 1))/ height;
ncols = (tems.ts_p_dimension.width + (width - 1))/ width;
! tem_safe_pix_cls_range(tem, 0, nrows, tems.ts_p_offset.y, 0, ncols,
! tems.ts_p_offset.x, B_FALSE, credp, called_from);
/*
* Since the whole screen is cleared, we don't need
* to clear OBP output later.
*/
*** 2002,2031 ****
void
tem_safe_pix_cursor(struct tem_vt_state *tem, short action,
cred_t *credp, enum called_from called_from)
{
struct vis_conscursor ca;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! ca.row = tem->tvs_c_cursor.row * tems.ts_font.height +
tems.ts_p_offset.y;
! ca.col = tem->tvs_c_cursor.col * tems.ts_font.width +
tems.ts_p_offset.x;
! ca.width = tems.ts_font.width;
! ca.height = tems.ts_font.height;
! if (tems.ts_pdepth == 8 || tems.ts_pdepth == 4) {
if (tem->tvs_flags & TEM_ATTR_REVERSE) {
- ca.fg_color.mono = TEM_TEXT_WHITE;
- ca.bg_color.mono = TEM_TEXT_BLACK;
- } else {
- ca.fg_color.mono = TEM_TEXT_BLACK;
- ca.bg_color.mono = TEM_TEXT_WHITE;
- }
- } else if (tems.ts_pdepth == 24 || tems.ts_pdepth == 32) {
- if (tem->tvs_flags & TEM_ATTR_REVERSE) {
ca.fg_color.twentyfour[0] = TEM_TEXT_WHITE24_RED;
ca.fg_color.twentyfour[1] = TEM_TEXT_WHITE24_GREEN;
ca.fg_color.twentyfour[2] = TEM_TEXT_WHITE24_BLUE;
ca.bg_color.twentyfour[0] = TEM_TEXT_BLACK24_RED;
--- 2126,2179 ----
void
tem_safe_pix_cursor(struct tem_vt_state *tem, short action,
cred_t *credp, enum called_from called_from)
{
struct vis_conscursor ca;
+ uint32_t color;
+ text_color_t fg, bg;
+ term_char_t c;
+ text_attr_t attr;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
! ca.row = tem->tvs_c_cursor.row * tems.ts_font.vf_height +
tems.ts_p_offset.y;
! ca.col = tem->tvs_c_cursor.col * tems.ts_font.vf_width +
tems.ts_p_offset.x;
! ca.width = (screen_size_t)tems.ts_font.vf_width;
! ca.height = (screen_size_t)tems.ts_font.vf_height;
!
! tem_safe_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
! TEM_ATTR_REVERSE);
! c.tc_char = TEM_ATTR(attr);
!
! tem_safe_get_color(&fg, &bg, c);
!
! switch (tems.ts_pdepth) {
! case 4:
! ca.fg_color.mono = fg;
! ca.bg_color.mono = bg;
! break;
! case 8:
! ca.fg_color.mono = tems.ts_color_map(fg);
! ca.bg_color.mono = tems.ts_color_map(bg);
! break;
! case 15:
! case 16:
! color = tems.ts_color_map(fg);
! ca.fg_color.sixteen[0] = (color >> 8) & 0xFF;
! ca.fg_color.sixteen[1] = color & 0xFF;
! color = tems.ts_color_map(bg);
! ca.bg_color.sixteen[0] = (color >> 8) & 0xFF;
! ca.bg_color.sixteen[1] = color & 0xFF;
! break;
! case 24:
! case 32:
! #ifdef _HAVE_TEM_FIRMWARE
! /* Keeping this block to support old binary only drivers */
if (tem->tvs_flags & TEM_ATTR_REVERSE) {
ca.fg_color.twentyfour[0] = TEM_TEXT_WHITE24_RED;
ca.fg_color.twentyfour[1] = TEM_TEXT_WHITE24_GREEN;
ca.fg_color.twentyfour[2] = TEM_TEXT_WHITE24_BLUE;
ca.bg_color.twentyfour[0] = TEM_TEXT_BLACK24_RED;
*** 2038,2125 ****
ca.bg_color.twentyfour[0] = TEM_TEXT_WHITE24_RED;
ca.bg_color.twentyfour[1] = TEM_TEXT_WHITE24_GREEN;
ca.bg_color.twentyfour[2] = TEM_TEXT_WHITE24_BLUE;
}
}
ca.action = action;
tems_safe_cursor(&ca, credp, called_from);
}
static void
! bit_to_pix4(struct tem_vt_state *tem, uchar_t c, text_color_t fg_color,
text_color_t bg_color)
{
uint8_t *dest = (uint8_t *)tem->tvs_pix_data;
font_bit_to_pix4(&tems.ts_font, dest, c, fg_color, bg_color);
}
static void
! bit_to_pix8(struct tem_vt_state *tem, uchar_t c, text_color_t fg_color,
text_color_t bg_color)
{
uint8_t *dest = (uint8_t *)tem->tvs_pix_data;
font_bit_to_pix8(&tems.ts_font, dest, c, fg_color, bg_color);
}
static void
! bit_to_pix24(struct tem_vt_state *tem, uchar_t c, text_color_t fg_color4,
text_color_t bg_color4)
{
! uint32_t fg_color32, bg_color32, *dest;
ASSERT(fg_color4 < 16 && bg_color4 < 16);
fg_color32 = PIX4TO32(fg_color4);
bg_color32 = PIX4TO32(bg_color4);
! dest = (uint32_t *)tem->tvs_pix_data;
font_bit_to_pix24(&tems.ts_font, dest, c, fg_color32, bg_color32);
}
! static text_color_t
! ansi_bg_to_solaris(struct tem_vt_state *tem, int ansi)
{
! if (tem->tvs_flags & TEM_ATTR_BRIGHT_BG)
! return (brt_xlate[ansi]);
! else
! return (dim_xlate[ansi]);
! }
! static text_color_t
! ansi_fg_to_solaris(struct tem_vt_state *tem, int ansi)
! {
! if (tem->tvs_flags & TEM_ATTR_BRIGHT_FG ||
! tem->tvs_flags & TEM_ATTR_BOLD) {
! return (brt_xlate[ansi]);
! } else {
! return (dim_xlate[ansi]);
! }
}
/*
* flag: TEM_ATTR_SCREEN_REVERSE or TEM_ATTR_REVERSE
*/
void
! tem_safe_get_color(struct tem_vt_state *tem, text_color_t *fg,
! text_color_t *bg, uint8_t flag)
{
if (tem->tvs_flags & flag) {
! *fg = ansi_fg_to_solaris(tem,
! tem->tvs_bg_color);
! *bg = ansi_bg_to_solaris(tem,
! tem->tvs_fg_color);
} else {
! *fg = ansi_fg_to_solaris(tem,
! tem->tvs_fg_color);
! *bg = ansi_bg_to_solaris(tem,
! tem->tvs_bg_color);
}
}
/*
* Clear a rectangle of screen for pixel mode.
*
* arguments:
* row: start row#
--- 2186,2338 ----
ca.bg_color.twentyfour[0] = TEM_TEXT_WHITE24_RED;
ca.bg_color.twentyfour[1] = TEM_TEXT_WHITE24_GREEN;
ca.bg_color.twentyfour[2] = TEM_TEXT_WHITE24_BLUE;
}
+ #else
+ color = tems.ts_color_map(fg);
+ ca.fg_color.twentyfour[0] = (color >> 16) & 0xFF;
+ ca.fg_color.twentyfour[1] = (color >> 8) & 0xFF;
+ ca.fg_color.twentyfour[2] = color & 0xFF;
+ color = tems.ts_color_map(bg);
+ ca.bg_color.twentyfour[0] = (color >> 16) & 0xFF;
+ ca.bg_color.twentyfour[1] = (color >> 8) & 0xFF;
+ ca.bg_color.twentyfour[2] = color & 0xFF;
+ break;
+ #endif
}
ca.action = action;
tems_safe_cursor(&ca, credp, called_from);
+
+ if (action == VIS_GET_CURSOR) {
+ tem->tvs_c_cursor.row = 0;
+ tem->tvs_c_cursor.col = 0;
+
+ if (ca.row != 0) {
+ tem->tvs_c_cursor.row = (ca.row - tems.ts_p_offset.y) /
+ tems.ts_font.vf_height;
+ }
+ if (ca.col != 0) {
+ tem->tvs_c_cursor.col = (ca.col - tems.ts_p_offset.x) /
+ tems.ts_font.vf_width;
+ }
+ }
}
static void
! bit_to_pix4(struct tem_vt_state *tem, tem_char_t c, text_color_t fg_color,
text_color_t bg_color)
{
uint8_t *dest = (uint8_t *)tem->tvs_pix_data;
font_bit_to_pix4(&tems.ts_font, dest, c, fg_color, bg_color);
}
static void
! bit_to_pix8(struct tem_vt_state *tem, tem_char_t c, text_color_t fg_color,
text_color_t bg_color)
{
uint8_t *dest = (uint8_t *)tem->tvs_pix_data;
+
+ fg_color = (text_color_t)tems.ts_color_map(fg_color);
+ bg_color = (text_color_t)tems.ts_color_map(bg_color);
font_bit_to_pix8(&tems.ts_font, dest, c, fg_color, bg_color);
}
static void
! bit_to_pix16(struct tem_vt_state *tem, tem_char_t c, text_color_t fg_color4,
text_color_t bg_color4)
{
! uint16_t fg_color16, bg_color16;
! uint16_t *dest;
ASSERT(fg_color4 < 16 && bg_color4 < 16);
+ fg_color16 = (uint16_t)tems.ts_color_map(fg_color4);
+ bg_color16 = (uint16_t)tems.ts_color_map(bg_color4);
+
+ dest = (uint16_t *)tem->tvs_pix_data;
+ font_bit_to_pix16(&tems.ts_font, dest, c, fg_color16, bg_color16);
+ }
+
+ static void
+ bit_to_pix24(struct tem_vt_state *tem, tem_char_t c, text_color_t fg_color4,
+ text_color_t bg_color4)
+ {
+ uint32_t fg_color32, bg_color32;
+ uint8_t *dest;
+
+ ASSERT(fg_color4 < 16 && bg_color4 < 16);
+
+ #ifdef _HAVE_TEM_FIRMWARE
fg_color32 = PIX4TO32(fg_color4);
bg_color32 = PIX4TO32(bg_color4);
+ #else
+ fg_color32 = tems.ts_color_map(fg_color4);
+ bg_color32 = tems.ts_color_map(bg_color4);
+ #endif
! dest = (uint8_t *)tem->tvs_pix_data;
font_bit_to_pix24(&tems.ts_font, dest, c, fg_color32, bg_color32);
}
! static void
! bit_to_pix32(struct tem_vt_state *tem, tem_char_t c, text_color_t fg_color4,
! text_color_t bg_color4)
{
! uint32_t fg_color32, bg_color32, *dest;
! ASSERT(fg_color4 < 16 && bg_color4 < 16);
!
! #ifdef _HAVE_TEM_FIRMWARE
! fg_color32 = PIX4TO32(fg_color4);
! bg_color32 = PIX4TO32(bg_color4);
! #else
! fg_color32 = ((uint32_t)0xFF << 24) | tems.ts_color_map(fg_color4);
! bg_color32 = ((uint32_t)0xFF << 24) | tems.ts_color_map(bg_color4);
! #endif
!
! dest = (uint32_t *)tem->tvs_pix_data;
! font_bit_to_pix32(&tems.ts_font, dest, c, fg_color32, bg_color32);
}
/*
* flag: TEM_ATTR_SCREEN_REVERSE or TEM_ATTR_REVERSE
*/
void
! tem_safe_get_attr(struct tem_vt_state *tem, text_color_t *fg,
! text_color_t *bg, text_attr_t *attr, uint8_t flag)
{
if (tem->tvs_flags & flag) {
! *fg = tem->tvs_bg_color;
! *bg = tem->tvs_fg_color;
} else {
! *fg = tem->tvs_fg_color;
! *bg = tem->tvs_bg_color;
}
+
+ if (attr == NULL)
+ return;
+
+ *attr = tem->tvs_flags;
}
+ static void
+ tem_safe_get_color(text_color_t *fg, text_color_t *bg, term_char_t c)
+ {
+ if (TEM_CHAR_ATTR(c.tc_char) & (TEM_ATTR_BRIGHT_FG | TEM_ATTR_BOLD))
+ *fg = brt_xlate[c.tc_fg_color];
+ else
+ *fg = dim_xlate[c.tc_fg_color];
+
+ if (TEM_CHAR_ATTR(c.tc_char) & TEM_ATTR_BRIGHT_BG)
+ *bg = brt_xlate[c.tc_bg_color];
+ else
+ *bg = dim_xlate[c.tc_bg_color];
+ }
+
/*
* Clear a rectangle of screen for pixel mode.
*
* arguments:
* row: start row#
*** 2139,2163 ****
enum called_from called_from)
{
struct vis_consdisplay da;
int i, j;
int row_add = 0;
! text_color_t fg_color;
! text_color_t bg_color;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
if (sroll_up)
row_add = tems.ts_c_dimension.height - 1;
! da.width = tems.ts_font.width;
! da.height = tems.ts_font.height;
! tem_safe_get_color(tem, &fg_color, &bg_color, TEM_ATTR_SCREEN_REVERSE);
! tem_safe_callback_bit2pix(tem, ' ', fg_color, bg_color);
da.data = (uchar_t *)tem->tvs_pix_data;
for (i = 0; i < nrows; i++, row++) {
da.row = (row + row_add) * da.height + offset_y;
da.col = col * da.width + offset_x;
--- 2352,2379 ----
enum called_from called_from)
{
struct vis_consdisplay da;
int i, j;
int row_add = 0;
! term_char_t c;
! text_attr_t attr;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
if (sroll_up)
row_add = tems.ts_c_dimension.height - 1;
! da.width = (screen_size_t)tems.ts_font.vf_width;
! da.height = (screen_size_t)tems.ts_font.vf_height;
! tem_safe_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
! TEM_ATTR_SCREEN_REVERSE);
! /* Make sure we will not draw underlines */
! c.tc_char = TEM_ATTR(attr & ~TEM_ATTR_UNDERLINE) | ' ';
! tem_safe_callback_bit2pix(tem, c);
da.data = (uchar_t *)tem->tvs_pix_data;
for (i = 0; i < nrows; i++, row++) {
da.row = (row + row_add) * da.height + offset_y;
da.col = col * da.width + offset_x;
*** 2170,2216 ****
/*
* virtual screen operations
*/
static void
! tem_safe_virtual_display(struct tem_vt_state *tem, unsigned char *string,
! int count, screen_pos_t row, screen_pos_t col,
! text_color_t fg_color, text_color_t bg_color)
{
int i, width;
! unsigned char *addr;
! text_color_t *pfgcolor;
! text_color_t *pbgcolor;
if (row < 0 || row >= tems.ts_c_dimension.height ||
col < 0 || col >= tems.ts_c_dimension.width ||
col + count > tems.ts_c_dimension.width)
return;
width = tems.ts_c_dimension.width;
addr = tem->tvs_screen_buf + (row * width + col);
- pfgcolor = tem->tvs_fg_buf + (row * width + col);
- pbgcolor = tem->tvs_bg_buf + (row * width + col);
for (i = 0; i < count; i++) {
*addr++ = string[i];
- *pfgcolor++ = fg_color;
- *pbgcolor++ = bg_color;
}
}
static void
! i_virtual_copy(unsigned char *base,
screen_pos_t s_col, screen_pos_t s_row,
screen_pos_t e_col, screen_pos_t e_row,
screen_pos_t t_col, screen_pos_t t_row)
{
! unsigned char *from;
! unsigned char *to;
int cnt;
screen_size_t chars_per_row;
! unsigned char *to_row_start;
! unsigned char *from_row_start;
screen_size_t rows_to_move;
int cols = tems.ts_c_dimension.width;
chars_per_row = e_col - s_col + 1;
rows_to_move = e_row - s_row + 1;
--- 2386,2425 ----
/*
* virtual screen operations
*/
static void
! tem_safe_virtual_display(struct tem_vt_state *tem, term_char_t *string,
! int count, screen_pos_t row, screen_pos_t col)
{
int i, width;
! term_char_t *addr;
if (row < 0 || row >= tems.ts_c_dimension.height ||
col < 0 || col >= tems.ts_c_dimension.width ||
col + count > tems.ts_c_dimension.width)
return;
width = tems.ts_c_dimension.width;
addr = tem->tvs_screen_buf + (row * width + col);
for (i = 0; i < count; i++) {
*addr++ = string[i];
}
}
static void
! i_virtual_copy_tem_chars(term_char_t *base,
screen_pos_t s_col, screen_pos_t s_row,
screen_pos_t e_col, screen_pos_t e_row,
screen_pos_t t_col, screen_pos_t t_row)
{
! term_char_t *from;
! term_char_t *to;
int cnt;
screen_size_t chars_per_row;
! term_char_t *to_row_start;
! term_char_t *from_row_start;
screen_size_t rows_to_move;
int cols = tems.ts_c_dimension.width;
chars_per_row = e_col - s_col + 1;
rows_to_move = e_row - s_row + 1;
*** 2273,2303 ****
/* More sanity checks. */
if (t_row + rows_to_move > rows ||
t_col + chars_per_row > cols)
return;
! i_virtual_copy(tem->tvs_screen_buf, s_col, s_row,
e_col, e_row, t_col, t_row);
-
- /* text_color_t is the same size as char */
- i_virtual_copy((unsigned char *)tem->tvs_fg_buf,
- s_col, s_row, e_col, e_row, t_col, t_row);
- i_virtual_copy((unsigned char *)tem->tvs_bg_buf,
- s_col, s_row, e_col, e_row, t_col, t_row);
-
}
static void
tem_safe_virtual_cls(struct tem_vt_state *tem,
int count, screen_pos_t row, screen_pos_t col)
{
! text_color_t fg_color;
! text_color_t bg_color;
! tem_safe_get_color(tem, &fg_color, &bg_color, TEM_ATTR_SCREEN_REVERSE);
! tem_safe_virtual_display(tem, tems.ts_blank_line, count, row, col,
! fg_color, bg_color);
}
/*
* only blank screen, not clear our screen buffer
*/
--- 2482,2511 ----
/* More sanity checks. */
if (t_row + rows_to_move > rows ||
t_col + chars_per_row > cols)
return;
! i_virtual_copy_tem_chars(tem->tvs_screen_buf, s_col, s_row,
e_col, e_row, t_col, t_row);
}
static void
tem_safe_virtual_cls(struct tem_vt_state *tem,
int count, screen_pos_t row, screen_pos_t col)
{
! int i;
! text_attr_t attr;
! term_char_t c;
! tem_safe_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
! TEM_ATTR_SCREEN_REVERSE);
! c.tc_char = TEM_ATTR(attr & ~TEM_ATTR_UNDERLINE) | ' ';
!
! for (i = 0; i < tems.ts_c_dimension.width; i++)
! tems.ts_blank_line[i] = c;
!
! tem_safe_virtual_display(tem, tems.ts_blank_line, count, row, col);
}
/*
* only blank screen, not clear our screen buffer
*/
*** 2327,2397 ****
*/
void
tem_safe_unblank_screen(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
! text_color_t fg_color, fg_last;
! text_color_t bg_color, bg_last;
! size_t tc_size = sizeof (text_color_t);
! int row, col, count, col_start;
! int width;
! unsigned char *buf;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
if (tems.ts_display_mode == VIS_PIXEL)
tem_safe_pix_clear_entire_screen(tem, credp, called_from);
tem_safe_callback_cursor(tem, VIS_HIDE_CURSOR, credp, called_from);
- width = tems.ts_c_dimension.width;
-
/*
* Display data in tvs_screen_buf to the actual framebuffer in a
* row by row way.
* When dealing with one row, output data with the same foreground
* and background color all together.
*/
for (row = 0; row < tems.ts_c_dimension.height; row++) {
! buf = tem->tvs_screen_buf + (row * width);
! count = col_start = 0;
! for (col = 0; col < width; col++) {
! fg_color =
! tem->tvs_fg_buf[(row * width + col) * tc_size];
! bg_color =
! tem->tvs_bg_buf[(row * width + col) * tc_size];
! if (col == 0) {
! fg_last = fg_color;
! bg_last = bg_color;
}
- if ((fg_color != fg_last) || (bg_color != bg_last)) {
- /*
- * Call the primitive to render this data.
- */
- tem_safe_callback_display(tem,
- buf, count, row, col_start,
- fg_last, bg_last, credp, called_from);
- buf += count;
- count = 1;
- col_start = col;
- fg_last = fg_color;
- bg_last = bg_color;
- } else {
- count++;
- }
- }
-
- if (col_start == (width - 1))
- continue;
-
- /*
- * Call the primitive to render this data.
- */
- tem_safe_callback_display(tem,
- buf, count, row, col_start,
- fg_last, bg_last, credp, called_from);
- }
-
tem_safe_callback_cursor(tem, VIS_DISPLAY_CURSOR, credp, called_from);
}
--- 2535,2562 ----
*/
void
tem_safe_unblank_screen(struct tem_vt_state *tem, cred_t *credp,
enum called_from called_from)
{
! int row;
ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) ||
called_from == CALLED_FROM_STANDALONE);
if (tems.ts_display_mode == VIS_PIXEL)
tem_safe_pix_clear_entire_screen(tem, credp, called_from);
tem_safe_callback_cursor(tem, VIS_HIDE_CURSOR, credp, called_from);
/*
* Display data in tvs_screen_buf to the actual framebuffer in a
* row by row way.
* When dealing with one row, output data with the same foreground
* and background color all together.
*/
for (row = 0; row < tems.ts_c_dimension.height; row++) {
! tem_safe_callback_display(tem, tem->tvs_screen_rows[row],
! tems.ts_c_dimension.width, row, 0, credp, called_from);
}
tem_safe_callback_cursor(tem, VIS_DISPLAY_CURSOR, credp, called_from);
}