#include <assert.h>
#include <realmode.h>
#include <bios.h>
#include <biosint.h>
#include <ipxe/console.h>
#include <ipxe/ansiesc.h>
#include <ipxe/keys.h>
#include <ipxe/keymap.h>
#include <ipxe/init.h>
#include <config/console.h>

Data Structures
struct	bios_key
	A BIOS key. More...

Macros
#define	ATTR_BOLD 0x08

#define	ATTR_FCOL_MASK 0x07

#define	ATTR_FCOL_BLACK 0x00

#define	ATTR_FCOL_BLUE 0x01

#define	ATTR_FCOL_GREEN 0x02

#define	ATTR_FCOL_CYAN 0x03

#define	ATTR_FCOL_RED 0x04

#define	ATTR_FCOL_MAGENTA 0x05

#define	ATTR_FCOL_YELLOW 0x06

#define	ATTR_FCOL_WHITE 0x07

#define	ATTR_BLINK 0x80

#define	ATTR_BCOL_MASK 0x70

#define	ATTR_BCOL_BLACK 0x00

#define	ATTR_BCOL_BLUE 0x10

#define	ATTR_BCOL_GREEN 0x20

#define	ATTR_BCOL_CYAN 0x30

#define	ATTR_BCOL_RED 0x40

#define	ATTR_BCOL_MAGENTA 0x50

#define	ATTR_BCOL_YELLOW 0x60

#define	ATTR_BCOL_WHITE 0x70

#define	ATTR_DEFAULT ATTR_FCOL_WHITE

#define	SCANCODE_RSHIFT 0x36
	Maximum keycode subject to remapping. More...

#define	SCANCODE_NON_US 0x56
	Scancode for the "non-US \ and \|" key. More...

#define	CONSOLE_PCBIOS ( CONSOLE_USAGE_ALL & ~CONSOLE_USAGE_LOG )

#define	bios_inject_lock __use_text16 ( bios_inject_lock )

#define	int16_vector __use_text16 ( int16_vector )

#define	BIOS_KEY(scancode, key) { scancode, KEY_REL ( key ) }
	Define a BIOS key mapping. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)

static uint8_t	__text16 (bios_inject_lock)
	Keypress injection lock. More...

static struct segoff	__text16 (int16_vector)
	Vector for chaining to other INT 16 handlers. More...

void	int16_wrapper (void)
	Assembly wrapper. More...

static void	bios_handle_cup (struct ansiesc_context *ctx __unused, unsigned int count __unused, int params[])
	Handle ANSI CUP (cursor position) More...

static void	bios_handle_ed (struct ansiesc_context *ctx __unused, unsigned int count __unused, int params[] __unused)
	Handle ANSI ED (erase in page) More...

static void	bios_handle_sgr (struct ansiesc_context *ctx __unused, unsigned int count, int params[])
	Handle ANSI SGR (set graphics rendition) More...

static void	bios_handle_dectcem_set (struct ansiesc_context *ctx __unused, unsigned int count __unused, int params[] __unused)
	Handle ANSI DECTCEM set (show cursor) More...

static void	bios_handle_dectcem_reset (struct ansiesc_context *ctx __unused, unsigned int count __unused, int params[] __unused)
	Handle ANSI DECTCEM reset (hide cursor) More...

static void	bios_putchar (int character)
	Print a character to BIOS console. More...

static const char *	bios_ansi_seq (unsigned int scancode)
	Get ANSI escape sequence corresponding to BIOS scancode. More...

static int	bios_getchar (void)
	Get character from BIOS console. More...

static int	bios_iskey (void)
	Check for character ready to read from BIOS console. More...

static __asmcall __used void	bios_inject (struct i386_all_regs *ix86)
	Inject keypresses. More...

static void	bios_inject_startup (void)
	Start up keypress injection. More...

static void	bios_inject_shutdown (int booting __unused)
	Shut down keypress injection. More...

struct startup_fn bios_inject_startup_fn	__startup_fn (STARTUP_NORMAL)
	Keypress injection startup function. More...

Variables
static unsigned int	bios_attr = ATTR_DEFAULT
	Current character attribute. More...

