payload.c 7.2 KB

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