This source file includes following definitions.
- efi_earlycon_remap_fb
- efi_earlycon_unmap_fb
- efi_earlycon_map
- efi_earlycon_unmap
- efi_earlycon_clear_scanline
- efi_earlycon_scroll_up
- efi_earlycon_write_char
- efi_earlycon_write
- efi_earlycon_setup
1
2
3
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
16 static const struct console *earlycon_console __initdata;
17 static const struct font_desc *font;
18 static u32 efi_x, efi_y;
19 static u64 fb_base;
20 static bool fb_wb;
21 static void *efi_fb;
22
23
24
25
26
27
28
29
30 static int __init efi_earlycon_remap_fb(void)
31 {
32
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 }
41 early_initcall(efi_earlycon_remap_fb);
42
43 static int __init efi_earlycon_unmap_fb(void)
44 {
45
46 if (efi_fb && !(earlycon_console->flags & CON_ENABLED))
47 memunmap(efi_fb);
48 return 0;
49 }
50 late_initcall(efi_earlycon_unmap_fb);
51
52 static __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
63 static __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
71 static 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
85 static 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
112 static 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 u8 s8;
118 int m;
119
120 src = font->data + c * font->height;
121 s8 = *(src + h);
122
123 for (m = 0; m < 8; m++) {
124 if ((s8 >> (7 - m)) & 1)
125 *dst = color_white;
126 else
127 *dst = color_black;
128 dst++;
129 }
130 }
131
132 static void
133 efi_earlycon_write(struct console *con, const char *str, unsigned int num)
134 {
135 struct screen_info *si;
136 unsigned int len;
137 const char *s;
138 void *dst;
139
140 si = &screen_info;
141 len = si->lfb_linelength;
142
143 while (num) {
144 unsigned int linemax;
145 unsigned int h, count = 0;
146
147 for (s = str; *s && *s != '\n'; s++) {
148 if (count == num)
149 break;
150 count++;
151 }
152
153 linemax = (si->lfb_width - efi_x) / font->width;
154 if (count > linemax)
155 count = linemax;
156
157 for (h = 0; h < font->height; h++) {
158 unsigned int n, x;
159
160 dst = efi_earlycon_map((efi_y + h) * len, len);
161 if (!dst)
162 return;
163
164 s = str;
165 n = count;
166 x = efi_x;
167
168 while (n-- > 0) {
169 efi_earlycon_write_char(dst + x*4, *s, h);
170 x += font->width;
171 s++;
172 }
173
174 efi_earlycon_unmap(dst, len);
175 }
176
177 num -= count;
178 efi_x += count * font->width;
179 str += count;
180
181 if (num > 0 && *s == '\n') {
182 efi_x = 0;
183 efi_y += font->height;
184 str++;
185 num--;
186 }
187
188 if (efi_x + font->width > si->lfb_width) {
189 efi_x = 0;
190 efi_y += font->height;
191 }
192
193 if (efi_y + font->height > si->lfb_height) {
194 u32 i;
195
196 efi_y -= font->height;
197 efi_earlycon_scroll_up();
198
199 for (i = 0; i < font->height; i++)
200 efi_earlycon_clear_scanline(efi_y + i);
201 }
202 }
203 }
204
205 static int __init efi_earlycon_setup(struct earlycon_device *device,
206 const char *opt)
207 {
208 struct screen_info *si;
209 u16 xres, yres;
210 u32 i;
211
212 if (screen_info.orig_video_isVGA != VIDEO_TYPE_EFI)
213 return -ENODEV;
214
215 fb_base = screen_info.lfb_base;
216 if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE)
217 fb_base |= (u64)screen_info.ext_lfb_base << 32;
218
219 fb_wb = opt && !strcmp(opt, "ram");
220
221 si = &screen_info;
222 xres = si->lfb_width;
223 yres = si->lfb_height;
224
225
226
227
228
229 if (si->lfb_depth != 32)
230 return -ENODEV;
231
232 font = get_default_font(xres, yres, -1, -1);
233 if (!font)
234 return -ENODEV;
235
236 efi_y = rounddown(yres, font->height) - font->height;
237 for (i = 0; i < (yres - efi_y) / font->height; i++)
238 efi_earlycon_scroll_up();
239
240 device->con->write = efi_earlycon_write;
241 earlycon_console = device->con;
242 return 0;
243 }
244 EARLYCON_DECLARE(efifb, efi_earlycon_setup);