#include "stddef.h"
#include <ipxe/console.h>
#include <ipxe/process.h>
#include <ipxe/nap.h>

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)

int	putchar (int character)
	Write a single character to each console device. More...

static struct console_driver *	has_input (void)
	Check to see if any input is available on any console. More...

int	getchar (void)
	Read a single character from any console. More...

int	iskey (void)
	Check for available input on any console. More...

int	console_configure (struct console_configuration *config)
	Configure console. More...

Variables
int	console_usage = CONSOLE_USAGE_STDOUT
	Current console usage. More...

unsigned int	console_width = CONSOLE_DEFAULT_WIDTH
	Console width. More...

unsigned int	console_height = CONSOLE_DEFAULT_HEIGHT
	Console height. More...

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ putchar()

int putchar ( int character )

Write a single character to each console device.

Parameters

character Character to be written

Return values

character Character written

The character is written out to all enabled console devices, using each device's console_driver::putchar() method.

Definition at line 28 of file console.c.

                               {
         struct console_driver *console;
 
         /* Automatic LF -> CR,LF translation */
         if ( character == '\n' )
                 putchar ( '\r' );
 
         for_each_table_entry ( console, CONSOLES ) {
                 if ( ( ! ( console->disabled & CONSOLE_DISABLED_OUTPUT ) ) &&
                      ( console_usage & console->usage ) &&
                      console->putchar )
                         console->putchar ( character );
         }
 
         return character;
 }

References CONSOLE_DISABLED_OUTPUT, console_usage, CONSOLES, console_driver::disabled, for_each_table_entry, putchar(), console_driver::putchar, and console_driver::usage.

Referenced by ansiscr_putc(), clrline(), eepro_poll(), epic100_open(), falcon_init_xmac(), get_eeprom_data(), int21(), monojob_clear(), print_user_string(), printf_putchar(), putchar(), readline_history(), and sync_console().

◆ has_input()

static struct console_driver* has_input ( void )

static

Check to see if any input is available on any console.

Return values

console Console device that has input available, or NULL

All enabled console devices are checked once for available input using each device's console_driver::iskey() method. The first console device that has available input will be returned, if any.

Definition at line 54 of file console.c.

                                                   {
         struct console_driver *console;
 
         for_each_table_entry ( console, CONSOLES ) {
                 if ( ( ! ( console->disabled & CONSOLE_DISABLED_INPUT ) ) &&
                      console->iskey ) {
                         if ( console->iskey () )
                                 return console;
                 }
         }
         return NULL;
 }

References CONSOLE_DISABLED_INPUT, CONSOLES, console_driver::disabled, for_each_table_entry, console_driver::iskey, and NULL.

Referenced by getchar(), and iskey().

◆ getchar()

int getchar ( void )

Read a single character from any console.

Return values

character Character read from a console.

A character will be read from the first enabled console device that has input available using that console's console_driver::getchar() method. If no console has input available to be read, this method will block. To perform a non-blocking read, use something like

int key = iskey() ? getchar() : -1;

The character read will not be echoed back to any console.

Definition at line 85 of file console.c.

                      {
         struct console_driver *console;
         int character;
 
         while ( 1 ) {
                 console = has_input();
                 if ( console && console->getchar ) {
                         character = console->getchar ();
                         break;
                 }
 
                 /* Doze for a while (until the next interrupt).  This works
                  * fine, because the keyboard is interrupt-driven, and the
                  * timer interrupt (approx. every 50msec) takes care of the
                  * serial port, which is read by polling.  This reduces the
                  * power dissipation of a modern CPU considerably, and also
                  * makes Etherboot waiting for user interaction waste a lot
                  * less CPU time in a VMware session.
                  */
                 cpu_nap();
 
                 /* Keep processing background tasks while we wait for
                  * input.
                  */
                 step();
         }
 
         /* CR -> LF translation */
         if ( character == '\r' )
                 character = '\n';
 
         return character;
 }

References cpu_nap(), console_driver::getchar, has_input(), and step().

Referenced by ansiscr_getc(), dbg_more(), dbg_pause(), getchar_timeout(), int21(), keypress_interrupted(), loopback_wait(), and monojob_wait().

◆ iskey()

int iskey ( void )

Check for available input on any console.

Return values

is_available Input is available on a console

All enabled console devices are checked once for available input using each device's console_driver::iskey() method. If any console device has input available, this call will return true. If this call returns true, you can then safely call getchar() without blocking.

Definition at line 130 of file console.c.

                    {
         return has_input() ? 1 : 0;
 }

References has_input().

Referenced by ansiscr_peek(), bios_inject(), getchar_timeout(), int21(), keypress_interrupted(), loopback_wait(), monojob_wait(), and pxe_menu_prompt_and_select().

◆ console_configure()

int console_configure ( struct console_configuration * config )

Configure console.

Parameters

config Console configuration

Return values

rc	Return status code

The configuration is passed to all configurable consoles, including those which are currently disabled. Consoles may choose to enable or disable themselves depending upon the configuration.

If configuration fails, then all consoles will be reset.

Definition at line 146 of file console.c.

                                                                {
         struct console_driver *console;
         int rc;
 
         /* Reset console width and height */
         console_set_size ( CONSOLE_DEFAULT_WIDTH, CONSOLE_DEFAULT_HEIGHT );
 
         /* Try to configure each console */
         for_each_table_entry ( console, CONSOLES ) {
                 if ( ( console->configure ) &&
                      ( ( rc = console->configure ( config ) ) != 0 ) )
                                 goto err;
         }
 
         return 0;
 
  err:
         /* Reset all consoles, avoiding a potential infinite loop */
         if ( config )
                 console_reset();
         return rc;
 }