xref: /openbmc/u-boot/lib/efi_loader/efi_console.c (revision 725e09b8)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  *  EFI application console interface
4  *
5  *  Copyright (c) 2016 Alexander Graf
6  */
7 
8 #include <common.h>
9 #include <charset.h>
10 #include <dm/device.h>
11 #include <efi_loader.h>
12 #include <stdio_dev.h>
13 #include <video_console.h>
14 
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 
45 const efi_guid_t efi_guid_text_output_protocol =
46 			EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID;
47 const efi_guid_t efi_guid_text_input_protocol =
48 			EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID;
49 
50 #define cESC '\x1b'
51 #define ESC "\x1b"
52 
53 /* Default to mode 0 */
54 static struct simple_text_output_mode efi_con_mode = {
55 	.max_mode = 1,
56 	.mode = 0,
57 	.attribute = 0,
58 	.cursor_column = 0,
59 	.cursor_row = 0,
60 	.cursor_visible = 1,
61 };
62 
63 /*
64  * Receive and parse a reply from the terminal.
65  *
66  * @n:		array of return values
67  * @num:	number of return values expected
68  * @end_char:	character indicating end of terminal message
69  * @return:	non-zero indicates error
70  */
71 static int term_read_reply(int *n, int num, char end_char)
72 {
73 	char c;
74 	int i = 0;
75 
76 	c = getc();
77 	if (c != cESC)
78 		return -1;
79 	c = getc();
80 	if (c != '[')
81 		return -1;
82 
83 	n[0] = 0;
84 	while (1) {
85 		c = getc();
86 		if (c == ';') {
87 			i++;
88 			if (i >= num)
89 				return -1;
90 			n[i] = 0;
91 			continue;
92 		} else if (c == end_char) {
93 			break;
94 		} else if (c > '9' || c < '0') {
95 			return -1;
96 		}
97 
98 		/* Read one more decimal position */
99 		n[i] *= 10;
100 		n[i] += c - '0';
101 	}
102 	if (i != num - 1)
103 		return -1;
104 
105 	return 0;
106 }
107 
108 static efi_status_t EFIAPI efi_cout_reset(
109 			struct efi_simple_text_output_protocol *this,
110 			char extended_verification)
111 {
112 	EFI_ENTRY("%p, %d", this, extended_verification);
113 	return EFI_EXIT(EFI_UNSUPPORTED);
114 }
115 
116 static efi_status_t EFIAPI efi_cout_output_string(
117 			struct efi_simple_text_output_protocol *this,
118 			const efi_string_t string)
119 {
120 	struct simple_text_output_mode *con = &efi_con_mode;
121 	struct cout_mode *mode = &efi_cout_modes[con->mode];
122 
123 	EFI_ENTRY("%p, %p", this, string);
124 
125 	unsigned int n16 = utf16_strlen(string);
126 	char buf[MAX_UTF8_PER_UTF16 * n16 + 1];
127 	u16 *p;
128 
129 	*utf16_to_utf8((u8 *)buf, string, n16) = '\0';
130 
131 	fputs(stdout, buf);
132 
133 	/*
134 	 * Update the cursor position.
135 	 *
136 	 * The UEFI spec provides advance rules for U+0000, U+0008, U+000A,
137 	 * and U000D. All other characters, including control characters
138 	 * U+0007 (bel) and U+0009 (tab), have to increase the column by one.
139 	 */
140 	for (p = string; *p; ++p) {
141 		switch (*p) {
142 		case '\b':	/* U+0008, backspace */
143 			con->cursor_column = max(0, con->cursor_column - 1);
144 			break;
145 		case '\n':	/* U+000A, newline */
146 			con->cursor_column = 0;
147 			con->cursor_row++;
148 			break;
149 		case '\r':	/* U+000D, carriage-return */
150 			con->cursor_column = 0;
151 			break;
152 		case 0xd800 ... 0xdbff:
153 			/*
154 			 * Ignore high surrogates, we do not want to count a
155 			 * Unicode character twice.
156 			 */
157 			break;
158 		default:
159 			con->cursor_column++;
160 			break;
161 		}
162 		if (con->cursor_column >= mode->columns) {
163 			con->cursor_column = 0;
164 			con->cursor_row++;
165 		}
166 		con->cursor_row = min(con->cursor_row, (s32)mode->rows - 1);
167 	}
168 
169 	return EFI_EXIT(EFI_SUCCESS);
170 }
171 
172 static efi_status_t EFIAPI efi_cout_test_string(
173 			struct efi_simple_text_output_protocol *this,
174 			const efi_string_t string)
175 {
176 	EFI_ENTRY("%p, %p", this, string);
177 	return EFI_EXIT(EFI_SUCCESS);
178 }
179 
180 static bool cout_mode_matches(struct cout_mode *mode, int rows, int cols)
181 {
182 	if (!mode->present)
183 		return false;
184 
185 	return (mode->rows == rows) && (mode->columns == cols);
186 }
187 
188 static int query_console_serial(int *rows, int *cols)
189 {
190 	/* Ask the terminal about its size */
191 	int n[3];
192 	u64 timeout;
193 
194 	/* Empty input buffer */
195 	while (tstc())
196 		getc();
197 
198 	printf(ESC"[18t");
199 
200 	/* Check if we have a terminal that understands */
201 	timeout = timer_get_us() + 1000000;
202 	while (!tstc())
203 		if (timer_get_us() > timeout)
204 			return -1;
205 
206 	/* Read {depth,rows,cols} */
207 	if (term_read_reply(n, 3, 't'))
208 		return -1;
209 
210 	*cols = n[2];
211 	*rows = n[1];
212 
213 	return 0;
214 }
215 
216 /*
217  * Update the mode table.
218  *
219  * By default the only mode available is 80x25. If the console has at least 50
220  * lines, enable mode 80x50. If we can query the console size and it is neither
221  * 80x25 nor 80x50, set it as an additional mode.
222  */
223 static void query_console_size(void)
224 {
225 	const char *stdout_name = env_get("stdout");
226 	int rows = 25, cols = 80;
227 
228 	if (stdout_name && !strcmp(stdout_name, "vidconsole") &&
229 	    IS_ENABLED(CONFIG_DM_VIDEO)) {
230 		struct stdio_dev *stdout_dev =
231 			stdio_get_by_name("vidconsole");
232 		struct udevice *dev = stdout_dev->priv;
233 		struct vidconsole_priv *priv =
234 			dev_get_uclass_priv(dev);
235 		rows = priv->rows;
236 		cols = priv->cols;
237 	} else if (query_console_serial(&rows, &cols)) {
238 		return;
239 	}
240 
241 	/* Test if we can have Mode 1 */
242 	if (cols >= 80 && rows >= 50) {
243 		efi_cout_modes[1].present = 1;
244 		efi_con_mode.max_mode = 2;
245 	}
246 
247 	/*
248 	 * Install our mode as mode 2 if it is different
249 	 * than mode 0 or 1 and set it as the currently selected mode
250 	 */
251 	if (!cout_mode_matches(&efi_cout_modes[0], rows, cols) &&
252 	    !cout_mode_matches(&efi_cout_modes[1], rows, cols)) {
253 		efi_cout_modes[EFI_COUT_MODE_2].columns = cols;
254 		efi_cout_modes[EFI_COUT_MODE_2].rows = rows;
255 		efi_cout_modes[EFI_COUT_MODE_2].present = 1;
256 		efi_con_mode.max_mode = EFI_MAX_COUT_MODE;
257 		efi_con_mode.mode = EFI_COUT_MODE_2;
258 	}
259 }
260 
261 static efi_status_t EFIAPI efi_cout_query_mode(
262 			struct efi_simple_text_output_protocol *this,
263 			unsigned long mode_number, unsigned long *columns,
264 			unsigned long *rows)
265 {
266 	EFI_ENTRY("%p, %ld, %p, %p", this, mode_number, columns, rows);
267 
268 	if (mode_number >= efi_con_mode.max_mode)
269 		return EFI_EXIT(EFI_UNSUPPORTED);
270 
271 	if (efi_cout_modes[mode_number].present != 1)
272 		return EFI_EXIT(EFI_UNSUPPORTED);
273 
274 	if (columns)
275 		*columns = efi_cout_modes[mode_number].columns;
276 	if (rows)
277 		*rows = efi_cout_modes[mode_number].rows;
278 
279 	return EFI_EXIT(EFI_SUCCESS);
280 }
281 
282 static efi_status_t EFIAPI efi_cout_set_mode(
283 			struct efi_simple_text_output_protocol *this,
284 			unsigned long mode_number)
285 {
286 	EFI_ENTRY("%p, %ld", this, mode_number);
287 
288 
289 	if (mode_number > efi_con_mode.max_mode)
290 		return EFI_EXIT(EFI_UNSUPPORTED);
291 
292 	efi_con_mode.mode = mode_number;
293 	efi_con_mode.cursor_column = 0;
294 	efi_con_mode.cursor_row = 0;
295 
296 	return EFI_EXIT(EFI_SUCCESS);
297 }
298 
299 static const struct {
300 	unsigned int fg;
301 	unsigned int bg;
302 } color[] = {
303 	{ 30, 40 },     /* 0: black */
304 	{ 34, 44 },     /* 1: blue */
305 	{ 32, 42 },     /* 2: green */
306 	{ 36, 46 },     /* 3: cyan */
307 	{ 31, 41 },     /* 4: red */
308 	{ 35, 45 },     /* 5: magenta */
309 	{ 33, 43 },     /* 6: brown, map to yellow as edk2 does*/
310 	{ 37, 47 },     /* 7: light grey, map to white */
311 };
312 
313 /* See EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.SetAttribute(). */
314 static efi_status_t EFIAPI efi_cout_set_attribute(
315 			struct efi_simple_text_output_protocol *this,
316 			unsigned long attribute)
317 {
318 	unsigned int bold = EFI_ATTR_BOLD(attribute);
319 	unsigned int fg = EFI_ATTR_FG(attribute);
320 	unsigned int bg = EFI_ATTR_BG(attribute);
321 
322 	EFI_ENTRY("%p, %lx", this, attribute);
323 
324 	if (attribute)
325 		printf(ESC"[%u;%u;%um", bold, color[fg].fg, color[bg].bg);
326 	else
327 		printf(ESC"[0;37;40m");
328 
329 	return EFI_EXIT(EFI_SUCCESS);
330 }
331 
332 static efi_status_t EFIAPI efi_cout_clear_screen(
333 			struct efi_simple_text_output_protocol *this)
334 {
335 	EFI_ENTRY("%p", this);
336 
337 	printf(ESC"[2J");
338 	efi_con_mode.cursor_column = 0;
339 	efi_con_mode.cursor_row = 0;
340 
341 	return EFI_EXIT(EFI_SUCCESS);
342 }
343 
344 static efi_status_t EFIAPI efi_cout_set_cursor_position(
345 			struct efi_simple_text_output_protocol *this,
346 			unsigned long column, unsigned long row)
347 {
348 	EFI_ENTRY("%p, %ld, %ld", this, column, row);
349 
350 	printf(ESC"[%d;%df", (int)row, (int)column);
351 	efi_con_mode.cursor_column = column;
352 	efi_con_mode.cursor_row = row;
353 
354 	return EFI_EXIT(EFI_SUCCESS);
355 }
356 
357 static efi_status_t EFIAPI efi_cout_enable_cursor(
358 			struct efi_simple_text_output_protocol *this,
359 			bool enable)
360 {
361 	EFI_ENTRY("%p, %d", this, enable);
362 
363 	printf(ESC"[?25%c", enable ? 'h' : 'l');
364 
365 	return EFI_EXIT(EFI_SUCCESS);
366 }
367 
368 struct efi_simple_text_output_protocol efi_con_out = {
369 	.reset = efi_cout_reset,
370 	.output_string = efi_cout_output_string,
371 	.test_string = efi_cout_test_string,
372 	.query_mode = efi_cout_query_mode,
373 	.set_mode = efi_cout_set_mode,
374 	.set_attribute = efi_cout_set_attribute,
375 	.clear_screen = efi_cout_clear_screen,
376 	.set_cursor_position = efi_cout_set_cursor_position,
377 	.enable_cursor = efi_cout_enable_cursor,
378 	.mode = (void*)&efi_con_mode,
379 };
380 
381 static efi_status_t EFIAPI efi_cin_reset(
382 			struct efi_simple_input_interface *this,
383 			bool extended_verification)
384 {
385 	EFI_ENTRY("%p, %d", this, extended_verification);
386 
387 	/* Empty input buffer */
388 	while (tstc())
389 		getc();
390 
391 	return EFI_EXIT(EFI_SUCCESS);
392 }
393 
394 /*
395  * Analyze modifiers (shift, alt, ctrl) for function keys.
396  * This gets called when we have already parsed CSI.
397  *
398  * @modifiers:  bitmask (shift, alt, ctrl)
399  * @return:	the unmodified code
400  */
401 static char skip_modifiers(int *modifiers)
402 {
403 	char c, mod = 0, ret = 0;
404 
405 	c = getc();
406 
407 	if (c != ';') {
408 		ret = c;
409 		if (c == '~')
410 			goto out;
411 		c = getc();
412 	}
413 	for (;;) {
414 		switch (c) {
415 		case '0'...'9':
416 			mod *= 10;
417 			mod += c - '0';
418 		/* fall through */
419 		case ';':
420 			c = getc();
421 			break;
422 		default:
423 			goto out;
424 		}
425 	}
426 out:
427 	if (mod)
428 		--mod;
429 	if (modifiers)
430 		*modifiers = mod;
431 	if (!ret)
432 		ret = c;
433 	return ret;
434 }
435 
436 static efi_status_t EFIAPI efi_cin_read_key_stroke(
437 			struct efi_simple_input_interface *this,
438 			struct efi_input_key *key)
439 {
440 	struct efi_input_key pressed_key = {
441 		.scan_code = 0,
442 		.unicode_char = 0,
443 	};
444 	char ch;
445 
446 	EFI_ENTRY("%p, %p", this, key);
447 
448 	/* We don't do interrupts, so check for timers cooperatively */
449 	efi_timer_check();
450 
451 	if (!tstc()) {
452 		/* No key pressed */
453 		return EFI_EXIT(EFI_NOT_READY);
454 	}
455 
456 	ch = getc();
457 	if (ch == cESC) {
458 		/*
459 		 * Xterm Control Sequences
460 		 * https://www.xfree86.org/4.8.0/ctlseqs.html
461 		 */
462 		ch = getc();
463 		switch (ch) {
464 		case cESC: /* ESC */
465 			pressed_key.scan_code = 23;
466 			break;
467 		case 'O': /* F1 - F4 */
468 			ch = getc();
469 			/* skip modifiers */
470 			if (ch <= '9')
471 				ch = getc();
472 			pressed_key.scan_code = ch - 'P' + 11;
473 			break;
474 		case 'a'...'z':
475 			ch = ch - 'a';
476 			break;
477 		case '[':
478 			ch = getc();
479 			switch (ch) {
480 			case 'A'...'D': /* up, down right, left */
481 				pressed_key.scan_code = ch - 'A' + 1;
482 				break;
483 			case 'F': /* End */
484 				pressed_key.scan_code = 6;
485 				break;
486 			case 'H': /* Home */
487 				pressed_key.scan_code = 5;
488 				break;
489 			case '1':
490 				ch = skip_modifiers(NULL);
491 				switch (ch) {
492 				case '1'...'5': /* F1 - F5 */
493 					pressed_key.scan_code = ch - '1' + 11;
494 					break;
495 				case '7'...'9': /* F6 - F8 */
496 					pressed_key.scan_code = ch - '7' + 16;
497 					break;
498 				case 'A'...'D': /* up, down right, left */
499 					pressed_key.scan_code = ch - 'A' + 1;
500 					break;
501 				case 'F':
502 					pressed_key.scan_code = 6; /* End */
503 					break;
504 				case 'H':
505 					pressed_key.scan_code = 5; /* Home */
506 					break;
507 				}
508 				break;
509 			case '2':
510 				ch = skip_modifiers(NULL);
511 				switch (ch) {
512 				case '0'...'1': /* F9 - F10 */
513 					pressed_key.scan_code = ch - '0' + 19;
514 					break;
515 				case '3'...'4': /* F11 - F12 */
516 					pressed_key.scan_code = ch - '3' + 21;
517 					break;
518 				case '~': /* INS */
519 					pressed_key.scan_code = 7;
520 					break;
521 				}
522 				break;
523 			case '3': /* DEL */
524 				pressed_key.scan_code = 8;
525 				skip_modifiers(NULL);
526 				break;
527 			case '5': /* PG UP */
528 				pressed_key.scan_code = 9;
529 				skip_modifiers(NULL);
530 				break;
531 			case '6': /* PG DOWN */
532 				pressed_key.scan_code = 10;
533 				skip_modifiers(NULL);
534 				break;
535 			}
536 			break;
537 		}
538 	} else if (ch == 0x7f) {
539 		/* Backspace */
540 		ch = 0x08;
541 	}
542 	if (!pressed_key.scan_code)
543 		pressed_key.unicode_char = ch;
544 	*key = pressed_key;
545 
546 	return EFI_EXIT(EFI_SUCCESS);
547 }
548 
549 struct efi_simple_input_interface efi_con_in = {
550 	.reset = efi_cin_reset,
551 	.read_key_stroke = efi_cin_read_key_stroke,
552 	.wait_for_key = NULL,
553 };
554 
555 static struct efi_event *console_timer_event;
556 
557 static void EFIAPI efi_key_notify(struct efi_event *event, void *context)
558 {
559 }
560 
561 /*
562  * Notification function of the console timer event.
563  *
564  * event:	console timer event
565  * context:	not used
566  */
567 static void EFIAPI efi_console_timer_notify(struct efi_event *event,
568 					    void *context)
569 {
570 	EFI_ENTRY("%p, %p", event, context);
571 
572 	/* Check if input is available */
573 	if (tstc()) {
574 		/* Queue the wait for key event */
575 		efi_con_in.wait_for_key->is_signaled = true;
576 		efi_signal_event(efi_con_in.wait_for_key, true);
577 	}
578 	EFI_EXIT(EFI_SUCCESS);
579 }
580 
581 /* This gets called from do_bootefi_exec(). */
582 int efi_console_register(void)
583 {
584 	efi_status_t r;
585 	struct efi_object *efi_console_output_obj;
586 	struct efi_object *efi_console_input_obj;
587 
588 	/* Set up mode information */
589 	query_console_size();
590 
591 	/* Create handles */
592 	r = efi_create_handle((efi_handle_t *)&efi_console_output_obj);
593 	if (r != EFI_SUCCESS)
594 		goto out_of_memory;
595 	r = efi_add_protocol(efi_console_output_obj->handle,
596 			     &efi_guid_text_output_protocol, &efi_con_out);
597 	if (r != EFI_SUCCESS)
598 		goto out_of_memory;
599 	r = efi_create_handle((efi_handle_t *)&efi_console_input_obj);
600 	if (r != EFI_SUCCESS)
601 		goto out_of_memory;
602 	r = efi_add_protocol(efi_console_input_obj->handle,
603 			     &efi_guid_text_input_protocol, &efi_con_in);
604 	if (r != EFI_SUCCESS)
605 		goto out_of_memory;
606 
607 	/* Create console events */
608 	r = efi_create_event(EVT_NOTIFY_WAIT, TPL_CALLBACK, efi_key_notify,
609 			     NULL, NULL, &efi_con_in.wait_for_key);
610 	if (r != EFI_SUCCESS) {
611 		printf("ERROR: Failed to register WaitForKey event\n");
612 		return r;
613 	}
614 	r = efi_create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK,
615 			     efi_console_timer_notify, NULL, NULL,
616 			     &console_timer_event);
617 	if (r != EFI_SUCCESS) {
618 		printf("ERROR: Failed to register console event\n");
619 		return r;
620 	}
621 	/* 5000 ns cycle is sufficient for 2 MBaud */
622 	r = efi_set_timer(console_timer_event, EFI_TIMER_PERIODIC, 50);
623 	if (r != EFI_SUCCESS)
624 		printf("ERROR: Failed to set console timer\n");
625 	return r;
626 out_of_memory:
627 	printf("ERROR: Out of meemory\n");
628 	return r;
629 }
630