static struct ansiesc_handler	bios_ansiesc_handlers []
	BIOS console ANSI escape sequence handlers. More...

static struct ansiesc_context	bios_ansiesc_ctx
	BIOS console ANSI escape sequence context. More...

static const char *	bios_ansi_input = ""
	Pointer to current ANSI output sequence. More...

static const struct bios_key	bios_keys []
	Mapping from BIOS scan codes to iPXE key codes. More...

struct console_driver bios_console	__console_driver
	BIOS console. More...

Macro Definition Documentation

◆ ATTR_BOLD

#define ATTR_BOLD 0x08

Definition at line 37 of file bios_console.c.

◆ ATTR_FCOL_MASK

#define ATTR_FCOL_MASK 0x07

Definition at line 39 of file bios_console.c.

◆ ATTR_FCOL_BLACK

#define ATTR_FCOL_BLACK 0x00

Definition at line 40 of file bios_console.c.

◆ ATTR_FCOL_BLUE

#define ATTR_FCOL_BLUE 0x01

Definition at line 41 of file bios_console.c.

◆ ATTR_FCOL_GREEN

#define ATTR_FCOL_GREEN 0x02

Definition at line 42 of file bios_console.c.

◆ ATTR_FCOL_CYAN

#define ATTR_FCOL_CYAN 0x03

Definition at line 43 of file bios_console.c.

◆ ATTR_FCOL_RED

#define ATTR_FCOL_RED 0x04

Definition at line 44 of file bios_console.c.

◆ ATTR_FCOL_MAGENTA

#define ATTR_FCOL_MAGENTA 0x05

Definition at line 45 of file bios_console.c.

◆ ATTR_FCOL_YELLOW

#define ATTR_FCOL_YELLOW 0x06

Definition at line 46 of file bios_console.c.

◆ ATTR_FCOL_WHITE

#define ATTR_FCOL_WHITE 0x07

Definition at line 47 of file bios_console.c.

◆ ATTR_BLINK

#define ATTR_BLINK 0x80

Definition at line 49 of file bios_console.c.

◆ ATTR_BCOL_MASK

#define ATTR_BCOL_MASK 0x70

Definition at line 51 of file bios_console.c.

◆ ATTR_BCOL_BLACK

#define ATTR_BCOL_BLACK 0x00

Definition at line 52 of file bios_console.c.

◆ ATTR_BCOL_BLUE

#define ATTR_BCOL_BLUE 0x10

Definition at line 53 of file bios_console.c.

◆ ATTR_BCOL_GREEN

#define ATTR_BCOL_GREEN 0x20

Definition at line 54 of file bios_console.c.

◆ ATTR_BCOL_CYAN

#define ATTR_BCOL_CYAN 0x30

Definition at line 55 of file bios_console.c.

◆ ATTR_BCOL_RED

#define ATTR_BCOL_RED 0x40

Definition at line 56 of file bios_console.c.

◆ ATTR_BCOL_MAGENTA

#define ATTR_BCOL_MAGENTA 0x50

Definition at line 57 of file bios_console.c.

◆ ATTR_BCOL_YELLOW

#define ATTR_BCOL_YELLOW 0x60

Definition at line 58 of file bios_console.c.

◆ ATTR_BCOL_WHITE

#define ATTR_BCOL_WHITE 0x70

Definition at line 59 of file bios_console.c.

◆ ATTR_DEFAULT

#define ATTR_DEFAULT ATTR_FCOL_WHITE

Definition at line 61 of file bios_console.c.

◆ SCANCODE_RSHIFT

#define SCANCODE_RSHIFT 0x36

Maximum keycode subject to remapping.

This allows us to avoid remapping the numeric keypad, which is necessary for keyboard layouts such as "fr" that swap the shifted and unshifted digit keys.

Definition at line 69 of file bios_console.c.

◆ SCANCODE_NON_US

#define SCANCODE_NON_US 0x56

Scancode for the "non-US \ and |" key.

This is the key that appears between Left Shift and Z on non-US keyboards.

Definition at line 76 of file bios_console.c.

◆ CONSOLE_PCBIOS

