arch/x86/cpu/efi/payload.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2015 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #include <common.h>
   8 #include <cpu_func.h>
   9 #include <efi.h>
  10 #include <errno.h>
  11 #include <usb.h>
  12 #include <asm/bootparam.h>
  13 #include <asm/e820.h>
  14 #include <asm/post.h>
  15
  16 DECLARE_GLOBAL_DATA_PTR;
  17
  18 /*
  19  * This function looks for the highest region of memory lower than 4GB which
  20  * has enough space for U-Boot where U-Boot is aligned on a page boundary.
  21  * It overrides the default implementation found elsewhere which simply
  22  * picks the end of ram, wherever that may be. The location of the stack,
  23  * the relocation address, and how far U-Boot is moved by relocation are
  24  * set in the global data structure.
  25  */
  26 ulong board_get_usable_ram_top(ulong total_size)
  27 {
  28         struct efi_mem_desc *desc, *end;
  29         struct efi_entry_memmap *map;
  30         int ret, size;
  31         uintptr_t dest_addr = 0;
  32         struct efi_mem_desc *largest = NULL;
  33
  34         /*
  35          * Find largest area of memory below 4GB. We could
  36          * call efi_build_mem_table() for a more accurate picture since it
  37          * merges areas together where possible. But that function uses more
  38          * pre-relocation memory, and it's not critical that we find the
  39          * absolute largest region.
  40          */
  41         ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
  42         if (ret) {
  43                 /* We should have stopped in dram_init(), something is wrong */
  44                 debug("%s: Missing memory map\n", __func__);
  45                 goto err;
  46         }
  47
  48         end = (struct efi_mem_desc *)((ulong)map + size);
  49         desc = map->desc;
  50         for (; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
  51                 if (desc->type != EFI_CONVENTIONAL_MEMORY ||
  52                     desc->physical_start >= 1ULL << 32)
  53                         continue;
  54                 if (!largest || desc->num_pages > largest->num_pages)
  55                         largest = desc;
  56         }
  57
  58         /* If no suitable area was found, return an error. */
  59         assert(largest);
  60         if (!largest || (largest->num_pages << EFI_PAGE_SHIFT) < (2 << 20))
  61                 goto err;
  62
  63         dest_addr = largest->physical_start + (largest->num_pages <<
  64                         EFI_PAGE_SHIFT);
  65
  66         return (ulong)dest_addr;
  67 err:
  68         panic("No available memory found for relocation");
  69         return 0;
  70 }
  71
  72 int dram_init(void)
  73 {
  74         struct efi_mem_desc *desc, *end;
  75         struct efi_entry_memmap *map;
  76         int size, ret;
  77
  78         ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
  79         if (ret) {
  80                 printf("Cannot find EFI memory map tables, ret=%d\n", ret);
  81
  82                 return -ENODEV;
  83         }
  84
  85         end = (struct efi_mem_desc *)((ulong)map + size);
  86         gd->ram_size = 0;
  87         desc = map->desc;
  88         for (; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
  89                 if (desc->type < EFI_MMAP_IO)
  90                         gd->ram_size += desc->num_pages << EFI_PAGE_SHIFT;
  91         }
  92
  93         return 0;
  94 }
  95
  96 int dram_init_banksize(void)
  97 {
  98         struct efi_mem_desc *desc, *end;
  99         struct efi_entry_memmap *map;
 100         int ret, size;
 101         int num_banks;
 102
 103         ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
 104         if (ret) {
 105                 /* We should have stopped in dram_init(), something is wrong */
 106                 debug("%s: Missing memory map\n", __func__);
 107                 return -ENXIO;
 108         }
 109         end = (struct efi_mem_desc *)((ulong)map + size);
 110         desc = map->desc;
 111         for (num_banks = 0;
 112              desc < end && num_banks < CONFIG_NR_DRAM_BANKS;
 113              desc = efi_get_next_mem_desc(map, desc)) {
 114                 /*
 115                  * We only use conventional memory and ignore
 116                  * anything less than 1MB.
 117                  */
 118                 if (desc->type != EFI_CONVENTIONAL_MEMORY ||
 119                     (desc->num_pages << EFI_PAGE_SHIFT) < 1 << 20)
 120                         continue;
 121                 gd->bd->bi_dram[num_banks].start = desc->physical_start;
 122                 gd->bd->bi_dram[num_banks].size = desc->num_pages <<
 123                         EFI_PAGE_SHIFT;
 124                 num_banks++;
 125         }
 126
 127         return 0;
 128 }
 129
 130 int arch_cpu_init(void)
 131 {
 132         post_code(POST_CPU_INIT);
 133
 134         return x86_cpu_init_f();
 135 }
 136
 137 int checkcpu(void)
 138 {
 139         return 0;
 140 }
 141
 142 int print_cpuinfo(void)
 143 {
 144         return default_print_cpuinfo();
 145 }
 146
 147 /* Find any available tables and copy them to a safe place */
 148 int reserve_arch(void)
 149 {
 150         struct efi_info_hdr *hdr;
 151
 152         debug("table=%lx\n", gd->arch.table);
 153         if (!gd->arch.table)
 154                 return 0;
 155
 156         hdr = (struct efi_info_hdr *)gd->arch.table;
 157
 158         gd->start_addr_sp -= hdr->total_size;
 159         memcpy((void *)gd->start_addr_sp, hdr, hdr->total_size);
 160         debug("Stashing EFI table at %lx to %lx, size %x\n",
 161               gd->arch.table, gd->start_addr_sp, hdr->total_size);
 162         gd->arch.table = gd->start_addr_sp;
 163
 164         return 0;
 165 }
 166
 167 int last_stage_init(void)
 168 {
 169         /* start usb so that usb keyboard can be used as input device */
 170         if (CONFIG_IS_ENABLED(USB_KEYBOARD))
 171                 usb_init();
 172
 173         return 0;
 174 }
 175
 176 unsigned int install_e820_map(unsigned int max_entries,
 177                               struct e820_entry *entries)
 178 {
 179         struct efi_mem_desc *desc, *end;
 180         struct efi_entry_memmap *map;
 181         int size, ret;
 182         efi_physical_addr_t last_end_addr = 0;
 183         struct e820_entry *last_entry = NULL;
 184         __u32 e820_type;
 185         unsigned int num_entries = 0;
 186
 187         ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
 188         if (ret) {
 189                 printf("Cannot find EFI memory map tables, ret=%d\n", ret);
 190
 191                 return -ENODEV;
 192         }
 193
 194         end = (struct efi_mem_desc *)((ulong)map + size);
 195         for (desc = map->desc; desc < end;
 196              desc = efi_get_next_mem_desc(map, desc)) {
 197                 if (desc->num_pages == 0)
 198                         continue;
 199
 200                 switch (desc->type) {
 201                 case EFI_LOADER_CODE:
 202                 case EFI_LOADER_DATA:
 203                 case EFI_BOOT_SERVICES_CODE:
 204                 case EFI_BOOT_SERVICES_DATA:
 205                 case EFI_CONVENTIONAL_MEMORY:
 206                         e820_type = E820_RAM;
 207                         break;
 208
 209                 case EFI_RESERVED_MEMORY_TYPE:
 210                 case EFI_RUNTIME_SERVICES_CODE:
 211                 case EFI_RUNTIME_SERVICES_DATA:
 212                 case EFI_MMAP_IO:
 213                 case EFI_MMAP_IO_PORT:
 214                 case EFI_PAL_CODE:
 215                         e820_type = E820_RESERVED;
 216                         break;
 217
 218                 case EFI_ACPI_RECLAIM_MEMORY:
 219                         e820_type = E820_ACPI;
 220                         break;
 221
 222                 case EFI_ACPI_MEMORY_NVS:
 223                         e820_type = E820_NVS;
 224                         break;
 225
 226                 case EFI_UNUSABLE_MEMORY:
 227                         e820_type = E820_UNUSABLE;
 228                         break;
 229
 230                 default:
 231                         printf("Invalid EFI memory descriptor type (0x%x)!\n",
 232                                desc->type);
 233                         continue;
 234                 }
 235
 236                 if (last_entry != NULL && last_entry->type == e820_type &&
 237                     desc->physical_start == last_end_addr) {
 238                         last_entry->size += (desc->num_pages << EFI_PAGE_SHIFT);
 239                         last_end_addr += (desc->num_pages << EFI_PAGE_SHIFT);
 240                 } else {
 241                         if (num_entries >= E820MAX)
 242                                 break;
 243
 244                         entries[num_entries].addr = desc->physical_start;
 245                         entries[num_entries].size = desc->num_pages;
 246                         entries[num_entries].size <<= EFI_PAGE_SHIFT;
 247                         entries[num_entries].type = e820_type;
 248                         last_entry = &entries[num_entries];
 249                         last_end_addr = last_entry->addr + last_entry->size;
 250                         num_entries++;
 251                 }
 252         }
 253
 254         return num_entries;
 255 }
 256
 257 void setup_efi_info(struct efi_info *efi_info)
 258 {
 259         struct efi_entry_systable *table;
 260         struct efi_entry_memmap *map;
 261         char *signature;
 262         int size, ret;
 263
 264         memset(efi_info, 0, sizeof(struct efi_info));
 265
 266         ret = efi_info_get(EFIET_SYS_TABLE, (void **)&table, &size);
 267         if (ret) {
 268                 printf("Cannot find EFI system table, ret=%d\n", ret);
 269                 return;
 270         }
 271         efi_info->efi_systab = (u32)(table->sys_table);
 272
 273         ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
 274         if (ret) {
 275                 printf("Cannot find EFI memory map tables, ret=%d\n", ret);
 276                 return;
 277         }
 278         efi_info->efi_memdesc_size = map->desc_size;
 279         efi_info->efi_memdesc_version = map->version;
 280         efi_info->efi_memmap = (u32)(map->desc);
 281         efi_info->efi_memmap_size = size - sizeof(struct efi_entry_memmap);
 282
 283 #ifdef CONFIG_EFI_STUB_64BIT
 284         efi_info->efi_systab_hi = table->sys_table >> 32;
 285         efi_info->efi_memmap_hi = (u64)(u32)(map->desc) >> 32;
 286         signature = EFI64_LOADER_SIGNATURE;
 287 #else
 288         signature = EFI32_LOADER_SIGNATURE;
 289 #endif
 290         memcpy(&efi_info->efi_loader_signature, signature, 4);
 291 }