[thirdparty/u-boot.git] / lib / efi_loader / efi_console.c

/*
 *  EFI application console interface
 *
 *  Copyright (c) 2016 Alexander Graf
 *
 *  SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <charset.h>
#include <efi_loader.h>

static bool console_size_queried;

#define EFI_COUT_MODE_2 2
#define EFI_MAX_COUT_MODE 3

struct cout_mode {
	unsigned long columns;
	unsigned long rows;
	int present;
};

static struct cout_mode efi_cout_modes[] = {
	/* EFI Mode 0 is 80x25 and always present */
	{
		.columns = 80,
		.rows = 25,
		.present = 1,
	},
	/* EFI Mode 1 is always 80x50 */
	{
		.columns = 80,
		.rows = 50,
		.present = 0,
	},
	/* Value are unknown until we query the console */
	{
		.columns = 0,
		.rows = 0,
		.present = 0,
	},
};

const efi_guid_t efi_guid_console_control = CONSOLE_CONTROL_GUID;

#define cESC '\x1b'
#define ESC "\x1b"

static efi_status_t EFIAPI efi_cin_get_mode(
			struct efi_console_control_protocol *this,
			int *mode, char *uga_exists, char *std_in_locked)
{
	EFI_ENTRY("%p, %p, %p, %p", this, mode, uga_exists, std_in_locked);

	if (mode)
		*mode = EFI_CONSOLE_MODE_TEXT;
	if (uga_exists)
		*uga_exists = 0;
	if (std_in_locked)
		*std_in_locked = 0;

	return EFI_EXIT(EFI_SUCCESS);
}

static efi_status_t EFIAPI efi_cin_set_mode(
			struct efi_console_control_protocol *this, int mode)
{
	EFI_ENTRY("%p, %d", this, mode);
	return EFI_EXIT(EFI_UNSUPPORTED);
}

static efi_status_t EFIAPI efi_cin_lock_std_in(
			struct efi_console_control_protocol *this,
			uint16_t *password)
{
	EFI_ENTRY("%p, %p", this, password);
	return EFI_EXIT(EFI_UNSUPPORTED);
}

const struct efi_console_control_protocol efi_console_control = {
	.get_mode = efi_cin_get_mode,
	.set_mode = efi_cin_set_mode,
	.lock_std_in = efi_cin_lock_std_in,
};

/* Default to mode 0 */
static struct simple_text_output_mode efi_con_mode = {
	.max_mode = 1,
	.mode = 0,
	.attribute = 0,
	.cursor_column = 0,
	.cursor_row = 0,
	.cursor_visible = 1,
};

static int term_read_reply(int *n, int maxnum, char end_char)
{
	char c;
	int i = 0;

	c = getc();
	if (c != cESC)
		return -1;
	c = getc();
	if (c != '[')
		return -1;

	n[0] = 0;
	while (1) {
		c = getc();
		if (c == ';') {
			i++;
			if (i >= maxnum)
				return -1;
			n[i] = 0;
			continue;
		} else if (c == end_char) {
			break;
		} else if (c > '9' || c < '0') {
			return -1;
		}

		/* Read one more decimal position */
		n[i] *= 10;
		n[i] += c - '0';
	}

	return 0;
}

static efi_status_t EFIAPI efi_cout_reset(
			struct efi_simple_text_output_protocol *this,
			char extended_verification)
{
	EFI_ENTRY("%p, %d", this, extended_verification);
	return EFI_EXIT(EFI_UNSUPPORTED);
}

static void print_unicode_in_utf8(u16 c)
{
	char utf8[MAX_UTF8_PER_UTF16] = { 0 };
	utf16_to_utf8((u8 *)utf8, &c, 1);
	puts(utf8);
}

