LXR uboot/arch/x86/lib/efi/efi.c

   1/*
   2 * Copyright (c) 2015 Google, Inc
   3 * Written by Simon Glass <sjg@chromium.org>
   4 *
   5 * SPDX-License-Identifier:     GPL-2.0+
   6 */
   7
   8#include <common.h>
   9#include <debug_uart.h>
  10#include <efi.h>
  11#include <errno.h>
  12#include <linux/err.h>
  13#include <linux/types.h>
  14
  15DECLARE_GLOBAL_DATA_PTR;
  16
  17/*
  18 * This function looks for the highest region of memory lower than 4GB which
  19 * has enough space for U-Boot where U-Boot is aligned on a page boundary.
  20 * It overrides the default implementation found elsewhere which simply
  21 * picks the end of ram, wherever that may be. The location of the stack,
  22 * the relocation address, and how far U-Boot is moved by relocation are
  23 * set in the global data structure.
  24 */
  25ulong board_get_usable_ram_top(ulong total_size)
  26{
  27        struct efi_mem_desc *desc, *end;
  28        struct efi_entry_memmap *map;
  29        int ret, size;
  30        uintptr_t dest_addr = 0;
  31        struct efi_mem_desc *largest = NULL;
  32
  33        /*
  34         * Find largest area of memory below 4GB. We could
  35         * call efi_build_mem_table() for a more accurate picture since it
  36         * merges areas together where possible. But that function uses more
  37         * pre-relocation memory, and it's not critical that we find the
  38         * absolute largest region.
  39         */
  40        ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
  41        if (ret) {
  42                /* We should have stopped in dram_init(), something is wrong */
  43                debug("%s: Missing memory map\n", __func__);
  44                goto err;
  45        }
  46
  47        end = (struct efi_mem_desc *)((ulong)map + size);
  48        desc = map->desc;
  49        for (; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
  50                if (desc->type != EFI_CONVENTIONAL_MEMORY ||
  51                    desc->physical_start >= 1ULL << 32)
  52                        continue;
  53                if (!largest || desc->num_pages > largest->num_pages)
  54                        largest = desc;
  55        }
  56
  57        /* If no suitable area was found, return an error. */
  58        assert(largest);
  59        if (!largest || (largest->num_pages << EFI_PAGE_SHIFT) < (2 << 20))
  60                goto err;
  61
  62        dest_addr = largest->physical_start + (largest->num_pages <<
  63                        EFI_PAGE_SHIFT);
  64
  65        return (ulong)dest_addr;
  66err:
  67        panic("No available memory found for relocation");
  68        return 0;
  69}
  70
  71int dram_init(void)
  72{
  73        struct efi_mem_desc *desc, *end;
  74        struct efi_entry_memmap *map;
  75        int size, ret;
  76
  77        ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
  78        if (ret) {
  79                printf("Cannot find EFI memory map tables, ret=%d\n", ret);
  80
  81                return -ENODEV;
  82        }
  83
  84        end = (struct efi_mem_desc *)((ulong)map + size);
  85        gd->ram_size = 0;
  86        desc = map->desc;
  87        for (; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
  88                if (desc->type < EFI_MMAP_IO)
  89                        gd->ram_size += desc->num_pages << EFI_PAGE_SHIFT;
  90        }
  91
  92        return 0;
  93}
  94
  95int dram_init_banksize(void)
  96{
  97        struct efi_mem_desc *desc, *end;
  98        struct efi_entry_memmap *map;
  99        int ret, size;
 100        int num_banks;
 101
 102        ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
 103        if (ret) {
 104                /* We should have stopped in dram_init(), something is wrong */
 105                debug("%s: Missing memory map\n", __func__);
 106                return -ENXIO;
 107        }
 108        end = (struct efi_mem_desc *)((ulong)map + size);
 109        desc = map->desc;
 110        for (num_banks = 0;
 111             desc < end && num_banks < CONFIG_NR_DRAM_BANKS;
 112             desc = efi_get_next_mem_desc(map, desc)) {
 113                /*
 114                 * We only use conventional memory below 4GB, and ignore
 115                 * anything less than 1MB.
 116                 */
 117                if (desc->type != EFI_CONVENTIONAL_MEMORY ||
 118                    desc->physical_start >= 1ULL << 32 ||
 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
 130int checkcpu(void)
 131{
 132        return 0;
 133}
 134
 135int print_cpuinfo(void)
 136{
 137        return default_print_cpuinfo();
 138}
 139
 140/* Find any available tables and copy them to a safe place */
 141int reserve_arch(void)
 142{
 143        struct efi_info_hdr *hdr;
 144
 145        debug("table=%lx\n", gd->arch.table);
 146        if (!gd->arch.table)
 147                return 0;
 148
 149        hdr = (struct efi_info_hdr *)gd->arch.table;
 150
 151        gd->start_addr_sp -= hdr->total_size;
 152        memcpy((void *)gd->start_addr_sp, hdr, hdr->total_size);
 153        debug("Stashing EFI table at %lx to %lx, size %x\n",
 154              gd->arch.table, gd->start_addr_sp, hdr->total_size);
 155        gd->arch.table = gd->start_addr_sp;
 156
 157        return 0;
 158}
 159