2 * This file is part of the coreboot project.
4 * Copyright 2015 Google Inc
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 #include <console/console.h>
18 #include <commonlib/endian.h>
19 #include <commonlib/fsp.h>
21 * Intel's code does not have a handle on changing global packing state.
22 * Therefore, one needs to protect against packing policies that are set
23 * globally for a compliation unit just by including a header file.
27 /* Default bind FSP 1.1 API to edk2 UEFI 2.4 types. */
28 #include <vendorcode/intel/edk2/uefi_2.4/uefi_types.h>
29 #include <vendorcode/intel/fsp/fsp1_1/IntelFspPkg/Include/FspInfoHeader.h>
31 /* Restore original packing policy. */
34 #include <commonlib/helpers.h>
39 #define FSP_DBG_LVL BIOS_NEVER
42 * UEFI defines everything as little endian. However, this piece of code
43 * can be integrated in a userland tool. That tool could be on a big endian
44 * machine so one needs to access the fields within UEFI structures using
45 * endian-aware accesses.
48 /* Return 0 if equal. Non-zero if not equal. */
49 static int guid_compare(const EFI_GUID
*le_guid
, const EFI_GUID
*native_guid
)
51 if (read_le32(&le_guid
->Data1
) != native_guid
->Data1
)
53 if (read_le16(&le_guid
->Data2
) != native_guid
->Data2
)
55 if (read_le16(&le_guid
->Data3
) != native_guid
->Data3
)
57 return memcmp(le_guid
->Data4
, native_guid
->Data4
,
58 ARRAY_SIZE(le_guid
->Data4
));
61 static const EFI_GUID ffs2_guid
= EFI_FIRMWARE_FILE_SYSTEM2_GUID
;
62 static const EFI_GUID fih_guid
= FSP_INFO_HEADER_GUID
;
64 struct fsp_patch_table
{
66 uint16_t header_length
;
67 uint8_t header_revision
;
69 uint32_t patch_entry_num
;
70 uint32_t patch_entries
[0];
73 #define FSPP_SIG 0x50505346
75 static void *relative_offset(void *base
, ssize_t offset
)
79 loc
= (uintptr_t)base
;
85 static uint32_t *fspp_reloc(void *fsp
, size_t fsp_size
, uint32_t e
)
89 /* Offsets live in bits 23:0. */
90 offset
= e
& 0xffffff;
92 /* If bit 31 is set then the offset is considered a negative value
93 * relative to the end of the image using 16MiB as the offset's
96 offset
= fsp_size
- (16 * MiB
- offset
);
98 /* Determine if offset falls within fsp_size for a 32 bit relocation. */
99 if (offset
> fsp_size
- sizeof(uint32_t))
102 return relative_offset(fsp
, offset
);
105 static int reloc_type(uint16_t reloc_entry
)
107 /* Reloc type in upper 4 bits */
108 return reloc_entry
>> 12;
111 static size_t reloc_offset(uint16_t reloc_entry
)
113 /* Offsets are in low 12 bits. */
114 return reloc_entry
& ((1 << 12) - 1);
117 static int te_relocate(uintptr_t new_addr
, void *te
)
119 EFI_TE_IMAGE_HEADER
*teih
;
120 EFI_IMAGE_DATA_DIRECTORY
*relocd
;
121 EFI_IMAGE_BASE_RELOCATION
*relocb
;
122 uintptr_t image_base
;
126 size_t relocd_offset
;
132 if (read_le16(&teih
->Signature
) != EFI_TE_IMAGE_HEADER_SIGNATURE
) {
133 printk(BIOS_ERR
, "TE Signature mismatch: %x vs %x\n",
134 read_le16(&teih
->Signature
),
135 EFI_TE_IMAGE_HEADER_SIGNATURE
);
140 * A TE image is created by converting a PE file. Because of this
141 * the offsets within the headers are off. In order to calculate
142 * the correct releative offets one needs to subtract fixup_offset
143 * from the encoded offets. Similarly, the linked address of the
144 * program is found by adding the fixup_offset to the ImageBase.
146 fixup_offset
= read_le16(&teih
->StrippedSize
);
147 fixup_offset
-= sizeof(EFI_TE_IMAGE_HEADER
);
148 /* Keep track of a base that is correctly adjusted so that offsets
149 * can be used directly. */
151 te_base
-= fixup_offset
;
153 image_base
= read_le64(&teih
->ImageBase
);
154 adj
= new_addr
- (image_base
+ fixup_offset
);
156 printk(FSP_DBG_LVL
, "TE Image %p -> %p adjust value: %x\n",
157 (void *)image_base
, (void *)new_addr
, adj
);
159 /* Adjust ImageBase for consistency. */
160 write_le64(&teih
->ImageBase
, (uint32_t)(image_base
+ adj
));
162 relocd
= &teih
->DataDirectory
[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC
];
165 /* Though the field name is VirtualAddress it's actually relative to
166 * the beginning of the image which is linked at ImageBase. */
167 relocb
= relative_offset(te
,
168 read_le32(&relocd
->VirtualAddress
) - fixup_offset
);
169 while (relocd_offset
< read_le32(&relocd
->Size
)) {
170 size_t rva_offset
= read_le32(&relocb
->VirtualAddress
);
172 printk(FSP_DBG_LVL
, "Relocs for RVA offset %zx\n", rva_offset
);
173 num_relocs
= read_le32(&relocb
->SizeOfBlock
) - sizeof(*relocb
);
174 num_relocs
/= sizeof(uint16_t);
175 reloc
= relative_offset(relocb
, sizeof(*relocb
));
177 printk(FSP_DBG_LVL
, "Num relocs in block: %zx\n", num_relocs
);
179 while (num_relocs
> 0) {
180 uint16_t reloc_val
= read_le16(reloc
);
181 int type
= reloc_type(reloc_val
);
182 size_t offset
= reloc_offset(reloc_val
);
184 printk(FSP_DBG_LVL
, "reloc type %x offset %zx\n",
187 if (type
== EFI_IMAGE_REL_BASED_HIGHLOW
) {
188 uint32_t *reloc_addr
;
191 offset
+= rva_offset
;
192 reloc_addr
= (void *)&te_base
[offset
];
193 val
= read_le32(reloc_addr
);
195 printk(FSP_DBG_LVL
, "Adjusting %p %x -> %x\n",
196 reloc_addr
, val
, val
+ adj
);
197 write_le32(reloc_addr
, val
+ adj
);
198 } else if (type
!= EFI_IMAGE_REL_BASED_ABSOLUTE
) {
199 printk(BIOS_ERR
, "Unknown reloc type: %x\n",
207 /* Track consumption of relocation directory contents. */
208 relocd_offset
+= read_le32(&relocb
->SizeOfBlock
);
209 /* Get next relocation block to process. */
210 relocb
= relative_offset(relocb
,
211 read_le32(&relocb
->SizeOfBlock
));
217 static size_t csh_size(const EFI_COMMON_SECTION_HEADER
*csh
)
221 /* Unpack the array into a type that can be used. */
223 size
|= read_le8(&csh
->Size
[0]) << 0;
224 size
|= read_le8(&csh
->Size
[1]) << 8;
225 size
|= read_le8(&csh
->Size
[2]) << 16;
230 static size_t section_data_offset(const EFI_COMMON_SECTION_HEADER
*csh
)
232 if (csh_size(csh
) == 0x00ffffff)
233 return sizeof(EFI_COMMON_SECTION_HEADER2
);
235 return sizeof(EFI_COMMON_SECTION_HEADER
);
238 static size_t section_data_size(const EFI_COMMON_SECTION_HEADER
*csh
)
242 if (csh_size(csh
) == 0x00ffffff)
243 section_size
= read_le32(&SECTION2_SIZE(csh
));
245 section_size
= csh_size(csh
);
247 return section_size
- section_data_offset(csh
);
250 static size_t file_section_offset(const EFI_FFS_FILE_HEADER
*ffsfh
)
252 if (IS_FFS_FILE2(ffsfh
))
253 return sizeof(EFI_FFS_FILE_HEADER2
);
255 return sizeof(EFI_FFS_FILE_HEADER
);
258 static size_t ffs_file_size(const EFI_FFS_FILE_HEADER
*ffsfh
)
262 if (IS_FFS_FILE2(ffsfh
)) {
264 * this cast is needed with UEFI 2.6 headers in order
265 * to read the UINT32 value that FFS_FILE2_SIZE converts
268 uint32_t file2_size
= FFS_FILE2_SIZE(ffsfh
);
269 size
= read_le32(&file2_size
);
271 size
= read_le8(&ffsfh
->Size
[0]) << 0;
272 size
|= read_le8(&ffsfh
->Size
[1]) << 8;
273 size
|= read_le8(&ffsfh
->Size
[2]) << 16;
278 static int relocate_patch_table(void *fsp
, size_t size
, size_t offset
,
281 struct fsp_patch_table
*table
;
285 table
= relative_offset(fsp
, offset
);
287 if ((offset
+ sizeof(*table
) > size
) ||
288 (read_le16(&table
->header_length
) + offset
) > size
) {
289 printk(BIOS_ERR
, "FSPP not entirely contained in region.\n");
293 num_entries
= read_le32(&table
->patch_entry_num
);
294 printk(FSP_DBG_LVL
, "FSPP relocs: %zx\n", num_entries
);
296 for (num
= 0; num
< num_entries
; num
++) {
300 reloc
= fspp_reloc(fsp
, size
,
301 read_le32(&table
->patch_entries
[num
]));
304 printk(BIOS_ERR
, "Ignoring FSPP entry: %x\n",
305 read_le32(&table
->patch_entries
[num
]));
309 reloc_val
= read_le32(reloc
);
310 printk(FSP_DBG_LVL
, "Adjusting %p %x -> %x\n",
312 (unsigned int)(reloc_val
+ adjustment
));
314 write_le32(reloc
, reloc_val
+ adjustment
);
320 static ssize_t
relocate_remaining_items(void *fsp
, size_t size
,
321 uintptr_t new_addr
, size_t fih_offset
)
323 EFI_FFS_FILE_HEADER
*ffsfh
;
324 EFI_COMMON_SECTION_HEADER
*csh
;
325 FSP_INFO_HEADER
*fih
;
329 printk(FSP_DBG_LVL
, "FSP_INFO_HEADER offset is %zx\n", fih_offset
);
331 if (fih_offset
== 0) {
332 printk(BIOS_ERR
, "FSP_INFO_HEADER offset is 0.\n");
336 /* FSP_INFO_HEADER at first file in FV within first RAW section. */
337 ffsfh
= relative_offset(fsp
, fih_offset
);
338 fih_offset
+= file_section_offset(ffsfh
);
339 csh
= relative_offset(fsp
, fih_offset
);
340 fih_offset
+= section_data_offset(csh
);
341 fih
= relative_offset(fsp
, fih_offset
);
343 if (guid_compare(&ffsfh
->Name
, &fih_guid
)) {
344 printk(BIOS_ERR
, "Bad FIH GUID.\n");
348 if (read_le8(&csh
->Type
) != EFI_SECTION_RAW
) {
349 printk(BIOS_ERR
, "FIH file should have raw section: %x\n",
350 read_le8(&csh
->Type
));
354 if (read_le32(&fih
->Signature
) != FSP_SIG
) {
355 printk(BIOS_ERR
, "Unexpected FIH signature: %08x\n",
356 read_le32(&fih
->Signature
));
360 adjustment
= (intptr_t)new_addr
- read_le32(&fih
->ImageBase
);
362 /* Update ImageBase to reflect FSP's new home. */
363 write_le32(&fih
->ImageBase
, adjustment
+ read_le32(&fih
->ImageBase
));
365 /* Need to find patch table and adjust each entry. The tables
366 * following FSP_INFO_HEADER have a 32-bit signature and header
367 * length. The patch table is denoted as having a 'FSPP' signature;
368 * the table format doesn't follow the other tables. */
369 offset
= fih_offset
+ read_le32(&fih
->HeaderLength
);
370 while (offset
+ 2 * sizeof(uint32_t) <= size
) {
371 uint32_t *table_headers
;
373 table_headers
= relative_offset(fsp
, offset
);
375 printk(FSP_DBG_LVL
, "Checking offset %zx for 'FSPP'\n",
378 if (read_le32(&table_headers
[0]) != FSPP_SIG
) {
379 offset
+= read_le32(&table_headers
[1]);
383 if (relocate_patch_table(fsp
, size
, offset
, adjustment
)) {
384 printk(BIOS_ERR
, "FSPP relocation failed.\n");
391 printk(BIOS_ERR
, "Could not find the FSP patch table.\n");
395 static ssize_t
relocate_fvh(uintptr_t new_addr
, void *fsp
, size_t fsp_size
,
396 size_t fvh_offset
, size_t *fih_offset
)
398 EFI_FIRMWARE_VOLUME_HEADER
*fvh
;
399 EFI_FFS_FILE_HEADER
*ffsfh
;
400 EFI_COMMON_SECTION_HEADER
*csh
;
407 fvh
= relative_offset(fsp
, offset
);
409 if (read_le32(&fvh
->Signature
) != EFI_FVH_SIGNATURE
)
412 fv_length
= read_le64(&fvh
->FvLength
);
414 printk(FSP_DBG_LVL
, "FVH length: %zx Offset: %zx Mapping length: %zx\n",
415 fv_length
, offset
, fsp_size
);
417 if (fv_length
+ offset
> fsp_size
)
420 /* Parse only this FV. However, the algorithm uses offsets into the
421 * entire FSP region so make size include the starting offset. */
422 size
= fv_length
+ offset
;
424 if (guid_compare(&fvh
->FileSystemGuid
, &ffs2_guid
)) {
425 printk(BIOS_ERR
, "FVH not an FFS2 type.\n");
429 if (read_le16(&fvh
->ExtHeaderOffset
) != 0) {
430 EFI_FIRMWARE_VOLUME_EXT_HEADER
*fveh
;
432 offset
+= read_le16(&fvh
->ExtHeaderOffset
);
433 fveh
= relative_offset(fsp
, offset
);
434 printk(FSP_DBG_LVL
, "Extended Header Offset: %zx Size: %zx\n",
435 (size_t)read_le16(&fvh
->ExtHeaderOffset
),
436 (size_t)read_le32(&fveh
->ExtHeaderSize
));
437 offset
+= read_le32(&fveh
->ExtHeaderSize
);
438 /* FFS files are 8 byte aligned after extended header. */
439 offset
= ALIGN_UP(offset
, 8);
441 offset
+= read_le16(&fvh
->HeaderLength
);
444 file_offset
= offset
;
445 while (file_offset
+ sizeof(*ffsfh
) < size
) {
446 offset
= file_offset
;
447 printk(FSP_DBG_LVL
, "file offset: %zx\n", file_offset
);
449 /* First file and section should be FSP info header. */
450 if (fih_offset
!= NULL
&& *fih_offset
== 0)
451 *fih_offset
= file_offset
;
453 ffsfh
= relative_offset(fsp
, file_offset
);
455 printk(FSP_DBG_LVL
, "file type = %x\n", read_le8(&ffsfh
->Type
));
456 printk(FSP_DBG_LVL
, "file attribs = %x\n",
457 read_le8(&ffsfh
->Attributes
));
459 /* Exit FV relocation when empty space found */
460 if (read_le8(&ffsfh
->Type
) == EFI_FV_FILETYPE_FFS_MAX
)
463 /* Next file on 8 byte alignment. */
464 file_offset
+= ffs_file_size(ffsfh
);
465 file_offset
= ALIGN_UP(file_offset
, 8);
467 /* Padding files have no section information. */
468 if (read_le8(&ffsfh
->Type
) == EFI_FV_FILETYPE_FFS_PAD
)
471 offset
+= file_section_offset(ffsfh
);
473 while (offset
+ sizeof(*csh
) < file_offset
) {
477 csh
= relative_offset(fsp
, offset
);
479 printk(FSP_DBG_LVL
, "section offset: %zx\n", offset
);
480 printk(FSP_DBG_LVL
, "section type: %x\n",
481 read_le8(&csh
->Type
));
483 data_size
= section_data_size(csh
);
484 data_offset
= section_data_offset(csh
);
486 if (data_size
+ data_offset
+ offset
> file_offset
) {
487 printk(BIOS_ERR
, "Section exceeds FV size.\n");
492 * The entire FSP image can be thought of as one
493 * program with a single link address even though there
494 * are multiple TEs linked separately. The reason is
495 * that each TE is linked for XIP. So in order to
496 * relocate the TE properly we need to form the
497 * relocated address based on the TE offset within
500 if (read_le8(&csh
->Type
) == EFI_SECTION_TE
) {
502 size_t te_offset
= offset
+ data_offset
;
503 uintptr_t te_addr
= new_addr
+ te_offset
;
505 printk(FSP_DBG_LVL
, "TE image at offset %zx\n",
507 te
= relative_offset(fsp
, te_offset
);
508 te_relocate(te_addr
, te
);
511 offset
+= data_size
+ data_offset
;
512 /* Sections are aligned to 4 bytes. */
513 offset
= ALIGN_UP(offset
, 4);
517 /* Return amount of buffer parsed: FV size. */
521 ssize_t
fsp_component_relocate(uintptr_t new_addr
, void *fsp
, size_t size
)
528 while (offset
< size
) {
531 /* Relocate each FV within the FSP region. The FSP_INFO_HEADER
532 * should only be located in the first FV. */
534 nparsed
= relocate_fvh(new_addr
, fsp
, size
, offset
,
537 nparsed
= relocate_fvh(new_addr
, fsp
, size
, offset
,
540 /* FV should be larger than 0 or failed to parse. */
542 printk(BIOS_ERR
, "FV @ offset %zx relocation failed\n",
550 return relocate_remaining_items(fsp
, size
, new_addr
, fih_offset
);
553 ssize_t
fsp1_1_relocate(uintptr_t new_addr
, void *fsp
, size_t size
)
555 return fsp_component_relocate(new_addr
, fsp
, size
);