#define CONSOLE_PCBIOS ( CONSOLE_USAGE_ALL & ~CONSOLE_USAGE_LOG )

Definition at line 81 of file bios_console.c.

◆ bios_inject_lock

#define bios_inject_lock __use_text16 ( bios_inject_lock )

Definition at line 89 of file bios_console.c.

◆ int16_vector

#define int16_vector __use_text16 ( int16_vector )

Definition at line 93 of file bios_console.c.

◆ BIOS_KEY

#define BIOS_KEY	(	scancode,
		key
	)	{ scancode, KEY_REL ( key ) }

Define a BIOS key mapping.

Parameters

scancode	Scancode
key	iPXE key code
bioskey	BIOS key mapping

Definition at line 304 of file bios_console.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ __text16() [1/2]

static uint8_t __text16 ( bios_inject_lock )

static

Keypress injection lock.

◆ __text16() [2/2]

static struct segoff __text16 ( int16_vector )

static

Vector for chaining to other INT 16 handlers.

◆ int16_wrapper()

void int16_wrapper ( void )

Assembly wrapper.

Referenced by bios_inject_shutdown(), and bios_inject_startup().

◆ bios_handle_cup()

static void bios_handle_cup	(	struct ansiesc_context *ctx	__unused,
		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 106 of file bios_console.c.

                                                                           {
         int cx = ( params[1] - 1 );
         int cy = ( params[0] - 1 );
 
         if ( cx < 0 )
                 cx = 0;
         if ( cy < 0 )
                 cy = 0;
 
         __asm__ __volatile__ ( REAL_CODE ( "int $0x10\n\t" )
                                : : "a" ( 0x0200 ), "b" ( 1 ),
                                    "d" ( ( cy << 8 ) | cx ) );
 }

References __asm__(), __volatile__(), cx, and REAL_CODE.

◆ bios_handle_ed()

static void bios_handle_ed	(	struct ansiesc_context *ctx	__unused,
		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 128 of file bios_console.c.

                                                      {
         /* We assume that we always clear the whole screen */
         assert ( params[0] == ANSIESC_ED_ALL );
 
         __asm__ __volatile__ ( REAL_CODE ( "int $0x10\n\t" )
                                : : "a" ( 0x0600 ), "b" ( bios_attr << 8 ),
                                    "c" ( 0 ),
                                    "d" ( ( ( console_height - 1 ) << 8 ) |
                                          ( console_width - 1 ) ) );
 }

References __asm__(), __volatile__(), ANSIESC_ED_ALL, assert(), bios_attr, console_height, console_width, and REAL_CODE.

◆ bios_handle_sgr()

static void bios_handle_sgr	(	struct ansiesc_context *ctx	__unused,
		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 148 of file bios_console.c.

                                                                  {
         static const uint8_t bios_attr_fcols[10] = {
                 ATTR_FCOL_BLACK, ATTR_FCOL_RED, ATTR_FCOL_GREEN,
                 ATTR_FCOL_YELLOW, ATTR_FCOL_BLUE, ATTR_FCOL_MAGENTA,
                 ATTR_FCOL_CYAN, ATTR_FCOL_WHITE,
                 ATTR_FCOL_WHITE, ATTR_FCOL_WHITE /* defaults */
         };
         static const uint8_t bios_attr_bcols[10] = {
                 ATTR_BCOL_BLACK, ATTR_BCOL_RED, ATTR_BCOL_GREEN,
                 ATTR_BCOL_YELLOW, ATTR_BCOL_BLUE, ATTR_BCOL_MAGENTA,
                 ATTR_BCOL_CYAN, ATTR_BCOL_WHITE,
                 ATTR_BCOL_BLACK, ATTR_BCOL_BLACK /* defaults */
         };
         unsigned int i;
         int aspect;
 
         for ( i = 0 ; i < count ; i++ ) {
                 aspect = params[i];
                 if ( aspect == 0 ) {
                         bios_attr = ATTR_DEFAULT;
                 } else if ( aspect == 1 ) {
                         bios_attr |= ATTR_BOLD;
                 } else if ( aspect == 5 ) {
                         bios_attr |= ATTR_BLINK;
                 } else if ( aspect == 22 ) {
                         bios_attr &= ~ATTR_BOLD;
                 } else if ( aspect == 25 ) {
                         bios_attr &= ~ATTR_BLINK;
                 } else if ( ( aspect >= 30 ) && ( aspect <= 39 ) ) {
                         bios_attr &= ~ATTR_FCOL_MASK;
                         bios_attr |= bios_attr_fcols[ aspect - 30 ];
                 } else if ( ( aspect >= 40 ) && ( aspect <= 49 ) ) {
                         bios_attr &= ~ATTR_BCOL_MASK;
                         bios_attr |= bios_attr_bcols[ aspect - 40 ];
                 }
         }
 }

References ATTR_BCOL_BLACK, ATTR_BCOL_BLUE, ATTR_BCOL_CYAN, ATTR_BCOL_GREEN, ATTR_BCOL_MAGENTA, ATTR_BCOL_MASK, ATTR_BCOL_RED, ATTR_BCOL_WHITE, ATTR_BCOL_YELLOW, ATTR_BLINK, ATTR_BOLD, ATTR_DEFAULT, ATTR_FCOL_BLACK, ATTR_FCOL_BLUE, ATTR_FCOL_CYAN, ATTR_FCOL_GREEN, ATTR_FCOL_MAGENTA, ATTR_FCOL_MASK, ATTR_FCOL_RED, ATTR_FCOL_WHITE, ATTR_FCOL_YELLOW, bios_attr, and count.

◆ bios_handle_dectcem_set()

static void bios_handle_dectcem_set	(	struct ansiesc_context *ctx	__unused,
		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 194 of file bios_console.c.

                                                               {
         uint8_t height;
 
         /* Get character height */
         get_real ( height, BDA_SEG, BDA_CHAR_HEIGHT );
 
         __asm__ __volatile__ ( REAL_CODE ( "int $0x10\n\t" )
                                : : "a" ( 0x0100 ),
                                    "c" ( ( ( height - 2 ) << 8 ) |
                                          ( height - 1 ) ) );
 }

References __asm__(), __volatile__(), BDA_CHAR_HEIGHT, BDA_SEG, get_real, and REAL_CODE.

◆ bios_handle_dectcem_reset()

static void bios_handle_dectcem_reset	(	struct ansiesc_context *ctx	__unused,
		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 215 of file bios_console.c.

                                                                 {
 
         __asm__ __volatile__ ( REAL_CODE ( "int $0x10\n\t" )
                                : : "a" ( 0x0100 ), "c" ( 0x2000 ) );
 }

References __asm__(), __volatile__(), and REAL_CODE.

◆ bios_putchar()

static void bios_putchar ( int character )

static

Print a character to BIOS console.

Parameters

character Character to be printed

Definition at line 243 of file bios_console.c.

                                            {
         int discard_a, discard_b, discard_c;
 
         /* Intercept ANSI escape sequences */
         character = ansiesc_process ( &bios_ansiesc_ctx, character );
         if ( character < 0 )
                 return;
 
         /* Print character with attribute */
         __asm__ __volatile__ ( REAL_CODE ( "pushl %%ebp\n\t" /* gcc bug */
                                            /* Skip non-printable characters */
                                            "cmpb $0x20, %%al\n\t"
                                            "jb 1f\n\t"
                                            /* Read attribute */
                                            "movb %%al, %%cl\n\t"
                                            "movb $0x08, %%ah\n\t"
                                            "int $0x10\n\t"
                                            "xchgb %%al, %%cl\n\t"
                                            /* Skip if attribute matches */
                                            "cmpb %%ah, %%bl\n\t"
                                            "je 1f\n\t"
                                            /* Set attribute */
                                            "movw $0x0001, %%cx\n\t"
                                            "movb $0x09, %%ah\n\t"
                                            "int $0x10\n\t"
                                            "\n1:\n\t"
                                            /* Print character */
                                            "xorw %%bx, %%bx\n\t"
                                            "movb $0x0e, %%ah\n\t"
                                            "int $0x10\n\t"
                                            "popl %%ebp\n\t" /* gcc bug */ )
                                : "=a" ( discard_a ), "=b" ( discard_b ),
                                  "=c" ( discard_c )
                                : "a" ( character ), "b" ( bios_attr ) );
 }

References __asm__(), __volatile__(), ansiesc_process(), bios_ansiesc_ctx, bios_attr, discard_c, and REAL_CODE.

◆ bios_ansi_seq()

static const char* bios_ansi_seq ( unsigned int scancode )

static

Get ANSI escape sequence corresponding to BIOS scancode.

Parameters

scancode BIOS scancode

Return values

ansi_seq ANSI escape sequence, if any, otherwise NULL

Definition at line 333 of file bios_console.c.

                                                             {
         static char buf[ 5 /* "[" + two digits + terminator + NUL */ ];
         unsigned int rkey;
         unsigned int terminator;
         unsigned int n;
         unsigned int i;
         char *tmp = buf;
 
         /* Construct ANSI escape sequence for scancode, if known */
         for ( i = 0 ; i < ( sizeof ( bios_keys ) /
                             sizeof ( bios_keys[0] ) ) ; i++ ) {
 
                 /* Look for matching scancode */
                 if ( bios_keys[i].scancode != scancode )
                         continue;
 
                 /* Construct escape sequence */
                 rkey = bios_keys[i].rkey;
                 n = KEY_ANSI_N ( rkey );
                 terminator = KEY_ANSI_TERMINATOR ( rkey );
                 *(tmp++) = '[';
                 if ( n )
                         tmp += sprintf ( tmp, "%d", n );
                 *(tmp++) = terminator;
                 *(tmp++) = '\0';
                 assert ( tmp <= &buf[ sizeof ( buf ) ] );
                 return buf;
         }
 
         DBG ( "Unrecognised BIOS scancode %02x\n", scancode );
         return NULL;
 }

References assert(), bios_keys, DBG, KEY_ANSI_N, KEY_ANSI_TERMINATOR, NULL, bios_key::rkey, bios_key::scancode, sprintf, terminator, and tmp.

Referenced by bios_getchar().

◆ bios_getchar()

static int bios_getchar ( void )

static

Get character from BIOS console.

Return values

character Character read from console

Definition at line 371 of file bios_console.c.

                                  {
         uint16_t keypress;
         uint8_t kb0;
         uint8_t kb2;
         unsigned int scancode;
         unsigned int character;
         const char *ansi_seq;
 
         /* If we are mid-sequence, pass out the next byte */
         if ( ( character = *bios_ansi_input ) ) {
                 bios_ansi_input++;
                 return character;
         }
 
         /* Do nothing if injection is in progress */
         if ( bios_inject_lock )
                 return 0;
 
         /* Read character from real BIOS console */
         bios_inject_lock++;
         __asm__ __volatile__ ( REAL_CODE ( "sti\n\t"
                                            "int $0x16\n\t"
                                            "cli\n\t" )
                                : "=a" ( keypress )
                                : "a" ( 0x1000 ), "m" ( bios_inject_lock ) );
         bios_inject_lock--;
         scancode = ( keypress >> 8 );
         character = ( keypress & 0xff );
         get_real ( kb0, BDA_SEG, BDA_KB0 );
         get_real ( kb2, BDA_SEG, BDA_KB2 );
 
         /* If it's a normal character, map (if applicable) and return it */
         if ( character && ( character < 0x80 ) ) {
 
                 /* Handle special scancodes */
                 if ( scancode == SCANCODE_NON_US ) {
                         /* Treat as "\|" with high bit set */
                         character |= KEYMAP_PSEUDO;
                 } else if ( scancode >= SCANCODE_RSHIFT ) {
                         /* Non-remappable scancode (e.g. numeric keypad) */
                         return character;
                 }
 
                 /* Apply modifiers */
                 if ( kb0 & BDA_KB0_CTRL )
                         character |= KEYMAP_CTRL;
                 if ( kb0 & BDA_KB0_CAPSLOCK )
                         character |= KEYMAP_CAPSLOCK_REDO;
                 if ( kb2 & BDA_KB2_RALT )
                         character |= KEYMAP_ALTGR;
 
                 /* Treat LShift+RShift as AltGr since many BIOSes will
                  * not return ASCII characters when AltGr is pressed.
                  */
                 if ( ( kb0 & ( BDA_KB0_LSHIFT | BDA_KB0_RSHIFT ) ) ==
                      ( BDA_KB0_LSHIFT | BDA_KB0_RSHIFT ) ) {
                         character |= KEYMAP_ALTGR;
                 }
 
                 /* Map and return */
                 return key_remap ( character );
         }
 
         /* Otherwise, check for a special key that we know about */
         if ( ( ansi_seq = bios_ansi_seq ( keypress >> 8 ) ) ) {
                 /* Start of escape sequence: return ESC (0x1b) */
                 bios_ansi_input = ansi_seq;
                 return 0x1b;
         }
 
         return 0;
 }

References __asm__(), __volatile__(), BDA_KB0, BDA_KB0_CAPSLOCK, BDA_KB0_CTRL, BDA_KB0_LSHIFT, BDA_KB0_RSHIFT, BDA_KB2, BDA_KB2_RALT, BDA_SEG, bios_ansi_input, bios_ansi_seq(), bios_inject_lock, get_real, key_remap(), KEYMAP_ALTGR, KEYMAP_CAPSLOCK_REDO, KEYMAP_CTRL, KEYMAP_PSEUDO, REAL_CODE, bios_key::scancode, SCANCODE_NON_US, and SCANCODE_RSHIFT.

◆ bios_iskey()

static int bios_iskey ( void )

static

Check for character ready to read from BIOS console.

Return values

True	Character available to read
False	No character available to read

Definition at line 450 of file bios_console.c.

                                {
         unsigned int discard_a;
         unsigned int flags;
 
         /* If we are mid-sequence, we are always ready */
         if ( *bios_ansi_input )
                 return 1;
 
         /* Do nothing if injection is in progress */
         if ( bios_inject_lock )
                 return 0;
 
         /* Otherwise check the real BIOS console */
         bios_inject_lock++;
         __asm__ __volatile__ ( REAL_CODE ( "sti\n\t"
                                            "int $0x16\n\t"
                                            "pushfw\n\t"
                                            "popw %w0\n\t"
                                            "cli\n\t" )
                                : "=R" ( flags ), "=a" ( discard_a )
                                : "a" ( 0x1100 ), "m" ( bios_inject_lock ) );
         bios_inject_lock--;
         return ( ! ( flags & ZF ) );
 }

References __asm__(), __volatile__(), bios_ansi_input, bios_inject_lock, flags, REAL_CODE, and ZF.

◆ bios_inject()

static __asmcall __used void bios_inject ( struct i386_all_regs * ix86 )

static

Inject keypresses.

Parameters

ix86	Registers as passed to INT 16

Definition at line 488 of file bios_console.c.

                                                                         {
         unsigned int discard_a;
         unsigned int scancode;
         unsigned int rkey;
         unsigned int i;
         uint16_t keypress;
         int key;
 
         /* If this is a blocking call, then loop until the
          * non-blocking variant of the call indicates that a keypress
          * is available.  Do this without acquiring the injection
          * lock, so that injection may take place.
          */
         if ( ( ix86->regs.ah & ~0x10 ) == 0x00 ) {
                 __asm__ __volatile__ ( REAL_CODE ( "sti\n\t"
                                                    "\n1:\n\t"
                                                    "pushw %%ax\n\t"
                                                    "int $0x16\n\t"
                                                    "popw %%ax\n\t"
                                                    "jc 2f\n\t"
                                                    "jz 1b\n\t"
                                                    "\n2:\n\t"
                                                    "cli\n\t" )
                                        : "=a" ( discard_a )
                                        : "a" ( ix86->regs.eax | 0x0100 ),
                                          "m" ( bios_inject_lock ) );
         }
 
         /* Acquire injection lock */
         bios_inject_lock++;
 
         /* Check for keypresses */
         if ( iskey() ) {
 
                 /* Get key */
                 key = getkey ( 0 );
 
                 /* Reverse internal CR->LF mapping */
                 if ( key == '\n' )
                         key = '\r';
 
                 /* Convert to keypress */
                 keypress = ( ( key << 8 ) | key );
 
                 /* Handle special keys */
                 if ( key >= KEY_MIN ) {
                         rkey = KEY_REL ( key );
                         for ( i = 0 ; i < ( sizeof ( bios_keys ) /
                                             sizeof ( bios_keys[0] ) ) ; i++ ) {
                                 if ( bios_keys[i].rkey == rkey ) {
                                         scancode = bios_keys[i].scancode;
                                         keypress = ( scancode << 8 );
                                         break;
                                 }
                         }
                 }
 
                 /* Inject keypress */
                 DBGC ( &bios_console, "BIOS injecting keypress %04x\n",
                        keypress );
                 __asm__ __volatile__ ( REAL_CODE ( "int $0x16\n\t" )
                                        : "=a" ( discard_a )
                                        : "a" ( 0x0500 ), "c" ( keypress ),
                                          "m" ( bios_inject_lock ) );
         }
 
         /* Release injection lock */
         bios_inject_lock--;
 }

References __asm__(), __volatile__(), i386_regs::ah, bios_console, bios_inject_lock, bios_keys, DBGC, i386_regs::eax, getkey(), iskey(), key, KEY_MIN, KEY_REL, REAL_CODE, i386_all_regs::regs, and bios_key::scancode.

Referenced by bios_inject_startup().

◆ bios_inject_startup()

static void bios_inject_startup ( void )

static

Start up keypress injection.

Definition at line 562 of file bios_console.c.

                                          {
 
         /* Assembly wrapper to call bios_inject() */
         __asm__ __volatile__ (
                 TEXT16_CODE ( "\nint16_wrapper:\n\t"
                               "pushfw\n\t"
                               "cmpb $0, %%cs:bios_inject_lock\n\t"
                               "jnz 1f\n\t"
                               VIRT_CALL ( bios_inject )
                               "\n1:\n\t"
                               "popfw\n\t"
                               "ljmp *%%cs:int16_vector\n\t" ) : );
 
         /* Hook INT 16 */
         hook_bios_interrupt ( 0x16, ( ( intptr_t ) int16_wrapper ),
                               &int16_vector );
 }

References __asm__(), __volatile__(), bios_inject(), hook_bios_interrupt(), int16_vector, int16_wrapper(), TEXT16_CODE, and VIRT_CALL.

◆ bios_inject_shutdown()

static void bios_inject_shutdown ( int booting __unused )

static

Shut down keypress injection.

Parameters

booting System is shutting down for OS boot

Definition at line 585 of file bios_console.c.

                                                           {
 
         /* Unhook INT 16 */
         unhook_bios_interrupt ( 0x16, ( ( intptr_t ) int16_wrapper ),
                                 &int16_vector );
 }

References int16_vector, int16_wrapper(), and unhook_bios_interrupt().

◆ __startup_fn()

struct startup_fn bios_inject_startup_fn __startup_fn ( STARTUP_NORMAL )

Keypress injection startup function.

Variable Documentation

◆ bios_attr

unsigned int bios_attr = ATTR_DEFAULT

static

Current character attribute.

Definition at line 85 of file bios_console.c.

Referenced by bios_handle_ed(), bios_handle_sgr(), and bios_putchar().

◆ bios_ansiesc_handlers

struct ansiesc_handler bios_ansiesc_handlers[]

static

Initial value:

= {
        { ANSIESC_CUP, bios_handle_cup },
        { ANSIESC_ED, bios_handle_ed },
        { ANSIESC_SGR, bios_handle_sgr },
        { ANSIESC_DECTCEM_SET, bios_handle_dectcem_set },
        { ANSIESC_DECTCEM_RESET, bios_handle_dectcem_reset },
        { 0, NULL }
}

BIOS console ANSI escape sequence handlers.

Definition at line 224 of file bios_console.c.

◆ bios_ansiesc_ctx

struct ansiesc_context bios_ansiesc_ctx

static

Initial value:

= {
        .handlers = bios_ansiesc_handlers,
}

BIOS console ANSI escape sequence context.

Definition at line 234 of file bios_console.c.

Referenced by bios_putchar().

◆ bios_ansi_input

const char* bios_ansi_input = ""

static

Pointer to current ANSI output sequence.

While we are in the middle of returning an ANSI sequence for a special key, this will point to the next character to return. When not in the middle of such a sequence, this will point to a NUL (note: not "will be NULL").

Definition at line 287 of file bios_console.c.

Referenced by bios_getchar(), and bios_iskey().

◆ bios_keys

const struct bios_key bios_keys[]

static

Initial value:

= {
        BIOS_KEY ( 0x53, KEY_DC ),
        BIOS_KEY ( 0x48, KEY_UP ),
        BIOS_KEY ( 0x50, KEY_DOWN ),
        BIOS_KEY ( 0x4b, KEY_LEFT ),
        BIOS_KEY ( 0x4d, KEY_RIGHT ),
        BIOS_KEY ( 0x47, KEY_HOME ),
        BIOS_KEY ( 0x4f, KEY_END ),
        BIOS_KEY ( 0x49, KEY_PPAGE ),
        BIOS_KEY ( 0x51, KEY_NPAGE ),
        BIOS_KEY ( 0x3f, KEY_F5 ),
        BIOS_KEY ( 0x40, KEY_F6 ),
        BIOS_KEY ( 0x41, KEY_F7 ),
        BIOS_KEY ( 0x42, KEY_F8 ),
        BIOS_KEY ( 0x43, KEY_F9 ),
        BIOS_KEY ( 0x44, KEY_F10 ),
        BIOS_KEY ( 0x85, KEY_F11 ),
        BIOS_KEY ( 0x86, KEY_F12 ),
}

Mapping from BIOS scan codes to iPXE key codes.

Definition at line 307 of file bios_console.c.

Referenced by bios_ansi_seq(), and bios_inject().

◆ __console_driver

struct console_driver bios_console __console_driver

Initial value:

= {
        .putchar = bios_putchar,
        .getchar = bios_getchar,
        .iskey = bios_iskey,
        .usage = CONSOLE_PCBIOS,
}

BIOS console.

Definition at line 476 of file bios_console.c.

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ ATTR_BOLD

◆ ATTR_FCOL_MASK

◆ ATTR_FCOL_BLACK

◆ ATTR_FCOL_BLUE

◆ ATTR_FCOL_GREEN

◆ ATTR_FCOL_CYAN

◆ ATTR_FCOL_RED

◆ ATTR_FCOL_MAGENTA

◆ ATTR_FCOL_YELLOW

◆ ATTR_FCOL_WHITE

◆ ATTR_BLINK

◆ ATTR_BCOL_MASK

◆ ATTR_BCOL_BLACK

◆ ATTR_BCOL_BLUE

◆ ATTR_BCOL_GREEN

◆ ATTR_BCOL_CYAN

◆ ATTR_BCOL_RED

◆ ATTR_BCOL_MAGENTA

◆ ATTR_BCOL_YELLOW

◆ ATTR_BCOL_WHITE

◆ ATTR_DEFAULT

◆ SCANCODE_RSHIFT

◆ SCANCODE_NON_US

◆ CONSOLE_PCBIOS

◆ bios_inject_lock

◆ int16_vector

◆ BIOS_KEY

Function Documentation

◆ FILE_LICENCE()

◆ __text16() [1/2]

◆ __text16() [2/2]

◆ int16_wrapper()

◆ bios_handle_cup()

◆ bios_handle_ed()

◆ bios_handle_sgr()

◆ bios_handle_dectcem_set()

◆ bios_handle_dectcem_reset()

◆ bios_putchar()

◆ bios_ansi_seq()

◆ bios_getchar()

◆ bios_iskey()

◆ bios_inject()

◆ bios_inject_startup()

◆ bios_inject_shutdown()

◆ __startup_fn()

Variable Documentation

◆ bios_attr

◆ bios_ansiesc_handlers

◆ bios_ansiesc_ctx

◆ bios_ansi_input

◆ bios_keys

◆ __console_driver