arch/x86/lib/fsp/fsp_support.c

   1 // SPDX-License-Identifier: Intel
   2 /*
   3  * Copyright (C) 2013, Intel Corporation
   4  * Copyright (C) 2014, Bin Meng <bmeng.cn@gmail.com>
   5  */
   6
   7 #include <common.h>
   8 #include <asm/fsp/fsp_support.h>
   9 #include <asm/post.h>
  10
  11 struct fsp_header *__attribute__((optimize("O0"))) find_fsp_header(void)
  12 {
  13         /*
  14          * This function may be called before the a stack is established,
  15          * so special care must be taken. First, it cannot declare any local
  16          * variable using stack. Only register variable can be used here.
  17          * Secondly, some compiler version will add prolog or epilog code
  18          * for the C function. If so the function call may not work before
  19          * stack is ready.
  20          *
  21          * GCC 4.8.1 has been verified to be working for the following codes.
  22          */
  23         volatile register u8 *fsp asm("eax");
  24
  25         /* Initalize the FSP base */
  26         fsp = (u8 *)CONFIG_FSP_ADDR;
  27
  28         /* Check the FV signature, _FVH */
  29         if (((struct fv_header *)fsp)->sign == EFI_FVH_SIGNATURE) {
  30                 /* Go to the end of the FV header and align the address */
  31                 fsp += ((struct fv_header *)fsp)->ext_hdr_off;
  32                 fsp += ((struct fv_ext_header *)fsp)->ext_hdr_size;
  33                 fsp  = (u8 *)(((u32)fsp + 7) & 0xFFFFFFF8);
  34         } else {
  35                 fsp  = 0;
  36         }
  37
  38         /* Check the FFS GUID */
  39         if (fsp &&
  40             ((struct ffs_file_header *)fsp)->name.b[0] == FSP_GUID_BYTE0 &&
  41             ((struct ffs_file_header *)fsp)->name.b[1] == FSP_GUID_BYTE1 &&
  42             ((struct ffs_file_header *)fsp)->name.b[2] == FSP_GUID_BYTE2 &&
  43             ((struct ffs_file_header *)fsp)->name.b[3] == FSP_GUID_BYTE3 &&
  44             ((struct ffs_file_header *)fsp)->name.b[4] == FSP_GUID_BYTE4 &&
  45             ((struct ffs_file_header *)fsp)->name.b[5] == FSP_GUID_BYTE5 &&
  46             ((struct ffs_file_header *)fsp)->name.b[6] == FSP_GUID_BYTE6 &&
  47             ((struct ffs_file_header *)fsp)->name.b[7] == FSP_GUID_BYTE7 &&
  48             ((struct ffs_file_header *)fsp)->name.b[8] == FSP_GUID_BYTE8 &&
  49             ((struct ffs_file_header *)fsp)->name.b[9] == FSP_GUID_BYTE9 &&
  50             ((struct ffs_file_header *)fsp)->name.b[10] == FSP_GUID_BYTE10 &&
  51             ((struct ffs_file_header *)fsp)->name.b[11] == FSP_GUID_BYTE11 &&
  52             ((struct ffs_file_header *)fsp)->name.b[12] == FSP_GUID_BYTE12 &&
  53             ((struct ffs_file_header *)fsp)->name.b[13] == FSP_GUID_BYTE13 &&
  54             ((struct ffs_file_header *)fsp)->name.b[14] == FSP_GUID_BYTE14 &&
  55             ((struct ffs_file_header *)fsp)->name.b[15] == FSP_GUID_BYTE15) {
  56                 /* Add the FFS header size to find the raw section header */
  57                 fsp += sizeof(struct ffs_file_header);
  58         } else {
  59                 fsp = 0;
  60         }
  61
  62         if (fsp &&
  63             ((struct raw_section *)fsp)->type == EFI_SECTION_RAW) {
  64                 /* Add the raw section header size to find the FSP header */
  65                 fsp += sizeof(struct raw_section);
  66         } else {
  67                 fsp = 0;
  68         }
  69
  70         return (struct fsp_header *)fsp;
  71 }
  72
  73 void fsp_continue(u32 status, void *hob_list)
  74 {
  75         post_code(POST_MRC);
  76
  77         assert(status == 0);
  78
  79         /* The boot loader main function entry */
  80         fsp_init_done(hob_list);
  81 }
  82
  83 void fsp_init(u32 stack_top, u32 boot_mode, void *nvs_buf)
  84 {
  85         struct fsp_config_data config_data;
  86         fsp_init_f init;
  87         struct fsp_init_params params;
  88         struct fspinit_rtbuf rt_buf;
  89         struct fsp_header *fsp_hdr;
  90         struct fsp_init_params *params_ptr;
  91 #ifdef CONFIG_FSP_USE_UPD
  92         struct vpd_region *fsp_vpd;
  93         struct upd_region *fsp_upd;
  94 #endif
  95
  96         fsp_hdr = find_fsp_header();
  97         if (fsp_hdr == NULL) {
  98                 /* No valid FSP info header was found */
  99                 panic("Invalid FSP header");
 100         }
 101
 102         config_data.common.fsp_hdr = fsp_hdr;
 103         config_data.common.stack_top = stack_top;
 104         config_data.common.boot_mode = boot_mode;
 105
 106 #ifdef CONFIG_FSP_USE_UPD
 107         /* Get VPD region start */
 108         fsp_vpd = (struct vpd_region *)(fsp_hdr->img_base +
 109                         fsp_hdr->cfg_region_off);
 110
 111         /* Verify the VPD data region is valid */
 112         assert(fsp_vpd->sign == VPD_IMAGE_ID);
 113
 114         fsp_upd = &config_data.fsp_upd;
 115
 116         /* Copy default data from Flash */
 117         memcpy(fsp_upd, (void *)(fsp_hdr->img_base + fsp_vpd->upd_offset),
 118                sizeof(struct upd_region));
 119
 120         /* Verify the UPD data region is valid */
 121         assert(fsp_upd->terminator == UPD_TERMINATOR);
 122 #endif
 123
 124         memset(&rt_buf, 0, sizeof(struct fspinit_rtbuf));
 125
 126         /* Override any configuration if required */
 127         update_fsp_configs(&config_data, &rt_buf);
 128
 129         memset(&params, 0, sizeof(struct fsp_init_params));
 130         params.nvs_buf = nvs_buf;
 131         params.rt_buf = (struct fspinit_rtbuf *)&rt_buf;
 132         params.continuation = (fsp_continuation_f)asm_continuation;
 133
 134         init = (fsp_init_f)(fsp_hdr->img_base + fsp_hdr->fsp_init);
 135         params_ptr = &params;
 136
 137         post_code(POST_PRE_MRC);
 138
 139         /* Load GDT for FSP */
 140         setup_fsp_gdt();
 141
 142         /*
 143          * Use ASM code to ensure the register value in EAX & EDX
 144          * will be passed into fsp_continue
 145          */
 146         asm volatile (
 147                 "pushl  %0;"
 148                 "call   *%%eax;"
 149                 ".global asm_continuation;"
 150                 "asm_continuation:;"
 151                 "movl   4(%%esp), %%eax;"       /* status */
 152                 "movl   8(%%esp), %%edx;"       /* hob_list */
 153                 "jmp    fsp_continue;"
 154                 : : "m"(params_ptr), "a"(init)
 155         );
 156
 157         /*
 158          * Should never get here.
 159          * Control will continue from fsp_continue.
 160          * This line below is to prevent the compiler from optimizing
 161          * structure intialization.
 162          *
 163          * DO NOT REMOVE!
 164          */
 165         init(&params);
 166 }
 167
 168 u32 fsp_notify(struct fsp_header *fsp_hdr, u32 phase)
 169 {
 170         fsp_notify_f notify;
 171         struct fsp_notify_params params;
 172         struct fsp_notify_params *params_ptr;
 173         u32 status;
 174
 175         if (!fsp_hdr)
 176                 fsp_hdr = (struct fsp_header *)find_fsp_header();
 177
 178         if (fsp_hdr == NULL) {
 179                 /* No valid FSP info header */
 180                 panic("Invalid FSP header");
 181         }
 182
 183         notify = (fsp_notify_f)(fsp_hdr->img_base + fsp_hdr->fsp_notify);
 184         params.phase = phase;
 185         params_ptr = &params;
 186
 187         /*
 188          * Use ASM code to ensure correct parameter is on the stack for
 189          * FspNotify as U-Boot is using different ABI from FSP
 190          */
 191         asm volatile (
 192                 "pushl  %1;"            /* push notify phase */
 193                 "call   *%%eax;"        /* call FspNotify */
 194                 "addl   $4, %%esp;"     /* clean up the stack */
 195                 : "=a"(status) : "m"(params_ptr), "a"(notify), "m"(*params_ptr)
 196         );
 197
 198         return status;
 199 }
 200
 201 u32 fsp_get_usable_lowmem_top(const void *hob_list)
 202 {
 203         const struct hob_header *hdr;
 204         struct hob_res_desc *res_desc;
 205         phys_addr_t phys_start;
 206         u32 top;
 207 #ifdef CONFIG_FSP_BROKEN_HOB
 208         struct hob_mem_alloc *res_mem;
 209         phys_addr_t mem_base = 0;
 210 #endif
 211
 212         /* Get the HOB list for processing */
 213         hdr = hob_list;
 214
 215         /* * Collect memory ranges */
 216         top = FSP_LOWMEM_BASE;
 217         while (!end_of_hob(hdr)) {
 218                 if (hdr->type == HOB_TYPE_RES_DESC) {
 219                         res_desc = (struct hob_res_desc *)hdr;
 220                         if (res_desc->type == RES_SYS_MEM) {
 221                                 phys_start = res_desc->phys_start;
 222                                 /* Need memory above 1MB to be collected here */
 223                                 if (phys_start >= FSP_LOWMEM_BASE &&
 224                                     phys_start < (phys_addr_t)FSP_HIGHMEM_BASE)
 225                                         top += (u32)(res_desc->len);
 226                         }
 227                 }
 228
 229 #ifdef CONFIG_FSP_BROKEN_HOB
 230                 /*
 231                  * Find out the lowest memory base address allocated by FSP
 232                  * for the boot service data
 233                  */
 234                 if (hdr->type == HOB_TYPE_MEM_ALLOC) {
 235                         res_mem = (struct hob_mem_alloc *)hdr;
 236                         if (!mem_base)
 237                                 mem_base = res_mem->mem_base;
 238                         if (res_mem->mem_base < mem_base)
 239                                 mem_base = res_mem->mem_base;
 240                 }
 241 #endif
 242
 243                 hdr = get_next_hob(hdr);
 244         }
 245
 246 #ifdef CONFIG_FSP_BROKEN_HOB
 247         /*
 248          * Check whether the memory top address is below the FSP HOB list.
 249          * If not, use the lowest memory base address allocated by FSP as
 250          * the memory top address. This is to prevent U-Boot relocation
 251          * overwrites the important boot service data which is used by FSP,
 252          * otherwise the subsequent call to fsp_notify() will fail.
 253          */
 254         if (top > (u32)hob_list) {
 255                 debug("Adjust memory top address due to a buggy FSP\n");
 256                 top = (u32)mem_base;
 257         }
 258 #endif
 259
 260         return top;
 261 }
 262
 263 u64 fsp_get_usable_highmem_top(const void *hob_list)
 264 {
 265         const struct hob_header *hdr;
 266         struct hob_res_desc *res_desc;
 267         phys_addr_t phys_start;
 268         u64 top;
 269
 270         /* Get the HOB list for processing */
 271         hdr = hob_list;
 272
 273         /* Collect memory ranges */
 274         top = FSP_HIGHMEM_BASE;
 275         while (!end_of_hob(hdr)) {
 276                 if (hdr->type == HOB_TYPE_RES_DESC) {
 277                         res_desc = (struct hob_res_desc *)hdr;
 278                         if (res_desc->type == RES_SYS_MEM) {
 279                                 phys_start = res_desc->phys_start;
 280                                 /* Need memory above 4GB to be collected here */
 281                                 if (phys_start >= (phys_addr_t)FSP_HIGHMEM_BASE)
 282                                         top += (u32)(res_desc->len);
 283                         }
 284                 }
 285                 hdr = get_next_hob(hdr);
 286         }
 287
 288         return top;
 289 }
 290
 291 u64 fsp_get_reserved_mem_from_guid(const void *hob_list, u64 *len,
 292                                    const efi_guid_t *guid)
 293 {
 294         const struct hob_header *hdr;
 295         struct hob_res_desc *res_desc;
 296
 297         /* Get the HOB list for processing */
 298         hdr = hob_list;
 299
 300         /* Collect memory ranges */
 301         while (!end_of_hob(hdr)) {
 302                 if (hdr->type == HOB_TYPE_RES_DESC) {
 303                         res_desc = (struct hob_res_desc *)hdr;
 304                         if (res_desc->type == RES_MEM_RESERVED) {
 305                                 if (!guidcmp(&res_desc->owner, guid)) {
 306                                         if (len)
 307                                                 *len = (u32)(res_desc->len);
 308
 309                                         return (u64)(res_desc->phys_start);
 310                                 }
 311                         }
 312                 }
 313                 hdr = get_next_hob(hdr);
 314         }
 315
 316         return 0;
 317 }
 318
 319 u32 fsp_get_fsp_reserved_mem(const void *hob_list, u32 *len)
 320 {
 321         const efi_guid_t guid = FSP_HOB_RESOURCE_OWNER_FSP_GUID;
 322         u64 length;
 323         u32 base;
 324
 325         base = (u32)fsp_get_reserved_mem_from_guid(hob_list,
 326                         &length, &guid);
 327         if ((len != 0) && (base != 0))
 328                 *len = (u32)length;
 329
 330         return base;
 331 }
 332
 333 u32 fsp_get_tseg_reserved_mem(const void *hob_list, u32 *len)
 334 {
 335         const efi_guid_t guid = FSP_HOB_RESOURCE_OWNER_TSEG_GUID;
 336         u64 length;
 337         u32 base;
 338
 339         base = (u32)fsp_get_reserved_mem_from_guid(hob_list,
 340                         &length, &guid);
 341         if ((len != 0) && (base != 0))
 342                 *len = (u32)length;
 343
 344         return base;
 345 }
 346
 347 void *fsp_get_nvs_data(const void *hob_list, u32 *len)
 348 {
 349         const efi_guid_t guid = FSP_NON_VOLATILE_STORAGE_HOB_GUID;
 350
 351         return hob_get_guid_hob_data(hob_list, len, &guid);
 352 }
 353
 354 void *fsp_get_bootloader_tmp_mem(const void *hob_list, u32 *len)
 355 {
 356         const efi_guid_t guid = FSP_BOOTLOADER_TEMP_MEM_HOB_GUID;
 357
 358         return hob_get_guid_hob_data(hob_list, len, &guid);
 359 }
 360
 361 void *fsp_get_graphics_info(const void *hob_list, u32 *len)
 362 {
 363         const efi_guid_t guid = FSP_GRAPHICS_INFO_HOB_GUID;
 364
 365         return hob_get_guid_hob_data(hob_list, len, &guid);
 366 }