[J-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 <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[4] = { 0 };
	char *b = utf8;

	if (c < 0x80) {
		*(b++) = c;
	} else if (c < 0x800) {
		*(b++) = 192 + c / 64;
		*(b++) = 128 + c % 64;
	} else {
		*(b++) = 224 + c / 4096;
		*(b++) = 128 + c / 64 % 64;
		*(b++) = 128 + c % 64;
	}

	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 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) {
		/* Ask the terminal about its size */
		int n[3];
		int cols;
		int rows;
		u64 timeout;

		console_size_queried = true;

		/* 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)
				goto out;

		/* Read {depth,rows,cols} */
		if (term_read_reply(n, 3, 't')) {
			goto out;
		}

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

		/* 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 efi_key_notify(struct efi_event *event, void *context)
{
}

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

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