/*
* Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/** @file
*
* Frame buffer console
*
*/
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <byteswap.h>
#include <ipxe/ansiesc.h>
#include <ipxe/image.h>
#include <ipxe/pixbuf.h>
#include <ipxe/umalloc.h>
#include <ipxe/console.h>
#include <ipxe/fbcon.h>
/**
* Calculate raw colour value
*
* @v fbcon Frame buffer console
* @v rgb 24-bit RGB value
* @ret raw Raw colour
*/
static uint32_t fbcon_colour ( struct fbcon *fbcon, uint32_t rgb ) {
struct fbcon_colour_map *map = fbcon->map;
uint8_t red = ( rgb >> 16 );
uint8_t green = ( rgb >> 8 );
uint8_t blue = ( rgb >> 0 );
uint32_t mapped;
mapped = ( ( ( red >> map->red_scale ) << map->red_lsb ) |
( ( green >> map->green_scale ) << map->green_lsb ) |
( ( blue >> map->blue_scale ) << map->blue_lsb ) );
return cpu_to_le32 ( mapped );
}
/**
* Calculate ANSI font colour
*
* @v fbcon Frame buffer console
* @v ansicol ANSI colour value (0-based)
* @ret colour Raw colour
*/
static uint32_t fbcon_ansi_colour ( struct fbcon *fbcon,
unsigned int ansicol ) {
uint32_t rgb;
/* Treat ansicol as 3-bit BGR with intensity 0xaa */
rgb = ( ( ( ansicol & ( 1 << 0 ) ) ? 0xaa0000 : 0 ) |
( ( ansicol & ( 1 << 1 ) ) ? 0x00aa00 : 0 ) |
( ( ansicol & ( 1 << 2 ) ) ? 0x0000aa : 0 ) );
return fbcon_colour ( fbcon, rgb );
}
/**
* Set default foreground colour
*
* @v fbcon Frame buffer console
*/
static void fbcon_set_default_foreground ( struct fbcon *fbcon ) {
/* Default to non-bold white foreground */
fbcon->foreground = fbcon_ansi_colour ( fbcon, 0x7 );
fbcon->bold = 0;
}
/**
* Set default background colour
*
* @v fbcon Frame buffer console
*/
static void fbcon_set_default_background ( struct fbcon *fbcon ) {
/* Default to transparent background */
fbcon->background = FBCON_TRANSPARENT;
}
/**
* Clear rows of characters
*
* @v fbcon Frame buffer console
* @v ypos Starting Y position
*/
static void fbcon_clear ( struct fbcon *fbcon, unsigned int ypos ) {
struct fbcon_text_cell cell = {
.foreground = fbcon->foreground,
.background = fbcon->background,
.character = ' ',
};
size_t offset;
unsigned int xpos;
/* Clear stored character array */
for ( ; ypos < fbcon->character.height ; ypos++ ) {
offset = ( ypos * fbcon->character.width * sizeof ( cell ) );
for ( xpos = 0 ; xpos < fbcon->character.width ; xpos++ ) {
copy_to_user ( fbcon->text.start, offset, &cell,
sizeof ( cell ) );
offset += sizeof ( cell );
}
}
}
/**
* Store character at specified position
*
* @v fbcon Frame buffer console
* @v cell Text cell
* @v xpos X position
* @v ypos Y position
*/
static void fbcon_store ( struct fbcon *fbcon, struct fbcon_text_cell *cell,
unsigned int xpos, unsigned int ypos ) {
size_t offset;
/* Store cell */
offset = ( ( ( ypos * fbcon->character.width ) + xpos ) *
sizeof ( *cell ) );
copy_to_user ( fbcon->text.start, offset, cell, sizeof ( *cell ) );
}
/**
* Draw character at specified position
*
* @v fbcon Frame buffer console
* @v cell Text cell
* @v xpos X position
* @v ypos Y position
*/
static void fbcon_draw ( struct fbcon *fbcon, struct fbcon_text_cell *cell,
unsigned int xpos, unsigned int ypos ) {
uint8_t glyph[fbcon->font->height];
size_t offset;
size_t pixel_len;
size_t skip_len;
unsigned int row;
unsigned int column;
uint8_t bitmask;
int transparent;
void *src;
/* Get font character */
fbcon->font->glyph ( cell->character, glyph );
/* Calculate pixel geometry */
offset = ( fbcon->indent +
( ypos * fbcon->character.stride ) +
( xpos * fbcon->character.len ) );
pixel_len = fbcon->pixel->len;
skip_len = ( fbcon->pixel->stride - fbcon->character.len );
/* Check for transparent background colour */
transparent = ( cell->background == FBCON_TRANSPARENT );
/* Draw character rows */
for ( row = 0 ; row < fbcon->font->height ; row++ ) {
/* Draw background picture, if applicable */
if ( transparent ) {
if ( fbcon->picture.start ) {
memcpy_user ( fbcon->start, offset,
fbcon->picture.start, offset,
fbcon->character.len );
} else {
memset_user ( fbcon->start, offset, 0,
fbcon->character.len );
}
}
/* Draw character row */
for ( column = FBCON_CHAR_WIDTH, bitmask = glyph[row] ;
column ; column--, bitmask <<= 1, offset += pixel_len ) {
if ( bitmask & 0x80 ) {
src = &cell->foreground;
} else if ( ! transparent ) {
src = &cell->background;
} else {
continue;
}
copy_to_user ( fbcon->start, offset, src, pixel_len );
}
/* Move to next row */
offset += skip_len;
}
}
/**
* Redraw all characters
*
* @v fbcon Frame buffer console
*/
static void fbcon_redraw ( struct fbcon *fbcon ) {
struct fbcon_text_cell cell;
size_t offset = 0;
unsigned int xpos;
unsigned int ypos;
/* Redraw characters */
for ( ypos = 0 ; ypos < fbcon->character.height ; ypos++ ) {
for ( xpos = 0 ; xpos < fbcon->character.width ; xpos++ ) {
copy_from_user ( &cell, fbcon->text.start, offset,
sizeof ( cell ) );
fbcon_draw ( fbcon, &cell, xpos, ypos );
offset += sizeof ( cell );
}
}
}
/**
* Scroll screen
*
* @v fbcon Frame buffer console
*/
static void fbcon_scroll ( struct fbcon *fbcon ) {
size_t row_len;
/* Sanity check */
assert ( fbcon->ypos == fbcon->character.height );
/* Scroll up character array */
row_len = ( fbcon->character.width * sizeof ( struct fbcon_text_cell ));
memmove_user ( fbcon->text.start, 0, fbcon->text.start, row_len,
( row_len * ( fbcon->character.height - 1 ) ) );
fbcon_clear ( fbcon, ( fbcon->character.height - 1 ) );
/* Update cursor position */
fbcon->ypos--;
/* Redraw all characters */
fbcon_redraw ( fbcon );
}
/**
* Draw character at cursor position
*
* @v fbcon Frame buffer console
* @v show_cursor Show cursor
*/
static void fbcon_draw_cursor ( struct fbcon *fbcon, int show_cursor ) {
struct fbcon_text_cell cell;
size_t offset;
offset = ( ( ( fbcon->ypos * fbcon->character.width ) + fbcon->xpos ) *
sizeof ( cell ) );
copy_from_user ( &cell, fbcon->text.start, offset, sizeof ( cell ) );
if ( show_cursor ) {
cell.background = fbcon->foreground;
cell.foreground = ( ( fbcon->background == FBCON_TRANSPARENT ) ?
0 : fbcon->background );
}
fbcon_draw ( fbcon, &cell, fbcon->xpos, fbcon->ypos );
}
/**
* Handle ANSI CUP (cursor position)
*
* @v ctx ANSI escape sequence context
* @v count Parameter count
* @v params[0] Row (1 is top)
* @v params[1] Column (1 is left)
*/
static void fbcon_handle_cup ( struct ansiesc_context *ctx,
unsigned int count __unused, int params[] ) {
struct fbcon *fbcon = container_of ( ctx, struct fbcon, ctx );
int cx = ( params[1] - 1 );
int cy = ( params[0] - 1 );
fbcon_draw_cursor ( fbcon, 0 );
fbcon->xpos = cx;
if ( fbcon->xpos >= fbcon->character.width )
fbcon->xpos = 0;
fbcon->ypos = cy;
if ( fbcon->ypos >= fbcon->character.height )
fbcon->ypos = 0;
fbcon_draw_cursor ( fbcon, fbcon->show_cursor );
}
/**
* Handle ANSI ED (erase in page)
*
* @v ctx ANSI escape sequence context
* @v count Parameter count
* @v params[0] Region to erase
*/
static void fbcon_handle_ed ( struct ansiesc_context *ctx,
unsigned int count __unused,
int params[] __unused ) {
struct fbcon *fbcon = container_of ( ctx, struct fbcon, ctx );
/* We assume that we always clear the whole screen */
assert ( params[0] == ANSIESC_ED_ALL );
/* Clear character array */
fbcon_clear ( fbcon, 0 );
/* Redraw all characters */
fbcon_redraw ( fbcon );
/* Reset cursor position */
fbcon->xpos = 0;
fbcon->ypos = 0;
fbcon_draw_cursor ( fbcon, fbcon->show_cursor );
}
/**
* Handle ANSI SGR (set graphics rendition)
*
* @v ctx ANSI escape sequence context
* @v count Parameter count
* @v params List of graphic rendition aspects
*/
static void fbcon_handle_sgr ( struct ansiesc_context *ctx, unsigned int count,
int params[] ) {
struct fbcon *fbcon = container_of ( ctx, struct fbcon, ctx );
uint32_t *custom = NULL;
uint32_t rgb;
unsigned int end;
unsigned int i;
int aspect;
for ( i = 0 ; i < count ; i++ ) {
/* Process aspect */
aspect = params[i];
if ( aspect == 0 ) {
fbcon_set_default_foreground ( fbcon );
fbcon_set_default_background ( fbcon );
} else if ( aspect == 1 ) {
fbcon->bold = fbcon_colour ( fbcon, FBCON_BOLD );
} else if ( aspect == 22 ) {
fbcon->bold = 0;
} else if ( ( aspect >= 30 ) && ( aspect <= 37 ) ) {
fbcon->foreground =
fbcon_ansi_colour ( fbcon, aspect - 30 );
} else if ( aspect == 38 ) {
custom = &fbcon->foreground;
} else if ( aspect == 39 ) {
fbcon_set_default_foreground ( fbcon );
} else if ( ( aspect >= 40 ) && ( aspect <= 47 ) ) {
fbcon->background =
fbcon_ansi_colour ( fbcon, aspect - 40 );
} else if ( aspect == 48 ) {
custom = &fbcon->background;
} else if ( aspect == 49 ) {
fbcon_set_default_background ( fbcon );
}
/* Process custom RGB colour, if applicable
*
* We support the xterm-compatible
* "<ESC>[38;2;<red>;<green>;<blue>m" and
* "<ESC>[48;2;<red>;<green>;<blue>m" sequences.
*/
if ( custom ) {
rgb = 0;
end = ( i + 5 );
for ( ; ( i < count ) && ( i < end ) ; i++ )
rgb = ( ( rgb << 8 ) | params[i] );
*custom = fbcon_colour ( fbcon, rgb );
custom = NULL;
}
}
}
/**
* Handle ANSI DECTCEM set (show cursor)
*
* @v ctx ANSI escape sequence context
* @v count Parameter count
* @v params List of graphic rendition aspects
*/
static void fbcon_handle_dectcem_set ( struct ansiesc_context *ctx,
unsigned int count __unused,
int params[] __unused ) {
struct fbcon *fbcon = container_of ( ctx, struct fbcon, ctx );
fbcon->show_cursor = 1;
fbcon_draw_cursor ( fbcon, 1 );
}
/**
* Handle ANSI DECTCEM reset (hide cursor)
*
* @v ctx ANSI escape sequence context
* @v count Parameter count
* @v params List of graphic rendition aspects
*/
static void fbcon_handle_dectcem_reset ( struct ansiesc_context *ctx,
unsigned int count __unused,
int params[] __unused ) {
struct fbcon *fbcon = container_of ( ctx, struct fbcon, ctx );
fbcon->show_cursor = 0;
fbcon_draw_cursor ( fbcon, 0 );
}
/** ANSI escape sequence handlers */
static struct ansiesc_handler fbcon_ansiesc_handlers[] = {
{ ANSIESC_CUP, fbcon_handle_cup },
{ ANSIESC_ED, fbcon_handle_ed },
{ ANSIESC_SGR, fbcon_handle_sgr },
{ ANSIESC_DECTCEM_SET, fbcon_handle_dectcem_set },
{ ANSIESC_DECTCEM_RESET, fbcon_handle_dectcem_reset },
{ 0, NULL }
};
/**
* Print a character to current cursor position
*
* @v fbcon Frame buffer console
* @v character Character
*/
void fbcon_putchar ( struct fbcon *fbcon, int character ) {
struct fbcon_text_cell cell;
/* Intercept ANSI escape sequences */
character = ansiesc_process ( &fbcon->ctx, character );
if ( character < 0 )
return;
/* Handle control characters */
switch ( character ) {
case '\r':
fbcon_draw_cursor ( fbcon, 0 );
fbcon->xpos = 0;
break;
case '\n':
fbcon_draw_cursor ( fbcon, 0 );
fbcon->xpos = 0;
fbcon->ypos++;
break;
case '\b':
fbcon_draw_cursor ( fbcon, 0 );
if ( fbcon->xpos ) {
fbcon->xpos--;
} else if ( fbcon->ypos ) {
fbcon->xpos = ( fbcon->character.width - 1 );
fbcon->ypos--;
}
break;
default:
/* Print character at current cursor position */
cell.foreground = ( fbcon->foreground | fbcon->bold );
cell.background = fbcon->background;
cell.character = character;
fbcon_store ( fbcon, &cell, fbcon->xpos, fbcon->ypos );
fbcon_draw ( fbcon, &cell, fbcon->xpos, fbcon->ypos );
/* Advance cursor */
fbcon->xpos++;
if ( fbcon->xpos >= fbcon->character.width ) {
fbcon->xpos = 0;
fbcon->ypos++;
}
break;
}
/* Scroll screen if necessary */
if ( fbcon->ypos >= fbcon->character.height )
fbcon_scroll ( fbcon );
/* Show cursor */
fbcon_draw_cursor ( fbcon, fbcon->show_cursor );
}
/**
* Initialise background picture
*
* @v fbcon Frame buffer console
* @v pixbuf Background picture
* @ret rc Return status code
*/
static int fbcon_picture_init ( struct fbcon *fbcon,
struct pixel_buffer *pixbuf ) {
struct fbcon_geometry *pixel = fbcon->pixel;
struct fbcon_picture *picture = &fbcon->picture;
size_t len;
size_t pixbuf_stride;
size_t indent;
size_t pixbuf_indent;
size_t offset;
size_t pixbuf_offset;
uint32_t rgb;
uint32_t raw;
unsigned int x;
unsigned int y;
unsigned int width;
unsigned int height;
int xgap;
int ygap;
int rc;
/* Allocate buffer */
len = ( pixel->height * pixel->stride );
picture->start = umalloc ( len );
if ( ! picture->start ) {
DBGC ( fbcon, "FBCON %p could not allocate %zd bytes for "
"picture\n", fbcon, len );
rc = -ENOMEM;
goto err_umalloc;
}
/* Centre picture on console */
pixbuf_stride = ( pixbuf->width * sizeof ( rgb ) );
xgap = ( ( ( int ) ( pixel->width - pixbuf->width ) ) / 2 );
ygap = ( ( ( int ) ( pixel->height - pixbuf->height ) ) / 2 );
indent = ( ( ( ( ygap >= 0 ) ? ygap : 0 ) * pixel->stride ) +
( ( ( xgap >= 0 ) ? xgap : 0 ) * pixel->len ) );
pixbuf_indent = ( ( ( ( ygap < 0 ) ? -ygap : 0 ) * pixbuf_stride ) +
( ( ( xgap < 0 ) ? -xgap : 0 ) * sizeof ( rgb ) ) );
width = pixbuf->width;
if ( width > pixel->width )
width = pixel->width;
height = pixbuf->height;
if ( height > pixel->height )
height = pixel->height;
DBGC ( fbcon, "FBCON %p picture is pixel %dx%d at [%d,%d),[%d,%d)\n",
fbcon, width, height, xgap, ( xgap + pixbuf->width ), ygap,
( ygap + pixbuf->height ) );
/* Convert to frame buffer raw format */
memset_user ( picture->start, 0, 0, len );
for ( y = 0 ; y < height ; y++ ) {
offset = ( indent + ( y * pixel->stride ) );
pixbuf_offset = ( pixbuf_indent + ( y * pixbuf_stride ) );
for ( x = 0 ; x < width ; x++ ) {
copy_from_user ( &rgb, pixbuf->data, pixbuf_offset,
sizeof ( rgb ) );
raw = fbcon_colour ( fbcon, rgb );
copy_to_user ( picture->start, offset, &raw,
pixel->len );
offset += pixel->len;
pixbuf_offset += sizeof ( rgb );
}
}
return 0;
ufree ( picture->start );
err_umalloc:
return rc;
}
/**
* Initialise frame buffer console
*
* @v fbcon Frame buffer console
* @v start Start address
* @v pixel Pixel geometry
* @v map Colour mapping
* @v font Font definition
* @v config Console configuration
* @ret rc Return status code
*/
int fbcon_init ( struct fbcon *fbcon, userptr_t start,
struct fbcon_geometry *pixel,
struct fbcon_colour_map *map,
struct fbcon_font *font,
struct console_configuration *config ) {
int width;
int height;
unsigned int xgap;
unsigned int ygap;
unsigned int left;
unsigned int right;
unsigned int top;
unsigned int bottom;
int rc;
/* Initialise data structure */
memset ( fbcon, 0, sizeof ( *fbcon ) );
fbcon->start = start;
fbcon->pixel = pixel;
assert ( pixel->len <= sizeof ( uint32_t ) );
fbcon->map = map;
fbcon->font = font;
fbcon->ctx.handlers = fbcon_ansiesc_handlers;
fbcon->show_cursor = 1;
/* Derive overall length */
fbcon->len = ( pixel->height * pixel->stride );
DBGC ( fbcon, "FBCON %p at [%08lx,%08lx)\n", fbcon,
user_to_phys ( fbcon->start, 0 ),
user_to_phys ( fbcon->start, fbcon->len ) );
/* Calculate margin. If the actual screen size is larger than
* the requested screen size, then update the margins so that
* the margin remains relative to the requested screen size.
* (As an exception, if a zero margin was specified then treat
* this as meaning "expand to edge of actual screen".)
*/
xgap = ( pixel->width - config->width );
ygap = ( pixel->height - config->height );
left = ( xgap / 2 );
right = ( xgap - left );
top = ( ygap / 2 );
bottom = ( ygap - top );
fbcon->margin.left = ( config->left + ( config->left ? left : 0 ) );
fbcon->margin.right = ( config->right + ( config->right ? right : 0 ) );
fbcon->margin.top = ( config->top + ( config->top ? top : 0 ) );
fbcon->margin.bottom =
( config->bottom + ( config->bottom ? bottom : 0 ) );
/* Expand margin to accommodate whole characters */
width = ( pixel->width - fbcon->margin.left - fbcon->margin.right );
height = ( pixel->height - fbcon->margin.top - fbcon->margin.bottom );
if ( ( width < FBCON_CHAR_WIDTH ) ||
( height < ( ( int ) font->height ) ) ) {
DBGC ( fbcon, "FBCON %p has unusable character area "
"[%d-%d),[%d-%d)\n", fbcon, fbcon->margin.left,
( pixel->width - fbcon->margin.right ),
fbcon->margin.top,
( pixel->height - fbcon->margin.bottom ) );
rc = -EINVAL;
goto err_margin;
}
xgap = ( width % FBCON_CHAR_WIDTH );
ygap = ( height % font->height );
fbcon->margin.left += ( xgap / 2 );
fbcon->margin.top += ( ygap / 2 );
fbcon->margin.right += ( xgap - ( xgap / 2 ) );
fbcon->margin.bottom += ( ygap - ( ygap / 2 ) );
fbcon->indent = ( ( fbcon->margin.top * pixel->stride ) +
( fbcon->margin.left * pixel->len ) );
/* Derive character geometry from pixel geometry */
fbcon->character.width = ( width / FBCON_CHAR_WIDTH );
fbcon->character.height = ( height / font->height );
fbcon->character.len = ( pixel->len * FBCON_CHAR_WIDTH );
fbcon->character.stride = ( pixel->stride * font->height );
DBGC ( fbcon, "FBCON %p is pixel %dx%d, char %dx%d at "
"[%d-%d),[%d-%d)\n", fbcon, fbcon->pixel->width,
fbcon->pixel->height, fbcon->character.width,
fbcon->character.height, fbcon->margin.left,
( fbcon->pixel->width - fbcon->margin.right ),
fbcon->margin.top,
( fbcon->pixel->height - fbcon->margin.bottom ) );
/* Set default colours */
fbcon_set_default_foreground ( fbcon );
fbcon_set_default_background ( fbcon );
/* Allocate and initialise stored character array */
fbcon->text.start = umalloc ( fbcon->character.width *
fbcon->character.height *
sizeof ( struct fbcon_text_cell ) );
if ( ! fbcon->text.start ) {
rc = -ENOMEM;
goto err_text;
}
fbcon_clear ( fbcon, 0 );
/* Set framebuffer to all black (including margins) */
memset_user ( fbcon->start, 0, 0, fbcon->len );
/* Generate pixel buffer from background image, if applicable */
if ( config->pixbuf &&
( ( rc = fbcon_picture_init ( fbcon, config->pixbuf ) ) != 0 ) )
goto err_picture;
/* Draw background picture (including margins), if applicable */
if ( fbcon->picture.start ) {
memcpy_user ( fbcon->start, 0, fbcon->picture.start, 0,
fbcon->len );
}
/* Update console width and height */
console_set_size ( fbcon->character.width, fbcon->character.height );
return 0;
ufree ( fbcon->picture.start );
err_picture:
ufree ( fbcon->text.start );
err_text:
err_margin:
return rc;
}
/**
* Finalise frame buffer console
*
* @v fbcon Frame buffer console
*/
void fbcon_fini ( struct fbcon *fbcon ) {
ufree ( fbcon->text.start );
ufree ( fbcon->picture.start );
}