static efi_status_t EFIAPI efi_cout_output_string(
			struct efi_simple_text_output_protocol *this,
			const unsigned short *string)
{
	struct cout_mode *mode;
	u16 ch;

	mode = &efi_cout_modes[efi_con_mode.mode];
	EFI_ENTRY("%p, %p", this, string);
	for (;(ch = *string); string++) {
		print_unicode_in_utf8(ch);
		efi_con_mode.cursor_column++;
		if (ch == '\n') {
			efi_con_mode.cursor_column = 1;
			efi_con_mode.cursor_row++;
		} else if (efi_con_mode.cursor_column > mode->columns) {
			efi_con_mode.cursor_column = 1;
			efi_con_mode.cursor_row++;
		}
		if (efi_con_mode.cursor_row > mode->rows)
			efi_con_mode.cursor_row = mode->rows;
	}

	return EFI_EXIT(EFI_SUCCESS);
}

static efi_status_t EFIAPI efi_cout_test_string(
			struct efi_simple_text_output_protocol *this,
			const unsigned short *string)
{
	EFI_ENTRY("%p, %p", this, string);
	return EFI_EXIT(EFI_SUCCESS);
}

static bool cout_mode_matches(struct cout_mode *mode, int rows, int cols)
{
	if (!mode->present)
		return false;

	return (mode->rows == rows) && (mode->columns == cols);
}

static int query_console_serial(int *rows, int *cols)
{
	/* Ask the terminal about its size */
	int n[3];
	u64 timeout;

	/* Empty input buffer */
	while (tstc())
		getc();

	printf(ESC"[18t");

	/* Check if we have a terminal that understands */
	timeout = timer_get_us() + 1000000;
	while (!tstc())
		if (timer_get_us() > timeout)
			return -1;

	/* Read {depth,rows,cols} */
	if (term_read_reply(n, 3, 't'))
		return -1;

	*cols = n[2];
	*rows = n[1];

	return 0;
}

static efi_status_t EFIAPI efi_cout_query_mode(
			struct efi_simple_text_output_protocol *this,
			unsigned long mode_number, unsigned long *columns,
			unsigned long *rows)
{
	EFI_ENTRY("%p, %ld, %p, %p", this, mode_number, columns, rows);

	if (!console_size_queried) {
		int rows, cols;

		console_size_queried = true;

		if (query_console_serial(&rows, &cols))
			goto out;

		/* Test if we can have Mode 1 */
		if (cols >= 80 && rows >= 50) {
			efi_cout_modes[1].present = 1;
			efi_con_mode.max_mode = 2;
		}

		/*
		 * Install our mode as mode 2 if it is different
		 * than mode 0 or 1 and set it  as the currently selected mode
		 */
		if (!cout_mode_matches(&efi_cout_modes[0], rows, cols) &&
		    !cout_mode_matches(&efi_cout_modes[1], rows, cols)) {
			efi_cout_modes[EFI_COUT_MODE_2].columns = cols;
			efi_cout_modes[EFI_COUT_MODE_2].rows = rows;
			efi_cout_modes[EFI_COUT_MODE_2].present = 1;
			efi_con_mode.max_mode = EFI_MAX_COUT_MODE;
			efi_con_mode.mode = EFI_COUT_MODE_2;
		}
	}

	if (mode_number >= efi_con_mode.max_mode)
		return EFI_EXIT(EFI_UNSUPPORTED);

	if (efi_cout_modes[mode_number].present != 1)
		return EFI_EXIT(EFI_UNSUPPORTED);

out:
	if (columns)
		*columns = efi_cout_modes[mode_number].columns;
	if (rows)
		*rows = efi_cout_modes[mode_number].rows;

	return EFI_EXIT(EFI_SUCCESS);
}

static efi_status_t EFIAPI efi_cout_set_mode(
			struct efi_simple_text_output_protocol *this,
			unsigned long mode_number)
{
	EFI_ENTRY("%p, %ld", this, mode_number);


	if (mode_number > efi_con_mode.max_mode)
		return EFI_EXIT(EFI_UNSUPPORTED);

	efi_con_mode.mode = mode_number;
	efi_con_mode.cursor_column = 0;
	efi_con_mode.cursor_row = 0;

	return EFI_EXIT(EFI_SUCCESS);
}

static efi_status_t EFIAPI efi_cout_set_attribute(
			struct efi_simple_text_output_protocol *this,
			unsigned long attribute)
{
	EFI_ENTRY("%p, %lx", this, attribute);

	/* Just ignore attributes (colors) for now */
	return EFI_EXIT(EFI_UNSUPPORTED);
}

