#include <console/video_console.h>
#include <console/serial_protos.h>
#include <kern/kern_types.h>
#include <kern/kalloc.h>
#include <kern/debug.h>
#include <kern/spl.h>
#include <kern/thread_call.h>
#include <vm/pmap.h>
#include <vm/vm_kern.h>
#include <machine/io_map_entries.h>
#include <machine/machine_cpu.h>
#include <pexpert/pexpert.h>
#include <sys/kdebug.h>
#include "iso_font.c"
#if !CONFIG_EMBEDDED
#include "progress_meter_data.c"
#endif
#include "sys/msgbuf.h"
struct vc_info vinfo;
void noroot_icon_test(void);
extern int disableConsoleOutput;
static boolean_t gc_enabled = FALSE;
static boolean_t gc_initialized = FALSE;
static boolean_t vm_initialized = FALSE;
static struct {
void (*initialize)(struct vc_info * info);
void (*enable)(boolean_t enable);
void (*paint_char)(unsigned int xx, unsigned int yy, unsigned char ch,
int attrs, unsigned char ch_previous,
int attrs_previous);
void (*clear_screen)(unsigned int xx, unsigned int yy, unsigned int top,
unsigned int bottom, int which);
void (*scroll_down)(int num, unsigned int top, unsigned int bottom);
void (*scroll_up)(int num, unsigned int top, unsigned int bottom);
void (*hide_cursor)(unsigned int xx, unsigned int yy);
void (*show_cursor)(unsigned int xx, unsigned int yy);
void (*update_color)(int color, boolean_t fore);
} gc_ops;
static unsigned char *gc_buffer_attributes;
static unsigned char *gc_buffer_characters;
static unsigned char *gc_buffer_colorcodes;
static unsigned char *gc_buffer_tab_stops;
static uint32_t gc_buffer_columns;
static uint32_t gc_buffer_rows;
static uint32_t gc_buffer_size;
#if defined(__i386__) || defined(__x86_64__)
decl_simple_lock_data(static, vcputc_lock);
#define VCPUTC_LOCK_INIT() \
MACRO_BEGIN \
simple_lock_init(&vcputc_lock, 0); \
MACRO_END
#define VCPUTC_LOCK_LOCK() \
MACRO_BEGIN \
boolean_t istate = ml_get_interrupts_enabled(); \
while (!simple_lock_try(&vcputc_lock)) \
{ \
if (!istate) \
handle_pending_TLB_flushes(); \
cpu_pause(); \
} \
MACRO_END
#define VCPUTC_LOCK_UNLOCK() \
MACRO_BEGIN \
simple_unlock(&vcputc_lock); \
MACRO_END
#else
static hw_lock_data_t vcputc_lock;
#define VCPUTC_LOCK_INIT() \
MACRO_BEGIN \
hw_lock_init(&vcputc_lock); \
MACRO_END
#define VCPUTC_LOCK_LOCK() \
MACRO_BEGIN \
if (!hw_lock_to(&vcputc_lock, ~0U))\
{ \
panic("VCPUTC_LOCK_LOCK"); \
} \
MACRO_END
#define VCPUTC_LOCK_UNLOCK() \
MACRO_BEGIN \
hw_lock_unlock(&vcputc_lock); \
MACRO_END
#endif
#define ATTR_NONE 0
#define ATTR_BOLD 1
#define ATTR_UNDER 2
#define ATTR_REVERSE 4
#define COLOR_BACKGROUND 0
#define COLOR_FOREGROUND 7
#define COLOR_CODE_GET(code, fore) (((code) & ((fore) ? 0xF0 : 0x0F)) >> ((fore) ? 4 : 0))
#define COLOR_CODE_SET(code, color, fore) (((code) & ((fore) ? 0x0F : 0xF0)) | ((color) << ((fore) ? 4 : 0)))
static unsigned char gc_color_code;
#define MAXPARS 16
static unsigned int gc_x, gc_y, gc_savex, gc_savey;
static unsigned int gc_par[MAXPARS], gc_numpars, gc_hanging_cursor, gc_attr, gc_saveattr;
static unsigned int gc_scrreg_top, gc_scrreg_bottom;
enum vt100state_e {
ESnormal,
ESesc,
ESsquare,
ESgetpars,
ESgotpars,
ESfunckey,
EShash,
ESsetG0,
ESsetG1,
ESask,
EScharsize,
ESignore
} gc_vt100state = ESnormal;
enum
{
kProgressAcquireDelay = 0,
#if CONFIG_EMBEDDED
kProgressReacquireDelay = 5,
#else
kProgressReacquireDelay = 5,
#endif
};
static int8_t vc_rotate_matr[4][2][2] = {
{ { 1, 0 },
{ 0, 1 } },
{ { 0, 1 },
{ -1, 0 } },
{ { -1, 0 },
{ 0, -1 } },
{ { 0, -1 },
{ 1, 0 } }
};
static int gc_wrap_mode = 1, gc_relative_origin = 0;
static int gc_charset_select = 0, gc_save_charset_s = 0;
static int gc_charset[2] = { 0, 0 };
static int gc_charset_save[2] = { 0, 0 };
static void gc_clear_line(unsigned int xx, unsigned int yy, int which);
static void gc_clear_screen(unsigned int xx, unsigned int yy, int top,
unsigned int bottom, int which);
static void gc_enable(boolean_t enable);
static void gc_hide_cursor(unsigned int xx, unsigned int yy);
static void gc_initialize(struct vc_info * info);
static boolean_t gc_is_tab_stop(unsigned int column);
static void gc_paint_char(unsigned int xx, unsigned int yy, unsigned char ch,
int attrs);
static void gc_putchar(char ch);
static void gc_putc_askcmd(unsigned char ch);
static void gc_putc_charsetcmd(int charset, unsigned char ch);
static void gc_putc_charsizecmd(unsigned char ch);
static void gc_putc_esc(unsigned char ch);
static void gc_putc_getpars(unsigned char ch);
static void gc_putc_gotpars(unsigned char ch);
static void gc_putc_normal(unsigned char ch);
static void gc_putc_square(unsigned char ch);
static void gc_reset_screen(void);
static void gc_reset_tabs(void);
static void gc_reset_vt100(void);
static void gc_scroll_down(int num, unsigned int top, unsigned int bottom);
static void gc_scroll_up(int num, unsigned int top, unsigned int bottom);
static void gc_set_tab_stop(unsigned int column, boolean_t enabled);
static void gc_show_cursor(unsigned int xx, unsigned int yy);
static void gc_update_color(int color, boolean_t fore);
static void
gc_clear_line(unsigned int xx, unsigned int yy, int which)
{
unsigned int start, end, i;
switch (which) {
case 0:
start = xx;
end = vinfo.v_columns-1;
break;
case 1:
start = 0;
end = xx;
break;
case 2:
start = 0;
end = vinfo.v_columns-1;
break;
default:
return;
}
for (i = start; i <= end; i++) {
gc_paint_char(i, yy, ' ', ATTR_NONE);
}
}
static void
gc_clear_screen(unsigned int xx, unsigned int yy, int top, unsigned int bottom,
int which)
{
if (!gc_buffer_size) return;
if ( xx < gc_buffer_columns && yy < gc_buffer_rows && bottom <= gc_buffer_rows )
{
uint32_t start, end;
switch (which) {
case 0:
start = (yy * gc_buffer_columns) + xx;
end = (bottom * gc_buffer_columns) - 1;
break;
case 1:
start = (top * gc_buffer_columns);
end = (yy * gc_buffer_columns) + xx;
break;
case 2:
start = (top * gc_buffer_columns);
end = (bottom * gc_buffer_columns) - 1;
break;
default:
start = 0;
end = 0;
break;
}
memset(gc_buffer_attributes + start, ATTR_NONE, end - start + 1);
memset(gc_buffer_characters + start, ' ', end - start + 1);
memset(gc_buffer_colorcodes + start, gc_color_code, end - start + 1);
}
gc_ops.clear_screen(xx, yy, top, bottom, which);
}
static void
gc_enable( boolean_t enable )
{
unsigned char *buffer_attributes = NULL;
unsigned char *buffer_characters = NULL;
unsigned char *buffer_colorcodes = NULL;
unsigned char *buffer_tab_stops = NULL;
uint32_t buffer_columns = 0;
uint32_t buffer_rows = 0;
uint32_t buffer_size = 0;
spl_t s;
if ( enable == FALSE )
{
if ( console_is_serial() == FALSE )
disableConsoleOutput = TRUE;
gc_enabled = FALSE;
gc_ops.enable(FALSE);
}
s = splhigh( );
VCPUTC_LOCK_LOCK( );
if ( gc_buffer_size )
{
buffer_attributes = gc_buffer_attributes;
buffer_characters = gc_buffer_characters;
buffer_colorcodes = gc_buffer_colorcodes;
buffer_tab_stops = gc_buffer_tab_stops;
buffer_columns = gc_buffer_columns;
buffer_rows = gc_buffer_rows;
buffer_size = gc_buffer_size;
gc_buffer_attributes = NULL;
gc_buffer_characters = NULL;
gc_buffer_colorcodes = NULL;
gc_buffer_tab_stops = NULL;
gc_buffer_columns = 0;
gc_buffer_rows = 0;
gc_buffer_size = 0;
VCPUTC_LOCK_UNLOCK( );
splx( s );
kfree( buffer_attributes, buffer_size );
kfree( buffer_characters, buffer_size );
kfree( buffer_colorcodes, buffer_size );
kfree( buffer_tab_stops, buffer_columns );
}
else
{
VCPUTC_LOCK_UNLOCK( );
splx( s );
}
if ( enable )
{
if ( vm_initialized )
{
buffer_columns = vinfo.v_columns;
buffer_rows = vinfo.v_rows;
buffer_size = buffer_columns * buffer_rows;
if ( buffer_size )
{
buffer_attributes = (unsigned char *) kalloc( buffer_size );
buffer_characters = (unsigned char *) kalloc( buffer_size );
buffer_colorcodes = (unsigned char *) kalloc( buffer_size );
buffer_tab_stops = (unsigned char *) kalloc( buffer_columns );
if ( buffer_attributes == NULL ||
buffer_characters == NULL ||
buffer_colorcodes == NULL ||
buffer_tab_stops == NULL )
{
if ( buffer_attributes ) kfree( buffer_attributes, buffer_size );
if ( buffer_characters ) kfree( buffer_characters, buffer_size );
if ( buffer_colorcodes ) kfree( buffer_colorcodes, buffer_size );
if ( buffer_tab_stops ) kfree( buffer_tab_stops, buffer_columns );
buffer_attributes = NULL;
buffer_characters = NULL;
buffer_colorcodes = NULL;
buffer_tab_stops = NULL;
buffer_columns = 0;
buffer_rows = 0;
buffer_size = 0;
}
else
{
memset( buffer_attributes, ATTR_NONE, buffer_size );
memset( buffer_characters, ' ', buffer_size );
memset( buffer_colorcodes, COLOR_CODE_SET( 0, COLOR_FOREGROUND, TRUE ), buffer_size );
memset( buffer_tab_stops, 0, buffer_columns );
}
}
}
s = splhigh( );
VCPUTC_LOCK_LOCK( );
gc_buffer_attributes = buffer_attributes;
gc_buffer_characters = buffer_characters;
gc_buffer_colorcodes = buffer_colorcodes;
gc_buffer_tab_stops = buffer_tab_stops;
gc_buffer_columns = buffer_columns;
gc_buffer_rows = buffer_rows;
gc_buffer_size = buffer_size;
gc_reset_screen();
VCPUTC_LOCK_UNLOCK( );
splx( s );
gc_ops.clear_screen(gc_x, gc_y, 0, vinfo.v_rows, 2);
gc_ops.show_cursor(gc_x, gc_y);
gc_ops.enable(TRUE);
gc_enabled = TRUE;
disableConsoleOutput = FALSE;
}
}
static void
gc_hide_cursor(unsigned int xx, unsigned int yy)
{
if ( xx < gc_buffer_columns && yy < gc_buffer_rows )
{
uint32_t index = (yy * gc_buffer_columns) + xx;
unsigned char attribute = gc_buffer_attributes[index];
unsigned char character = gc_buffer_characters[index];
unsigned char colorcode = gc_buffer_colorcodes[index];
unsigned char colorcodesave = gc_color_code;
gc_update_color(COLOR_CODE_GET(colorcode, TRUE ), TRUE );
gc_update_color(COLOR_CODE_GET(colorcode, FALSE), FALSE);
gc_ops.paint_char(xx, yy, character, attribute, 0, 0);
gc_update_color(COLOR_CODE_GET(colorcodesave, TRUE ), TRUE );
gc_update_color(COLOR_CODE_GET(colorcodesave, FALSE), FALSE);
}
else
{
gc_ops.hide_cursor(xx, yy);
}
}
static void
gc_initialize(struct vc_info * info)
{
if ( gc_initialized == FALSE )
{
VCPUTC_LOCK_INIT();
gc_initialized = TRUE;
}
gc_ops.initialize(info);
gc_reset_vt100();
gc_x = gc_y = 0;
}
static void
gc_paint_char(unsigned int xx, unsigned int yy, unsigned char ch, int attrs)
{
if ( xx < gc_buffer_columns && yy < gc_buffer_rows )
{
uint32_t index = (yy * gc_buffer_columns) + xx;
gc_buffer_attributes[index] = attrs;
gc_buffer_characters[index] = ch;
gc_buffer_colorcodes[index] = gc_color_code;
}
gc_ops.paint_char(xx, yy, ch, attrs, 0, 0);
}
static void
gc_putchar(char ch)
{
if (!ch) {
return;
}
switch (gc_vt100state) {
default:gc_vt100state = ESnormal;
case ESnormal:
gc_putc_normal(ch);
break;
case ESesc:
gc_putc_esc(ch);
break;
case ESsquare:
gc_putc_square(ch);
break;
case ESgetpars:
gc_putc_getpars(ch);
break;
case ESgotpars:
gc_putc_gotpars(ch);
break;
case ESask:
gc_putc_askcmd(ch);
break;
case EScharsize:
gc_putc_charsizecmd(ch);
break;
case ESsetG0:
gc_putc_charsetcmd(0, ch);
break;
case ESsetG1:
gc_putc_charsetcmd(1, ch);
break;
}
if (gc_x >= vinfo.v_columns) {
if (0 == vinfo.v_columns)
gc_x = 0;
else
gc_x = vinfo.v_columns - 1;
}
if (gc_y >= vinfo.v_rows) {
if (0 == vinfo.v_rows)
gc_y = 0;
else
gc_y = vinfo.v_rows - 1;
}
}
static void
gc_putc_askcmd(unsigned char ch)
{
if (ch >= '0' && ch <= '9') {
gc_par[gc_numpars] = (10*gc_par[gc_numpars]) + (ch-'0');
return;
}
gc_vt100state = ESnormal;
switch (gc_par[0]) {
case 6:
gc_relative_origin = ch == 'h';
break;
case 7:
gc_wrap_mode = ch == 'h';
break;
default:
break;
}
}
static void
gc_putc_charsetcmd(int charset, unsigned char ch)
{
gc_vt100state = ESnormal;
switch (ch) {
case 'A' :
case 'B' :
default:
gc_charset[charset] = 0;
break;
case '0' :
case '2' :
gc_charset[charset] = 0x21;
break;
}
}
static void
gc_putc_charsizecmd(unsigned char ch)
{
gc_vt100state = ESnormal;
switch (ch) {
case '3' :
case '4' :
case '5' :
case '6' :
break;
case '8' :
{
unsigned int xx, yy;
for (yy = 0; yy < vinfo.v_rows; yy++)
for (xx = 0; xx < vinfo.v_columns; xx++)
gc_paint_char(xx, yy, 'E', ATTR_NONE);
}
break;
}
}
static void
gc_putc_esc(unsigned char ch)
{
gc_vt100state = ESnormal;
switch (ch) {
case '[':
gc_vt100state = ESsquare;
break;
case 'c':
gc_reset_vt100();
gc_clear_screen(gc_x, gc_y, 0, vinfo.v_rows, 2);
gc_x = gc_y = 0;
break;
case 'D':
case 'E':
if (gc_y >= gc_scrreg_bottom -1) {
gc_scroll_up(1, gc_scrreg_top, gc_scrreg_bottom);
gc_y = gc_scrreg_bottom - 1;
} else {
gc_y++;
}
if (ch == 'E') gc_x = 0;
break;
case 'H':
gc_set_tab_stop(gc_x, TRUE);
break;
case 'M':
if (gc_y <= gc_scrreg_top) {
gc_scroll_down(1, gc_scrreg_top, gc_scrreg_bottom);
gc_y = gc_scrreg_top;
} else {
gc_y--;
}
break;
case '>':
gc_reset_vt100();
break;
case '7':
gc_savex = gc_x;
gc_savey = gc_y;
gc_saveattr = gc_attr;
gc_save_charset_s = gc_charset_select;
gc_charset_save[0] = gc_charset[0];
gc_charset_save[1] = gc_charset[1];
break;
case '8':
gc_x = gc_savex;
gc_y = gc_savey;
gc_attr = gc_saveattr;
gc_charset_select = gc_save_charset_s;
gc_charset[0] = gc_charset_save[0];
gc_charset[1] = gc_charset_save[1];
break;
case 'Z':
break;
case '#':
gc_vt100state = EScharsize;
break;
case '(':
gc_vt100state = ESsetG0;
break;
case ')':
gc_vt100state = ESsetG1;
break;
case '=':
break;
default:
break;
}
}
static void
gc_putc_getpars(unsigned char ch)
{
if (ch == '?') {
gc_vt100state = ESask;
return;
}
if (ch == '[') {
gc_vt100state = ESnormal;
return;
}
if (ch == ';' && gc_numpars < MAXPARS - 1) {
gc_numpars++;
} else
if (ch >= '0' && ch <= '9') {
gc_par[gc_numpars] *= 10;
gc_par[gc_numpars] += ch - '0';
} else {
gc_numpars++;
gc_vt100state = ESgotpars;
gc_putc_gotpars(ch);
}
}
static void
gc_putc_gotpars(unsigned char ch)
{
unsigned int i;
if (ch < ' ') {
gc_putc_normal(ch);
gc_vt100state = ESgotpars;
return;
}
gc_vt100state = ESnormal;
switch (ch) {
case 'A':
gc_y -= gc_par[0] ? gc_par[0] : 1;
if (gc_y < gc_scrreg_top)
gc_y = gc_scrreg_top;
break;
case 'B':
gc_y += gc_par[0] ? gc_par[0] : 1;
if (gc_y >= gc_scrreg_bottom)
gc_y = gc_scrreg_bottom - 1;
break;
case 'C':
gc_x += gc_par[0] ? gc_par[0] : 1;
if (gc_x >= vinfo.v_columns)
gc_x = vinfo.v_columns-1;
break;
case 'D':
if (gc_par[0] > gc_x)
gc_x = 0;
else if (gc_par[0])
gc_x -= gc_par[0];
else if (gc_x)
--gc_x;
break;
case 'H':
case 'f':
gc_x = gc_par[1] ? gc_par[1] - 1 : 0;
gc_y = gc_par[0] ? gc_par[0] - 1 : 0;
if (gc_relative_origin)
gc_y += gc_scrreg_top;
gc_hanging_cursor = 0;
break;
case 'X':
if (gc_numpars) {
for (i = gc_x; i < gc_x + gc_par[0]; i++)
gc_paint_char(i, gc_y, ' ', ATTR_NONE);
}
break;
case 'J':
gc_clear_screen(gc_x, gc_y, 0, vinfo.v_rows, gc_par[0]);
break;
case 'K':
gc_clear_line(gc_x, gc_y, gc_par[0]);
break;
case 'g':
switch (gc_par[0]) {
case 1:
case 2:
break;
case 3:
{
for (i = 0; i <= vinfo.v_columns; i++)
gc_set_tab_stop(i, FALSE);
}
break;
case 0:
gc_set_tab_stop(gc_x, FALSE);
break;
}
break;
case 'm':
for (i = 0; i < gc_numpars; i++) {
switch (gc_par[i]) {
case 0:
gc_attr = ATTR_NONE;
gc_update_color(COLOR_BACKGROUND, FALSE);
gc_update_color(COLOR_FOREGROUND, TRUE );
break;
case 1:
gc_attr |= ATTR_BOLD;
break;
case 4:
gc_attr |= ATTR_UNDER;
break;
case 7:
gc_attr |= ATTR_REVERSE;
break;
case 22:
gc_attr &= ~ATTR_BOLD;
break;
case 24:
gc_attr &= ~ATTR_UNDER;
break;
case 27:
gc_attr &= ~ATTR_REVERSE;
break;
case 5:
case 25:
break;
default:
if (gc_par[i] >= 30 && gc_par[i] <= 37)
gc_update_color(gc_par[i] - 30, TRUE);
if (gc_par[i] >= 40 && gc_par[i] <= 47)
gc_update_color(gc_par[i] - 40, FALSE);
break;
}
}
break;
case 'r':
gc_x = gc_y = 0;
if ((gc_numpars > 0) && (gc_par[0] < vinfo.v_rows)) {
gc_scrreg_top = gc_par[0] ? gc_par[0] - 1 : 0;
} else {
gc_scrreg_top = 0;
}
if ((gc_numpars > 1) && (gc_par[1] <= vinfo.v_rows) && (gc_par[1] > gc_par[0])) {
gc_scrreg_bottom = gc_par[1];
if (gc_scrreg_bottom > vinfo.v_rows)
gc_scrreg_bottom = vinfo.v_rows;
} else {
gc_scrreg_bottom = vinfo.v_rows;
}
if (gc_relative_origin)
gc_y = gc_scrreg_top;
break;
}
}
static void
gc_putc_normal(unsigned char ch)
{
switch (ch) {
case '\a':
break;
case 127:
case '\b':
if (gc_hanging_cursor) {
gc_hanging_cursor = 0;
} else
if (gc_x > 0) {
gc_x--;
}
break;
case '\t':
if (gc_buffer_tab_stops) while (gc_x < vinfo.v_columns && !gc_is_tab_stop(++gc_x));
if (gc_x >= vinfo.v_columns)
gc_x = vinfo.v_columns-1;
break;
case 0x0b:
case 0x0c:
case '\n':
if (gc_y >= gc_scrreg_bottom -1 ) {
gc_scroll_up(1, gc_scrreg_top, gc_scrreg_bottom);
gc_y = gc_scrreg_bottom - 1;
} else {
gc_y++;
}
break;
case '\r':
gc_x = 0;
gc_hanging_cursor = 0;
break;
case 0x0e:
gc_charset_select = 1;
break;
case 0x0f:
gc_charset_select = 0;
break;
case 0x18 :
case 0x1A :
break;
case '\033':
gc_vt100state = ESesc;
gc_hanging_cursor = 0;
break;
default:
if (ch >= ' ') {
if (gc_hanging_cursor) {
gc_x = 0;
if (gc_y >= gc_scrreg_bottom -1 ) {
gc_scroll_up(1, gc_scrreg_top, gc_scrreg_bottom);
gc_y = gc_scrreg_bottom - 1;
} else {
gc_y++;
}
gc_hanging_cursor = 0;
}
gc_paint_char(gc_x, gc_y, (ch >= 0x60 && ch <= 0x7f) ? ch + gc_charset[gc_charset_select]
: ch, gc_attr);
if (gc_x == vinfo.v_columns - 1) {
gc_hanging_cursor = gc_wrap_mode;
} else {
gc_x++;
}
}
break;
}
}
static void
gc_putc_square(unsigned char ch)
{
int i;
for (i = 0; i < MAXPARS; i++) {
gc_par[i] = 0;
}
gc_numpars = 0;
gc_vt100state = ESgetpars;
gc_putc_getpars(ch);
}
static void
gc_reset_screen(void)
{
gc_reset_vt100();
gc_x = gc_y = 0;
}
static void
gc_reset_tabs(void)
{
unsigned int i;
if (!gc_buffer_tab_stops) return;
for (i = 0; i < vinfo.v_columns; i++) {
gc_buffer_tab_stops[i] = ((i % 8) == 0);
}
}
static void
gc_set_tab_stop(unsigned int column, boolean_t enabled)
{
if (gc_buffer_tab_stops && (column < vinfo.v_columns)) {
gc_buffer_tab_stops[column] = enabled;
}
}
static boolean_t gc_is_tab_stop(unsigned int column)
{
if (gc_buffer_tab_stops == NULL)
return ((column % 8) == 0);
if (column < vinfo.v_columns)
return gc_buffer_tab_stops[column];
else
return FALSE;
}
static void
gc_reset_vt100(void)
{
gc_reset_tabs();
gc_scrreg_top = 0;
gc_scrreg_bottom = vinfo.v_rows;
gc_attr = ATTR_NONE;
gc_charset[0] = gc_charset[1] = 0;
gc_charset_select = 0;
gc_wrap_mode = 1;
gc_relative_origin = 0;
gc_update_color(COLOR_BACKGROUND, FALSE);
gc_update_color(COLOR_FOREGROUND, TRUE);
}
static void
gc_scroll_down(int num, unsigned int top, unsigned int bottom)
{
if (!gc_buffer_size) return;
if ( bottom <= gc_buffer_rows )
{
unsigned char colorcodesave = gc_color_code;
uint32_t column, row;
uint32_t index, jump;
jump = num * gc_buffer_columns;
for ( row = bottom - 1 ; row >= top + num ; row-- )
{
index = row * gc_buffer_columns;
for ( column = 0 ; column < gc_buffer_columns ; index++, column++ )
{
if ( gc_buffer_attributes[index] != gc_buffer_attributes[index - jump] ||
gc_buffer_characters[index] != gc_buffer_characters[index - jump] ||
gc_buffer_colorcodes[index] != gc_buffer_colorcodes[index - jump] )
{
if ( gc_color_code != gc_buffer_colorcodes[index - jump] )
{
gc_update_color(COLOR_CODE_GET(gc_buffer_colorcodes[index - jump], TRUE ), TRUE );
gc_update_color(COLOR_CODE_GET(gc_buffer_colorcodes[index - jump], FALSE), FALSE);
}
if ( gc_buffer_colorcodes[index] != gc_buffer_colorcodes[index - jump] )
{
gc_ops.paint_char( column,
row,
gc_buffer_characters[index - jump],
gc_buffer_attributes[index - jump],
0,
0 );
}
else
{
gc_ops.paint_char( column,
row,
gc_buffer_characters[index - jump],
gc_buffer_attributes[index - jump],
gc_buffer_characters[index],
gc_buffer_attributes[index] );
}
gc_buffer_attributes[index] = gc_buffer_attributes[index - jump];
gc_buffer_characters[index] = gc_buffer_characters[index - jump];
gc_buffer_colorcodes[index] = gc_buffer_colorcodes[index - jump];
}
}
}
if ( colorcodesave != gc_color_code )
{
gc_update_color(COLOR_CODE_GET(colorcodesave, TRUE ), TRUE );
gc_update_color(COLOR_CODE_GET(colorcodesave, FALSE), FALSE);
}
for ( row = top ; row < top + num ; row++ )
{
index = row * gc_buffer_columns;
for ( column = 0 ; column < gc_buffer_columns ; index++, column++ )
{
if ( gc_buffer_attributes[index] != ATTR_NONE ||
gc_buffer_characters[index] != ' ' ||
gc_buffer_colorcodes[index] != gc_color_code )
{
if ( gc_buffer_colorcodes[index] != gc_color_code )
{
gc_ops.paint_char( column,
row,
' ',
ATTR_NONE,
0,
0 );
}
else
{
gc_ops.paint_char( column,
row,
' ',
ATTR_NONE,
gc_buffer_characters[index],
gc_buffer_attributes[index] );
}
gc_buffer_attributes[index] = ATTR_NONE;
gc_buffer_characters[index] = ' ';
gc_buffer_colorcodes[index] = gc_color_code;
}
}
}
}
else
{
gc_ops.scroll_down(num, top, bottom);
gc_clear_screen(vinfo.v_columns - 1, top + num - 1, top, bottom, 1);
}
}
static void
gc_scroll_up(int num, unsigned int top, unsigned int bottom)
{
if (!gc_buffer_size) return;
if ( bottom <= gc_buffer_rows )
{
unsigned char colorcodesave = gc_color_code;
uint32_t column, row;
uint32_t index, jump;
jump = num * gc_buffer_columns;
for ( row = top ; row < bottom - num ; row++ )
{
index = row * gc_buffer_columns;
for ( column = 0 ; column < gc_buffer_columns ; index++, column++ )
{
if ( gc_buffer_attributes[index] != gc_buffer_attributes[index + jump] ||
gc_buffer_characters[index] != gc_buffer_characters[index + jump] ||
gc_buffer_colorcodes[index] != gc_buffer_colorcodes[index + jump] )
{
if ( gc_color_code != gc_buffer_colorcodes[index + jump] )
{
gc_update_color(COLOR_CODE_GET(gc_buffer_colorcodes[index + jump], TRUE ), TRUE );
gc_update_color(COLOR_CODE_GET(gc_buffer_colorcodes[index + jump], FALSE), FALSE);
}
if ( gc_buffer_colorcodes[index] != gc_buffer_colorcodes[index + jump] )
{
gc_ops.paint_char( column,
row,
gc_buffer_characters[index + jump],
gc_buffer_attributes[index + jump],
0,
0 );
}
else
{
gc_ops.paint_char( column,
row,
gc_buffer_characters[index + jump],
gc_buffer_attributes[index + jump],
gc_buffer_characters[index],
gc_buffer_attributes[index] );
}
gc_buffer_attributes[index] = gc_buffer_attributes[index + jump];
gc_buffer_characters[index] = gc_buffer_characters[index + jump];
gc_buffer_colorcodes[index] = gc_buffer_colorcodes[index + jump];
}
}
}
if ( colorcodesave != gc_color_code )
{
gc_update_color(COLOR_CODE_GET(colorcodesave, TRUE ), TRUE );
gc_update_color(COLOR_CODE_GET(colorcodesave, FALSE), FALSE);
}
for ( row = bottom - num ; row < bottom ; row++ )
{
index = row * gc_buffer_columns;
for ( column = 0 ; column < gc_buffer_columns ; index++, column++ )
{
if ( gc_buffer_attributes[index] != ATTR_NONE ||
gc_buffer_characters[index] != ' ' ||
gc_buffer_colorcodes[index] != gc_color_code )
{
if ( gc_buffer_colorcodes[index] != gc_color_code )
{
gc_ops.paint_char( column,
row,
' ',
ATTR_NONE,
0,
0 );
}
else
{
gc_ops.paint_char( column,
row,
' ',
ATTR_NONE,
gc_buffer_characters[index],
gc_buffer_attributes[index] );
}
gc_buffer_attributes[index] = ATTR_NONE;
gc_buffer_characters[index] = ' ';
gc_buffer_colorcodes[index] = gc_color_code;
}
}
}
}
else
{
gc_ops.scroll_up(num, top, bottom);
gc_clear_screen(0, bottom - num, top, bottom, 0);
}
}
static void
gc_show_cursor(unsigned int xx, unsigned int yy)
{
if ( xx < gc_buffer_columns && yy < gc_buffer_rows )
{
uint32_t index = (yy * gc_buffer_columns) + xx;
unsigned char attribute = gc_buffer_attributes[index];
unsigned char character = gc_buffer_characters[index];
unsigned char colorcode = gc_buffer_colorcodes[index];
unsigned char colorcodesave = gc_color_code;
gc_update_color(COLOR_CODE_GET(colorcode, FALSE), TRUE );
gc_update_color(COLOR_CODE_GET(colorcode, TRUE ), FALSE);
gc_ops.paint_char(xx, yy, character, attribute, 0, 0);
gc_update_color(COLOR_CODE_GET(colorcodesave, TRUE ), TRUE );
gc_update_color(COLOR_CODE_GET(colorcodesave, FALSE), FALSE);
}
else
{
gc_ops.show_cursor(xx, yy);
}
}
static void
gc_update_color(int color, boolean_t fore)
{
assert(gc_ops.update_color);
gc_color_code = COLOR_CODE_SET(gc_color_code, color, fore);
gc_ops.update_color(color, fore);
}
void
vcputc(__unused int l, __unused int u, int c)
{
if ( gc_initialized && gc_enabled )
{
spl_t s;
s = splhigh();
#if defined(__i386__) || defined(__x86_64__)
x86_filter_TLB_coherency_interrupts(TRUE);
#endif
VCPUTC_LOCK_LOCK();
if ( gc_enabled )
{
gc_hide_cursor(gc_x, gc_y);
gc_putchar(c);
gc_show_cursor(gc_x, gc_y);
}
VCPUTC_LOCK_UNLOCK();
#if defined(__i386__) || defined(__x86_64__)
x86_filter_TLB_coherency_interrupts(FALSE);
#endif
splx(s);
}
}
static unsigned char vc_color_index_table[33] =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2 };
static uint32_t vc_colors[8][4] = {
{ 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000 },
{ 0x23232323, 0x7C007C00, 0x00FF0000, 0x3FF00000 },
{ 0xb9b9b9b9, 0x03e003e0, 0x0000FF00, 0x000FFC00 },
{ 0x05050505, 0x7FE07FE0, 0x00FFFF00, 0x3FFFFC00 },
{ 0xd2d2d2d2, 0x001f001f, 0x000000FF, 0x000003FF },
{ 0x18181818, 0x7C1F7C1F, 0x00FF00FF, 0x3FF003FF },
{ 0xb4b4b4b4, 0x03FF03FF, 0x0000FFFF, 0x000FFFFF },
{ 0x00000000, 0x7FFF7FFF, 0x00FFFFFF, 0x3FFFFFFF }
};
static uint32_t vc_color_fore = 0;
static uint32_t vc_color_back = 0;
static unsigned char *vc_rendered_font = NULL;
static uint32_t vc_rendered_font_size = 0;
static int vc_rendered_char_size = 0;
#define REN_MAX_DEPTH 32
static unsigned char vc_rendered_char[ISO_CHAR_HEIGHT * ((REN_MAX_DEPTH / 8) * ISO_CHAR_WIDTH)];
#if !CONFIG_EMBEDDED
static void
internal_set_progressmeter(int new_value);
static void
internal_enable_progressmeter(int new_value);
enum
{
kProgressMeterOff = FALSE,
kProgressMeterUser = TRUE,
kProgressMeterKernel = 3,
};
enum
{
kProgressMeterMax = 1024,
kProgressMeterEnd = 512,
};
#endif
static boolean_t vc_progress_white =
#ifdef CONFIG_VC_PROGRESS_WHITE
TRUE;
#else
FALSE;
#endif
static int vc_acquire_delay = kProgressAcquireDelay;
static void
vc_clear_screen(unsigned int xx, unsigned int yy, unsigned int scrreg_top,
unsigned int scrreg_bottom, int which)
{
uint32_t *p, *endp, *row;
int linelongs, col;
int rowline, rowlongs;
if(!vinfo.v_depth)
return;
linelongs = vinfo.v_rowbytes * (ISO_CHAR_HEIGHT >> 2);
rowline = vinfo.v_rowscanbytes >> 2;
rowlongs = vinfo.v_rowbytes >> 2;
p = (uint32_t*) vinfo.v_baseaddr;
endp = (uint32_t*) vinfo.v_baseaddr;
switch (which) {
case 0:
gc_clear_line(xx, yy, 0);
if (yy < scrreg_bottom - 1) {
p += (yy + 1) * linelongs;
endp += scrreg_bottom * linelongs;
}
break;
case 1:
gc_clear_line(xx, yy, 1);
if (yy > scrreg_top) {
p += scrreg_top * linelongs;
endp += yy * linelongs;
}
break;
case 2:
p += scrreg_top * linelongs;
if (scrreg_bottom == vinfo.v_rows) {
endp += rowlongs * vinfo.v_height;
} else {
endp += scrreg_bottom * linelongs;
}
break;
}
for (row = p ; row < endp ; row += rowlongs) {
for (col = 0; col < rowline; col++)
*(row+col) = vc_color_back;
}
}
static void
vc_render_char(unsigned char ch, unsigned char *renderptr, short newdepth)
{
union {
unsigned char *charptr;
unsigned short *shortptr;
uint32_t *longptr;
} current;
unsigned char *theChar;
int line;
current.charptr = renderptr;
theChar = iso_font + (ch * ISO_CHAR_HEIGHT);
for (line = 0; line < ISO_CHAR_HEIGHT; line++) {
unsigned char mask = 1;
do {
switch (newdepth) {
case 8:
*current.charptr++ = (*theChar & mask) ? 0xFF : 0;
break;
case 16:
*current.shortptr++ = (*theChar & mask) ? 0xFFFF : 0;
break;
case 30:
case 32:
*current.longptr++ = (*theChar & mask) ? 0xFFFFFFFF : 0;
break;
}
mask <<= 1;
} while (mask);
theChar++;
}
}
static void
vc_paint_char_8(unsigned int xx, unsigned int yy, unsigned char ch, int attrs,
__unused unsigned char ch_previous, __unused int attrs_previous)
{
uint32_t *theChar;
uint32_t *where;
int i;
if (vc_rendered_font) {
theChar = (uint32_t*)(vc_rendered_font + (ch * vc_rendered_char_size));
} else {
vc_render_char(ch, vc_rendered_char, 8);
theChar = (uint32_t*)(vc_rendered_char);
}
where = (uint32_t*)(vinfo.v_baseaddr +
(yy * ISO_CHAR_HEIGHT * vinfo.v_rowbytes) +
(xx * ISO_CHAR_WIDTH));
if (!attrs) for (i = 0; i < ISO_CHAR_HEIGHT; i++) {
uint32_t *store = where;
int x;
for (x = 0; x < 2; x++) {
uint32_t val = *theChar++;
val = (vc_color_back & ~val) | (vc_color_fore & val);
*store++ = val;
}
where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
} else for (i = 0; i < ISO_CHAR_HEIGHT; i++) {
uint32_t *store = where, lastpixel = 0;
int x;
for (x = 0 ; x < 2; x++) {
uint32_t val = *theChar++, save = val;
if (attrs & ATTR_BOLD) {
if (lastpixel && !(save & 0xFF000000))
val |= 0xff000000;
if ((save & 0xFFFF0000) == 0xFF000000)
val |= 0x00FF0000;
if ((save & 0x00FFFF00) == 0x00FF0000)
val |= 0x0000FF00;
if ((save & 0x0000FFFF) == 0x0000FF00)
val |= 0x000000FF;
}
if (attrs & ATTR_REVERSE) val = ~val;
if (attrs & ATTR_UNDER && i == ISO_CHAR_HEIGHT-1) val = ~val;
val = (vc_color_back & ~val) | (vc_color_fore & val);
*store++ = val;
lastpixel = save & 0xff;
}
where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
}
}
static void
vc_paint_char_16(unsigned int xx, unsigned int yy, unsigned char ch, int attrs,
__unused unsigned char ch_previous,
__unused int attrs_previous)
{
uint32_t *theChar;
uint32_t *where;
int i;
if (vc_rendered_font) {
theChar = (uint32_t*)(vc_rendered_font + (ch * vc_rendered_char_size));
} else {
vc_render_char(ch, vc_rendered_char, 16);
theChar = (uint32_t*)(vc_rendered_char);
}
where = (uint32_t*)(vinfo.v_baseaddr +
(yy * ISO_CHAR_HEIGHT * vinfo.v_rowbytes) +
(xx * ISO_CHAR_WIDTH * 2));
if (!attrs) for (i = 0; i < ISO_CHAR_HEIGHT; i++) {
uint32_t *store = where;
int x;
for (x = 0; x < 4; x++) {
uint32_t val = *theChar++;
val = (vc_color_back & ~val) | (vc_color_fore & val);
*store++ = val;
}
where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
} else for (i = 0; i < ISO_CHAR_HEIGHT; i++) {
uint32_t *store = where, lastpixel = 0;
int x;
for (x = 0 ; x < 4; x++) {
uint32_t val = *theChar++, save = val;
if (attrs & ATTR_BOLD) {
if (save == 0xFFFF0000) val |= 0xFFFF;
else if (lastpixel && !(save & 0xFFFF0000))
val |= 0xFFFF0000;
}
if (attrs & ATTR_REVERSE) val = ~val;
if (attrs & ATTR_UNDER && i == ISO_CHAR_HEIGHT-1) val = ~val;
val = (vc_color_back & ~val) | (vc_color_fore & val);
*store++ = val;
lastpixel = save & 0x7fff;
}
where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
}
}
static void
vc_paint_char_32(unsigned int xx, unsigned int yy, unsigned char ch, int attrs,
unsigned char ch_previous, int attrs_previous)
{
uint32_t *theChar;
uint32_t *theCharPrevious;
uint32_t *where;
int i;
if (vc_rendered_font) {
theChar = (uint32_t*)(vc_rendered_font + (ch * vc_rendered_char_size));
theCharPrevious = (uint32_t*)(vc_rendered_font + (ch_previous * vc_rendered_char_size));
} else {
vc_render_char(ch, vc_rendered_char, 32);
theChar = (uint32_t*)(vc_rendered_char);
theCharPrevious = NULL;
}
if (!ch_previous) {
theCharPrevious = NULL;
}
if (attrs_previous) {
theCharPrevious = NULL;
}
where = (uint32_t*)(vinfo.v_baseaddr +
(yy * ISO_CHAR_HEIGHT * vinfo.v_rowbytes) +
(xx * ISO_CHAR_WIDTH * 4));
if (!attrs) for (i = 0; i < ISO_CHAR_HEIGHT; i++) {
uint32_t *store = where;
int x;
for (x = 0; x < 8; x++) {
uint32_t val = *theChar++;
if (theCharPrevious == NULL || val != *theCharPrevious++ ) {
val = (vc_color_back & ~val) | (vc_color_fore & val);
*store++ = val;
} else {
store++;
}
}
where = (uint32_t *)(((unsigned char*)where)+vinfo.v_rowbytes);
} else for (i = 0; i < ISO_CHAR_HEIGHT; i++) {
uint32_t *store = where, lastpixel = 0;
int x;
for (x = 0 ; x < 8; x++) {
uint32_t val = *theChar++, save = val;
if (attrs & ATTR_BOLD) {
if (lastpixel && !save)
val = 0xFFFFFFFF;
}
if (attrs & ATTR_REVERSE) val = ~val;
if (attrs & ATTR_UNDER && i == ISO_CHAR_HEIGHT-1) val = ~val;
val = (vc_color_back & ~val) | (vc_color_fore & val);
*store++ = val;
lastpixel = save;
}
where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
}
}
static void
vc_paint_char(unsigned int xx, unsigned int yy, unsigned char ch, int attrs,
unsigned char ch_previous, int attrs_previous)
{
if(!vinfo.v_depth)
return;
switch(vinfo.v_depth) {
case 8:
vc_paint_char_8(xx, yy, ch, attrs, ch_previous, attrs_previous);
break;
case 16:
vc_paint_char_16(xx, yy, ch, attrs, ch_previous,
attrs_previous);
break;
case 30:
case 32:
vc_paint_char_32(xx, yy, ch, attrs, ch_previous,
attrs_previous);
break;
}
}
static void
vc_render_font(short newdepth)
{
static short olddepth = 0;
int charindex;
unsigned char *rendered_font;
unsigned int rendered_font_size;
int rendered_char_size;
spl_t s;
if (vm_initialized == FALSE) {
return;
}
if (olddepth == newdepth && vc_rendered_font) {
return;
}
s = splhigh();
VCPUTC_LOCK_LOCK();
rendered_font = vc_rendered_font;
rendered_font_size = vc_rendered_font_size;
rendered_char_size = vc_rendered_char_size;
vc_rendered_font = NULL;
vc_rendered_font_size = 0;
vc_rendered_char_size = 0;
VCPUTC_LOCK_UNLOCK();
splx(s);
if (rendered_font) {
kfree(rendered_font, rendered_font_size);
rendered_font = NULL;
}
if (newdepth) {
rendered_char_size = ISO_CHAR_HEIGHT * (((newdepth + 7) / 8) * ISO_CHAR_WIDTH);
rendered_font_size = (ISO_CHAR_MAX-ISO_CHAR_MIN+1) * rendered_char_size;
rendered_font = (unsigned char *) kalloc(rendered_font_size);
}
if (rendered_font == NULL) {
return;
}
for (charindex = ISO_CHAR_MIN; charindex <= ISO_CHAR_MAX; charindex++) {
vc_render_char(charindex, rendered_font + (charindex * rendered_char_size), newdepth);
}
olddepth = newdepth;
s = splhigh();
VCPUTC_LOCK_LOCK();
vc_rendered_font = rendered_font;
vc_rendered_font_size = rendered_font_size;
vc_rendered_char_size = rendered_char_size;
VCPUTC_LOCK_UNLOCK();
splx(s);
}
static void
vc_enable(boolean_t enable)
{
vc_render_font(enable ? vinfo.v_depth : 0);
}
static void
vc_reverse_cursor(unsigned int xx, unsigned int yy)
{
uint32_t *where;
int line, col;
if(!vinfo.v_depth)
return;
where = (uint32_t*)(vinfo.v_baseaddr +
(yy * ISO_CHAR_HEIGHT * vinfo.v_rowbytes) +
(xx * vinfo.v_depth));
for (line = 0; line < ISO_CHAR_HEIGHT; line++) {
switch (vinfo.v_depth) {
case 8:
where[0] = ~where[0];
where[1] = ~where[1];
break;
case 16:
for (col = 0; col < 4; col++)
where[col] = ~where[col];
break;
case 32:
for (col = 0; col < 8; col++)
where[col] = ~where[col];
break;
}
where = (uint32_t*)(((unsigned char*)where)+vinfo.v_rowbytes);
}
}
static void
vc_scroll_down(int num, unsigned int scrreg_top, unsigned int scrreg_bottom)
{
uint32_t *from, *to, linelongs, i, line, rowline, rowscanline;
if(!vinfo.v_depth)
return;
linelongs = vinfo.v_rowbytes * (ISO_CHAR_HEIGHT >> 2);
rowline = vinfo.v_rowbytes >> 2;
rowscanline = vinfo.v_rowscanbytes >> 2;
to = (uint32_t *) vinfo.v_baseaddr + (linelongs * scrreg_bottom)
- (rowline - rowscanline);
from = to - (linelongs * num);
i = (scrreg_bottom - scrreg_top) - num;
while (i-- > 0) {
for (line = 0; line < ISO_CHAR_HEIGHT; line++) {
video_scroll_down(from,
(from-(vinfo.v_rowscanbytes >> 2)),
to);
from -= rowline;
to -= rowline;
}
}
}
static void
vc_scroll_up(int num, unsigned int scrreg_top, unsigned int scrreg_bottom)
{
uint32_t *from, *to, linelongs, i, line, rowline, rowscanline;
if(!vinfo.v_depth)
return;
linelongs = vinfo.v_rowbytes * (ISO_CHAR_HEIGHT >> 2);
rowline = vinfo.v_rowbytes >> 2;
rowscanline = vinfo.v_rowscanbytes >> 2;
to = (uint32_t *) vinfo.v_baseaddr + (scrreg_top * linelongs);
from = to + (linelongs * num);
i = (scrreg_bottom - scrreg_top) - num;
while (i-- > 0) {
for (line = 0; line < ISO_CHAR_HEIGHT; line++) {
video_scroll_up(from,
(from+(vinfo.v_rowscanbytes >> 2)),
to);
from += rowline;
to += rowline;
}
}
}
static void
vc_update_color(int color, boolean_t fore)
{
if (!vinfo.v_depth)
return;
if (fore) {
vc_color_fore = vc_colors[color][vc_color_index_table[vinfo.v_depth]];
} else {
vc_color_back = vc_colors[color][vc_color_index_table[vinfo.v_depth]];
}
}
static vc_progress_element * vc_progress;
enum { kMaxProgressData = 3 };
static const unsigned char * vc_progress_data[kMaxProgressData];
static const unsigned char * vc_progress_alpha;
static boolean_t vc_progress_enable;
static const unsigned char * vc_clut;
static const unsigned char * vc_clut8;
static unsigned char vc_revclut8[256];
static uint32_t vc_progress_interval;
static uint32_t vc_progress_count;
static uint32_t vc_progress_angle;
static uint64_t vc_progress_deadline;
static thread_call_data_t vc_progress_call;
static boolean_t vc_needsave;
static void * vc_saveunder;
static vm_size_t vc_saveunder_len;
static int8_t vc_uiscale = 1;
vc_progress_user_options vc_progress_options;
vc_progress_user_options vc_user_options;
decl_simple_lock_data(,vc_progress_lock)
#if !CONFIG_EMBEDDED
static int vc_progress_withmeter = 3;
int vc_progressmeter_enable;
static int vc_progressmeter_drawn;
int vc_progressmeter_value;
static uint32_t vc_progressmeter_count;
static uint32_t vc_progress_meter_start;
static uint32_t vc_progress_meter_end;
static uint64_t vc_progressmeter_interval;
static uint64_t vc_progressmeter_deadline;
static thread_call_data_t vc_progressmeter_call;
static void * vc_progressmeter_backbuffer;
static boolean_t vc_progressmeter_hold;
static uint32_t vc_progressmeter_diskspeed = 256;
#endif
enum {
kSave = 0x10,
kDataIndexed = 0x20,
kDataAlpha = 0x40,
kDataBack = 0x80,
kDataRotate = 0x03,
kDataRotate0 = 0,
kDataRotate90 = 1,
kDataRotate180 = 2,
kDataRotate270 = 3
};
static void vc_blit_rect(int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
void * backBuffer,
unsigned int flags);
static void vc_blit_rect_8(int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
unsigned char * backBuffer,
unsigned int flags);
static void vc_blit_rect_16(int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
unsigned short * backBuffer,
unsigned int flags);
static void vc_blit_rect_32(int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
unsigned int * backBuffer,
unsigned int flags);
static void vc_blit_rect_30(int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
unsigned int * backBuffer,
unsigned int flags);
static void vc_progress_task( void * arg0, void * arg );
#if !CONFIG_EMBEDDED
static void vc_progressmeter_task( void * arg0, void * arg );
#endif
static void vc_blit_rect(int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
void * backBuffer,
unsigned int flags)
{
if (!vinfo.v_depth) return;
if (((unsigned int)(x + width)) > vinfo.v_width) return;
if (((unsigned int)(y + height)) > vinfo.v_height) return;
switch( vinfo.v_depth) {
case 8:
if( vc_clut8 == vc_clut)
vc_blit_rect_8( x, y, bx, width, height, sourceRow, backRow, dataPtr, (unsigned char *) backBuffer, flags );
break;
case 16:
vc_blit_rect_16( x, y, bx, width, height, sourceRow, backRow, dataPtr, (unsigned short *) backBuffer, flags );
break;
case 32:
vc_blit_rect_32( x, y, bx, width, height, sourceRow, backRow, dataPtr, (unsigned int *) backBuffer, flags );
break;
case 30:
vc_blit_rect_30( x, y, bx, width, height, sourceRow, backRow, dataPtr, (unsigned int *) backBuffer, flags );
break;
}
}
static void
vc_blit_rect_8(int x, int y, __unused int bx,
int width, int height,
int sourceRow, __unused int backRow,
const unsigned char * dataPtr,
__unused unsigned char * backBuffer,
__unused unsigned int flags)
{
volatile unsigned short * dst;
int line, col;
unsigned int data = 0, out = 0;
int sx, sy, a, b, c, d;
int scale = 0x10000;
a = vc_rotate_matr[kDataRotate & flags][0][0] * scale;
b = vc_rotate_matr[kDataRotate & flags][0][1] * scale;
c = vc_rotate_matr[kDataRotate & flags][1][0] * scale;
d = vc_rotate_matr[kDataRotate & flags][1][1] * scale;
sx = ((a + b) < 0) ? ((width * scale) - 0x8000) : 0;
sy = ((c + d) < 0) ? ((height * scale) - 0x8000) : 0;
if (!sourceRow) data = (unsigned int)(uintptr_t)dataPtr;
else if (1 == sourceRow) a = 0;
dst = (volatile unsigned short *) (vinfo.v_baseaddr +
(y * vinfo.v_rowbytes) +
(x * 4));
for( line = 0; line < height; line++)
{
for( col = 0; col < width; col++)
{
if (sourceRow) data = dataPtr[((sx + (col * a) + (line * b)) >> 16)
+ sourceRow * (((sy + (col * c) + (line * d)) >> 16))];
if (kDataAlpha & flags)
out = vc_revclut8[data];
else
out = data;
*(dst + col) = out;
}
dst = (volatile unsigned short *) (((volatile char*)dst) + vinfo.v_rowbytes);
}
}
#ifdef __arm__
#define CLUT_MASK_R 0xf8
#define CLUT_MASK_G 0xfc
#define CLUT_MASK_B 0xf8
#define CLUT_SHIFT_R << 8
#define CLUT_SHIFT_G << 3
#define CLUT_SHIFT_B >> 3
#define MASK_R 0xf800
#define MASK_G 0x07e0
#define MASK_B 0x001f
#define MASK_R_8 0x7f800
#define MASK_G_8 0x01fe0
#define MASK_B_8 0x000ff
#else
#define CLUT_MASK_R 0xf8
#define CLUT_MASK_G 0xf8
#define CLUT_MASK_B 0xf8
#define CLUT_SHIFT_R << 7
#define CLUT_SHIFT_G << 2
#define CLUT_SHIFT_B >> 3
#define MASK_R 0x7c00
#define MASK_G 0x03e0
#define MASK_B 0x001f
#define MASK_R_8 0x3fc00
#define MASK_G_8 0x01fe0
#define MASK_B_8 0x000ff
#endif
static void vc_blit_rect_16( int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
unsigned short * backPtr,
unsigned int flags)
{
volatile unsigned short * dst;
int line, col;
unsigned int data = 0, out = 0, back = 0;
int sx, sy, a, b, c, d;
int scale = 0x10000;
a = vc_rotate_matr[kDataRotate & flags][0][0] * scale;
b = vc_rotate_matr[kDataRotate & flags][0][1] * scale;
c = vc_rotate_matr[kDataRotate & flags][1][0] * scale;
d = vc_rotate_matr[kDataRotate & flags][1][1] * scale;
sx = ((a + b) < 0) ? ((width * scale) - 0x8000) : 0;
sy = ((c + d) < 0) ? ((height * scale) - 0x8000) : 0;
if (!sourceRow) data = (unsigned int)(uintptr_t)dataPtr;
else if (1 == sourceRow) a = 0;
if (backPtr)
backPtr += bx;
dst = (volatile unsigned short *) (vinfo.v_baseaddr +
(y * vinfo.v_rowbytes) +
(x * 2));
for( line = 0; line < height; line++)
{
for( col = 0; col < width; col++)
{
if (sourceRow) data = dataPtr[((sx + (col * a) + (line * b)) >> 16)
+ sourceRow * (((sy + (col * c) + (line * d)) >> 16))];
if (backPtr) {
if (kSave & flags) {
back = *(dst + col);
*backPtr++ = back;
} else
back = *backPtr++;
}
if (kDataIndexed & flags) {
out = ( (CLUT_MASK_R & (vc_clut[data*3 + 0])) CLUT_SHIFT_R)
| ( (CLUT_MASK_G & (vc_clut[data*3 + 1])) CLUT_SHIFT_G)
| ( (CLUT_MASK_B & (vc_clut[data*3 + 2])) CLUT_SHIFT_B);
} else if (kDataAlpha & flags) {
out = (((((back & MASK_R) * data) + MASK_R_8) >> 8) & MASK_R)
| (((((back & MASK_G) * data) + MASK_G_8) >> 8) & MASK_G)
| (((((back & MASK_B) * data) + MASK_B_8) >> 8) & MASK_B);
if (vc_progress_white) out += (((0xff - data) & CLUT_MASK_R) CLUT_SHIFT_R)
| (((0xff - data) & CLUT_MASK_G) CLUT_SHIFT_G)
| (((0xff - data) & CLUT_MASK_B) CLUT_SHIFT_B);
} else if (kDataBack & flags)
out = back;
else
out = data;
*(dst + col) = out;
}
dst = (volatile unsigned short *) (((volatile char*)dst) + vinfo.v_rowbytes);
if (backPtr)
backPtr += backRow - width;
}
}
static void vc_blit_rect_32(int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
unsigned int * backPtr,
unsigned int flags)
{
volatile unsigned int * dst;
int line, col;
unsigned int data = 0, out = 0, back = 0;
int sx, sy, a, b, c, d;
int scale = 0x10000;
a = vc_rotate_matr[kDataRotate & flags][0][0] * scale;
b = vc_rotate_matr[kDataRotate & flags][0][1] * scale;
c = vc_rotate_matr[kDataRotate & flags][1][0] * scale;
d = vc_rotate_matr[kDataRotate & flags][1][1] * scale;
sx = ((a + b) < 0) ? ((width * scale) - 0x8000) : 0;
sy = ((c + d) < 0) ? ((height * scale) - 0x8000) : 0;
if (!sourceRow) data = (unsigned int)(uintptr_t)dataPtr;
else if (1 == sourceRow) a = 0;
if (backPtr)
backPtr += bx;
dst = (volatile unsigned int *) (vinfo.v_baseaddr +
(y * vinfo.v_rowbytes) +
(x * 4));
for( line = 0; line < height; line++)
{
for( col = 0; col < width; col++)
{
if (sourceRow) data = dataPtr[((sx + (col * a) + (line * b)) >> 16)
+ sourceRow * (((sy + (col * c) + (line * d)) >> 16))];
if (backPtr) {
if (kSave & flags) {
back = *(dst + col);
*backPtr++ = back;
} else
back = *backPtr++;
}
if (kDataIndexed & flags) {
out = (vc_clut[data*3 + 0] << 16)
| (vc_clut[data*3 + 1] << 8)
| (vc_clut[data*3 + 2]);
} else if (kDataAlpha & flags) {
out = (((((back & 0x00ff00ff) * data) + 0x00ff00ff) >> 8) & 0x00ff00ff)
| (((((back & 0x0000ff00) * data) + 0x0000ff00) >> 8) & 0x0000ff00);
if (vc_progress_white) out += ((0xff - data) << 16)
| ((0xff - data) << 8)
| (0xff - data);
} else if (kDataBack & flags)
out = back;
else
out = data;
*(dst + col) = out;
}
dst = (volatile unsigned int *) (((volatile char*)dst) + vinfo.v_rowbytes);
if (backPtr)
backPtr += backRow - width;
}
}
static void vc_blit_rect_30(int x, int y, int bx,
int width, int height,
int sourceRow, int backRow,
const unsigned char * dataPtr,
unsigned int * backPtr,
unsigned int flags)
{
volatile unsigned int * dst;
int line, col;
unsigned int data = 0, out = 0, back = 0;
unsigned long long exp;
int sx, sy, a, b, c, d;
int scale = 0x10000;
a = vc_rotate_matr[kDataRotate & flags][0][0] * scale;
b = vc_rotate_matr[kDataRotate & flags][0][1] * scale;
c = vc_rotate_matr[kDataRotate & flags][1][0] * scale;
d = vc_rotate_matr[kDataRotate & flags][1][1] * scale;
sx = ((a + b) < 0) ? ((width * scale) - 0x8000) : 0;
sy = ((c + d) < 0) ? ((height * scale) - 0x8000) : 0;
if (!sourceRow) data = (unsigned int)(uintptr_t)dataPtr;
else if (1 == sourceRow) a = 0;
if (backPtr)
backPtr += bx;
dst = (volatile unsigned int *) (vinfo.v_baseaddr +
(y * vinfo.v_rowbytes) +
(x * 4));
for( line = 0; line < height; line++)
{
for( col = 0; col < width; col++)
{
if (sourceRow) data = dataPtr[((sx + (col * a) + (line * b)) >> 16)
+ sourceRow * (((sy + (col * c) + (line * d)) >> 16))];
if (backPtr) {
if (kSave & flags) {
back = *(dst + col);
*backPtr++ = back;
} else
back = *backPtr++;
}
if (kDataIndexed & flags) {
out = (vc_clut[data*3 + 0] << 22)
| (vc_clut[data*3 + 1] << 12)
| (vc_clut[data*3 + 2] << 2);
} else if (kDataAlpha & flags) {
exp = back;
exp = (((((exp & 0x3FF003FF) * data) + 0x0FF000FF) >> 8) & 0x3FF003FF)
| (((((exp & 0x000FFC00) * data) + 0x0003FC00) >> 8) & 0x000FFC00);
out = (unsigned int)exp;
if (vc_progress_white) out += ((0xFF - data) << 22)
| ((0xFF - data) << 12)
| ((0xFF - data) << 2);
} else if (kDataBack & flags)
out = back;
else
out = data;
*(dst + col) = out;
}
dst = (volatile unsigned int *) (((volatile char*)dst) + vinfo.v_rowbytes);
if (backPtr)
backPtr += backRow - width;
}
}
static void vc_clean_boot_graphics(void)
{
#if !CONFIG_EMBEDDED
vc_progress_set(FALSE, 0);
const unsigned char *
color = (typeof(color))(uintptr_t)(vc_progress_white ? 0x00000000 : 0xBFBFBFBF);
vc_blit_rect(0, 0, 0, vinfo.v_width, vinfo.v_height, 0, 0, color, NULL, 0);
#endif
}
struct lzss_image_state {
uint32_t col;
uint32_t row;
uint32_t width;
uint32_t height;
uint32_t bytes_per_row;
volatile uint32_t * row_start;
const uint8_t* clut;
};
typedef struct lzss_image_state lzss_image_state;
static inline int
vc_decompress_lzss_next_pixel (int next_data, lzss_image_state* state)
{
uint32_t palette_index = 0;
uint32_t pixel_value = 0;
palette_index = next_data * 3;
pixel_value = ( (uint32_t) state->clut[palette_index + 0] << 16)
| ( (uint32_t) state->clut[palette_index + 1] << 8)
| ( (uint32_t) state->clut[palette_index + 2]);
*(state->row_start + state->col) = pixel_value;
if (++state->col >= state->width) {
state->col = 0;
if (++state->row >= state->height) {
return 1;
}
state->row_start = (volatile uint32_t *) (((uintptr_t)state->row_start) + state->bytes_per_row);
}
return 0;
}
#define N 4096
#define F 18
#define THRESHOLD 2
int
vc_display_lzss_icon(uint32_t dst_x, uint32_t dst_y,
uint32_t image_width, uint32_t image_height,
const uint8_t *compressed_image,
uint32_t compressed_size,
const uint8_t *clut)
{
uint32_t* image_start;
uint32_t bytes_per_pixel = 4;
uint32_t bytes_per_row = vinfo.v_rowbytes;
vc_clean_boot_graphics();
image_start = (uint32_t *) (vinfo.v_baseaddr + (dst_y * bytes_per_row) + (dst_x * bytes_per_pixel));
lzss_image_state state = {0, 0, image_width, image_height, bytes_per_row, image_start, clut};
int rval = 0;
const uint8_t *src = compressed_image;
uint32_t srclen = compressed_size;
uint8_t text_buf[N + F - 1];
const uint8_t *srcend = src + srclen;
int i, j, k, r, c;
unsigned int flags;
srcend = src + srclen;
for (i = 0; i < N - F; i++)
text_buf[i] = ' ';
r = N - F;
flags = 0;
for ( ; ; ) {
if (((flags >>= 1) & 0x100) == 0) {
if (src < srcend) c = *src++; else break;
flags = c | 0xFF00;
}
if (flags & 1) {
if (src < srcend) c = *src++; else break;
rval = vc_decompress_lzss_next_pixel(c, &state);
if (rval != 0)
return rval;
text_buf[r++] = c;
r &= (N - 1);
} else {
if (src < srcend) i = *src++; else break;
if (src < srcend) j = *src++; else break;
i |= ((j & 0xF0) << 4);
j = (j & 0x0F) + THRESHOLD;
for (k = 0; k <= j; k++) {
c = text_buf[(i + k) & (N - 1)];
rval = vc_decompress_lzss_next_pixel(c, &state);
if (rval != 0 )
return rval;
text_buf[r++] = c;
r &= (N - 1);
}
}
}
return 0;
}
void noroot_icon_test(void) {
boolean_t o_vc_progress_enable = vc_progress_enable;
vc_progress_enable = 1;
PE_display_icon( 0, "noroot");
vc_progress_enable = o_vc_progress_enable;
}
void vc_display_icon( vc_progress_element * desc,
const unsigned char * data )
{
int x, y, width, height;
if( vc_progress_enable && vc_clut) {
vc_clean_boot_graphics();
width = desc->width;
height = desc->height;
x = desc->dx;
y = desc->dy;
if( 1 & desc->flags) {
x += ((vinfo.v_width - width) / 2);
y += ((vinfo.v_height - height) / 2);
}
vc_blit_rect( x, y, 0, width, height, width, 0, data, NULL, kDataIndexed );
}
}
void
vc_progress_initialize( vc_progress_element * desc,
const unsigned char * data1x,
const unsigned char * data2x,
const unsigned char * data3x,
const unsigned char * clut )
{
uint64_t abstime;
if( (!clut) || (!desc) || (!data1x))
return;
vc_clut = clut;
vc_clut8 = clut;
vc_progress = desc;
vc_progress_data[0] = data1x;
vc_progress_data[1] = data2x;
vc_progress_data[2] = data3x;
if( 2 & vc_progress->flags)
vc_progress_alpha = data1x
+ vc_progress->count * vc_progress->width * vc_progress->height;
else
vc_progress_alpha = NULL;
thread_call_setup(&vc_progress_call, vc_progress_task, NULL);
clock_interval_to_absolutetime_interval(vc_progress->time, 1000 * 1000, &abstime);
vc_progress_interval = (uint32_t)abstime;
#if !CONFIG_EMBEDDED
thread_call_setup(&vc_progressmeter_call, vc_progressmeter_task, NULL);
clock_interval_to_absolutetime_interval(1000 / 8, 1000 * 1000, &abstime);
vc_progressmeter_interval = (uint32_t)abstime;
#endif
}
void
vc_progress_set(boolean_t enable, uint32_t vc_delay)
{
spl_t s;
void *saveBuf = NULL;
vm_size_t saveLen = 0;
unsigned int count;
unsigned int index;
unsigned char pdata8;
unsigned short pdata16;
unsigned short * buf16;
unsigned int pdata32;
unsigned int * buf32;
#if !CONFIG_EMBEDDED
if (kBootArgsFlagBlack & ((boot_args *) PE_state.bootArgs)->flags) return;
if (1 & vc_progress_withmeter)
{
if (enable) internal_enable_progressmeter(kProgressMeterKernel);
s = splhigh();
simple_lock(&vc_progress_lock);
if( vc_progress_enable != enable) {
vc_progress_enable = enable;
if( enable)
{
vc_progressmeter_count = 0;
clock_interval_to_deadline(vc_delay,
1000 * 1000 * 1000 ,
&vc_progressmeter_deadline);
thread_call_enter_delayed(&vc_progressmeter_call, vc_progressmeter_deadline);
}
else thread_call_cancel(&vc_progressmeter_call);
}
simple_unlock(&vc_progress_lock);
splx(s);
if (!enable) internal_enable_progressmeter(kProgressMeterOff);
return;
}
#endif
if(!vc_progress) return;
if( enable) {
saveLen = (vc_progress->width * vc_uiscale) * (vc_progress->height * vc_uiscale) * ((vinfo.v_depth + 7) / 8);
saveBuf = kalloc( saveLen );
switch( vinfo.v_depth) {
case 8 :
for( count = 0; count < 256; count++) {
vc_revclut8[count] = vc_clut[0x01 * 3];
pdata8 = (vc_clut[0x01 * 3] * count + 0x0ff) >> 8;
for( index = 0; index < 256; index++) {
if( (pdata8 == vc_clut[index * 3 + 0]) &&
(pdata8 == vc_clut[index * 3 + 1]) &&
(pdata8 == vc_clut[index * 3 + 2])) {
vc_revclut8[count] = index;
break;
}
}
}
memset( saveBuf, 0x01, saveLen );
break;
case 16 :
buf16 = (unsigned short *) saveBuf;
pdata16 = ((vc_clut[0x01 * 3 + 0] & CLUT_MASK_R) CLUT_SHIFT_R)
| ((vc_clut[0x01 * 3 + 0] & CLUT_MASK_G) CLUT_SHIFT_G)
| ((vc_clut[0x01 * 3 + 0] & CLUT_MASK_B) CLUT_SHIFT_B);
for( count = 0; count < saveLen / 2; count++)
buf16[count] = pdata16;
break;
case 32 :
buf32 = (unsigned int *) saveBuf;
pdata32 = ((vc_clut[0x01 * 3 + 0] & 0xff) << 16)
| ((vc_clut[0x01 * 3 + 1] & 0xff) << 8)
| ((vc_clut[0x01 * 3 + 2] & 0xff) << 0);
for( count = 0; count < saveLen / 4; count++)
buf32[count] = pdata32;
break;
}
}
s = splhigh();
simple_lock(&vc_progress_lock);
if( vc_progress_enable != enable) {
vc_progress_enable = enable;
if( enable) {
vc_needsave = TRUE;
vc_saveunder = saveBuf;
vc_saveunder_len = saveLen;
saveBuf = NULL;
saveLen = 0;
vc_progress_count = 0;
vc_progress_angle = 0;
clock_interval_to_deadline(vc_delay,
1000 * 1000 * 1000 ,
&vc_progress_deadline);
thread_call_enter_delayed(&vc_progress_call, vc_progress_deadline);
} else {
if( vc_saveunder) {
saveBuf = vc_saveunder;
saveLen = vc_saveunder_len;
vc_saveunder = NULL;
vc_saveunder_len = 0;
}
thread_call_cancel(&vc_progress_call);
}
}
simple_unlock(&vc_progress_lock);
splx(s);
if( saveBuf)
kfree( saveBuf, saveLen );
}
#if !CONFIG_EMBEDDED
static uint32_t vc_progressmeter_range(uint32_t pos)
{
uint32_t ret;
if (pos > kProgressMeterEnd) pos = kProgressMeterEnd;
ret = vc_progress_meter_start
+ ((pos * (vc_progress_meter_end - vc_progress_meter_start)) / kProgressMeterEnd);
return (ret);
}
static void
vc_progressmeter_task(__unused void *arg0, __unused void *arg)
{
spl_t s;
uint64_t interval;
s = splhigh();
simple_lock(&vc_progress_lock);
if (vc_progressmeter_enable)
{
uint32_t pos = (vc_progressmeter_count >> 13);
internal_set_progressmeter(vc_progressmeter_range(pos));
if (pos < kProgressMeterEnd)
{
static uint16_t incr[8] = { 10000, 10000, 8192, 4096, 2048, 384, 384, 64 };
vc_progressmeter_count += incr[(pos * 8) / kProgressMeterEnd];
interval = vc_progressmeter_interval;
interval = ((interval * 256) / vc_progressmeter_diskspeed);
clock_deadline_for_periodic_event(interval, mach_absolute_time(), &vc_progressmeter_deadline);
thread_call_enter_delayed(&vc_progressmeter_call, vc_progressmeter_deadline);
}
}
simple_unlock(&vc_progress_lock);
splx(s);
}
void vc_progress_setdiskspeed(uint32_t speed)
{
vc_progressmeter_diskspeed = speed;
}
#endif
static void
vc_progress_task(__unused void *arg0, __unused void *arg)
{
spl_t s;
int x, y, width, height;
uint64_t x_pos, y_pos;
const unsigned char * data;
s = splhigh();
simple_lock(&vc_progress_lock);
if( vc_progress_enable) do {
vc_progress_count++;
if( vc_progress_count >= vc_progress->count) {
vc_progress_count = 0;
vc_progress_angle++;
}
width = (vc_progress->width * vc_uiscale);
height = (vc_progress->height * vc_uiscale);
data = vc_progress_data[vc_uiscale - 1];
if (!data) break;
if (kVCUsePosition & vc_progress_options.options) {
switch (3 & vinfo.v_rotate) {
case 0:
x_pos = vc_progress_options.x_pos;
y_pos = vc_progress_options.y_pos;
break;
case 2:
x_pos = 0xFFFFFFFF - vc_progress_options.x_pos;
y_pos = 0xFFFFFFFF - vc_progress_options.y_pos;
break;
case 1:
x_pos = 0xFFFFFFFF - vc_progress_options.y_pos;
y_pos = vc_progress_options.x_pos;
break;
case 3:
x_pos = vc_progress_options.y_pos;
y_pos = 0xFFFFFFFF - vc_progress_options.x_pos;
break;
}
x = (uint32_t)((x_pos * (uint64_t) vinfo.v_width) / 0xFFFFFFFFULL);
y = (uint32_t)((y_pos * (uint64_t) vinfo.v_height) / 0xFFFFFFFFULL);
x -= (width / 2);
y -= (height / 2);
} else {
x = (vc_progress->dx * vc_uiscale);
y = (vc_progress->dy * vc_uiscale);
if( 1 & vc_progress->flags) {
x += ((vinfo.v_width - width) / 2);
y += ((vinfo.v_height - height) / 2);
}
}
if ((x + width) > (int)vinfo.v_width) break;
if ((y + height) > (int)vinfo.v_height) break;
data += vc_progress_count * width * height;
vc_blit_rect( x, y, 0,
width, height, width, width,
data, vc_saveunder,
kDataAlpha
| (vc_progress_angle & kDataRotate)
| (vc_needsave ? kSave : 0) );
vc_needsave = FALSE;
clock_deadline_for_periodic_event(vc_progress_interval, mach_absolute_time(), &vc_progress_deadline);
thread_call_enter_delayed(&vc_progress_call, vc_progress_deadline);
}
while (FALSE);
simple_unlock(&vc_progress_lock);
splx(s);
}
#if defined (__i386__) || defined (__x86_64__)
#include <pexpert/i386/boot.h>
#endif
static boolean_t gc_acquired = FALSE;
static boolean_t gc_graphics_boot = FALSE;
static boolean_t gc_desire_text = FALSE;
static boolean_t gc_paused_progress;
static vm_offset_t lastVideoVirt = 0;
static vm_size_t lastVideoMapSize = 0;
static boolean_t lastVideoMapKmap = FALSE;
static void
gc_pause( boolean_t pause, boolean_t graphics_now )
{
spl_t s;
s = splhigh( );
VCPUTC_LOCK_LOCK( );
disableConsoleOutput = (pause && !console_is_serial());
gc_enabled = (!pause && !graphics_now);
VCPUTC_LOCK_UNLOCK( );
simple_lock(&vc_progress_lock);
if (pause)
{
gc_paused_progress = vc_progress_enable;
vc_progress_enable = FALSE;
}
else vc_progress_enable = gc_paused_progress;
if (vc_progress_enable)
{
#if !CONFIG_EMBEDDED
if (1 & vc_progress_withmeter) thread_call_enter_delayed(&vc_progressmeter_call, vc_progressmeter_deadline);
else
#endif
thread_call_enter_delayed(&vc_progress_call, vc_progress_deadline);
}
simple_unlock(&vc_progress_lock);
splx(s);
}
static void
vc_initialize(__unused struct vc_info * vinfo_p)
{
#ifdef __arm__
unsigned long cnt, data16, data32;
if (vinfo.v_depth == 16) {
for (cnt = 0; cnt < 8; cnt++) {
data32 = vc_colors[cnt][2];
data16 = (data32 & 0x0000F8) << 8;
data16 |= (data32 & 0x00FC00) >> 5;
data16 |= (data32 & 0xF80000) >> 19;
data16 |= data16 << 16;
vc_colors[cnt][1] = data16;
}
}
#endif
vinfo.v_rows = vinfo.v_height / ISO_CHAR_HEIGHT;
vinfo.v_columns = vinfo.v_width / ISO_CHAR_WIDTH;
vinfo.v_rowscanbytes = ((vinfo.v_depth + 7) / 8) * vinfo.v_width;
vc_uiscale = vinfo.v_scale;
if (vc_uiscale > kMaxProgressData) vc_uiscale = kMaxProgressData;
else if (!vc_uiscale) vc_uiscale = 1;
}
void
initialize_screen(PE_Video * boot_vinfo, unsigned int op)
{
unsigned int newMapSize = 0;
vm_offset_t newVideoVirt = 0;
boolean_t graphics_now;
uint32_t delay;
if ( boot_vinfo )
{
struct vc_info new_vinfo = vinfo;
boolean_t makeMapping = FALSE;
if (kPEBaseAddressChange != op)
{
new_vinfo.v_width = (unsigned int)boot_vinfo->v_width;
new_vinfo.v_height = (unsigned int)boot_vinfo->v_height;
new_vinfo.v_depth = (unsigned int)boot_vinfo->v_depth;
new_vinfo.v_rowbytes = (unsigned int)boot_vinfo->v_rowBytes;
if (kernel_map == VM_MAP_NULL) {
new_vinfo.v_rotate = (unsigned int)boot_vinfo->v_rotate;
}
#if defined(__i386__) || defined(__x86_64__)
new_vinfo.v_type = (unsigned int)boot_vinfo->v_display;
#else
new_vinfo.v_type = 0;
#endif
unsigned int scale = (unsigned int)boot_vinfo->v_scale;
if (scale == kPEScaleFactor1x )
new_vinfo.v_scale = kPEScaleFactor1x;
else if (scale == kPEScaleFactor2x)
new_vinfo.v_scale = kPEScaleFactor2x;
else
new_vinfo.v_scale = kPEScaleFactor1x;
}
new_vinfo.v_name[0] = 0;
new_vinfo.v_physaddr = 0;
newVideoVirt = boot_vinfo->v_baseAddr;
makeMapping = (kernel_map == VM_MAP_NULL) || (0 != (1 & newVideoVirt));
if (makeMapping)
{
newVideoVirt = 0;
new_vinfo.v_physaddr = boot_vinfo->v_baseAddr & ~3UL;
#ifndef __LP64__
new_vinfo.v_physaddr |= (((uint64_t) boot_vinfo->v_baseAddrHigh) << 32);
#endif
kprintf("initialize_screen: b=%08llX, w=%08X, h=%08X, r=%08X, d=%08X\n",
new_vinfo.v_physaddr, new_vinfo.v_width, new_vinfo.v_height, new_vinfo.v_rowbytes, new_vinfo.v_type);
}
if (!newVideoVirt && !new_vinfo.v_physaddr)
{
kprintf("initialize_screen: No video - forcing serial mode\n");
new_vinfo.v_depth = 0;
(void)switch_to_serial_console();
gc_graphics_boot = FALSE;
disableConsoleOutput = FALSE;
gc_acquired = TRUE;
}
else
{
if (makeMapping)
{
unsigned int flags = VM_WIMG_IO;
if (boot_vinfo->v_length != 0)
newMapSize = (unsigned int) round_page(boot_vinfo->v_length);
else
newMapSize = (unsigned int) round_page(new_vinfo.v_height * new_vinfo.v_rowbytes);
newVideoVirt = io_map_spec((vm_map_offset_t)new_vinfo.v_physaddr, newMapSize, flags);
}
new_vinfo.v_baseaddr = newVideoVirt + boot_vinfo->v_offset;
}
#if defined(__x86_64__)
new_vinfo.v_baseaddr |= (VM_MIN_KERNEL_ADDRESS & ~LOW_4GB_MASK);
#endif
if (vc_progress)
{
simple_lock(&vc_progress_lock);
vinfo = new_vinfo;
simple_unlock(&vc_progress_lock);
}
else
{
vinfo = new_vinfo;
}
if (newVideoVirt != 0)
{
if (lastVideoVirt && lastVideoMapSize)
{
if (!TEST_PAGE_SIZE_4K && lastVideoMapSize)
{
pmap_remove(kernel_pmap, trunc_page_64(lastVideoVirt),
round_page_64(lastVideoVirt + lastVideoMapSize));
}
if (lastVideoMapKmap)
{
kmem_free(kernel_map, lastVideoVirt, lastVideoMapSize);
}
}
lastVideoMapKmap = (NULL != kernel_map);
lastVideoMapSize = newMapSize;
lastVideoVirt = newVideoVirt;
}
if (kPEBaseAddressChange != op)
{
gc_ops.initialize = vc_initialize;
gc_ops.enable = vc_enable;
gc_ops.paint_char = vc_paint_char;
gc_ops.scroll_down = vc_scroll_down;
gc_ops.scroll_up = vc_scroll_up;
gc_ops.clear_screen = vc_clear_screen;
gc_ops.hide_cursor = vc_reverse_cursor;
gc_ops.show_cursor = vc_reverse_cursor;
gc_ops.update_color = vc_update_color;
gc_initialize(&vinfo);
}
}
graphics_now = gc_graphics_boot && !gc_desire_text;
switch ( op )
{
case kPEGraphicsMode:
gc_graphics_boot = TRUE;
gc_desire_text = FALSE;
break;
case kPETextMode:
gc_graphics_boot = FALSE;
break;
case kPEAcquireScreen:
if ( gc_acquired ) break;
vc_progress_options = vc_user_options;
bzero(&vc_user_options, sizeof(vc_user_options));
if (kVCAcquireImmediate & vc_progress_options.options) delay = 0;
else if (kVCDarkReboot & vc_progress_options.options) delay = 120;
else delay = vc_acquire_delay;
if (kVCDarkBackground & vc_progress_options.options) vc_progress_white = TRUE;
else if (kVCLightBackground & vc_progress_options.options) vc_progress_white = FALSE;
#if !defined(XNU_TARGET_OS_BRIDGE)
vc_progress_set( graphics_now, delay );
#endif
gc_enable( !graphics_now );
gc_acquired = TRUE;
gc_desire_text = FALSE;
break;
case kPEDisableScreen:
if (gc_acquired)
{
gc_pause( TRUE, graphics_now );
}
break;
case kPEEnableScreen:
if (gc_acquired)
{
gc_pause( FALSE, graphics_now );
}
break;
case kPETextScreen:
if ( console_is_serial() ) break;
if ( gc_acquired == FALSE )
{
gc_desire_text = TRUE;
break;
}
if ( gc_graphics_boot == FALSE ) break;
vc_progress_set( FALSE, 0 );
#if !CONFIG_EMBEDDED
vc_enable_progressmeter( FALSE );
#endif
gc_enable( TRUE );
break;
case kPEReleaseScreen:
gc_acquired = FALSE;
gc_desire_text = FALSE;
gc_enable( FALSE );
if ( gc_graphics_boot == FALSE ) break;
vc_progress_set( FALSE, 0 );
vc_acquire_delay = kProgressReacquireDelay;
vc_progress_white = TRUE;
#if !CONFIG_EMBEDDED
vc_enable_progressmeter(FALSE);
vc_progress_withmeter &= ~1;
#endif
vc_clut8 = NULL;
break;
#if !CONFIG_EMBEDDED
case kPERefreshBootGraphics:
{
spl_t s;
boolean_t save;
if (kBootArgsFlagBlack & ((boot_args *) PE_state.bootArgs)->flags) break;
save = vc_progress_white;
vc_progress_white = (0 != (kBootArgsFlagBlackBg & ((boot_args *) PE_state.bootArgs)->flags));
internal_enable_progressmeter(kProgressMeterKernel);
s = splhigh();
simple_lock(&vc_progress_lock);
vc_progressmeter_drawn = 0;
internal_set_progressmeter(vc_progressmeter_range(vc_progressmeter_count >> 13));
simple_unlock(&vc_progress_lock);
splx(s);
internal_enable_progressmeter(kProgressMeterOff);
vc_progress_white = save;
}
#endif
}
}
void vcattach(void);
void
vcattach(void)
{
vm_initialized = TRUE;
#if !CONFIG_EMBEDDED
const boot_args * bootargs = (typeof(bootargs)) PE_state.bootArgs;
vc_progress_white = (0 != ((kBootArgsFlagBlackBg | kBootArgsFlagLoginUI)
& bootargs->flags));
PE_parse_boot_argn("meter", &vc_progress_withmeter, sizeof(vc_progress_withmeter));
if (kBootArgsFlagInstallUI & bootargs->flags)
{
vc_progress_meter_start = (bootargs->bootProgressMeterStart * kProgressMeterMax) / 65535;
vc_progress_meter_end = (bootargs->bootProgressMeterEnd * kProgressMeterMax) / 65535;
}
else
{
vc_progress_meter_start = 0;
vc_progress_meter_end = kProgressMeterMax;
}
#endif
simple_lock_init(&vc_progress_lock, 0);
if ( gc_graphics_boot == FALSE )
{
long index;
if ( gc_acquired )
{
initialize_screen(NULL, kPEReleaseScreen);
}
initialize_screen(NULL, kPEAcquireScreen);
for ( index = 0 ; index < msgbufp->msg_bufx ; index++ )
{
if (msgbufp->msg_bufc[index] == '\0') {
continue;
}
vcputc( 0, 0, msgbufp->msg_bufc[index] );
if ( msgbufp->msg_bufc[index] == '\n' )
{
vcputc( 0, 0,'\r' );
}
}
}
}
#if !CONFIG_EMBEDDED
static void
vc_draw_progress_meter(unsigned int flags, int x1, int x2, int x3)
{
const unsigned char * data;
int x, w;
int ox, oy;
int endCapPos;
int onoff;
int style = (0 == (2 & vc_progress_withmeter));
ox = ((vinfo.v_width - (kProgressBarWidth * vc_uiscale)) / 2);
oy = vinfo.v_height - (vinfo.v_height / 3) - ((kProgressBarHeight * vc_uiscale) / 2);
if (kDataBack == flags)
{
vc_blit_rect(ox + x1, oy, x1,
x2, (kProgressBarHeight * vc_uiscale), 0, (kProgressBarWidth * vc_uiscale),
NULL, vc_progressmeter_backbuffer, flags);
return;
}
for (x = x1; x < x2; x += w)
{
onoff = (x < x3);
endCapPos = ((style && onoff) ? x3 : (kProgressBarWidth * vc_uiscale));
if (x < (kProgressBarCapWidth * vc_uiscale))
{
if (x2 < (kProgressBarCapWidth * vc_uiscale))
w = x2 - x;
else
w = (kProgressBarCapWidth * vc_uiscale) - x;
data = progressmeter_leftcap[vc_uiscale >= 2][onoff];
data += x;
vc_blit_rect(ox + x, oy, x, w,
(kProgressBarHeight * vc_uiscale),
(kProgressBarCapWidth * vc_uiscale),
(kProgressBarWidth * vc_uiscale),
data, vc_progressmeter_backbuffer, flags);
}
else if (x < (endCapPos - (kProgressBarCapWidth * vc_uiscale)))
{
if (x2 < (endCapPos - (kProgressBarCapWidth * vc_uiscale)))
w = x2 - x;
else
w = (endCapPos - (kProgressBarCapWidth * vc_uiscale)) - x;
data = progressmeter_middle[vc_uiscale >= 2][onoff];
vc_blit_rect(ox + x, oy, x, w,
(kProgressBarHeight * vc_uiscale),
1,
(kProgressBarWidth * vc_uiscale),
data, vc_progressmeter_backbuffer, flags);
}
else
{
w = endCapPos - x;
data = progressmeter_rightcap[vc_uiscale >= 2][onoff];
data += x - (endCapPos - (kProgressBarCapWidth * vc_uiscale));
vc_blit_rect(ox + x, oy, x, w,
(kProgressBarHeight * vc_uiscale),
(kProgressBarCapWidth * vc_uiscale),
(kProgressBarWidth * vc_uiscale),
data, vc_progressmeter_backbuffer, flags);
}
}
}
extern void IORecordProgressBackbuffer(void * buffer, size_t size, uint32_t theme);
static void
internal_enable_progressmeter(int new_value)
{
spl_t s;
void * new_buffer;
boolean_t stashBackbuffer;
stashBackbuffer = FALSE;
new_buffer = NULL;
if (new_value)
{
new_buffer = kalloc((kProgressBarWidth * vc_uiscale)
* (kProgressBarHeight * vc_uiscale) * sizeof(int));
}
s = splhigh();
simple_lock(&vc_progress_lock);
if (kProgressMeterUser == new_value)
{
if (gc_enabled || !gc_acquired || !gc_graphics_boot
|| (kProgressMeterKernel == vc_progressmeter_enable)) new_value = vc_progressmeter_enable;
}
if (new_value != vc_progressmeter_enable)
{
if (new_value)
{
if (kProgressMeterOff == vc_progressmeter_enable)
{
vc_progressmeter_backbuffer = new_buffer;
vc_draw_progress_meter(kDataAlpha | kSave, 0, (kProgressBarWidth * vc_uiscale), 0);
new_buffer = NULL;
vc_progressmeter_drawn = 0;
}
vc_progressmeter_enable = new_value;
}
else if (vc_progressmeter_backbuffer)
{
if (kProgressMeterUser == vc_progressmeter_enable)
{
vc_draw_progress_meter(kDataBack, 0, (kProgressBarWidth * vc_uiscale), vc_progressmeter_drawn);
}
else stashBackbuffer = TRUE;
new_buffer = vc_progressmeter_backbuffer;
vc_progressmeter_backbuffer = NULL;
vc_progressmeter_enable = FALSE;
}
}
simple_unlock(&vc_progress_lock);
splx(s);
if (new_buffer)
{
if (stashBackbuffer) IORecordProgressBackbuffer(new_buffer,
(kProgressBarWidth * vc_uiscale)
* (kProgressBarHeight * vc_uiscale)
* sizeof(int),
vc_progress_white);
kfree(new_buffer, (kProgressBarWidth * vc_uiscale)
* (kProgressBarHeight * vc_uiscale) * sizeof(int));
}
}
static void
internal_set_progressmeter(int new_value)
{
int x1, x3;
int capRedraw;
int style = (0 == (2 & vc_progress_withmeter));
if ((new_value < 0) || (new_value > kProgressMeterMax)) return;
if (vc_progressmeter_enable)
{
vc_progressmeter_value = new_value;
capRedraw = (style ? (kProgressBarCapWidth * vc_uiscale) : 0);
x3 = (((kProgressBarWidth * vc_uiscale) - 2 * capRedraw) * vc_progressmeter_value) / kProgressMeterMax;
x3 += (2 * capRedraw);
if (x3 > vc_progressmeter_drawn)
{
x1 = capRedraw;
if (x1 > vc_progressmeter_drawn) x1 = vc_progressmeter_drawn;
vc_draw_progress_meter(kDataAlpha, vc_progressmeter_drawn - x1, x3, x3);
}
else
{
vc_draw_progress_meter(kDataAlpha, x3 - capRedraw, vc_progressmeter_drawn, x3);
}
vc_progressmeter_drawn = x3;
}
}
void
vc_enable_progressmeter(int new_value)
{
if (kProgressMeterKernel == vc_progressmeter_enable)
{
vc_progressmeter_hold = new_value;
}
else
{
internal_enable_progressmeter(new_value ? kProgressMeterUser : kProgressMeterOff);
}
}
void
vc_set_progressmeter(int new_value)
{
spl_t s;
s = splhigh();
simple_lock(&vc_progress_lock);
if (vc_progressmeter_enable && (kProgressMeterKernel != vc_progressmeter_enable))
{
internal_set_progressmeter((new_value * kProgressMeterMax) / 100);
}
simple_unlock(&vc_progress_lock);
splx(s);
}
#endif