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 | */ |
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(con: earlycon_console)) |
37 | return 0; |
38 | |
39 | efi_fb = memremap(offset: fb_base, size: screen_info.lfb_size, |
40 | flags: fb_wb ? MEMREMAP_WB : MEMREMAP_WC); |
41 | |
42 | return efi_fb ? 0 : -ENOMEM; |
43 | } |
44 | early_initcall(efi_earlycon_remap_fb); |
45 | |
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(con: earlycon_console)) |
50 | memunmap(addr: efi_fb); |
51 | return 0; |
52 | } |
53 | late_initcall(efi_earlycon_unmap_fb); |
54 | |
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(phys_addr: fb_base + start, size: len, pgprot_val(fb_prot)); |
64 | } |
65 | |
66 | static __ref void efi_earlycon_unmap(void *addr, unsigned long len) |
67 | { |
68 | if (efi_fb) |
69 | return; |
70 | |
71 | early_memunmap(addr, size: len); |
72 | } |
73 | |
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(start: y*len, len); |
81 | if (!dst) |
82 | return; |
83 | |
84 | memset(dst, 0, len); |
85 | efi_earlycon_unmap(addr: dst, len); |
86 | } |
87 | |
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(start: i*len, len); |
107 | if (!dst) |
108 | return; |
109 | |
110 | src = efi_earlycon_map(start: (i + font->height) * len, len); |
111 | if (!src) { |
112 | efi_earlycon_unmap(addr: dst, len); |
113 | return; |
114 | } |
115 | |
116 | memmove(dst, src, maxlen); |
117 | |
118 | efi_earlycon_unmap(addr: src, len); |
119 | efi_earlycon_unmap(addr: dst, len); |
120 | } |
121 | } |
122 | |
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 |
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(start: (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: dst + x*4, c: *s, h); |
178 | x += font->width; |
179 | s++; |
180 | } |
181 | |
182 | efi_earlycon_unmap(addr: 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(y: efi_y + i); |
214 | } |
215 | } |
216 | } |
217 | |
218 | static bool __initdata fb_probed; |
219 | |
220 | void __init efi_earlycon_reprobe(void) |
221 | { |
222 | if (fb_probed) |
223 | setup_earlycon("efifb" ); |
224 | } |
225 | |
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, font_w: -1, font_h: -1); |
256 | if (!font) |
257 | return -ENODEV; |
258 | |
259 | /* Fill the cache with maximum possible value of x coordinate */ |
260 | memset32(s: 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 | |