static efi_status_t EFIAPI efi_cout_clear_screen(
			struct efi_simple_text_output_protocol *this)
{
	EFI_ENTRY("%p", this);

	printf(ESC"[2J");

	return EFI_EXIT(EFI_SUCCESS);
}

static efi_status_t EFIAPI efi_cout_set_cursor_position(
			struct efi_simple_text_output_protocol *this,
			unsigned long column, unsigned long row)
{
	EFI_ENTRY("%p, %ld, %ld", this, column, row);

	printf(ESC"[%d;%df", (int)row, (int)column);
	efi_con_mode.cursor_column = column;
	efi_con_mode.cursor_row = row;

	return EFI_EXIT(EFI_SUCCESS);
}

static efi_status_t EFIAPI efi_cout_enable_cursor(
			struct efi_simple_text_output_protocol *this,
			bool enable)
{
	EFI_ENTRY("%p, %d", this, enable);

	printf(ESC"[?25%c", enable ? 'h' : 'l');

	return EFI_EXIT(EFI_SUCCESS);
}

const struct efi_simple_text_output_protocol efi_con_out = {
	.reset = efi_cout_reset,
	.output_string = efi_cout_output_string,
	.test_string = efi_cout_test_string,
	.query_mode = efi_cout_query_mode,
	.set_mode = efi_cout_set_mode,
	.set_attribute = efi_cout_set_attribute,
	.clear_screen = efi_cout_clear_screen,
	.set_cursor_position = efi_cout_set_cursor_position,
	.enable_cursor = efi_cout_enable_cursor,
	.mode = (void*)&efi_con_mode,
};

static efi_status_t EFIAPI efi_cin_reset(
			struct efi_simple_input_interface *this,
			bool extended_verification)
{
	EFI_ENTRY("%p, %d", this, extended_verification);
	return EFI_EXIT(EFI_UNSUPPORTED);
}

static efi_status_t EFIAPI efi_cin_read_key_stroke(
			struct efi_simple_input_interface *this,
			struct efi_input_key *key)
{
	struct efi_input_key pressed_key = {
		.scan_code = 0,
		.unicode_char = 0,
	};
	char ch;

	EFI_ENTRY("%p, %p", this, key);

	/* We don't do interrupts, so check for timers cooperatively */
	efi_timer_check();

	if (!tstc()) {
		/* No key pressed */
		return EFI_EXIT(EFI_NOT_READY);
	}

	ch = getc();
	if (ch == cESC) {
		/* Escape Sequence */
		ch = getc();
		switch (ch) {
		case cESC: /* ESC */
			pressed_key.scan_code = 23;
			break;
		case 'O': /* F1 - F4 */
			pressed_key.scan_code = getc() - 'P' + 11;
			break;
		case 'a'...'z':
			ch = ch - 'a';
			break;
		case '[':
			ch = getc();
			switch (ch) {
			case 'A'...'D': /* up, down right, left */
				pressed_key.scan_code = ch - 'A' + 1;
				break;
			case 'F': /* End */
				pressed_key.scan_code = 6;
				break;
			case 'H': /* Home */
				pressed_key.scan_code = 5;
				break;
			case '1': /* F5 - F8 */
				pressed_key.scan_code = getc() - '0' + 11;
				getc();
				break;
			case '2': /* F9 - F12 */
				pressed_key.scan_code = getc() - '0' + 19;
				getc();
				break;
			case '3': /* DEL */
				pressed_key.scan_code = 8;
				getc();
				break;
			}
			break;
		}
	} else if (ch == 0x7f) {
		/* Backspace */
		ch = 0x08;
	}
	pressed_key.unicode_char = ch;
	*key = pressed_key;

	return EFI_EXIT(EFI_SUCCESS);
}

struct efi_simple_input_interface efi_con_in = {
	.reset = efi_cin_reset,
	.read_key_stroke = efi_cin_read_key_stroke,
	.wait_for_key = NULL,
};

