xref: /openbmc/linux/drivers/firmware/efi/earlycon.c (revision 8b3a149d)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2013 Intel Corporation; author Matt Fleming
4  */
5 
6 #include <linux/console.h>
7 #include <linux/efi.h>
8 #include <linux/font.h>
9 #include <linux/io.h>
10 #include <linux/kernel.h>
11 #include <linux/serial_core.h>
12 #include <linux/screen_info.h>
13 #include <linux/string.h>
14 
15 #include <asm/early_ioremap.h>
16 
17 static const struct console *earlycon_console __initdata;
18 static const struct font_desc *font;
19 static u16 cur_line_y, max_line_y;
20 static u32 efi_x_array[1024];
21 static u32 efi_x, efi_y;
22 static u64 fb_base;
23 static bool fb_wb;
24 static void *efi_fb;
25 
26 /*
27  * EFI earlycon needs to use early_memremap() to map the framebuffer.
28  * But early_memremap() is not usable for 'earlycon=efifb keep_bootcon',
29  * memremap() should be used instead. memremap() will be available after
30  * paging_init() which is earlier than initcall callbacks. Thus adding this
31  * early initcall function early_efi_map_fb() to map the whole EFI framebuffer.
32  */
efi_earlycon_remap_fb(void)33 static int __init efi_earlycon_remap_fb(void)
34 {
35 	/* bail if there is no bootconsole or it was unregistered already */
36 	if (!earlycon_console || !console_is_registered(earlycon_console))
37 		return 0;
38 
39 	efi_fb = memremap(fb_base, screen_info.lfb_size,
40 			  fb_wb ? MEMREMAP_WB : MEMREMAP_WC);
41 
42 	return efi_fb ? 0 : -ENOMEM;
43 }
44 early_initcall(efi_earlycon_remap_fb);
45 
efi_earlycon_unmap_fb(void)46 static int __init efi_earlycon_unmap_fb(void)
47 {
48 	/* unmap the bootconsole fb unless keep_bootcon left it registered */
49 	if (efi_fb && !console_is_registered(earlycon_console))
50 		memunmap(efi_fb);
51 	return 0;
52 }
53 late_initcall(efi_earlycon_unmap_fb);
54 
efi_earlycon_map(unsigned long start,unsigned long len)55 static __ref void *efi_earlycon_map(unsigned long start, unsigned long len)
56 {
57 	pgprot_t fb_prot;
58 
59 	if (efi_fb)
60 		return efi_fb + start;
61 
62 	fb_prot = fb_wb ? PAGE_KERNEL : pgprot_writecombine(PAGE_KERNEL);
63 	return early_memremap_prot(fb_base + start, len, pgprot_val(fb_prot));
64 }
65 
efi_earlycon_unmap(void * addr,unsigned long len)66 static __ref void efi_earlycon_unmap(void *addr, unsigned long len)
67 {
68 	if (efi_fb)
69 		return;
70 
71 	early_memunmap(addr, len);
72 }
73 
efi_earlycon_clear_scanline(unsigned int y)74 static void efi_earlycon_clear_scanline(unsigned int y)
75 {
76 	unsigned long *dst;
77 	u16 len;
78 
79 	len = screen_info.lfb_linelength;
80 	dst = efi_earlycon_map(y*len, len);
81 	if (!dst)
82 		return;
83 
84 	memset(dst, 0, len);
85 	efi_earlycon_unmap(dst, len);
86 }
87 
efi_earlycon_scroll_up(void)88 static void efi_earlycon_scroll_up(void)
89 {
90 	unsigned long *dst, *src;
91 	u16 maxlen = 0;
92 	u16 len;
93 	u32 i, height;
94 
95 	/* Find the cached maximum x coordinate */
96 	for (i = 0; i < max_line_y; i++) {
97 		if (efi_x_array[i] > maxlen)
98 			maxlen = efi_x_array[i];
99 	}
100 	maxlen *= 4;
101 
102 	len = screen_info.lfb_linelength;
103 	height = screen_info.lfb_height;
104 
105 	for (i = 0; i < height - font->height; i++) {
106 		dst = efi_earlycon_map(i*len, len);
107 		if (!dst)
108 			return;
109 
110 		src = efi_earlycon_map((i + font->height) * len, len);
111 		if (!src) {
112 			efi_earlycon_unmap(dst, len);
113 			return;
114 		}
115 
116 		memmove(dst, src, maxlen);
117 
118 		efi_earlycon_unmap(src, len);
119 		efi_earlycon_unmap(dst, len);
120 	}
121 }
122 
efi_earlycon_write_char(u32 * dst,unsigned char c,unsigned int h)123 static void efi_earlycon_write_char(u32 *dst, unsigned char c, unsigned int h)
124 {
125 	const u32 color_black = 0x00000000;
126 	const u32 color_white = 0x00ffffff;
127 	const u8 *src;
128 	int m, n, bytes;
129 	u8 x;
130 
131 	bytes = BITS_TO_BYTES(font->width);
132 	src = font->data + c * font->height * bytes + h * bytes;
133 
134 	for (m = 0; m < font->width; m++) {
135 		n = m % 8;
136 		x = *(src + m / 8);
137 		if ((x >> (7 - n)) & 1)
138 			*dst = color_white;
139 		else
140 			*dst = color_black;
141 		dst++;
142 	}
143 }
144 
145 static void
efi_earlycon_write(struct console * con,const char * str,unsigned int num)146 efi_earlycon_write(struct console *con, const char *str, unsigned int num)
147 {
148 	struct screen_info *si;
149 	u32 cur_efi_x = efi_x;
150 	unsigned int len;
151 	const char *s;
152 	void *dst;
153 
154 	si = &screen_info;
155 	len = si->lfb_linelength;
156 
157 	while (num) {
158 		unsigned int linemax = (si->lfb_width - efi_x) / font->width;
159 		unsigned int h, count;
160 
161 		count = strnchrnul(str, num, '\n') - str;
162 		if (count > linemax)
163 			count = linemax;
164 
165 		for (h = 0; h < font->height; h++) {
166 			unsigned int n, x;
167 
168 			dst = efi_earlycon_map((efi_y + h) * len, len);
169 			if (!dst)
170 				return;
171 
172 			s = str;
173 			n = count;
174 			x = efi_x;
175 
176 			while (n-- > 0) {
177 				efi_earlycon_write_char(dst + x*4, *s, h);
178 				x += font->width;
179 				s++;
180 			}
181 
182 			efi_earlycon_unmap(dst, len);
183 		}
184 
185 		num -= count;
186 		efi_x += count * font->width;
187 		str += count;
188 
189 		if (num > 0 && *s == '\n') {
190 			cur_efi_x = efi_x;
191 			efi_x = 0;
192 			efi_y += font->height;
193 			str++;
194 			num--;
195 		}
196 
197 		if (efi_x + font->width > si->lfb_width) {
198 			cur_efi_x = efi_x;
199 			efi_x = 0;
200 			efi_y += font->height;
201 		}
202 
203 		if (efi_y + font->height > si->lfb_height) {
204 			u32 i;
205 
206 			efi_x_array[cur_line_y] = cur_efi_x;
207 			cur_line_y = (cur_line_y + 1) % max_line_y;
208 
209 			efi_y -= font->height;
210 			efi_earlycon_scroll_up();
211 
212 			for (i = 0; i < font->height; i++)
213 				efi_earlycon_clear_scanline(efi_y + i);
214 		}
215 	}
216 }
217 
218 static bool __initdata fb_probed;
219 
efi_earlycon_reprobe(void)220 void __init efi_earlycon_reprobe(void)
221 {
222 	if (fb_probed)
223 		setup_earlycon("efifb");
224 }
225 
efi_earlycon_setup(struct earlycon_device * device,const char * opt)226 static int __init efi_earlycon_setup(struct earlycon_device *device,
227 				     const char *opt)
228 {
229 	struct screen_info *si;
230 	u16 xres, yres;
231 	u32 i;
232 
233 	fb_wb = opt && !strcmp(opt, "ram");
234 
235 	if (screen_info.orig_video_isVGA != VIDEO_TYPE_EFI) {
236 		fb_probed = true;
237 		return -ENODEV;
238 	}
239 
240 	fb_base = screen_info.lfb_base;
241 	if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE)
242 		fb_base |= (u64)screen_info.ext_lfb_base << 32;
243 
244 	si = &screen_info;
245 	xres = si->lfb_width;
246 	yres = si->lfb_height;
247 
248 	/*
249 	 * efi_earlycon_write_char() implicitly assumes a framebuffer with
250 	 * 32 bits per pixel.
251 	 */
252 	if (si->lfb_depth != 32)
253 		return -ENODEV;
254 
255 	font = get_default_font(xres, yres, -1, -1);
256 	if (!font)
257 		return -ENODEV;
258 
259 	/* Fill the cache with maximum possible value of x coordinate */
260 	memset32(efi_x_array, rounddown(xres, font->width), ARRAY_SIZE(efi_x_array));
261 	efi_y = rounddown(yres, font->height);
262 
263 	/* Make sure we have cache for the x coordinate for the full screen */
264 	max_line_y = efi_y / font->height + 1;
265 	cur_line_y = 0;
266 
267 	efi_y -= font->height;
268 	for (i = 0; i < (yres - efi_y) / font->height; i++)
269 		efi_earlycon_scroll_up();
270 
271 	device->con->write = efi_earlycon_write;
272 	earlycon_console = device->con;
273 	return 0;
274 }
275 EARLYCON_DECLARE(efifb, efi_earlycon_setup);
276