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