static struct efi_event *console_timer_event;

static void EFIAPI efi_key_notify(struct efi_event *event, void *context)
{
}

static void EFIAPI efi_console_timer_notify(struct efi_event *event,
					    void *context)
{
	EFI_ENTRY("%p, %p", event, context);
	if (tstc()) {
		efi_con_in.wait_for_key->signaled = 1;
		efi_signal_event(efi_con_in.wait_for_key);
		}
	EFI_EXIT(EFI_SUCCESS);
}


static struct efi_object efi_console_control_obj =
	EFI_PROTOCOL_OBJECT(efi_guid_console_control, &efi_console_control);
static struct efi_object efi_console_output_obj =
	EFI_PROTOCOL_OBJECT(EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID, &efi_con_out);
static struct efi_object efi_console_input_obj =
	EFI_PROTOCOL_OBJECT(EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID, &efi_con_in);

/* This gets called from do_bootefi_exec(). */
int efi_console_register(void)
{
	efi_status_t r;

	/* Hook up to the device list */
	list_add_tail(&efi_console_control_obj.link, &efi_obj_list);
	list_add_tail(&efi_console_output_obj.link, &efi_obj_list);
	list_add_tail(&efi_console_input_obj.link, &efi_obj_list);

	r = efi_create_event(EVT_NOTIFY_WAIT, TPL_CALLBACK,
			     efi_key_notify, NULL, &efi_con_in.wait_for_key);
	if (r != EFI_SUCCESS) {
		printf("ERROR: Failed to register WaitForKey event\n");
		return r;
	}
	r = efi_create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK,
			     efi_console_timer_notify, NULL,
			     &console_timer_event);
	if (r != EFI_SUCCESS) {
		printf("ERROR: Failed to register console event\n");
		return r;
	}
	/* 5000 ns cycle is sufficient for 2 MBaud */
	r = efi_set_timer(console_timer_event, EFI_TIMER_PERIODIC, 50);
	if (r != EFI_SUCCESS)
		printf("ERROR: Failed to set console timer\n");
	return r;
}
Commit	Line	Data
c1311ad4 AG	1	/*
	2	* EFI application console interface
	3	*
	4	* Copyright (c) 2016 Alexander Graf
	5	*
	6	* SPDX-License-Identifier: GPL-2.0+
	7	*/
	8
	9	#include <common.h>
78178bb0	10	#include <charset.h>
c1311ad4 AG	11	#include <efi_loader.h>
c1311ad4 AG	12
c1311ad4 AG	13	static bool console_size_queried;
c1311ad4 AG	14
5be8b0a3 EV	15	#define EFI_COUT_MODE_2 2
	16	#define EFI_MAX_COUT_MODE 3
	17
	18	struct cout_mode {
	19	unsigned long columns;
	20	unsigned long rows;
	21	int present;
	22	};
	23
	24	static struct cout_mode efi_cout_modes[] = {
	25	/* EFI Mode 0 is 80x25 and always present */
	26	{
	27	.columns = 80,
	28	.rows = 25,
	29	.present = 1,
	30	},
	31	/* EFI Mode 1 is always 80x50 */
	32	{
	33	.columns = 80,
	34	.rows = 50,
	35	.present = 0,
	36	},
	37	/* Value are unknown until we query the console */
	38	{
	39	.columns = 0,
	40	.rows = 0,
	41	.present = 0,
	42	},
	43	};
	44
