vesafb.c File Reference

VESA frame buffer console. More...

#include <stdlib.h>
#include <errno.h>
#include <limits.h>
#include <realmode.h>
#include <ipxe/console.h>
#include <ipxe/io.h>
#include <ipxe/ansicol.h>
#include <ipxe/fbcon.h>
#include <ipxe/vesafb.h>
#include <config/console.h>

Go to the source code of this file.

Data Structures
struct	vesafb
	A VESA frame buffer. More...
union	vbe_buffer
	Base memory buffer used for VBE calls. More...

Macros
#define	EIO_FAILED   __einfo_error ( EINFO_EIO_FAILED )
#define	EINFO_EIO_FAILED
#define	EIO_HARDWARE   __einfo_error ( EINFO_EIO_HARDWARE )
#define	EINFO_EIO_HARDWARE
#define	EIO_MODE   __einfo_error ( EINFO_EIO_MODE )
#define	EINFO_EIO_MODE
#define	EIO_VBE(code)   EUNIQ ( EINFO_EIO, (code), EIO_FAILED, EIO_HARDWARE, EIO_MODE )
#define	CONSOLE_VESAFB   ( CONSOLE_USAGE_ALL & ~CONSOLE_USAGE_LOG )
#define	VESAFB_CHAR_HEIGHT   16
	Character height. More...
#define	VESAFB_FONT   VBE_FONT_8x16
	Font corresponding to selected character width and height. More...
#define	VESAFB_ASCII   128
	Number of ASCII glyphs within the font. More...
#define	VESAFB_UNKNOWN   0xfe
	Glyph to render for non-ASCII characters. More...
#define	vbe_buf   __use_data16 ( vbe_buf )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static union vbe_buffer	__bss16 (vbe_buf)
static int	vesafb_rc (unsigned int status)
	Convert VBE status code to iPXE status code. More...
static void	vesafb_glyph (unsigned int character, uint8_t *glyph)
	Get character glyph. More...
static void	vesafb_font (void)
	Get font definition. More...
static int	vesafb_mode_list (uint16_t **mode_numbers)
	Get VBE mode list. More...
static int	vesafb_mode_info (unsigned int mode_number)
	Get video mode information. More...
static int	vesafb_set_mode (unsigned int mode_number)
	Set video mode. More...
static int	vesafb_select_mode (const uint16_t *mode_numbers, unsigned int min_width, unsigned int min_height, unsigned int min_bpp)
	Select video mode. More...
static void	vesafb_restore (void)
	Restore video mode. More...
static int	vesafb_init (struct console_configuration *config)
	Initialise VESA frame buffer. More...
static void	vesafb_fini (void)
	Finalise VESA frame buffer. More...
static void	vesafb_putchar (int character)
	Print a character to current cursor position. More...
static int	vesafb_configure (struct console_configuration *config)
	Configure console. More...

Variables
struct console_driver	bios_console
struct console_driver vesafb_console	__console_driver
	VESA frame buffer console driver. More...
struct vesafb	__attribute__
static struct vesafb	vesafb
	The VESA frame buffer. More...

Detailed Description

VESA frame buffer console.

Definition in file vesafb.c.

Macro Definition Documentation

EIO_FAILED

#define EIO_FAILED   __einfo_error ( EINFO_EIO_FAILED )

Definition at line 48 of file vesafb.c.

EINFO_EIO_FAILED

#define EINFO_EIO_FAILED

Value:

__einfo_uniqify ( EINFO_EIO, 0x01,                              \
                          "Function call failed" )

Definition at line 49 of file vesafb.c.

EIO_HARDWARE

#define EIO_HARDWARE   __einfo_error ( EINFO_EIO_HARDWARE )

Definition at line 52 of file vesafb.c.

EINFO_EIO_HARDWARE

#define EINFO_EIO_HARDWARE

Value:

__einfo_uniqify ( EINFO_EIO, 0x02,                              \
                          "Not supported in current configuration" )

Definition at line 53 of file vesafb.c.

EIO_MODE

