fbcon.c File Reference

Frame buffer console. More...

#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/uaccess.h>
#include <ipxe/umalloc.h>
#include <ipxe/console.h>
#include <ipxe/fbcon.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static uint32_t	fbcon_colour (struct fbcon *fbcon, uint32_t rgb)
	Calculate raw colour value.
static uint32_t	fbcon_ansi_colour (struct fbcon *fbcon, unsigned int ansicol)
	Calculate ANSI font colour.
static void	fbcon_set_default_foreground (struct fbcon *fbcon)
	Set default foreground colour.
static void	fbcon_set_default_background (struct fbcon *fbcon)
	Set default background colour.
static struct fbcon_text_cell *	fbcon_cell (struct fbcon *fbcon, unsigned int xpos, unsigned int ypos)
	Get character cell.
static void	fbcon_clear (struct fbcon *fbcon, unsigned int ypos)
	Clear rows of characters.
static void	fbcon_draw (struct fbcon *fbcon, struct fbcon_text_cell *cell, unsigned int xpos, unsigned int ypos)
	Draw character at specified position.
static void	fbcon_redraw (struct fbcon *fbcon)
	Redraw all characters.
static void	fbcon_scroll (struct fbcon *fbcon)
	Scroll screen.
static void	fbcon_draw_cursor (struct fbcon *fbcon, int show_cursor)
	Draw character at cursor position.
static void	fbcon_handle_cup (struct ansiesc_context *ctx, unsigned int count __unused, int params[])
	Handle ANSI CUP (cursor position)
static void	fbcon_handle_ed (struct ansiesc_context *ctx, unsigned int count __unused, int params[] __unused)
	Handle ANSI ED (erase in page)
static void	fbcon_handle_sgr (struct ansiesc_context *ctx, unsigned int count, int params[])
	Handle ANSI SGR (set graphics rendition)
static void	fbcon_handle_dectcem_set (struct ansiesc_context *ctx, unsigned int count __unused, int params[] __unused)
	Handle ANSI DECTCEM set (show cursor)
static void	fbcon_handle_dectcem_reset (struct ansiesc_context *ctx, unsigned int count __unused, int params[] __unused)
	Handle ANSI DECTCEM reset (hide cursor)
void	fbcon_putchar (struct fbcon *fbcon, int character)
	Print a character to current cursor position.
static int	fbcon_picture_init (struct fbcon *fbcon, struct pixel_buffer *pixbuf)
	Initialise background picture.
int	fbcon_init (struct fbcon *fbcon, void *start, struct fbcon_geometry *pixel, struct fbcon_colour_map *map, struct fbcon_font *font, struct console_configuration *config)
	Initialise frame buffer console.
void	fbcon_fini (struct fbcon *fbcon)
	Finalise frame buffer console.

Variables
static struct ansiesc_handler	fbcon_ansiesc_handlers []
	ANSI escape sequence handlers.

Detailed Description

Frame buffer console.

Definition in file fbcon.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

fbcon_colour()

uint32_t fbcon_colour ( struct fbcon * fbcon, uint32_t rgb )

static

Calculate raw colour value.

Parameters

fbcon	Frame buffer console
rgb	24-bit RGB value

Return values

raw	Raw colour

Definition at line 52 of file fbcon.c.

                                                                   {
        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 );
}

References cpu_to_le32, fbcon::map, and map.

Referenced by fbcon_ansi_colour(), fbcon_handle_sgr(), and fbcon_picture_init().

fbcon_ansi_colour()

uint32_t fbcon_ansi_colour ( struct fbcon * fbcon, unsigned int ansicol )

static

Calculate ANSI font colour.

Parameters

fbcon	Frame buffer console
ansicol	ANSI colour value (0-based)

Return values

colour

Raw colour

Definition at line 72 of file fbcon.c.

                                                           {
        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 );
}

References fbcon_colour().

Referenced by fbcon_handle_sgr(), and fbcon_set_default_foreground().

fbcon_set_default_foreground()

void fbcon_set_default_foreground ( struct fbcon * fbcon )

static

Set default foreground colour.

Parameters

fbcon

Frame buffer console

Definition at line 89 of file fbcon.c.

                                                                 {
 
        /* Default to non-bold white foreground */
        fbcon->foreground = fbcon_ansi_colour ( fbcon, 0x7 );
        fbcon->bold = 0;
}