c1311ad4 AG	45	const efi_guid_t efi_guid_console_control = CONSOLE_CONTROL_GUID;
	46
	47	#define cESC '\x1b'
	48	#define ESC "\x1b"
	49
	50	static efi_status_t EFIAPI efi_cin_get_mode(
	51	struct efi_console_control_protocol *this,
	52	int mode, char uga_exists, char *std_in_locked)
	53	{
	54	EFI_ENTRY("%p, %p, %p, %p", this, mode, uga_exists, std_in_locked);
	55
	56	if (mode)
	57	*mode = EFI_CONSOLE_MODE_TEXT;
	58	if (uga_exists)
	59	*uga_exists = 0;
	60	if (std_in_locked)
	61	*std_in_locked = 0;
	62
	63	return EFI_EXIT(EFI_SUCCESS);
	64	}
	65
	66	static efi_status_t EFIAPI efi_cin_set_mode(
	67	struct efi_console_control_protocol *this, int mode)
	68	{
	69	EFI_ENTRY("%p, %d", this, mode);
	70	return EFI_EXIT(EFI_UNSUPPORTED);
	71	}
	72
	73	static efi_status_t EFIAPI efi_cin_lock_std_in(
	74	struct efi_console_control_protocol *this,
	75	uint16_t *password)
	76	{
	77	EFI_ENTRY("%p, %p", this, password);
	78	return EFI_EXIT(EFI_UNSUPPORTED);
	79	}
	80
	81	const struct efi_console_control_protocol efi_console_control = {
	82	.get_mode = efi_cin_get_mode,
	83	.set_mode = efi_cin_set_mode,
	84	.lock_std_in = efi_cin_lock_std_in,
	85	};
	86
5be8b0a3	87	/* Default to mode 0 */
c1311ad4	88	static struct simple_text_output_mode efi_con_mode = {
5be8b0a3	89	.max_mode = 1,
c1311ad4 AG	90	.mode = 0,
	91	.attribute = 0,
	92	.cursor_column = 0,
	93	.cursor_row = 0,
	94	.cursor_visible = 1,
	95	};
	96
	97	static int term_read_reply(int *n, int maxnum, char end_char)
	98	{
	99	char c;
	100	int i = 0;
	101
	102	c = getc();
	103	if (c != cESC)
	104	return -1;
	105	c = getc();
	106	if (c != '[')
	107	return -1;
	108
	109	n[0] = 0;
	110	while (1) {
	111	c = getc();
	112	if (c == ';') {
	113	i++;
	114	if (i >= maxnum)
	115	return -1;
	116	n[i] = 0;
	117	continue;
	118	} else if (c == end_char) {
	119	break;
	120	} else if (c > '9' \|\| c < '0') {
	121	return -1;
	122	}
	123
	124	/* Read one more decimal position */
	125	n[i] *= 10;
	126	n[i] += c - '0';
	127	}
	128
	129	return 0;
	130	}
	131
	132	static efi_status_t EFIAPI efi_cout_reset(
	133	struct efi_simple_text_output_protocol *this,
	134	char extended_verification)
	135	{
	136	EFI_ENTRY("%p, %d", this, extended_verification);
	137	return EFI_EXIT(EFI_UNSUPPORTED);
	138	}
	139
	140	static void print_unicode_in_utf8(u16 c)
	141	{
78178bb0 RC	142	char utf8[MAX_UTF8_PER_UTF16] = { 0 };
78178bb0 RC	143	utf16_to_utf8((u8 *)utf8, &c, 1);
c1311ad4 AG	144	puts(utf8);
	145	}
	146
	147	static efi_status_t EFIAPI efi_cout_output_string(
	148	struct efi_simple_text_output_protocol *this,
	149	const unsigned short *string)
	150	{
5be8b0a3	151	struct cout_mode *mode;
c1311ad4 AG	152	u16 ch;
c1311ad4 AG	153
5be8b0a3	154	mode = &efi_cout_modes[efi_con_mode.mode];
c1311ad4 AG	155	EFI_ENTRY("%p, %p", this, string);
	156	for (;(ch = *string); string++) {
	157	print_unicode_in_utf8(ch);
	158	efi_con_mode.cursor_column++;
	159	if (ch == '\n') {
	160	efi_con_mode.cursor_column = 1;
	161	efi_con_mode.cursor_row++;
5be8b0a3	162	} else if (efi_con_mode.cursor_column > mode->columns) {
c1311ad4 AG	163	efi_con_mode.cursor_column = 1;
	164	efi_con_mode.cursor_row++;
	165	}
5be8b0a3 EV	166	if (efi_con_mode.cursor_row > mode->rows)
5be8b0a3 EV	167	efi_con_mode.cursor_row = mode->rows;
c1311ad4 AG	168	}
	169
	170	return EFI_EXIT(EFI_SUCCESS);
	171	}
	172
	173	static efi_status_t EFIAPI efi_cout_test_string(
	174	struct efi_simple_text_output_protocol *this,
	175	const unsigned short *string)
	176	{
	177	EFI_ENTRY("%p, %p", this, string);
	178	return EFI_EXIT(EFI_SUCCESS);
	179	}
	180