#define EIO_MODE   __einfo_error ( EINFO_EIO_MODE )

Definition at line 56 of file vesafb.c.

EINFO_EIO_MODE

#define EINFO_EIO_MODE

Value:

__einfo_uniqify ( EINFO_EIO, 0x03,                              \
                          "Invalid in current video mode" )

Definition at line 57 of file vesafb.c.

EIO_VBE

#define EIO_VBE

(

code

)

EUNIQ ( EINFO_EIO, (code), EIO_FAILED, EIO_HARDWARE, EIO_MODE )

Definition at line 60 of file vesafb.c.

CONSOLE_VESAFB

#define CONSOLE_VESAFB   ( CONSOLE_USAGE_ALL & ~CONSOLE_USAGE_LOG )

Definition at line 72 of file vesafb.c.

VESAFB_CHAR_HEIGHT

#define VESAFB_CHAR_HEIGHT   16

Character height.

Definition at line 76 of file vesafb.c.

VESAFB_FONT

#define VESAFB_FONT   VBE_FONT_8x16

Font corresponding to selected character width and height.

Definition at line 79 of file vesafb.c.

VESAFB_ASCII

#define VESAFB_ASCII   128

Number of ASCII glyphs within the font.

Definition at line 82 of file vesafb.c.

VESAFB_UNKNOWN

#define VESAFB_UNKNOWN   0xfe

Glyph to render for non-ASCII characters.

We choose to use one of the box-drawing glyphs.

Definition at line 88 of file vesafb.c.

vbe_buf

#define vbe_buf   __use_data16 ( vbe_buf )

Definition at line 122 of file vesafb.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

__bss16()

static union vbe_buffer __bss16 ( vbe_buf  )

static

vesafb_rc()

static int vesafb_rc ( unsigned int  status )

static

Convert VBE status code to iPXE status code.

Parameters

status

VBE status code

Return values

rc	Return status code

Definition at line 130 of file vesafb.c.

                                             {
        unsigned int code;

        if ( ( status & 0xff ) != 0x4f )
                return -ENOTSUP;
        code = ( ( status >> 8 ) & 0xff );
        return ( code ? -EIO_VBE ( code ) : 0 );
}

References code, EIO_VBE, ENOTSUP, and status.

Referenced by vesafb_mode_info(), vesafb_mode_list(), and vesafb_set_mode().

vesafb_glyph()

static void vesafb_glyph ( unsigned int  character, uint8_t *  glyph  )

static

Get character glyph.

Parameters

character	Unicode character
glyph	Character glyph to fill in

Definition at line 145 of file vesafb.c.

                                                                    {
        unsigned int index;
        size_t offset;

        /* Identify glyph */
        if ( character < VESAFB_ASCII ) {
                /* ASCII character: use corresponding glyph */
                index = character;
        } else {
                /* Non-ASCII character: use "unknown" glyph */
                index = VESAFB_UNKNOWN;
        }

        /* Copy glyph from BIOS font table */
        offset = ( index * VESAFB_CHAR_HEIGHT );
        copy_from_real ( glyph, vesafb.glyphs.segment,
                         ( vesafb.glyphs.offset + offset ), VESAFB_CHAR_HEIGHT);
}

References copy_from_real, vesafb::glyphs, index, offset, segoff::offset, segoff::segment, VESAFB_ASCII, VESAFB_CHAR_HEIGHT, and VESAFB_UNKNOWN.

Referenced by vesafb_font().

vesafb_font()

static void vesafb_font ( void  )

static

Get font definition.

