lib/efi/efi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Functions shared by the app and stub
   4  *
   5  * Copyright (c) 2015 Google, Inc
   6  *
   7  * EFI information obtained here:
   8  * http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES
   9  *
  10  * Common EFI functions
  11  */
  12
  13 #include <common.h>
  14 #include <debug_uart.h>
  15 #include <errno.h>
  16 #include <malloc.h>
  17 #include <linux/err.h>
  18 #include <linux/types.h>
  19 #include <efi.h>
  20 #include <efi_api.h>
  21
  22 static struct efi_priv *global_priv;
  23
  24 struct efi_priv *efi_get_priv(void)
  25 {
  26         return global_priv;
  27 }
  28
  29 void efi_set_priv(struct efi_priv *priv)
  30 {
  31         global_priv = priv;
  32 }
  33
  34 struct efi_system_table *efi_get_sys_table(void)
  35 {
  36         return global_priv->sys_table;
  37 }
  38
  39 struct efi_boot_services *efi_get_boot(void)
  40 {
  41         return global_priv->boot;
  42 }
  43
  44 unsigned long efi_get_ram_base(void)
  45 {
  46         return global_priv->ram_base;
  47 }
  48
  49 /*
  50  * Global declaration of gd.
  51  *
  52  * As we write to it before relocation we have to make sure it is not put into
  53  * a .bss section which may overlap a .rela section. Initialization forces it
  54  * into a .data section which cannot overlap any .rela section.
  55  */
  56 struct global_data *global_data_ptr = (struct global_data *)~0;
  57
  58 /*
  59  * Unfortunately we cannot access any code outside what is built especially
  60  * for the stub. lib/string.c is already being built for the U-Boot payload
  61  * so it uses the wrong compiler flags. Add our own memset() here.
  62  */
  63 static void efi_memset(void *ptr, int ch, int size)
  64 {
  65         char *dest = ptr;
  66
  67         while (size-- > 0)
  68                 *dest++ = ch;
  69 }
  70
  71 /*
  72  * Since the EFI stub cannot access most of the U-Boot code, add our own
  73  * simple console output functions here. The EFI app will not use these since
  74  * it can use the normal console.
  75  */
  76 void efi_putc(struct efi_priv *priv, const char ch)
  77 {
  78         struct efi_simple_text_output_protocol *con = priv->sys_table->con_out;
  79         uint16_t ucode[2];
  80
  81         ucode[0] = ch;
  82         ucode[1] = '\0';
  83         con->output_string(con, ucode);
  84 }
  85
  86 void efi_puts(struct efi_priv *priv, const char *str)
  87 {
  88         while (*str)
  89                 efi_putc(priv, *str++);
  90 }
  91
  92 int efi_init(struct efi_priv *priv, const char *banner, efi_handle_t image,
  93              struct efi_system_table *sys_table)
  94 {
  95         efi_guid_t loaded_image_guid = EFI_LOADED_IMAGE_PROTOCOL_GUID;
  96         struct efi_boot_services *boot = sys_table->boottime;
  97         struct efi_loaded_image *loaded_image;
  98         int ret;
  99
 100         efi_memset(priv, '\0', sizeof(*priv));
 101         priv->sys_table = sys_table;
 102         priv->boot = sys_table->boottime;
 103         priv->parent_image = image;
 104         priv->run = sys_table->runtime;
 105
 106         efi_puts(priv, "U-Boot EFI ");
 107         efi_puts(priv, banner);
 108         efi_putc(priv, ' ');
 109
 110         ret = boot->open_protocol(priv->parent_image, &loaded_image_guid,
 111                                   (void **)&loaded_image, priv->parent_image,
 112                                   NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 113         if (ret) {
 114                 efi_puts(priv, "Failed to get loaded image protocol\n");
 115                 return ret;
 116         }
 117         priv->image_data_type = loaded_image->image_data_type;
 118
 119         return 0;
 120 }
 121
 122 void *efi_malloc(struct efi_priv *priv, int size, efi_status_t *retp)
 123 {
 124         struct efi_boot_services *boot = priv->boot;
 125         void *buf = NULL;
 126
 127         *retp = boot->allocate_pool(priv->image_data_type, size, &buf);
 128
 129         return buf;
 130 }
 131
 132 void efi_free(struct efi_priv *priv, void *ptr)
 133 {
 134         struct efi_boot_services *boot = priv->boot;
 135
 136         boot->free_pool(ptr);
 137 }
 138
 139 int efi_store_memory_map(struct efi_priv *priv)
 140 {
 141         struct efi_boot_services *boot = priv->sys_table->boottime;
 142         efi_uintn_t size, desc_size;
 143         efi_status_t ret;
 144
 145         /* Get the memory map so we can switch off EFI */
 146         size = 0;
 147         ret = boot->get_memory_map(&size, NULL, &priv->memmap_key,
 148                                    &priv->memmap_desc_size,
 149                                    &priv->memmap_version);
 150         if (ret != EFI_BUFFER_TOO_SMALL) {
 151                 /*
 152                  * Note this function avoids using printf() since it is not
 153                  * available in the stub
 154                  */
 155                 printhex2(EFI_BITS_PER_LONG);
 156                 putc(' ');
 157                 printhex2(ret);
 158                 puts(" No memory map\n");
 159                 return ret;
 160         }
 161         /*
 162          * Since doing a malloc() may change the memory map and also we want to
 163          * be able to read the memory map in efi_call_exit_boot_services()
 164          * below, after more changes have happened
 165          */
 166         priv->memmap_alloc = size + 1024;
 167         priv->memmap_size = priv->memmap_alloc;
 168         priv->memmap_desc = efi_malloc(priv, size, &ret);
 169         if (!priv->memmap_desc) {
 170                 printhex2(ret);
 171                 puts(" No memory for memory descriptor\n");
 172                 return ret;
 173         }
 174
 175         ret = boot->get_memory_map(&priv->memmap_size, priv->memmap_desc,
 176                                    &priv->memmap_key, &desc_size,
 177                                    &priv->memmap_version);
 178         if (ret) {
 179                 printhex2(ret);
 180                 puts(" Can't get memory map\n");
 181                 return ret;
 182         }
 183
 184         return 0;
 185 }
 186
 187 int efi_call_exit_boot_services(void)
 188 {
 189         struct efi_priv *priv = efi_get_priv();
 190         const struct efi_boot_services *boot = priv->boot;
 191         efi_uintn_t size;
 192         u32 version;
 193         efi_status_t ret;
 194
 195         size = priv->memmap_alloc;
 196         ret = boot->get_memory_map(&size, priv->memmap_desc,
 197                                    &priv->memmap_key,
 198                                    &priv->memmap_desc_size, &version);
 199         if (ret) {
 200                 printhex2(ret);
 201                 puts(" Can't get memory map\n");
 202                 return ret;
 203         }
 204         ret = boot->exit_boot_services(priv->parent_image, priv->memmap_key);
 205         if (ret)
 206                 return ret;
 207
 208         return 0;
 209 }