blob: 8ef7326fef2ec04df0da7866947cb047aca5d298 [file] [log] [blame]
Alexander Grafc1311ad2016-03-04 01:10:00 +01001/*
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
Alexander Grafc1311ad2016-03-04 01:10:00 +010012static bool console_size_queried;
13
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +010014#define EFI_COUT_MODE_2 2
15#define EFI_MAX_COUT_MODE 3
16
17struct cout_mode {
18 unsigned long columns;
19 unsigned long rows;
20 int present;
21};
22
23static 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
Alexander Grafc1311ad2016-03-04 01:10:00 +010044const efi_guid_t efi_guid_console_control = CONSOLE_CONTROL_GUID;
45
46#define cESC '\x1b'
47#define ESC "\x1b"
48
49static 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
65static 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
72static 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
80const 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
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +010086/* Default to mode 0 */
Alexander Grafc1311ad2016-03-04 01:10:00 +010087static struct simple_text_output_mode efi_con_mode = {
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +010088 .max_mode = 1,
Alexander Grafc1311ad2016-03-04 01:10:00 +010089 .mode = 0,
90 .attribute = 0,
91 .cursor_column = 0,
92 .cursor_row = 0,
93 .cursor_visible = 1,
94};
95
96static 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
131static 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
139static 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
158static efi_status_t EFIAPI efi_cout_output_string(
159 struct efi_simple_text_output_protocol *this,
160 const unsigned short *string)
161{
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100162 struct cout_mode *mode;
Alexander Grafc1311ad2016-03-04 01:10:00 +0100163 u16 ch;
164
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100165 mode = &efi_cout_modes[efi_con_mode.mode];
Alexander Grafc1311ad2016-03-04 01:10:00 +0100166 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++;
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100173 } else if (efi_con_mode.cursor_column > mode->columns) {
Alexander Grafc1311ad2016-03-04 01:10:00 +0100174 efi_con_mode.cursor_column = 1;
175 efi_con_mode.cursor_row++;
176 }
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100177 if (efi_con_mode.cursor_row > mode->rows)
178 efi_con_mode.cursor_row = mode->rows;
Alexander Grafc1311ad2016-03-04 01:10:00 +0100179 }
180
181 return EFI_EXIT(EFI_SUCCESS);
182}
183
184static 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
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100192static 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
Alexander Grafc1311ad2016-03-04 01:10:00 +0100200static 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];
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100210 int cols;
211 int rows;
Alexander Grafc1311ad2016-03-04 01:10:00 +0100212 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
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100233 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 }
Alexander Grafc1311ad2016-03-04 01:10:00 +0100254 }
255
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100256 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
Alexander Grafc1311ad2016-03-04 01:10:00 +0100262out:
263 if (columns)
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100264 *columns = efi_cout_modes[mode_number].columns;
Alexander Grafc1311ad2016-03-04 01:10:00 +0100265 if (rows)
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100266 *rows = efi_cout_modes[mode_number].rows;
Alexander Grafc1311ad2016-03-04 01:10:00 +0100267
268 return EFI_EXIT(EFI_SUCCESS);
269}
270
271static 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
Alexander Grafc1311ad2016-03-04 01:10:00 +0100277
Emmanuel Vadot5be8b0a2016-11-08 06:03:29 +0100278 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);
Alexander Grafc1311ad2016-03-04 01:10:00 +0100286}
287
288static 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
298static 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
308static 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
321static 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
332const 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
345static 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
353static 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
424const struct efi_simple_input_interface efi_con_in = {
425 .reset = efi_cin_reset,
426 .read_key_stroke = efi_cin_read_key_stroke,
427 .wait_for_key = NULL,
428};