Definition at line 168 of file vesafb.c.

                                 {

        /* Get font information
         *
         * Working around gcc bugs is icky here.  The value we want is
         * returned in %ebp, but there's no way to specify %ebp in an
         * output constraint.  We can't put %ebp in the clobber list,
         * because this tends to cause random build failures on some
         * gcc versions.  We can't manually push/pop %ebp and return
         * the value via a generic register output constraint, because
         * gcc might choose to use %ebp to satisfy that constraint
         * (and we have no way to prevent it from so doing).
         *
         * Work around this hideous mess by using %ecx and %edx as the
         * output registers, since they get clobbered anyway.
         */
        __asm__ __volatile__ ( REAL_CODE ( "pushw %%bp\n\t" /* gcc bug */
                                           "int $0x10\n\t"
                                           "movw %%es, %%cx\n\t"
                                           "movw %%bp, %%dx\n\t"
                                           "popw %%bp\n\t" /* gcc bug */ )
                               : "=c" ( vesafb.glyphs.segment ),
                                 "=d" ( vesafb.glyphs.offset )
                               : "a" ( VBE_GET_FONT ),
                                 "b" ( VESAFB_FONT ) );
        DBGC ( &vbe_buf, "VESAFB has font %04x at %04x:%04x\n",
               VESAFB_FONT, vesafb.glyphs.segment, vesafb.glyphs.offset );
        vesafb.font.height = VESAFB_CHAR_HEIGHT;
        vesafb.font.glyph = vesafb_glyph;
}

References __asm__(), __volatile__(), DBGC, vesafb::font, fbcon_font::glyph, vesafb::glyphs, fbcon_font::height, segoff::offset, REAL_CODE, segoff::segment, vbe_buf, VBE_GET_FONT, VESAFB_CHAR_HEIGHT, VESAFB_FONT, and vesafb_glyph().

Referenced by vesafb_init().

vesafb_mode_list()

static int vesafb_mode_list ( uint16_t **  mode_numbers )

static

Get VBE mode list.

Return values

mode_numbers	Mode number list (terminated with VBE_MODE_END)
rc	Return status code

The caller is responsible for eventually freeing the mode list.

Definition at line 207 of file vesafb.c.

                                                        {
        struct vbe_controller_info *controller = &vbe_buf.controller;
        userptr_t video_mode_ptr;
        uint16_t mode_number;
        uint16_t status;
        size_t len;
        int rc;

        /* Avoid returning uninitialised data on error */
        *mode_numbers = NULL;

        /* Get controller information block */
        controller->vbe_signature = 0;
        __asm__ __volatile__ ( REAL_CODE ( "int $0x10" )
                               : "=a" ( status )
                               : "a" ( VBE_CONTROLLER_INFO ),
                                 "D" ( __from_data16 ( controller ) )
                               : "memory", "ebx", "edx" );
        if ( ( rc = vesafb_rc ( status ) ) != 0 ) {
                DBGC ( &vbe_buf, "VESAFB could not get controller information: "
                       "[%04x] %s\n", status, strerror ( rc ) );
                return rc;
        }
        if ( controller->vbe_signature != VBE_CONTROLLER_SIGNATURE ) {
                DBGC ( &vbe_buf, "VESAFB invalid controller signature "
                       "\"%c%c%c%c\"\n", ( controller->vbe_signature >> 0 ),
                       ( controller->vbe_signature >> 8 ),
                       ( controller->vbe_signature >> 16 ),
                       ( controller->vbe_signature >> 24 ) );
                DBGC_HDA ( &vbe_buf, 0, controller, sizeof ( *controller ) );
                return -EINVAL;
        }
        DBGC ( &vbe_buf, "VESAFB found VBE version %d.%d with mode list at "
               "%04x:%04x\n", controller->vbe_major_version,
               controller->vbe_minor_version,
               controller->video_mode_ptr.segment,
               controller->video_mode_ptr.offset );

        /* Calculate length of mode list */
        video_mode_ptr = real_to_user ( controller->video_mode_ptr.segment,
                                        controller->video_mode_ptr.offset );
        len = 0;
        do {
                copy_from_user ( &mode_number, video_mode_ptr, len,
                                 sizeof ( mode_number ) );
                len += sizeof ( mode_number );
        } while ( mode_number != VBE_MODE_END );

        /* Allocate and fill mode list */
        *mode_numbers = malloc ( len );
        if ( ! *mode_numbers )
                return -ENOMEM;
        copy_from_user ( *mode_numbers, video_mode_ptr, 0, len );

        return 0;
}

