/* * Copyright (C) 2006 Michael Brown . * * 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ FILE_LICENCE ( GPL2_OR_LATER ); #include #include #include #include #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_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 /** Current character attribute */ static unsigned int bios_attr = ATTR_DEFAULT; /** * Handle ANSI CUP (cursor position) * * @v count Parameter count * @v params[0] Row (1 is top) * @v params[1] Column (1 is left) */ static void bios_handle_cup ( unsigned int count __unused, int params[] ) { int cx = ( params[1] - 1 ); int cy = ( params[0] - 1 ); if ( cx < 0 ) cx = 0; if ( cy < 0 ) cy = 0; __asm__ __volatile__ ( REAL_CODE ( "sti\n\t" "int $0x10\n\t" "cli\n\t" ) : : "a" ( 0x0200 ), "b" ( 1 ), "d" ( ( cy << 8 ) | cx ) ); } /** * Handle ANSI ED (erase in page) * * @v count Parameter count * @v params[0] Region to erase */ static void bios_handle_ed ( unsigned int count __unused, int params[] __unused ) { /* We assume that we always clear the whole screen */ assert ( params[0] == ANSIESC_ED_ALL ); __asm__ __volatile__ ( REAL_CODE ( "sti\n\t" "int $0x10\n\t" "cli\n\t" ) : : "a" ( 0x0600 ), "b" ( bios_attr << 8 ), "c" ( 0 ), "d" ( 0xffff ) ); } /** * Handle ANSI SGR (set graphics rendition) * * @v count Parameter count * @v params List of graphic rendition aspects */ static void bios_handle_sgr ( unsigned int count, int params[] ) { 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 == 22 ) { bios_attr &= ~ATTR_BOLD; } 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 ]; } } } /** BIOS console ANSI escape sequence handlers */ static struct ansiesc_handler bios_ansiesc_handlers[] = { { ANSIESC_CUP, bios_handle_cup }, { ANSIESC_ED, bios_handle_ed }, { ANSIESC_SGR, bios_handle_sgr }, { 0, NULL } }; /** BIOS console ANSI escape sequence context */ static struct ansiesc_context bios_ansiesc_ctx = { .handlers = bios_ansiesc_handlers, }; /** * Print a character to BIOS console * * @v character Character to be printed */ static void bios_putchar ( int character ) { 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 ( "sti\n\t" /* Skip non-printable characters */ "cmpb $0x20, %%al\n\t" "jb 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" "cli\n\t" ) : "=a" ( discard_a ), "=b" ( discard_b ), "=c" ( discard_c ) : "a" ( character ), "b" ( bios_attr ) : "ebp" ); } /** * 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"). */ static const char *ansi_input = ""; /** * Lowest BIOS scancode of interest * * Most of the BIOS key scancodes that we are interested in are in a * dense range, so subtracting a constant and treating them as offsets * into an array works efficiently. */ #define BIOS_KEY_MIN 0x42 /** Offset into list of interesting BIOS scancodes */ #define BIOS_KEY(scancode) ( (scancode) - BIOS_KEY_MIN ) /** Mapping from BIOS scan codes to ANSI escape sequences */ static const char *ansi_sequences[] = { [ BIOS_KEY ( 0x42 ) ] = "[19~", /* F8 (required for PXE) */ [ BIOS_KEY ( 0x47 ) ] = "[H", /* Home */ [ BIOS_KEY ( 0x48 ) ] = "[A", /* Up arrow */ [ BIOS_KEY ( 0x4b ) ] = "[D", /* Left arrow */ [ BIOS_KEY ( 0x4d ) ] = "[C", /* Right arrow */ [ BIOS_KEY ( 0x4f ) ] = "[F", /* End */ [ BIOS_KEY ( 0x50 ) ] = "[B", /* Down arrow */ [ BIOS_KEY ( 0x53 ) ] = "[3~", /* Delete */ }; /** * Get ANSI escape sequence corresponding to BIOS scancode * * @v scancode BIOS scancode * @ret ansi_seq ANSI escape sequence, if any, otherwise NULL */ static const char * scancode_to_ansi_seq ( unsigned int scancode ) { unsigned int bios_key = BIOS_KEY ( scancode ); if ( bios_key < ( sizeof ( ansi_sequences ) / sizeof ( ansi_sequences[0] ) ) ) { return ansi_sequences[bios_key]; } DBG ( "Unrecognised BIOS scancode %02x\n", scancode ); return NULL; } /** * Get character from BIOS console * * @ret character Character read from console */ static int bios_getchar ( void ) { uint16_t keypress; unsigned int character; const char *ansi_seq; /* If we are mid-sequence, pass out the next byte */ if ( ( character = *ansi_input ) ) { ansi_input++; return character; } /* Read character from real BIOS console */ __asm__ __volatile__ ( REAL_CODE ( "sti\n\t" "int $0x16\n\t" "cli\n\t" ) : "=a" ( keypress ) : "a" ( 0x1000 ) ); character = ( keypress & 0xff ); /* If it's a normal character, just return it */ if ( character && ( character < 0x80 ) ) return character; /* Otherwise, check for a special key that we know about */ if ( ( ansi_seq = scancode_to_ansi_seq ( keypress >> 8 ) ) ) { /* Start of escape sequence: return ESC (0x1b) */ ansi_input = ansi_seq; return 0x1b; } return 0; } /** * Check for character ready to read from BIOS console * * @ret True Character available to read * @ret False No character available to read */ static int bios_iskey ( void ) { unsigned int discard_a; unsigned int flags; /* If we are mid-sequence, we are always ready */ if ( *ansi_input ) return 1; /* Otherwise check the real BIOS console */ __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" ( 0x0100 ) ); return ( ! ( flags & ZF ) ); } struct console_driver bios_console __console_driver = { .putchar = bios_putchar, .getchar = bios_getchar, .iskey = bios_iskey, };