References fbcon::bold, fbcon_ansi_colour(), and fbcon::foreground.

Referenced by fbcon_handle_sgr(), and fbcon_init().

fbcon_set_default_background()

void fbcon_set_default_background ( struct fbcon * fbcon )

static

Set default background colour.

Parameters

fbcon

Frame buffer console

Definition at line 101 of file fbcon.c.

                                                                 {
 
        /* Default to transparent background */
        fbcon->background = FBCON_TRANSPARENT;
}

References fbcon::background, and FBCON_TRANSPARENT.

Referenced by fbcon_handle_sgr(), and fbcon_init().

fbcon_cell()

struct fbcon_text_cell * fbcon_cell ( struct fbcon * fbcon, unsigned int xpos, unsigned int ypos )

inlinestatic

Get character cell.

Parameters

fbcon	Frame buffer console
xpos	X position
ypos	Y position

Return values

cell

Text cell

Definition at line 115 of file fbcon.c.

                                                                        {
        unsigned int index;
 
        index = ( ( ypos * fbcon->character.width ) + xpos );
        return &fbcon->text.cells[index];
}

References fbcon_text::cells, fbcon::character, index, fbcon::text, and fbcon_geometry::width.

Referenced by fbcon_clear(), fbcon_draw_cursor(), fbcon_putchar(), fbcon_redraw(), and fbcon_scroll().

fbcon_clear()

void fbcon_clear ( struct fbcon * fbcon, unsigned int ypos )

static

Clear rows of characters.

Parameters

fbcon	Frame buffer console
ypos	Starting Y position

Definition at line 130 of file fbcon.c.

                                                                   {
        struct fbcon_text_cell *cell;
        unsigned int xpos;
 
        /* Clear stored character array */
        cell = fbcon_cell ( fbcon, 0, ypos );
        for ( ; ypos < fbcon->character.height ; ypos++ ) {
                for ( xpos = 0 ; xpos < fbcon->character.width ; xpos++ ) {
                        cell->foreground = fbcon->foreground;
                        cell->background = fbcon->background;
                        cell->character = ' ';
                        cell++;
                }
        }
}

References fbcon::background, fbcon_text_cell::background, fbcon::character, fbcon_text_cell::character, fbcon_cell(), fbcon::foreground, fbcon_text_cell::foreground, fbcon_geometry::height, and fbcon_geometry::width.

Referenced by fbcon_handle_ed(), fbcon_init(), and fbcon_scroll().

fbcon_draw()

void fbcon_draw ( struct fbcon * fbcon, struct fbcon_text_cell * cell, unsigned int xpos, unsigned int ypos )

static

Draw character at specified position.

Parameters

fbcon	Frame buffer console
cell	Text cell
xpos	X position
ypos	Y position

Definition at line 154 of file fbcon.c.

                                                                {
        const uint8_t *glyph;
        size_t offset;
        size_t pixel_len;
        size_t skip_len;
        unsigned int row;
        unsigned int column;
        uint8_t bitmask;
        int transparent;
        const void *src;
 
        /* Get font character */
        glyph = fbcon->font->glyph ( cell->character );
 
        /* 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 ( ( fbcon->start + offset ),
                                         ( fbcon->picture.start + offset ),
                                         fbcon->character.len );
                        } else {
                                memset ( ( 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;
                        }
                        memcpy ( ( fbcon->start + offset ), src, pixel_len );
                }
 
                /* Move to next row */
                offset += skip_len;
        }
}

References fbcon_text_cell::background, fbcon::character, fbcon_text_cell::character, FBCON_CHAR_WIDTH, FBCON_TRANSPARENT, fbcon::font, fbcon_text_cell::foreground, fbcon_font::glyph, fbcon_font::height, fbcon::indent, fbcon_geometry::len, memcpy(), memset(), offset, fbcon::picture, fbcon::pixel, src, fbcon::start, fbcon_picture::start, and fbcon_geometry::stride.

Referenced by fbcon_draw_cursor(), fbcon_putchar(), fbcon_redraw(), and fbcon_scroll().

fbcon_redraw()

void fbcon_redraw ( struct fbcon * fbcon )

static

Redraw all characters.

Parameters

fbcon

Frame buffer console