References __asm__(), __from_data16, __volatile__(), controller, copy_from_user(), DBGC, DBGC_HDA, EINVAL, ENOMEM, len, malloc(), NULL, rc, REAL_CODE, real_to_user(), status, strerror(), vbe_buf, VBE_CONTROLLER_INFO, VBE_CONTROLLER_SIGNATURE, VBE_MODE_END, vesafb_rc(), and video_mode_ptr.

Referenced by vesafb_init().

vesafb_mode_info()

static int vesafb_mode_info ( unsigned int  mode_number )

static

Get video mode information.

Parameters

mode_number

Mode number

Return values

rc	Return status code

Definition at line 270 of file vesafb.c.

                                                         {
        struct vbe_mode_info *mode = &vbe_buf.mode;
        uint16_t status;
        int rc;

        /* Get mode information */
        __asm__ __volatile__ ( REAL_CODE ( "int $0x10" )
                               : "=a" ( status )
                               : "a" ( VBE_MODE_INFO ),
                                 "c" ( mode_number ),
                                 "D" ( __from_data16 ( mode ) )
                               : "memory" );
        if ( ( rc = vesafb_rc ( status ) ) != 0 ) {
                DBGC ( &vbe_buf, "VESAFB could not get mode %04x information: "
                       "[%04x] %s\n", mode_number, status, strerror ( rc ) );
                return rc;
        }
        DBGC ( &vbe_buf, "VESAFB mode %04x %dx%d %dbpp(%d:%d:%d:%d) model "
               "%02x [x%d]%s%s%s%s%s\n", mode_number, mode->x_resolution,
               mode->y_resolution, mode->bits_per_pixel, mode->rsvd_mask_size,
               mode->red_mask_size, mode->green_mask_size, mode->blue_mask_size,
               mode->memory_model, ( mode->number_of_image_pages + 1 ),
               ( ( mode->mode_attributes & VBE_MODE_ATTR_SUPPORTED ) ?
                 "" : " [unsupported]" ),
               ( ( mode->mode_attributes & VBE_MODE_ATTR_TTY ) ?
                 " [tty]" : "" ),
               ( ( mode->mode_attributes & VBE_MODE_ATTR_GRAPHICS ) ?
                 "" : " [text]" ),
               ( ( mode->mode_attributes & VBE_MODE_ATTR_LINEAR ) ?
                 "" : " [nonlinear]" ),
               ( ( mode->mode_attributes & VBE_MODE_ATTR_TRIPLE_BUF ) ?
                 " [buf]" : "" ) );

        return 0;
}

References __asm__(), __from_data16, __volatile__(), vbe_mode_info::bits_per_pixel, vbe_mode_info::blue_mask_size, DBGC, vbe_mode_info::green_mask_size, vbe_mode_info::memory_model, vbe_mode_info::mode_attributes, vbe_mode_info::number_of_image_pages, rc, REAL_CODE, vbe_mode_info::red_mask_size, vbe_mode_info::rsvd_mask_size, status, strerror(), vbe_buf, VBE_MODE_ATTR_GRAPHICS, VBE_MODE_ATTR_LINEAR, VBE_MODE_ATTR_SUPPORTED, VBE_MODE_ATTR_TRIPLE_BUF, VBE_MODE_ATTR_TTY, VBE_MODE_INFO, vesafb_rc(), vbe_mode_info::x_resolution, and vbe_mode_info::y_resolution.

Referenced by vesafb_select_mode(), and vesafb_set_mode().

vesafb_set_mode()

static int vesafb_set_mode ( unsigned int  mode_number )

static

Set video mode.

Parameters

mode_number

Mode number

Return values

rc	Return status code