5be8b0a3 EV	181	static bool cout_mode_matches(struct cout_mode *mode, int rows, int cols)
	182	{
	183	if (!mode->present)
	184	return false;
	185
	186	return (mode->rows == rows) && (mode->columns == cols);
	187	}
	188
71cc25c3 RC	189	static int query_console_serial(int rows, int cols)
	190	{
	191	/* Ask the terminal about its size */
	192	int n[3];
	193	u64 timeout;
	194
	195	/* Empty input buffer */
	196	while (tstc())
	197	getc();
	198
	199	printf(ESC"[18t");
	200
	201	/* Check if we have a terminal that understands */
	202	timeout = timer_get_us() + 1000000;
	203	while (!tstc())
	204	if (timer_get_us() > timeout)
	205	return -1;
	206
	207	/* Read {depth,rows,cols} */
	208	if (term_read_reply(n, 3, 't'))
	209	return -1;
	210
	211	*cols = n[2];
	212	*rows = n[1];
	213
	214	return 0;
	215	}
	216
c1311ad4 AG	217	static efi_status_t EFIAPI efi_cout_query_mode(
	218	struct efi_simple_text_output_protocol *this,
	219	unsigned long mode_number, unsigned long *columns,
	220	unsigned long *rows)
	221	{
	222	EFI_ENTRY("%p, %ld, %p, %p", this, mode_number, columns, rows);
	223
	224	if (!console_size_queried) {
71cc25c3	225	int rows, cols;
c1311ad4 AG	226
	227	console_size_queried = true;
	228
71cc25c3	229	if (query_console_serial(&rows, &cols))
c1311ad4	230	goto out;
5be8b0a3 EV	231
	232	/* Test if we can have Mode 1 */
	233	if (cols >= 80 && rows >= 50) {
	234	efi_cout_modes[1].present = 1;
	235	efi_con_mode.max_mode = 2;
	236	}
	237
	238	/*
	239	* Install our mode as mode 2 if it is different
	240	* than mode 0 or 1 and set it as the currently selected mode
	241	*/
	242	if (!cout_mode_matches(&efi_cout_modes[0], rows, cols) &&
	243	!cout_mode_matches(&efi_cout_modes[1], rows, cols)) {
	244	efi_cout_modes[EFI_COUT_MODE_2].columns = cols;
	245	efi_cout_modes[EFI_COUT_MODE_2].rows = rows;
	246	efi_cout_modes[EFI_COUT_MODE_2].present = 1;
	247	efi_con_mode.max_mode = EFI_MAX_COUT_MODE;
	248	efi_con_mode.mode = EFI_COUT_MODE_2;
	249	}
c1311ad4 AG	250	}
c1311ad4 AG	251
5be8b0a3 EV	252	if (mode_number >= efi_con_mode.max_mode)
	253	return EFI_EXIT(EFI_UNSUPPORTED);
	254
	255	if (efi_cout_modes[mode_number].present != 1)
	256	return EFI_EXIT(EFI_UNSUPPORTED);
	257
c1311ad4 AG	258	out:
c1311ad4 AG	259	if (columns)
5be8b0a3	260	*columns = efi_cout_modes[mode_number].columns;
c1311ad4	261	if (rows)
5be8b0a3	262	*rows = efi_cout_modes[mode_number].rows;
c1311ad4 AG	263
	264	return EFI_EXIT(EFI_SUCCESS);
	265	}
	266
	267	static efi_status_t EFIAPI efi_cout_set_mode(
	268	struct efi_simple_text_output_protocol *this,
	269	unsigned long mode_number)
	270	{
	271	EFI_ENTRY("%p, %ld", this, mode_number);
	272
c1311ad4	273
5be8b0a3 EV	274	if (mode_number > efi_con_mode.max_mode)
	275	return EFI_EXIT(EFI_UNSUPPORTED);
	276
	277	efi_con_mode.mode = mode_number;
	278	efi_con_mode.cursor_column = 0;
	279	efi_con_mode.cursor_row = 0;
	280
	281	return EFI_EXIT(EFI_SUCCESS);
c1311ad4 AG	282	}
	283
	284	static efi_status_t EFIAPI efi_cout_set_attribute(
	285	struct efi_simple_text_output_protocol *this,
	286	unsigned long attribute)
	287	{
	288	EFI_ENTRY("%p, %lx", this, attribute);
	289
	290	/* Just ignore attributes (colors) for now */
	291	return EFI_EXIT(EFI_UNSUPPORTED);
	292	}
	293
	294	static efi_status_t EFIAPI efi_cout_clear_screen(
	295	struct efi_simple_text_output_protocol *this)
	296	{
	297	EFI_ENTRY("%p", this);
	298
	299	printf(ESC"[2J");
	300
	301	return EFI_EXIT(EFI_SUCCESS);
	302	}
	303
	304	static efi_status_t EFIAPI efi_cout_set_cursor_position(
	305	struct efi_simple_text_output_protocol *this,
	306	unsigned long column, unsigned long row)
	307	{
	308	EFI_ENTRY("%p, %ld, %ld", this, column, row);
	309
	310	printf(ESC"[%d;%df", (int)row, (int)column);
	311	efi_con_mode.cursor_column = column;
	312	efi_con_mode.cursor_row = row;
	313
	314	return EFI_EXIT(EFI_SUCCESS);
	315	}
	316
	317	static efi_status_t EFIAPI efi_cout_enable_cursor(
	318	struct efi_simple_text_output_protocol *this,
	319	bool enable)
	320	{
	321	EFI_ENTRY("%p, %d", this, enable);
	322
	323	printf(ESC"[?25%c", enable ? 'h' : 'l');
	324
	325	return EFI_EXIT(EFI_SUCCESS);
	326	}
	327
	328	const struct efi_simple_text_output_protocol efi_con_out = {
	329	.reset = efi_cout_reset,
	330	.output_string = efi_cout_output_string,
	331	.test_string = efi_cout_test_string,
	332	.query_mode = efi_cout_query_mode,
	333	.set_mode = efi_cout_set_mode,
	334	.set_attribute = efi_cout_set_attribute,
	335	.clear_screen = efi_cout_clear_screen,
	336	.set_cursor_position = efi_cout_set_cursor_position,
	337	.enable_cursor = efi_cout_enable_cursor,
	338	.mode = (void*)&efi_con_mode,
	339	};
	340
	341	static efi_status_t EFIAPI efi_cin_reset(
	342	struct efi_simple_input_interface *this,
	343	bool extended_verification)
	344	{
	345	EFI_ENTRY("%p, %d", this, extended_verification);
346	return EFI_EXIT(EFI_UNSUPPORTED);
347	}
348
349	static efi_status_t EFIAPI efi_cin_read_key_stroke(
350	struct efi_simple_input_interface *this,
351	struct efi_input_key *key)
352	{
353	struct efi_input_key pressed_key = {
354	.scan_code = 0,
355	.unicode_char = 0,
356	};
357	char ch;
358
359	EFI_ENTRY("%p, %p", this, key);
360
361	/* We don't do interrupts, so check for timers cooperatively */
362	efi_timer_check();
363
364	if (!tstc()) {
365	/* No key pressed */
366	return EFI_EXIT(EFI_NOT_READY);
367	}
368
369	ch = getc();
370	if (ch == cESC) {
371	/* Escape Sequence */
372	ch = getc();
373	switch (ch) {
374	case cESC: /* ESC */
375	pressed_key.scan_code = 23;
376	break;
377	case 'O': /* F1 - F4 */
378	pressed_key.scan_code = getc() - 'P' + 11;
379	break;
380	case 'a'...'z':
381	ch = ch - 'a';
382	break;
383	case '[':
384	ch = getc();
385	switch (ch) {
386	case 'A'...'D': /* up, down right, left */
387	pressed_key.scan_code = ch - 'A' + 1;
388	break;
389	case 'F': /* End */
390	pressed_key.scan_code = 6;
391	break;
392	case 'H': /* Home */
393	pressed_key.scan_code = 5;
394	break;
395	case '1': /* F5 - F8 */
396	pressed_key.scan_code = getc() - '0' + 11;
397	getc();
398	break;
399	case '2': /* F9 - F12 */
400	pressed_key.scan_code = getc() - '0' + 19;
401	getc();
402	break;
403	case '3': /* DEL */
404	pressed_key.scan_code = 8;
405	getc();
406	break;
407	}
408	break;
409	}
410	} else if (ch == 0x7f) {
411	/* Backspace */
412	ch = 0x08;
413	}
414	pressed_key.unicode_char = ch;
415	*key = pressed_key;
416
417	return EFI_EXIT(EFI_SUCCESS);
418	}
419
91be9a77	420	struct efi_simple_input_interface efi_con_in = {
c1311ad4 AG	421	.reset = efi_cin_reset,
	422	.read_key_stroke = efi_cin_read_key_stroke,
	423	.wait_for_key = NULL,
	424	};