Definition at line 217 of file fbcon.c.

                                                 {
        struct fbcon_text_cell *cell;
        unsigned int xpos;
        unsigned int ypos;
 
        /* Redraw characters */
        cell = fbcon_cell ( fbcon, 0, 0 );
        for ( ypos = 0 ; ypos < fbcon->character.height ; ypos++ ) {
                for ( xpos = 0 ; xpos < fbcon->character.width ; xpos++ ) {
                        fbcon_draw ( fbcon, cell, xpos, ypos );
                        cell++;
                }
        }
}

References fbcon::character, fbcon_cell(), fbcon_draw(), fbcon_geometry::height, and fbcon_geometry::width.

Referenced by fbcon_handle_ed().

fbcon_scroll()

void fbcon_scroll ( struct fbcon * fbcon )

static

Scroll screen.

Parameters

fbcon

Frame buffer console

Definition at line 237 of file fbcon.c.

                                                 {
        const struct fbcon_text_cell *old;
        struct fbcon_text_cell *new;
        unsigned int xpos;
        unsigned int ypos;
        unsigned int character;
        uint32_t foreground;
        uint32_t background;
 
        /* Sanity check */
        assert ( fbcon->ypos == fbcon->character.height );
 
        /* Scroll up character array */
        new = fbcon_cell ( fbcon, 0, 0 );
        old = fbcon_cell ( fbcon, 0, 1 );
        for ( ypos = 0 ; ypos < ( fbcon->character.height - 1 ) ; ypos++ ) {
                for ( xpos = 0 ; xpos < fbcon->character.width ; xpos++ ) {
                        /* Redraw character (if changed) */
                        character = old->character;
                        foreground = old->foreground;
                        background = old->background;
                        if ( ( new->character != character ) ||
                             ( new->foreground != foreground ) ||
                             ( new->background != background ) ) {
                                new->character = character;
                                new->foreground = foreground;
                                new->background = background;
                                fbcon_draw ( fbcon, new, xpos, ypos );
                        }
                        new++;
                        old++;
                }
        }
 
        /* Clear bottom row */
        fbcon_clear ( fbcon, ypos );
        for ( xpos = 0 ; xpos < fbcon->character.width ; xpos++ )
                fbcon_draw ( fbcon, new++, xpos, ypos );
 
        /* Update cursor position */
        fbcon->ypos--;
}

References assert, fbcon_text_cell::background, fbcon::character, fbcon_text_cell::character, fbcon_cell(), fbcon_clear(), fbcon_draw(), fbcon_text_cell::foreground, fbcon_geometry::height, old, fbcon_geometry::width, and fbcon::ypos.

Referenced by fbcon_putchar().

fbcon_draw_cursor()

void fbcon_draw_cursor ( struct fbcon * fbcon, int show_cursor )

static

Draw character at cursor position.

Parameters

fbcon	Frame buffer console
show_cursor	Show cursor

Definition at line 286 of file fbcon.c.

                                                                       {
        struct fbcon_text_cell *cell;
        struct fbcon_text_cell cursor;
 
        cell = fbcon_cell ( fbcon, fbcon->xpos, fbcon->ypos );
        if ( show_cursor ) {
                cursor.background = fbcon->foreground;
                cursor.foreground =
                        ( ( fbcon->background == FBCON_TRANSPARENT ) ?
                          0 : fbcon->background );
                cursor.character = cell->character;
                cell = &cursor;
        }
        fbcon_draw ( fbcon, cell, fbcon->xpos, fbcon->ypos );
}

References fbcon::background, fbcon_text_cell::background, fbcon_text_cell::character, fbcon_cell(), fbcon_draw(), FBCON_TRANSPARENT, fbcon::foreground, fbcon_text_cell::foreground, fbcon::xpos, and fbcon::ypos.

Referenced by fbcon_handle_cup(), fbcon_handle_dectcem_reset(), fbcon_handle_dectcem_set(), fbcon_handle_ed(), and fbcon_putchar().

fbcon_handle_cup()

void fbcon_handle_cup ( struct ansiesc_context * ctx, unsigned int count __unused, int params[] )

static

Handle ANSI CUP (cursor position)

Parameters

ctx	ANSI escape sequence context
count	Parameter count
params[0]	Row (1 is top)
params[1]	Column (1 is left)

Definition at line 310 of file fbcon.c.

                                                                           {
        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 );
}

References __unused, fbcon::character, container_of, count, ctx, cx, fbcon_draw_cursor(), fbcon_geometry::height, fbcon::show_cursor, fbcon_geometry::width, fbcon::xpos, and fbcon::ypos.

