xref: /freebsd/stand/efi/libefi/efi_console.c (revision 396c556d77189a5c474d35cec6f44a762e310b7d)
1 /*-
2  * Copyright (c) 2000 Doug Rabson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include <efi.h>
31 #include <efilib.h>
32 
33 #include "bootstrap.h"
34 
35 static SIMPLE_TEXT_OUTPUT_INTERFACE	*conout;
36 static SIMPLE_INPUT_INTERFACE		*conin;
37 
38 #ifdef TERM_EMU
39 #define	DEFAULT_FGCOLOR	EFI_LIGHTGRAY
40 #define	DEFAULT_BGCOLOR	EFI_BLACK
41 
42 #define	MAXARGS	8
43 static int args[MAXARGS], argc;
44 static int fg_c, bg_c, curx, cury;
45 static int esc;
46 
47 void get_pos(int *x, int *y);
48 void curs_move(int *_x, int *_y, int x, int y);
49 static void CL(int);
50 void HO(void);
51 void end_term(void);
52 #endif
53 
54 static EFI_INPUT_KEY key_cur;
55 static int key_pending;
56 
57 static void efi_cons_probe(struct console *);
58 static int efi_cons_init(int);
59 void efi_cons_putchar(int);
60 int efi_cons_getchar(void);
61 void efi_cons_efiputchar(int);
62 int efi_cons_poll(void);
63 
64 struct console efi_console = {
65 	"efi",
66 	"EFI console",
67 	C_WIDEOUT,
68 	efi_cons_probe,
69 	efi_cons_init,
70 	efi_cons_putchar,
71 	efi_cons_getchar,
72 	efi_cons_poll
73 };
74 
75 #ifdef TERM_EMU
76 
77 /* Get cursor position. */
78 void
79 get_pos(int *x, int *y)
80 {
81 	*x = conout->Mode->CursorColumn;
82 	*y = conout->Mode->CursorRow;
83 }
84 
85 /* Move cursor to x rows and y cols (0-based). */
86 void
87 curs_move(int *_x, int *_y, int x, int y)
88 {
89 	conout->SetCursorPosition(conout, x, y);
90 	if (_x != NULL)
91 		*_x = conout->Mode->CursorColumn;
92 	if (_y != NULL)
93 		*_y = conout->Mode->CursorRow;
94 }
95 
96 /* Clear internal state of the terminal emulation code. */
97 void
98 end_term(void)
99 {
100 	esc = 0;
101 	argc = -1;
102 }
103 
104 #endif
105 
106 static void
107 efi_cons_probe(struct console *cp)
108 {
109 	conout = ST->ConOut;
110 	conin = ST->ConIn;
111 	cp->c_flags |= C_PRESENTIN | C_PRESENTOUT;
112 }
113 
114 static int
115 efi_cons_init(int arg)
116 {
117 #ifdef TERM_EMU
118 	conout->SetAttribute(conout, EFI_TEXT_ATTR(DEFAULT_FGCOLOR,
119 	    DEFAULT_BGCOLOR));
120 	end_term();
121 	get_pos(&curx, &cury);
122 	curs_move(&curx, &cury, curx, cury);
123 	fg_c = DEFAULT_FGCOLOR;
124 	bg_c = DEFAULT_BGCOLOR;
125 #endif
126 	conout->EnableCursor(conout, TRUE);
127 	return 0;
128 }
129 
130 static void
131 efi_cons_rawputchar(int c)
132 {
133 	int i;
134 	UINTN x, y;
135 	conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
136 
137 	if (c == '\t')
138 		/* XXX lame tab expansion */
139 		for (i = 0; i < 8; i++)
140 			efi_cons_rawputchar(' ');
141 	else {
142 #ifndef	TERM_EMU
143 		if (c == '\n')
144 			efi_cons_efiputchar('\r');
145 		efi_cons_efiputchar(c);
146 #else
147 		switch (c) {
148 		case '\r':
149 			curx = 0;
150 			curs_move(&curx, &cury, curx, cury);
151 			return;
152 		case '\n':
153 			cury++;
154 			if (cury >= y) {
155 				efi_cons_efiputchar('\n');
156 				cury--;
157 			} else
158 				curs_move(&curx, &cury, curx, cury);
159 			return;
160 		case '\b':
161 			if (curx > 0) {
162 				curx--;
163 				curs_move(&curx, &cury, curx, cury);
164 			}
165 			return;
166 		default:
167 			efi_cons_efiputchar(c);
168 			curx++;
169 			if (curx > x-1) {
170 				curx = 0;
171 				cury++;
172 			}
173 			if (cury > y-1) {
174 				curx = 0;
175 				cury--;
176 			}
177 		}
178 		curs_move(&curx, &cury, curx, cury);
179 #endif
180 	}
181 }
182 
183 #ifdef TERM_EMU
184 /* Gracefully exit ESC-sequence processing in case of misunderstanding. */
185 static void
186 bail_out(int c)
187 {
188 	char buf[16], *ch;
189 	int i;
190 
191 	if (esc) {
192 		efi_cons_rawputchar('\033');
193 		if (esc != '\033')
194 			efi_cons_rawputchar(esc);
195 		for (i = 0; i <= argc; ++i) {
196 			sprintf(buf, "%d", args[i]);
197 			ch = buf;
198 			while (*ch)
199 				efi_cons_rawputchar(*ch++);
200 		}
201 	}
202 	efi_cons_rawputchar(c);
203 	end_term();
204 }
205 
206 /* Clear display from current position to end of screen. */
207 static void
208 CD(void) {
209 	int i;
210 	UINTN x, y;
211 
212 	get_pos(&curx, &cury);
213 	if (curx == 0 && cury == 0) {
214 		conout->ClearScreen(conout);
215 		end_term();
216 		return;
217 	}
218 
219 	conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
220 	CL(0);  /* clear current line from cursor to end */
221 	for (i = cury + 1; i < y-1; i++) {
222 		curs_move(NULL, NULL, 0, i);
223 		CL(0);
224 	}
225 	curs_move(NULL, NULL, curx, cury);
226 	end_term();
227 }
228 
229 /*
230  * Absolute cursor move to args[0] rows and args[1] columns
231  * (the coordinates are 1-based).
232  */
233 static void
234 CM(void)
235 {
236 	if (args[0] > 0)
237 		args[0]--;
238 	if (args[1] > 0)
239 		args[1]--;
240 	curs_move(&curx, &cury, args[1], args[0]);
241 	end_term();
242 }
243 
244 /* Home cursor (left top corner), also called from mode command. */
245 void
246 HO(void)
247 {
248 	argc = 1;
249 	args[0] = args[1] = 1;
250 	CM();
251 }
252 
253 /* Clear line from current position to end of line */
254 static void
255 CL(int direction)
256 {
257 	int i, len;
258 	UINTN x, y;
259 	CHAR16 *line;
260 
261 	conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
262 	switch (direction) {
263 	case 0:         /* from cursor to end */
264 		len = x - curx + 1;
265 		break;
266 	case 1:         /* from beginning to cursor */
267 		len = curx;
268 		break;
269 	case 2:         /* entire line */
270 		len = x;
271 		break;
272 	default:	/* NOTREACHED */
273 		__unreachable();
274 	}
275 
276 	if (cury == y - 1)
277 		len--;
278 
279 	line = malloc(len * sizeof (CHAR16));
280 	if (line == NULL) {
281 		printf("out of memory\n");
282 		return;
283 	}
284 	for (i = 0; i < len; i++)
285 		line[i] = ' ';
286 	line[len-1] = 0;
287 
288 	if (direction != 0)
289 		curs_move(NULL, NULL, 0, cury);
290 
291 	conout->OutputString(conout, line);
292 	/* restore cursor position */
293 	curs_move(NULL, NULL, curx, cury);
294 	free(line);
295 	end_term();
296 }
297 
298 static void
299 get_arg(int c)
300 {
301 	if (argc < 0)
302 		argc = 0;
303 	args[argc] *= 10;
304 	args[argc] += c - '0';
305 }
306 
307 /* Emulate basic capabilities of cons25 terminal */
308 static void
309 efi_term_emu(int c)
310 {
311 	static int ansi_col[] = {
312 		0, 4, 2, 6, 1, 5, 3, 7
313 	};
314 	int t, i;
315 
316 	switch (esc) {
317 	case 0:
318 		switch (c) {
319 		case '\033':
320 			esc = c;
321 			break;
322 		default:
323 			efi_cons_rawputchar(c);
324 			break;
325 		}
326 		break;
327 	case '\033':
328 		switch (c) {
329 		case '[':
330 			esc = c;
331 			args[0] = 0;
332 			argc = -1;
333 			break;
334 		default:
335 			bail_out(c);
336 			break;
337 		}
338 		break;
339 	case '[':
340 		switch (c) {
341 		case ';':
342 			if (argc < 0)
343 				argc = 0;
344 			else if (argc + 1 >= MAXARGS)
345 				bail_out(c);
346 			else
347 				args[++argc] = 0;
348 			break;
349 		case 'H':               /* ho = \E[H */
350 			if (argc < 0)
351 				HO();
352 			else if (argc == 1)
353 				CM();
354 			else
355 				bail_out(c);
356 			break;
357 		case 'J':               /* cd = \E[J */
358 			if (argc < 0)
359 				CD();
360 			else
361 				bail_out(c);
362 			break;
363 		case 'm':
364 			if (argc < 0) {
365 				fg_c = DEFAULT_FGCOLOR;
366 				bg_c = DEFAULT_BGCOLOR;
367 			}
368 			for (i = 0; i <= argc; ++i) {
369 				switch (args[i]) {
370 				case 0:         /* back to normal */
371 					fg_c = DEFAULT_FGCOLOR;
372 					bg_c = DEFAULT_BGCOLOR;
373 					break;
374 				case 1:         /* bold */
375 					fg_c |= 0x8;
376 					break;
377 				case 4:         /* underline */
378 				case 5:         /* blink */
379 					bg_c |= 0x8;
380 					break;
381 				case 7:         /* reverse */
382 					t = fg_c;
383 					fg_c = bg_c;
384 					bg_c = t;
385 					break;
386 				case 30: case 31: case 32: case 33:
387 				case 34: case 35: case 36: case 37:
388 					fg_c = ansi_col[args[i] - 30];
389 					break;
390 				case 39:        /* normal */
391 					fg_c = DEFAULT_FGCOLOR;
392 					break;
393 				case 40: case 41: case 42: case 43:
394 				case 44: case 45: case 46: case 47:
395 					bg_c = ansi_col[args[i] - 40];
396 					break;
397 				case 49:        /* normal */
398 					bg_c = DEFAULT_BGCOLOR;
399 					break;
400 				}
401 			}
402 			conout->SetAttribute(conout, EFI_TEXT_ATTR(fg_c, bg_c));
403 			end_term();
404 			break;
405 		default:
406 			if (isdigit(c))
407 				get_arg(c);
408 			else
409 				bail_out(c);
410 			break;
411 		}
412 		break;
413 	default:
414 		bail_out(c);
415 		break;
416 	}
417 }
418 #else
419 void
420 HO(void)
421 {
422 }
423 #endif
424 
425 void
426 efi_cons_putchar(int c)
427 {
428 #ifdef TERM_EMU
429 	efi_term_emu(c);
430 #else
431 	efi_cons_rawputchar(c);
432 #endif
433 }
434 
435 int
436 efi_cons_getchar()
437 {
438 	EFI_INPUT_KEY key;
439 	EFI_STATUS status;
440 	UINTN junk;
441 
442 	if (key_pending) {
443 		key = key_cur;
444 		key_pending = 0;
445 	} else {
446 		/* Try to read a key stroke. We wait for one if none is pending. */
447 		status = conin->ReadKeyStroke(conin, &key);
448 		while (status == EFI_NOT_READY) {
449 			/* Some EFI implementation (u-boot for example) do not support WaitForKey */
450 			if (conin->WaitForKey != NULL)
451 				BS->WaitForEvent(1, &conin->WaitForKey, &junk);
452 			status = conin->ReadKeyStroke(conin, &key);
453 		}
454 	}
455 
456 	switch (key.ScanCode) {
457 	case 0x17: /* ESC */
458 		return (0x1b);  /* esc */
459 	}
460 
461 	/* this can return  */
462 	return (key.UnicodeChar);
463 }
464 
465 int
466 efi_cons_poll()
467 {
468 	EFI_INPUT_KEY key;
469 	EFI_STATUS status;
470 
471 	if (conin->WaitForKey == NULL) {
472 		if (key_pending)
473 			return (1);
474 		status = conin->ReadKeyStroke(conin, &key);
475 		if (status == EFI_SUCCESS) {
476 			key_cur = key;
477 			key_pending = 1;
478 		}
479 		return (key_pending);
480 	}
481 
482 	/* This can clear the signaled state. */
483 	return (BS->CheckEvent(conin->WaitForKey) == EFI_SUCCESS);
484 }
485 
486 /* Plain direct access to EFI OutputString(). */
487 void
488 efi_cons_efiputchar(int c)
489 {
490 	CHAR16 buf[2];
491 
492 	/*
493 	 * translate box chars to unicode
494 	 */
495 	switch (c) {
496 	/* single frame */
497 	case 0xb3: buf[0] = BOXDRAW_VERTICAL; break;
498 	case 0xbf: buf[0] = BOXDRAW_DOWN_LEFT; break;
499 	case 0xc0: buf[0] = BOXDRAW_UP_RIGHT; break;
500 	case 0xc4: buf[0] = BOXDRAW_HORIZONTAL; break;
501 	case 0xda: buf[0] = BOXDRAW_DOWN_RIGHT; break;
502 	case 0xd9: buf[0] = BOXDRAW_UP_LEFT; break;
503 
504 	/* double frame */
505 	case 0xba: buf[0] = BOXDRAW_DOUBLE_VERTICAL; break;
506 	case 0xbb: buf[0] = BOXDRAW_DOUBLE_DOWN_LEFT; break;
507 	case 0xbc: buf[0] = BOXDRAW_DOUBLE_UP_LEFT; break;
508 	case 0xc8: buf[0] = BOXDRAW_DOUBLE_UP_RIGHT; break;
509 	case 0xc9: buf[0] = BOXDRAW_DOUBLE_DOWN_RIGHT; break;
510 	case 0xcd: buf[0] = BOXDRAW_DOUBLE_HORIZONTAL; break;
511 
512 	default:
513 		buf[0] = c;
514 	}
515         buf[1] = 0;     /* terminate string */
516 
517 	conout->OutputString(conout, buf);
518 }
519