91be9a77 HS	425
	426	static struct efi_event *console_timer_event;
	427
ff925938	428	static void EFIAPI efi_key_notify(struct efi_event event, void context)
91be9a77 HS	429	{
	430	}
	431
ff925938 HS	432	static void EFIAPI efi_console_timer_notify(struct efi_event *event,
ff925938 HS	433	void *context)
91be9a77 HS	434	{
91be9a77 HS	435	EFI_ENTRY("%p, %p", event, context);
ca62a4f5 HS	436	if (tstc()) {
ca62a4f5 HS	437	efi_con_in.wait_for_key->signaled = 1;
91be9a77	438	efi_signal_event(efi_con_in.wait_for_key);
ca62a4f5	439	}
91be9a77 HS	440	EFI_EXIT(EFI_SUCCESS);
	441	}
	442
a17e62cc RC	443
	444	static struct efi_object efi_console_control_obj =
	445	EFI_PROTOCOL_OBJECT(efi_guid_console_control, &efi_console_control);
	446	static struct efi_object efi_console_output_obj =
	447	EFI_PROTOCOL_OBJECT(EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID, &efi_con_out);
	448	static struct efi_object efi_console_input_obj =
	449	EFI_PROTOCOL_OBJECT(EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID, &efi_con_in);
	450