fbcon_handle_ed()

void fbcon_handle_ed ( struct ansiesc_context * ctx, unsigned int count __unused, int params[] __unused )

static

Handle ANSI ED (erase in page)

Parameters

ctx	ANSI escape sequence context
count	Parameter count
params[0]	Region to erase

Definition at line 333 of file fbcon.c.

                                                      {
        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 );
}

References __unused, ANSIESC_ED_ALL, assert, container_of, count, ctx, fbcon_clear(), fbcon_draw_cursor(), fbcon_redraw(), fbcon::show_cursor, fbcon::xpos, and fbcon::ypos.

fbcon_handle_sgr()

void fbcon_handle_sgr ( struct ansiesc_context * ctx, unsigned int count, int params[] )

static

Handle ANSI SGR (set graphics rendition)

Parameters

ctx	ANSI escape sequence context
count	Parameter count
params	List of graphic rendition aspects

Definition at line 360 of file fbcon.c.

                                              {
        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;
                }
        }
}

References fbcon::background, fbcon::bold, container_of, count, ctx, end, fbcon_ansi_colour(), FBCON_BOLD, fbcon_colour(), fbcon_set_default_background(), fbcon_set_default_foreground(), fbcon::foreground, and NULL.

fbcon_handle_dectcem_set()

void fbcon_handle_dectcem_set ( struct ansiesc_context * ctx, unsigned int count __unused, int params[] __unused )

static

Handle ANSI DECTCEM set (show cursor)

Parameters

ctx	ANSI escape sequence context
count	Parameter count
params	List of graphic rendition aspects

Definition at line 420 of file fbcon.c.

                                                               {
        struct fbcon *fbcon = container_of ( ctx, struct fbcon, ctx );
 
        fbcon->show_cursor = 1;
        fbcon_draw_cursor ( fbcon, 1 );
}

References __unused, container_of, count, ctx, fbcon_draw_cursor(), and fbcon::show_cursor.

fbcon_handle_dectcem_reset()

void fbcon_handle_dectcem_reset ( struct ansiesc_context * ctx, unsigned int count __unused, int params[] __unused )

static

Handle ANSI DECTCEM reset (hide cursor)

Parameters

ctx	ANSI escape sequence context
count	Parameter count
params	List of graphic rendition aspects

Definition at line 436 of file fbcon.c.

                                                                 {
        struct fbcon *fbcon = container_of ( ctx, struct fbcon, ctx );
 
        fbcon->show_cursor = 0;
        fbcon_draw_cursor ( fbcon, 0 );
}

References __unused, container_of, count, ctx, fbcon_draw_cursor(), and fbcon::show_cursor.

fbcon_putchar()

void fbcon_putchar	(	struct fbcon *	fbcon,
		int	character )

Print a character to current cursor position.

Parameters

fbcon	Frame buffer console
character	Character

Definition at line 461 of file fbcon.c.

                                                          {
        struct fbcon_text_cell *cell;
 
        /* Intercept ANSI escape sequences */
        character = ansiesc_process ( &fbcon->ctx, character );
        if ( character < 0 )
                return;
 
        /* Accumulate Unicode characters */
        character = utf8_accumulate ( &fbcon->utf8, 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 = fbcon_cell ( fbcon, fbcon->xpos, fbcon->ypos );
                cell->foreground = ( fbcon->foreground | fbcon->bold );
                cell->background = fbcon->background;
                cell->character = character;
                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 );
}

References ansiesc_process(), fbcon::background, fbcon_text_cell::background, fbcon::bold, fbcon::character, fbcon_text_cell::character, fbcon::ctx, fbcon_cell(), fbcon_draw(), fbcon_draw_cursor(), fbcon_scroll(), fbcon::foreground, fbcon_text_cell::foreground, fbcon_geometry::height, fbcon::show_cursor, fbcon::utf8, utf8_accumulate(), fbcon_geometry::width, fbcon::xpos, and fbcon::ypos.

Referenced by efifb_putchar(), and vesafb_putchar().

fbcon_picture_init()

int fbcon_picture_init ( struct fbcon * fbcon, struct pixel_buffer * pixbuf )

static

Initialise background picture.

Parameters

fbcon	Frame buffer console
pixbuf	Background picture

Return values

rc	Return status code

