fsp_support.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401
  1. /*
  2. * Copyright (C) 2013, Intel Corporation
  3. * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
  4. *
  5. * SPDX-License-Identifier: Intel
  6. */
  7. #include <common.h>
  8. #include <asm/arch/fsp/fsp_support.h>
  9. #include <asm/post.h>
  10. /**
  11. * Compares two GUIDs
  12. *
  13. * If the GUIDs are identical then true is returned.
  14. * If there are any bit differences in the two GUIDs, then false is returned.
  15. *
  16. * @guid1: A pointer to a 128 bit GUID.
  17. * @guid2: A pointer to a 128 bit GUID.
  18. *
  19. * @retval true: guid1 and guid2 are identical.
  20. * @retval false: guid1 and guid2 are not identical.
  21. */
  22. static bool compare_guid(const struct efi_guid *guid1,
  23. const struct efi_guid *guid2)
  24. {
  25. if (memcmp(guid1, guid2, sizeof(struct efi_guid)) == 0)
  26. return true;
  27. else
  28. return false;
  29. }
  30. u32 __attribute__((optimize("O0"))) find_fsp_header(void)
  31. {
  32. /*
  33. * This function may be called before the a stack is established,
  34. * so special care must be taken. First, it cannot declare any local
  35. * variable using stack. Only register variable can be used here.
  36. * Secondly, some compiler version will add prolog or epilog code
  37. * for the C function. If so the function call may not work before
  38. * stack is ready.
  39. *
  40. * GCC 4.8.1 has been verified to be working for the following codes.
  41. */
  42. volatile register u8 *fsp asm("eax");
  43. /* Initalize the FSP base */
  44. fsp = (u8 *)CONFIG_FSP_ADDR;
  45. /* Check the FV signature, _FVH */
  46. if (((struct fv_header *)fsp)->sign == EFI_FVH_SIGNATURE) {
  47. /* Go to the end of the FV header and align the address */
  48. fsp += ((struct fv_header *)fsp)->ext_hdr_off;
  49. fsp += ((struct fv_ext_header *)fsp)->ext_hdr_size;
  50. fsp = (u8 *)(((u32)fsp + 7) & 0xFFFFFFF8);
  51. } else {
  52. fsp = 0;
  53. }
  54. /* Check the FFS GUID */
  55. if (fsp &&
  56. ((struct ffs_file_header *)fsp)->name.data1 == FSP_GUID_DATA1 &&
  57. ((struct ffs_file_header *)fsp)->name.data2 == FSP_GUID_DATA2 &&
  58. ((struct ffs_file_header *)fsp)->name.data3 == FSP_GUID_DATA3 &&
  59. ((struct ffs_file_header *)fsp)->name.data4[0] == FSP_GUID_DATA4_0 &&
  60. ((struct ffs_file_header *)fsp)->name.data4[1] == FSP_GUID_DATA4_1 &&
  61. ((struct ffs_file_header *)fsp)->name.data4[2] == FSP_GUID_DATA4_2 &&
  62. ((struct ffs_file_header *)fsp)->name.data4[3] == FSP_GUID_DATA4_3 &&
  63. ((struct ffs_file_header *)fsp)->name.data4[4] == FSP_GUID_DATA4_4 &&
  64. ((struct ffs_file_header *)fsp)->name.data4[5] == FSP_GUID_DATA4_5 &&
  65. ((struct ffs_file_header *)fsp)->name.data4[6] == FSP_GUID_DATA4_6 &&
  66. ((struct ffs_file_header *)fsp)->name.data4[7] == FSP_GUID_DATA4_7) {
  67. /* Add the FFS header size to find the raw section header */
  68. fsp += sizeof(struct ffs_file_header);
  69. } else {
  70. fsp = 0;
  71. }
  72. if (fsp &&
  73. ((struct raw_section *)fsp)->type == EFI_SECTION_RAW) {
  74. /* Add the raw section header size to find the FSP header */
  75. fsp += sizeof(struct raw_section);
  76. } else {
  77. fsp = 0;
  78. }
  79. return (u32)fsp;
  80. }
  81. void fsp_continue(struct shared_data *shared_data, u32 status, void *hob_list)
  82. {
  83. u32 stack_len;
  84. u32 stack_base;
  85. u32 stack_top;
  86. post_code(POST_MRC);
  87. assert(status == 0);
  88. /* Get the migrated stack in normal memory */
  89. stack_base = (u32)fsp_get_bootloader_tmp_mem(hob_list, &stack_len);
  90. assert(stack_base != 0);
  91. stack_top = stack_base + stack_len - sizeof(u32);
  92. /*
  93. * Old stack base is stored at the very end of the stack top,
  94. * use it to calculate the migrated shared data base
  95. */
  96. shared_data = (struct shared_data *)(stack_base +
  97. ((u32)shared_data - *(u32 *)stack_top));
  98. /* The boot loader main function entry */
  99. fsp_init_done(hob_list);
  100. }
  101. void fsp_init(u32 stack_top, u32 boot_mode, void *nvs_buf)
  102. {
  103. struct shared_data shared_data;
  104. fsp_init_f init;
  105. struct fsp_init_params params;
  106. struct fspinit_rtbuf rt_buf;
  107. struct vpd_region *fsp_vpd;
  108. struct fsp_header *fsp_hdr;
  109. struct fsp_init_params *params_ptr;
  110. struct upd_region *fsp_upd;
  111. fsp_hdr = (struct fsp_header *)find_fsp_header();
  112. if (fsp_hdr == NULL) {
  113. /* No valid FSP info header was found */
  114. panic("Invalid FSP header");
  115. }
  116. fsp_upd = (struct upd_region *)&shared_data.fsp_upd;
  117. memset(&rt_buf, 0, sizeof(struct fspinit_rtbuf));
  118. /* Reserve a gap in stack top */
  119. rt_buf.common.stack_top = (u32 *)stack_top - 32;
  120. rt_buf.common.boot_mode = boot_mode;
  121. rt_buf.common.upd_data = (struct upd_region *)fsp_upd;
  122. /* Get VPD region start */
  123. fsp_vpd = (struct vpd_region *)(fsp_hdr->img_base +
  124. fsp_hdr->cfg_region_off);
  125. /* Verifify the VPD data region is valid */
  126. assert((fsp_vpd->img_rev == VPD_IMAGE_REV) &&
  127. (fsp_vpd->sign == VPD_IMAGE_ID));
  128. /* Copy default data from Flash */
  129. memcpy(fsp_upd, (void *)(fsp_hdr->img_base + fsp_vpd->upd_offset),
  130. sizeof(struct upd_region));
  131. /* Verifify the UPD data region is valid */
  132. assert(fsp_upd->terminator == UPD_TERMINATOR);
  133. /* Override any UPD setting if required */
  134. update_fsp_upd(fsp_upd);
  135. memset(&params, 0, sizeof(struct fsp_init_params));
  136. params.nvs_buf = nvs_buf;
  137. params.rt_buf = (struct fspinit_rtbuf *)&rt_buf;
  138. params.continuation = (fsp_continuation_f)asm_continuation;
  139. init = (fsp_init_f)(fsp_hdr->img_base + fsp_hdr->fsp_init);
  140. params_ptr = &params;
  141. shared_data.fsp_hdr = fsp_hdr;
  142. shared_data.stack_top = (u32 *)stack_top;
  143. post_code(POST_PRE_MRC);
  144. /*
  145. * Use ASM code to ensure the register value in EAX & ECX
  146. * will be passed into BlContinuationFunc
  147. */
  148. asm volatile (
  149. "pushl %0;"
  150. "call *%%eax;"
  151. ".global asm_continuation;"
  152. "asm_continuation:;"
  153. "movl %%ebx, %%eax;" /* shared_data */
  154. "movl 4(%%esp), %%edx;" /* status */
  155. "movl 8(%%esp), %%ecx;" /* hob_list */
  156. "jmp fsp_continue;"
  157. : : "m"(params_ptr), "a"(init), "b"(&shared_data)
  158. );
  159. /*
  160. * Should never get here.
  161. * Control will continue from fsp_continue.
  162. * This line below is to prevent the compiler from optimizing
  163. * structure intialization.
  164. *
  165. * DO NOT REMOVE!
  166. */
  167. init(&params);
  168. }
  169. u32 fsp_notify(struct fsp_header *fsp_hdr, u32 phase)
  170. {
  171. fsp_notify_f notify;
  172. struct fsp_notify_params params;
  173. struct fsp_notify_params *params_ptr;
  174. u32 status;
  175. if (!fsp_hdr)
  176. fsp_hdr = (struct fsp_header *)find_fsp_header();
  177. if (fsp_hdr == NULL) {
  178. /* No valid FSP info header */
  179. panic("Invalid FSP header");
  180. }
  181. notify = (fsp_notify_f)(fsp_hdr->img_base + fsp_hdr->fsp_notify);
  182. params.phase = phase;
  183. params_ptr = &params;
  184. /*
  185. * Use ASM code to ensure correct parameter is on the stack for
  186. * FspNotify as U-Boot is using different ABI from FSP
  187. */
  188. asm volatile (
  189. "pushl %1;" /* push notify phase */
  190. "call *%%eax;" /* call FspNotify */
  191. "addl $4, %%esp;" /* clean up the stack */
  192. : "=a"(status) : "m"(params_ptr), "a"(notify), "m"(*params_ptr)
  193. );
  194. return status;
  195. }
  196. u32 fsp_get_usable_lowmem_top(const void *hob_list)
  197. {
  198. union hob_pointers hob;
  199. phys_addr_t phys_start;
  200. u32 top;
  201. /* Get the HOB list for processing */
  202. hob.raw = (void *)hob_list;
  203. /* * Collect memory ranges */
  204. top = FSP_LOWMEM_BASE;
  205. while (!end_of_hob(hob)) {
  206. if (get_hob_type(hob) == HOB_TYPE_RES_DESC) {
  207. if (hob.res_desc->type == RES_SYS_MEM) {
  208. phys_start = hob.res_desc->phys_start;
  209. /* Need memory above 1MB to be collected here */
  210. if (phys_start >= FSP_LOWMEM_BASE &&
  211. phys_start < (phys_addr_t)FSP_HIGHMEM_BASE)
  212. top += (u32)(hob.res_desc->len);
  213. }
  214. }
  215. hob.raw = get_next_hob(hob);
  216. }
  217. return top;
  218. }
  219. u64 fsp_get_usable_highmem_top(const void *hob_list)
  220. {
  221. union hob_pointers hob;
  222. phys_addr_t phys_start;
  223. u64 top;
  224. /* Get the HOB list for processing */
  225. hob.raw = (void *)hob_list;
  226. /* Collect memory ranges */
  227. top = FSP_HIGHMEM_BASE;
  228. while (!end_of_hob(hob)) {
  229. if (get_hob_type(hob) == HOB_TYPE_RES_DESC) {
  230. if (hob.res_desc->type == RES_SYS_MEM) {
  231. phys_start = hob.res_desc->phys_start;
  232. /* Need memory above 1MB to be collected here */
  233. if (phys_start >= (phys_addr_t)FSP_HIGHMEM_BASE)
  234. top += (u32)(hob.res_desc->len);
  235. }
  236. }
  237. hob.raw = get_next_hob(hob);
  238. }
  239. return top;
  240. }
  241. u64 fsp_get_reserved_mem_from_guid(const void *hob_list, u64 *len,
  242. struct efi_guid *guid)
  243. {
  244. union hob_pointers hob;
  245. /* Get the HOB list for processing */
  246. hob.raw = (void *)hob_list;
  247. /* Collect memory ranges */
  248. while (!end_of_hob(hob)) {
  249. if (get_hob_type(hob) == HOB_TYPE_RES_DESC) {
  250. if (hob.res_desc->type == RES_MEM_RESERVED) {
  251. if (compare_guid(&hob.res_desc->owner, guid)) {
  252. if (len)
  253. *len = (u32)(hob.res_desc->len);
  254. return (u64)(hob.res_desc->phys_start);
  255. }
  256. }
  257. }
  258. hob.raw = get_next_hob(hob);
  259. }
  260. return 0;
  261. }
  262. u32 fsp_get_fsp_reserved_mem(const void *hob_list, u32 *len)
  263. {
  264. const struct efi_guid guid = FSP_HOB_RESOURCE_OWNER_FSP_GUID;
  265. u64 length;
  266. u32 base;
  267. base = (u32)fsp_get_reserved_mem_from_guid(hob_list,
  268. &length, (struct efi_guid *)&guid);
  269. if ((len != 0) && (base != 0))
  270. *len = (u32)length;
  271. return base;
  272. }
  273. u32 fsp_get_tseg_reserved_mem(const void *hob_list, u32 *len)
  274. {
  275. const struct efi_guid guid = FSP_HOB_RESOURCE_OWNER_TSEG_GUID;
  276. u64 length;
  277. u32 base;
  278. base = (u32)fsp_get_reserved_mem_from_guid(hob_list,
  279. &length, (struct efi_guid *)&guid);
  280. if ((len != 0) && (base != 0))
  281. *len = (u32)length;
  282. return base;
  283. }
  284. void *fsp_get_next_hob(u16 type, const void *hob_list)
  285. {
  286. union hob_pointers hob;
  287. assert(hob_list != NULL);
  288. hob.raw = (u8 *)hob_list;
  289. /* Parse the HOB list until end of list or matching type is found */
  290. while (!end_of_hob(hob)) {
  291. if (get_hob_type(hob) == type)
  292. return hob.raw;
  293. hob.raw = get_next_hob(hob);
  294. }
  295. return NULL;
  296. }
  297. void *fsp_get_next_guid_hob(const struct efi_guid *guid, const void *hob_list)
  298. {
  299. union hob_pointers hob;
  300. hob.raw = (u8 *)hob_list;
  301. while ((hob.raw = fsp_get_next_hob(HOB_TYPE_GUID_EXT,
  302. hob.raw)) != NULL) {
  303. if (compare_guid(guid, &hob.guid->name))
  304. break;
  305. hob.raw = get_next_hob(hob);
  306. }
  307. return hob.raw;
  308. }
  309. void *fsp_get_guid_hob_data(const void *hob_list, u32 *len,
  310. struct efi_guid *guid)
  311. {
  312. u8 *guid_hob;
  313. guid_hob = fsp_get_next_guid_hob(guid, hob_list);
  314. if (guid_hob == NULL) {
  315. return NULL;
  316. } else {
  317. if (len)
  318. *len = get_guid_hob_data_size(guid_hob);
  319. return get_guid_hob_data(guid_hob);
  320. }
  321. }
  322. void *fsp_get_nvs_data(const void *hob_list, u32 *len)
  323. {
  324. const struct efi_guid guid = FSP_NON_VOLATILE_STORAGE_HOB_GUID;
  325. return fsp_get_guid_hob_data(hob_list, len, (struct efi_guid *)&guid);
  326. }
  327. void *fsp_get_bootloader_tmp_mem(const void *hob_list, u32 *len)
  328. {
  329. const struct efi_guid guid = FSP_BOOTLOADER_TEMP_MEM_HOB_GUID;
  330. return fsp_get_guid_hob_data(hob_list, len, (struct efi_guid *)&guid);
  331. }