Definition at line 312 of file vesafb.c.

                                                        {
        struct vbe_mode_info *mode = &vbe_buf.mode;
        uint16_t status;
        int rc;

        /* Get mode information */
        if ( ( rc = vesafb_mode_info ( mode_number ) ) != 0 )
                return rc;

        /* Record mode parameters */
        vesafb.start = mode->phys_base_ptr;
        vesafb.pixel.width = mode->x_resolution;
        vesafb.pixel.height = mode->y_resolution;
        vesafb.pixel.len = ( ( mode->bits_per_pixel + 7 ) / 8 );
        vesafb.pixel.stride = mode->bytes_per_scan_line;
        DBGC ( &vbe_buf, "VESAFB mode %04x has frame buffer at %08x\n",
               mode_number, mode->phys_base_ptr );

        /* Initialise font colours */
        vesafb.map.red_scale = ( 8 - mode->red_mask_size );
        vesafb.map.green_scale = ( 8 - mode->green_mask_size );
        vesafb.map.blue_scale = ( 8 - mode->blue_mask_size );
        vesafb.map.red_lsb = mode->red_field_position;
        vesafb.map.green_lsb = mode->green_field_position;
        vesafb.map.blue_lsb = mode->blue_field_position;

        /* Select this mode */
        __asm__ __volatile__ ( REAL_CODE ( "int $0x10" )
                               : "=a" ( status )
                               : "a" ( VBE_SET_MODE ),
                                 "b" ( mode_number ) );
        if ( ( rc = vesafb_rc ( status ) ) != 0 ) {
                DBGC ( &vbe_buf, "VESAFB could not set mode %04x: [%04x] %s\n",
                       mode_number, status, strerror ( rc ) );
                return rc;
        }

        return 0;
}

References __asm__(), __volatile__(), vbe_mode_info::bits_per_pixel, vbe_mode_info::blue_field_position, fbcon_colour_map::blue_lsb, vbe_mode_info::blue_mask_size, fbcon_colour_map::blue_scale, vbe_mode_info::bytes_per_scan_line, DBGC, vbe_mode_info::green_field_position, fbcon_colour_map::green_lsb, vbe_mode_info::green_mask_size, fbcon_colour_map::green_scale, fbcon_geometry::height, fbcon_geometry::len, vesafb::map, vbe_mode_info::phys_base_ptr, vesafb::pixel, rc, REAL_CODE, vbe_mode_info::red_field_position, fbcon_colour_map::red_lsb, vbe_mode_info::red_mask_size, fbcon_colour_map::red_scale, vesafb::start, status, strerror(), fbcon_geometry::stride, vbe_buf, VBE_SET_MODE, vesafb_mode_info(), vesafb_rc(), fbcon_geometry::width, vbe_mode_info::x_resolution, and vbe_mode_info::y_resolution.

Referenced by vesafb_init().

vesafb_select_mode()

static int vesafb_select_mode ( const uint16_t *  mode_numbers, unsigned int  min_width, unsigned int  min_height, unsigned int  min_bpp  )

static

Select video mode.

Parameters

mode_numbers	Mode number list (terminated with VBE_MODE_END)
min_width	Minimum required width (in pixels)
min_height	Minimum required height (in pixels)
min_bpp	Minimum required colour depth (in bits per pixel)

Return values

mode_number

Mode number, or negative error

