drivers/firmware/efi/earlycon.c

   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
  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  * 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  */
  30 static 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 }
  41 early_initcall(efi_earlycon_remap_fb);
  42
  43 static 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 }
  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          * efi_earlycon_write_char() implicitly assumes a framebuffer with
 227          * 32 bits per pixel.
 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);