[people/ms/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 <dm/device.h>
#include <efi_loader.h>
#include <stdio_dev.h>
#include <video_console.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;
const efi_guid_t efi_guid_text_output_protocol =
			EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID;
const efi_guid_t efi_guid_text_input_protocol =
			EFI_SIMPLE_TEXT_INPUT_PROTOCOL_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);
}

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 efi_status_t EFIAPI efi_cout_output_string(
			struct efi_simple_text_output_protocol *this,
			const efi_string_t string)
{
	struct simple_text_output_mode *con = &efi_con_mode;
	struct cout_mode *mode = &efi_cout_modes[con->mode];

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

	unsigned int n16 = utf16_strlen(string);
	char buf[MAX_UTF8_PER_UTF16 * n16 + 1];
	char *p;

	*utf16_to_utf8((u8 *)buf, string, n16) = '\0';

	fputs(stdout, buf);

	for (p = buf; *p; p++) {
		switch (*p) {
		case '\r':   /* carriage-return */
			con->cursor_column = 0;
			break;
		case '\n':   /* newline */
			con->cursor_column = 0;
			con->cursor_row++;
			break;
		case '\t':   /* tab, assume 8 char align */
			break;
		case '\b':   /* backspace */
			con->cursor_column = max(0, con->cursor_column - 1);
			break;
		default:
			con->cursor_column++;
			break;
		}
		if (con->cursor_column >= mode->columns) {
			con->cursor_column = 0;
			con->cursor_row++;
		}
		con->cursor_row = min(con->cursor_row, (s32)mode->rows - 1);
	}

	return EFI_EXIT(EFI_SUCCESS);
}

static efi_status_t EFIAPI efi_cout_test_string(
			struct efi_simple_text_output_protocol *this,
			const efi_string_t 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) {
		const char *stdout_name = env_get("stdout");
		int rows, cols;

		console_size_queried = true;

		if (stdout_name && !strcmp(stdout_name, "vidconsole") &&
		    IS_ENABLED(CONFIG_DM_VIDEO)) {
			struct stdio_dev *stdout_dev =
				stdio_get_by_name("vidconsole");
			struct udevice *dev = stdout_dev->priv;
			struct vidconsole_priv *priv =
				dev_get_uclass_priv(dev);
			rows = priv->rows;
			cols = priv->cols;
		} else 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 const struct {
	unsigned int fg;
	unsigned int bg;
} color[] = {
	{ 30, 40 },     /* 0: black */
	{ 34, 44 },     /* 1: blue */
	{ 32, 42 },     /* 2: green */
	{ 36, 46 },     /* 3: cyan */
	{ 31, 41 },     /* 4: red */
	{ 35, 45 },     /* 5: magenta */
	{ 33, 43 },     /* 6: brown, map to yellow as edk2 does*/
	{ 37, 47 },     /* 7: light grey, map to white */
};

/* See EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.SetAttribute(). */
static efi_status_t EFIAPI efi_cout_set_attribute(
			struct efi_simple_text_output_protocol *this,
			unsigned long attribute)
{
	unsigned int bold = EFI_ATTR_BOLD(attribute);
	unsigned int fg = EFI_ATTR_FG(attribute);
	unsigned int bg = EFI_ATTR_BG(attribute);

	EFI_ENTRY("%p, %lx", this, attribute);

	if (attribute)
		printf(ESC"[%u;%u;%um", bold, color[fg].fg, color[bg].bg);
	else
		printf(ESC"[0;37;40m");

	return EFI_EXIT(EFI_SUCCESS);
}

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);
}

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->is_signaled = true;
		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;
	struct efi_object *efi_console_control_obj;
	struct efi_object *efi_console_output_obj;
	struct efi_object *efi_console_input_obj;

	/* Create handles */
	r = efi_create_handle((void **)&efi_console_control_obj);
	if (r != EFI_SUCCESS)
		goto out_of_memory;
	r = efi_add_protocol(efi_console_control_obj->handle,
			     &efi_guid_console_control, &efi_console_control);
	if (r != EFI_SUCCESS)
		goto out_of_memory;
	r = efi_create_handle((void **)&efi_console_output_obj);
	if (r != EFI_SUCCESS)
		goto out_of_memory;
	r = efi_add_protocol(efi_console_output_obj->handle,
			     &efi_guid_text_output_protocol, &efi_con_out);
	if (r != EFI_SUCCESS)
		goto out_of_memory;
	r = efi_create_handle((void **)&efi_console_input_obj);
	if (r != EFI_SUCCESS)
		goto out_of_memory;
	r = efi_add_protocol(efi_console_input_obj->handle,
			     &efi_guid_text_input_protocol, &efi_con_in);
	if (r != EFI_SUCCESS)
		goto out_of_memory;

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