Definition at line 526 of file fbcon.c.

                                                              {
        struct fbcon_geometry *pixel = fbcon->pixel;
        struct fbcon_picture *picture = &fbcon->picture;
        size_t len;
        size_t indent;
        size_t offset;
        const 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 */
        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 ) );
        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 ( picture->start, 0, len );
        for ( y = 0 ; y < height ; y++ ) {
                offset = ( indent + ( y * pixel->stride ) );
                rgb = pixbuf_pixel ( pixbuf, ( ( xgap < 0 ) ? -xgap : 0 ),
                                     ( ( ( ygap < 0 ) ? -ygap : 0 ) + y ) );
                for ( x = 0 ; x < width ; x++ ) {
                        raw = fbcon_colour ( fbcon, *rgb );
                        memcpy ( ( picture->start + offset ), &raw,
                                 pixel->len );
                        offset += pixel->len;
                        rgb++;
                }
        }
 
        return 0;
 
        ufree ( picture->start );
 err_umalloc:
        return rc;
}

References DBGC, ENOMEM, fbcon_colour(), fbcon_geometry::height, pixel_buffer::height, fbcon_geometry::len, len, memcpy(), memset(), offset, fbcon::picture, fbcon::pixel, raw, rc, fbcon_picture::start, fbcon_geometry::stride, ufree(), umalloc(), fbcon_geometry::width, pixel_buffer::width, x, and y.

Referenced by fbcon_init().

fbcon_init()

int fbcon_init	(	struct fbcon *	fbcon,
		void *	start,
		struct fbcon_geometry *	pixel,
		struct fbcon_colour_map *	map,
		struct fbcon_font *	font,
		struct console_configuration *	config )

Initialise frame buffer console.

Parameters

fbcon	Frame buffer console
start	Start address
pixel	Pixel geometry
map	Colour mapping
font	Font definition
config	Console configuration

Return values

rc	Return status code

Definition at line 601 of file fbcon.c.

                                                        {
        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,
               virt_to_phys ( fbcon->start ),
               ( virt_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.cells = umalloc ( fbcon->character.width *
                                      fbcon->character.height *
                                      sizeof ( fbcon->text.cells[0] ) );
        if ( ! fbcon->text.cells ) {
                rc = -ENOMEM;
                goto err_text;
        }
        fbcon_clear ( fbcon, 0 );
 
        /* Set framebuffer to all black (including margins) */
        memset ( fbcon->start, 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 ( fbcon->start, fbcon->picture.start, 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.cells );
 err_text:
 err_margin:
        return rc;
}

References assert, console_configuration::bottom, fbcon_margin::bottom, fbcon_text::cells, fbcon::character, console_set_size(), fbcon::ctx, DBGC, EINVAL, ENOMEM, fbcon_ansiesc_handlers, FBCON_CHAR_WIDTH, fbcon_clear(), fbcon_picture_init(), fbcon_set_default_background(), fbcon_set_default_foreground(), fbcon::font, ansiesc_context::handlers, console_configuration::height, fbcon_font::height, fbcon_geometry::height, fbcon::indent, console_configuration::left, fbcon_margin::left, fbcon::len, fbcon_geometry::len, fbcon::map, map, fbcon::margin, memcpy(), memset(), fbcon::picture, console_configuration::pixbuf, fbcon::pixel, rc, console_configuration::right, fbcon_margin::right, fbcon::show_cursor, fbcon::start, fbcon_picture::start, start, fbcon_geometry::stride, fbcon::text, console_configuration::top, fbcon_margin::top, ufree(), umalloc(), console_configuration::width, and fbcon_geometry::width.

Referenced by efifb_init(), and vesafb_init().

fbcon_fini()

void fbcon_fini

(

struct fbcon *

fbcon

)

Finalise frame buffer console.

Parameters

fbcon

Frame buffer console

Definition at line 729 of file fbcon.c.

                                        {
 
        ufree ( fbcon->text.cells );
        ufree ( fbcon->picture.start );
}

References fbcon_text::cells, fbcon::picture, fbcon_picture::start, fbcon::text, and ufree().

Referenced by efifb_fini(), efifb_init(), vesafb_fini(), and vesafb_init().

Variable Documentation

fbcon_ansiesc_handlers

struct ansiesc_handler fbcon_ansiesc_handlers[]

static

Initial value:

= {
        { 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 }
}

ANSI escape sequence handlers.

Definition at line 446 of file fbcon.c.

                                                         {
        { 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 }
};

Referenced by fbcon_init().