Definition at line 361 of file vesafb.c.

                                                       {
        struct vbe_mode_info *mode = &vbe_buf.mode;
        int best_mode_number = -ENOENT;
        unsigned int best_score = INT_MAX;
        unsigned int score;
        uint16_t mode_number;
        int rc;

        /* Find the first suitable mode */
        while ( ( mode_number = *(mode_numbers++) ) != VBE_MODE_END ) {

                /* Force linear mode variant */
                mode_number |= VBE_MODE_LINEAR;

                /* Get mode information */
                if ( ( rc = vesafb_mode_info ( mode_number ) ) != 0 )
                        continue;

                /* Skip unusable modes */
                if ( ( mode->mode_attributes & ( VBE_MODE_ATTR_SUPPORTED |
                                                 VBE_MODE_ATTR_GRAPHICS |
                                                 VBE_MODE_ATTR_LINEAR ) ) !=
                     ( VBE_MODE_ATTR_SUPPORTED | VBE_MODE_ATTR_GRAPHICS |
                       VBE_MODE_ATTR_LINEAR ) ) {
                        continue;
                }
                if ( mode->memory_model != VBE_MODE_MODEL_DIRECT_COLOUR )
                        continue;

                /* Skip modes not meeting the requirements */
                if ( ( mode->x_resolution < min_width ) ||
                     ( mode->y_resolution < min_height ) ||
                     ( mode->bits_per_pixel < min_bpp ) ) {
                        continue;
                }

                /* Select this mode if it has the best (i.e. lowest)
                 * score.  We choose the scoring system to favour
                 * modes close to the specified width and height;
                 * within modes of the same width and height we prefer
                 * a higher colour depth.
                 */
                score = ( ( mode->x_resolution * mode->y_resolution ) -
                          mode->bits_per_pixel );
                if ( score < best_score ) {
                        best_mode_number = mode_number;
                        best_score = score;
                }
        }

        if ( best_mode_number >= 0 ) {
                DBGC ( &vbe_buf, "VESAFB selected mode %04x\n",
                       best_mode_number );
        } else {
                DBGC ( &vbe_buf, "VESAFB found no suitable mode\n" );
        }

        return best_mode_number;
}

References vbe_mode_info::bits_per_pixel, DBGC, ENOENT, INT_MAX, vbe_mode_info::memory_model, vbe_mode_info::mode_attributes, rc, vbe_buf, VBE_MODE_ATTR_GRAPHICS, VBE_MODE_ATTR_LINEAR, VBE_MODE_ATTR_SUPPORTED, VBE_MODE_END, VBE_MODE_LINEAR, VBE_MODE_MODEL_DIRECT_COLOUR, vesafb_mode_info(), vbe_mode_info::x_resolution, and vbe_mode_info::y_resolution.

Referenced by vesafb_init().

vesafb_restore()

static void vesafb_restore ( void  )

static

Restore video mode.

Definition at line 427 of file vesafb.c.

                                    {
        uint32_t discard_a;

        /* Restore saved VGA mode */
        __asm__ __volatile__ ( REAL_CODE ( "int $0x10" )
                               : "=a" ( discard_a )
                               : "a" ( VBE_SET_VGA_MODE | vesafb.saved_mode ) );
        DBGC ( &vbe_buf, "VESAFB restored VGA mode %#02x\n",
               vesafb.saved_mode );
}

References __asm__(), __volatile__(), DBGC, REAL_CODE, vesafb::saved_mode, vbe_buf, and VBE_SET_VGA_MODE.

Referenced by vesafb_fini(), and vesafb_init().

vesafb_init()

static int vesafb_init ( struct console_configuration *  config )

static

Initialise VESA frame buffer.

Parameters

config

Console configuration, or NULL to reset

Return values

rc	Return status code

Definition at line 444 of file vesafb.c.

                                                                {
        uint32_t discard_b;
        uint16_t *mode_numbers;
        int mode_number;
        int rc;

        /* Record current VGA mode */
        __asm__ __volatile__ ( REAL_CODE ( "int $0x10" )
                               : "=a" ( vesafb.saved_mode ), "=b" ( discard_b )
                               : "a" ( VBE_GET_VGA_MODE ) );
        DBGC ( &vbe_buf, "VESAFB saved VGA mode %#02x\n", vesafb.saved_mode );

        /* Get VESA mode list */
        if ( ( rc = vesafb_mode_list ( &mode_numbers ) ) != 0 )
                goto err_mode_list;

        /* Select mode */
        if ( ( mode_number = vesafb_select_mode ( mode_numbers, config->width,
                                                  config->height,
                                                  config->depth ) ) < 0 ) {
                rc = mode_number;
                goto err_select_mode;
        }

        /* Set mode */
        if ( ( rc = vesafb_set_mode ( mode_number ) ) != 0 )
                goto err_set_mode;

        /* Get font data */
        vesafb_font();

        /* Initialise frame buffer console */
        if ( ( rc = fbcon_init ( &vesafb.fbcon, phys_to_user ( vesafb.start ),
                                 &vesafb.pixel, &vesafb.map, &vesafb.font,
                                 config ) ) != 0 )
                goto err_fbcon_init;

        free ( mode_numbers );
        return 0;

        fbcon_fini ( &vesafb.fbcon );
 err_fbcon_init:
 err_set_mode:
        vesafb_restore();
 err_select_mode:
        free ( mode_numbers );
 err_mode_list:
        return rc;
}