91be9a77 HS	451	/* This gets called from do_bootefi_exec(). */
	452	int efi_console_register(void)
	453	{
	454	efi_status_t r;
a17e62cc RC	455
	456	/* Hook up to the device list */
	457	list_add_tail(&efi_console_control_obj.link, &efi_obj_list);
	458	list_add_tail(&efi_console_output_obj.link, &efi_obj_list);
	459	list_add_tail(&efi_console_input_obj.link, &efi_obj_list);
	460
91be9a77 HS	461	r = efi_create_event(EVT_NOTIFY_WAIT, TPL_CALLBACK,
	462	efi_key_notify, NULL, &efi_con_in.wait_for_key);
	463	if (r != EFI_SUCCESS) {
	464	printf("ERROR: Failed to register WaitForKey event\n");
	465	return r;
	466	}
	467	r = efi_create_event(EVT_TIMER \| EVT_NOTIFY_SIGNAL, TPL_CALLBACK,
	468	efi_console_timer_notify, NULL,
	469	&console_timer_event);
	470	if (r != EFI_SUCCESS) {
	471	printf("ERROR: Failed to register console event\n");
	472	return r;
	473	}
	474	/* 5000 ns cycle is sufficient for 2 MBaud */
	475	r = efi_set_timer(console_timer_event, EFI_TIMER_PERIODIC, 50);
	476	if (r != EFI_SUCCESS)
	477	printf("ERROR: Failed to set console timer\n");
	478	return r;
	479	}