References __asm__(), __volatile__(), DBGC, console_configuration::depth, vesafb::fbcon, fbcon_fini(), fbcon_init(), vesafb::font, free, console_configuration::height, vesafb::map, phys_to_user(), vesafb::pixel, rc, REAL_CODE, vesafb::saved_mode, vesafb::start, vbe_buf, VBE_GET_VGA_MODE, vesafb_font(), vesafb_mode_list(), vesafb_restore(), vesafb_select_mode(), vesafb_set_mode(), and console_configuration::width.

Referenced by vesafb_configure().

vesafb_fini()

static void vesafb_fini ( void  )

static

Finalise VESA frame buffer.

Definition at line 498 of file vesafb.c.

                                 {

        /* Finalise frame buffer console */
        fbcon_fini ( &vesafb.fbcon );

        /* Restore saved VGA mode */
        vesafb_restore();
}

References vesafb::fbcon, fbcon_fini(), and vesafb_restore().

Referenced by vesafb_configure().

vesafb_putchar()

static void vesafb_putchar ( int  character )

static

Print a character to current cursor position.

Parameters

character

Character

Definition at line 512 of file vesafb.c.

                                             {

        fbcon_putchar ( &vesafb.fbcon, character );
}

References vesafb::fbcon, and fbcon_putchar().

vesafb_configure()

static int vesafb_configure ( struct console_configuration *  config )

static

Configure console.

Parameters

config

Console configuration, or NULL to reset

Return values

rc	Return status code

Definition at line 523 of file vesafb.c.

                                                                     {
        int rc;

        /* Reset console, if applicable */
        if ( ! vesafb_console.disabled ) {
                vesafb_fini();
                bios_console.disabled &= ~CONSOLE_DISABLED_OUTPUT;
                ansicol_reset_magic();
        }
        vesafb_console.disabled = CONSOLE_DISABLED;

        /* Do nothing more unless we have a usable configuration */
        if ( ( config == NULL ) ||
             ( config->width == 0 ) || ( config->height == 0 ) ) {
                return 0;
        }

        /* Initialise VESA frame buffer */
        if ( ( rc = vesafb_init ( config ) ) != 0 )
                return rc;

        /* Mark console as enabled */
        vesafb_console.disabled = 0;
        bios_console.disabled |= CONSOLE_DISABLED_OUTPUT;

        /* Set magic colour to transparent if we have a background picture */
        if ( config->pixbuf )
                ansicol_set_magic_transparent();

        return 0;
}

References ansicol_reset_magic(), ansicol_set_magic_transparent(), bios_console, CONSOLE_DISABLED, CONSOLE_DISABLED_OUTPUT, console_driver::disabled, console_configuration::height, NULL, console_configuration::pixbuf, rc, vesafb_fini(), vesafb_init(), and console_configuration::width.

Variable Documentation

bios_console

struct console_driver bios_console

Definition at line 45 of file vesafb.c.

Referenced by bios_inject(), and vesafb_configure().

__console_driver

struct console_driver vesafb_console __console_driver

Initial value:

= {
        .usage = CONSOLE_VESAFB,
        .putchar = vesafb_putchar,
        .configure = vesafb_configure,
        .disabled = CONSOLE_DISABLED,
}

VESA frame buffer console driver.

Definition at line 91 of file vesafb.c.

__attribute__

struct vesafb __attribute__

vesafb

struct vesafb vesafb

static

The VESA frame buffer.

Definition at line 112 of file vesafb.c.