coreboot-gerrit March 2015

coreboot-gerrit@coreboot.org

1 participants
2443 discussions

New patch to review for coreboot: 6075ab0 drivers/pc80/mc146818rtc_early: Honor Kconfig reboot count clear setting
by Timothy Pearson 28 Mar '15

28 Mar '15

Timothy Pearson (tpearson(a)raptorengineeringinc.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/9155 -gerrit commit 6075ab0b136417e9ee9bffaebfac4b235535513b Author: Timothy Pearson <tpearson(a)raptorengineeringinc.com> Date: Sat Mar 28 14:59:50 2015 -0500 drivers/pc80/mc146818rtc_early: Honor Kconfig reboot count clear setting Change-Id: I6426ea2ca1732a6edfae059fe5dbf4f398bc9b98 Signed-off-by: Timothy Pearson <tpearson(a)raptorengineeringinc.com> --- src/drivers/pc80/mc146818rtc_early.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/drivers/pc80/mc146818rtc_early.c b/src/drivers/pc80/mc146818rtc_early.c index 145fe21..421af2f 100644 --- a/src/drivers/pc80/mc146818rtc_early.c +++ b/src/drivers/pc80/mc146818rtc_early.c @@ -67,10 +67,10 @@ static inline __attribute__((unused)) int do_normal_boot(void) /* The RTC_BOOT_BYTE is now o.k. see where to go. */ byte = cmos_read(RTC_BOOT_BYTE); - /* Are we in normal mode? */ - if (byte & 1) { - byte &= 0x0f; /* yes, clear the boot count */ - } + if (!IS_ENABLED(CONFIG_SKIP_MAX_REBOOT_CNT_CLEAR)) + /* Are we in normal mode? */ + if (byte & 1) + byte &= 0x0f; /* yes, clear the boot count */ /* Properly set the last boot flag */ byte &= 0xfc;

1 0

New patch to review for coreboot: 043d2db google/veyron_pinky: Don't auto select CHROMEOS
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/9154 -gerrit commit 043d2dba261490e758db2912bf846c0d56bc78d8 Author: Aaron Durbin <adurbin(a)chromium.org> Date: Sat Mar 28 14:41:04 2015 -0500 google/veyron_pinky: Don't auto select CHROMEOS Indicate to reset of coreboot that MAINBOARD_HAS_CHROMEOS instead of auto-selecting it. Change-Id: Ide84bc0d8f801c79457dc05f768dd717a8a2f700 Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/mainboard/google/veyron_pinky/Kconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mainboard/google/veyron_pinky/Kconfig b/src/mainboard/google/veyron_pinky/Kconfig index ea025bf..04d466d 100644 --- a/src/mainboard/google/veyron_pinky/Kconfig +++ b/src/mainboard/google/veyron_pinky/Kconfig @@ -22,11 +22,11 @@ if BOARD_GOOGLE_VEYRON_PINKY config BOARD_SPECIFIC_OPTIONS # dummy def_bool y select BOARD_ID_SUPPORT - select CHROMEOS select EC_GOOGLE_CHROMEEC select EC_GOOGLE_CHROMEEC_SPI select SOC_ROCKCHIP_RK3288 select MAINBOARD_DO_NATIVE_VGA_INIT + select MAINBOARD_HAS_CHROMEOS select BOARD_ROMSIZE_KB_4096 select MAINBOARD_HAS_BOOTBLOCK_INIT select HAVE_HARD_RESET

1 0

New patch to review for coreboot: 5b99306 google/nyan_blaze: Don't auto select CHROMEOS
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/9153 -gerrit commit 5b993067229c9da560ab331e1ca87918af9be70b Author: Aaron Durbin <adurbin(a)chromium.org> Date: Sat Mar 28 14:39:49 2015 -0500 google/nyan_blaze: Don't auto select CHROMEOS Indicate to reset of coreboot that MAINBOARD_HAS_CHROMEOS instead of auto-selecting it. Change-Id: I61cde263f4ad7bd6758a61fc54c456c2ad2f343e Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/mainboard/google/nyan_blaze/Kconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mainboard/google/nyan_blaze/Kconfig b/src/mainboard/google/nyan_blaze/Kconfig index 9557ec4..5938e7e 100644 --- a/src/mainboard/google/nyan_blaze/Kconfig +++ b/src/mainboard/google/nyan_blaze/Kconfig @@ -23,13 +23,13 @@ config BOARD_SPECIFIC_OPTIONS # dummy def_bool y select ARCH_ARM select BOARD_ID_SUPPORT - select CHROMEOS select EC_GOOGLE_CHROMEEC select EC_GOOGLE_CHROMEEC_SPI select EC_SOFTWARE_SYNC select SOC_NVIDIA_TEGRA124 select TEGRA124_MODEL_CD570M select MAINBOARD_HAS_BOOTBLOCK_INIT + select MAINBOARD_HAS_CHROMEOS select MAINBOARD_DO_NATIVE_VGA_INIT select BOARD_ROMSIZE_KB_1024 select SPI_FLASH

1 0

Patch set updated for coreboot: b04d3e7 program loading: unify on struct prog
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/8849 -gerrit commit b04d3e7bd5b620cb5cf169203e231fbf0daf4142 Author: Aaron Durbin <adurbin(a)chromium.org> Date: Fri Mar 20 16:37:12 2015 -0500 program loading: unify on struct prog Instead of having different structures for loading ramstage and payload align to using struct prog. This also removes arch_payload_run() in favor of the prog_run() interface. Change-Id: I31483096094eacc713a7433811cd69cc5621c43e Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/arch/arm/boot.c | 5 ---- src/arch/arm64/boot.c | 5 ---- src/arch/mips/boot.c | 5 ---- src/arch/riscv/boot.c | 5 ---- src/arch/x86/boot/boot.c | 21 +++++++++----- src/include/program_loading.h | 49 ++++++++++++--------------------- src/lib/loaders/cbfs_payload_loader.c | 10 +++---- src/lib/loaders/cbfs_ramstage_loader.c | 4 +-- src/lib/loaders/load_and_run_payload.c | 35 +++++++++++------------ src/lib/loaders/load_and_run_ramstage.c | 12 ++++---- src/lib/selfboot.c | 8 +++--- 11 files changed, 65 insertions(+), 94 deletions(-) diff --git a/src/arch/arm/boot.c b/src/arch/arm/boot.c index 6a2934b..806e0d1 100644 --- a/src/arch/arm/boot.c +++ b/src/arch/arm/boot.c @@ -29,8 +29,3 @@ void arch_prog_run(struct prog *prog) doit = prog_entry(prog); doit(prog_entry_arg(prog)); } - -void arch_payload_run(struct payload *payload) -{ - arch_prog_run(&payload->prog); -} diff --git a/src/arch/arm64/boot.c b/src/arch/arm64/boot.c index f3632b5..bb771b2 100644 --- a/src/arch/arm64/boot.c +++ b/src/arch/arm64/boot.c @@ -82,8 +82,3 @@ void arch_prog_run(struct prog *prog) doit = prog_entry(prog); doit(prog_entry_arg(prog)); } - -void arch_payload_run(struct payload *payload) -{ - arch_prog_run(&payload->prog); -} diff --git a/src/arch/mips/boot.c b/src/arch/mips/boot.c index ebc45bb..549d483 100644 --- a/src/arch/mips/boot.c +++ b/src/arch/mips/boot.c @@ -24,8 +24,3 @@ void arch_prog_run(struct prog *prog) { stage_exit(prog_entry(prog)); } - -void arch_payload_run(struct payload *payload) -{ - arch_prog_run(&payload->prog); -} diff --git a/src/arch/riscv/boot.c b/src/arch/riscv/boot.c index f66c02f..d273430 100644 --- a/src/arch/riscv/boot.c +++ b/src/arch/riscv/boot.c @@ -26,8 +26,3 @@ void arch_prog_run(struct prog *prog) doit = prog_entry(prog); doit(prog_entry_arg(prog)); } - -void arch_payload_run(struct payload *payload) -{ - arch_prog_run(&payload->prog); -} diff --git a/src/arch/x86/boot/boot.c b/src/arch/x86/boot/boot.c index d536584..1b61bcb 100644 --- a/src/arch/x86/boot/boot.c +++ b/src/arch/x86/boot/boot.c @@ -4,6 +4,7 @@ #include <ip_checksum.h> #include <string.h> +#if ENV_RAMSTAGE /* When the ramstage is relocatable the elf loading ensures an elf image cannot * be loaded over the ramstage code. */ static void jmp_payload_no_bounce_buffer(void *entry) @@ -123,18 +124,24 @@ static void jmp_payload(void *entry, unsigned long buffer, unsigned long size) ); } -void arch_payload_run(struct payload *payload) +static void try_payload(struct prog *prog) { - if (IS_ENABLED(CONFIG_RELOCATABLE_RAMSTAGE)) - jmp_payload_no_bounce_buffer(prog_entry(&payload->prog)); - else - jmp_payload(prog_entry(&payload->prog), - (uintptr_t)payload->bounce.data, - payload->bounce.size); + if (prog->type == PROG_PAYLOAD) { + if (IS_ENABLED(CONFIG_RELOCATABLE_RAMSTAGE)) + jmp_payload_no_bounce_buffer(prog_entry(prog)); + else + jmp_payload(prog_entry(prog), + (uintptr_t)prog->bounce.data, + prog->bounce.size); + } } +#else +static inline void try_payload(struct prog *prog) {} +#endif void arch_prog_run(struct prog *prog) { + try_payload(prog); __asm__ volatile ( "jmp *%%edi\n" :: "D"(prog_entry(prog)) diff --git a/src/include/program_loading.h b/src/include/program_loading.h index 1df1825..0261b59 100644 --- a/src/include/program_loading.h +++ b/src/include/program_loading.h @@ -22,6 +22,7 @@ #include <stdint.h> #include <stddef.h> +#include <rules.h> enum { /* Last segment of program. Can be used to take different actions for @@ -52,6 +53,10 @@ struct prog { * program is. e.g. a payload prog uses this field for the backing * store of the payload_segments and data. */ struct buffer_area area; +#if ENV_RAMSTAGE + /* Only payloads use the bounce buffer so conditionally include it. */ + struct buffer_area bounce; +#endif /* Entry to program with optional argument. It's up to the architecture * to decide if argument is passed. */ void (*entry)(void *); @@ -100,6 +105,14 @@ void arch_prog_run(struct prog *prog); * code it needs to that as well. */ void platform_prog_run(struct prog *prog); +struct prog_loader_ops { + const char *name; + /* Returns < 0 on error or 0 on success. This function needs to do + * different things depending on the prog type. See definition + * of struct prog above. */ + int (*prepare)(struct prog *prog); +}; + /************************ * ROMSTAGE LOADING * ************************/ @@ -111,6 +124,9 @@ void run_romstage(void); * RAMSTAGE LOADING * ************************/ +/* Run ramstage from romstage. */ +void run_ramstage(void); + struct romstage_handoff; #if IS_ENABLED(CONFIG_RELOCATABLE_RAMSTAGE) /* Cache the loaded ramstage described by prog. */ @@ -124,25 +140,10 @@ static inline void load_cached_ramstage(struct romstage_handoff *h, struct prog *p) {} #endif -/* Run ramstage from romstage. */ -void run_ramstage(void); - -struct ramstage_loader_ops { - const char *name; - /* Returns 0 on succes. < 0 on error. */ - int (*load)(struct prog *ramstage); -}; - /*********************** * PAYLOAD LOADING * ***********************/ -struct payload { - struct prog prog; - /* Used when payload wants memory coreboot ramstage is running at. */ - struct buffer_area bounce; -}; - /* Load payload into memory in preparation to run. */ void payload_load(void); @@ -150,23 +151,9 @@ void payload_load(void); void payload_run(void); /* Mirror the payload to be loaded. */ -void mirror_payload(struct payload *payload); - -/* architecture specific function to run payload. */ -void arch_payload_run(struct payload *payload); - -/* Payload loading operations. */ -struct payload_loader_ops { - const char *name; - /* - * Fill in payload_backing_store structure. Return 0 on success, < 0 - * on failure. - */ - int (*locate)(struct payload *payload); -}; +void mirror_payload(struct prog *payload); /* Defined in src/lib/selfboot.c */ -void *selfload(struct payload *payload); - +void *selfload(struct prog *payload); #endif /* PROGRAM_LOADING_H */ diff --git a/src/lib/loaders/cbfs_payload_loader.c b/src/lib/loaders/cbfs_payload_loader.c index 609d123..3928613 100644 --- a/src/lib/loaders/cbfs_payload_loader.c +++ b/src/lib/loaders/cbfs_payload_loader.c @@ -20,24 +20,24 @@ #include <cbfs.h> #include <program_loading.h> -static int cbfs_locate_payload(struct payload *payload) +static int cbfs_locate_payload(struct prog *payload) { void *buffer; size_t size; const int type = CBFS_TYPE_PAYLOAD; - buffer = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, payload->prog.name, + buffer = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, payload->name, type, &size); if (buffer == NULL) return -1; - prog_set_area(&payload->prog, buffer, size); + prog_set_area(payload, buffer, size); return 0; } -const struct payload_loader_ops cbfs_payload_loader = { +const struct prog_loader_ops cbfs_payload_loader = { .name = "CBFS", - .locate = cbfs_locate_payload, + .prepare = cbfs_locate_payload, }; diff --git a/src/lib/loaders/cbfs_ramstage_loader.c b/src/lib/loaders/cbfs_ramstage_loader.c index 27be88e..e565329 100644 --- a/src/lib/loaders/cbfs_ramstage_loader.c +++ b/src/lib/loaders/cbfs_ramstage_loader.c @@ -54,7 +54,7 @@ static int cbfs_load_ramstage(struct prog *ramstage) #endif /* CONFIG_RELOCATABLE_RAMSTAGE */ -const struct ramstage_loader_ops cbfs_ramstage_loader = { +const struct prog_loader_ops cbfs_ramstage_loader = { .name = "CBFS", - .load = cbfs_load_ramstage, + .prepare = cbfs_load_ramstage, }; diff --git a/src/lib/loaders/load_and_run_payload.c b/src/lib/loaders/load_and_run_payload.c index e3208a9..6c42a58 100644 --- a/src/lib/loaders/load_and_run_payload.c +++ b/src/lib/loaders/load_and_run_payload.c @@ -26,24 +26,22 @@ #include <program_loading.h> #include <timestamp.h> -extern const struct payload_loader_ops vboot_payload_loader; -extern const struct payload_loader_ops cbfs_payload_loader; +extern const struct prog_loader_ops vboot_payload_loader; +extern const struct prog_loader_ops cbfs_payload_loader; -static const struct payload_loader_ops *payload_ops[] = { +static const struct prog_loader_ops *payload_ops[] = { #if CONFIG_VBOOT_VERIFY_FIRMWARE &vboot_payload_loader, #endif &cbfs_payload_loader, }; -static struct payload global_payload = { - .prog = { - .name = CONFIG_CBFS_PREFIX "/payload", - .type = PROG_PAYLOAD, - }, +static struct prog global_payload = { + .name = CONFIG_CBFS_PREFIX "/payload", + .type = PROG_PAYLOAD, }; -void __attribute__((weak)) mirror_payload(struct payload *payload) +void __attribute__((weak)) mirror_payload(struct prog *payload) { return; } @@ -51,19 +49,18 @@ void __attribute__((weak)) mirror_payload(struct payload *payload) void payload_load(void) { int i; - const struct payload_loader_ops *ops; - struct payload *payload = &global_payload; - struct prog * prog = &payload->prog; + const struct prog_loader_ops *ops; + struct prog *payload = &global_payload; for (i = 0; i < ARRAY_SIZE(payload_ops); i++) { ops = payload_ops[i]; - if (ops->locate(payload) < 0) { + if (ops->prepare(payload) < 0) { printk(BIOS_DEBUG, "%s: could not locate payload.\n", ops->name); continue; } printk(BIOS_DEBUG, "%s: located payload @ %p, %zu bytes.\n", - ops->name, prog_start(prog), prog_size(prog)); + ops->name, prog_start(payload), prog_size(payload)); break; } @@ -73,23 +70,23 @@ void payload_load(void) mirror_payload(payload); /* Pass cbtables to payload if architecture desires it. */ - prog_set_entry(&payload->prog, selfload(payload), + prog_set_entry(payload, selfload(payload), cbmem_find(CBMEM_ID_CBTABLE)); out: - if (prog_entry(&payload->prog) == NULL) + if (prog_entry(payload) == NULL) die("Payload not loaded.\n"); } void payload_run(void) { - struct payload *payload = &global_payload; + struct prog *payload = &global_payload; /* Reset to booting from this image as late as possible */ boot_successful(); printk(BIOS_DEBUG, "Jumping to boot code at %p(%p)\n", - prog_entry(&payload->prog), prog_entry_arg(&payload->prog)); + prog_entry(payload), prog_entry_arg(payload)); post_code(POST_ENTER_ELF_BOOT); timestamp_add_now(TS_SELFBOOT_JUMP); @@ -99,5 +96,5 @@ void payload_run(void) */ checkstack(_estack, 0); - arch_payload_run(payload); + prog_run(payload); } diff --git a/src/lib/loaders/load_and_run_ramstage.c b/src/lib/loaders/load_and_run_ramstage.c index 9067a28..b3728a1 100644 --- a/src/lib/loaders/load_and_run_ramstage.c +++ b/src/lib/loaders/load_and_run_ramstage.c @@ -25,10 +25,10 @@ #include <romstage_handoff.h> #include <timestamp.h> -extern const struct ramstage_loader_ops cbfs_ramstage_loader; -extern const struct ramstage_loader_ops vboot_ramstage_loader; +extern const struct prog_loader_ops cbfs_ramstage_loader; +extern const struct prog_loader_ops vboot_ramstage_loader; -static const struct ramstage_loader_ops *loaders[] = { +static const struct prog_loader_ops *loaders[] = { #if CONFIG_VBOOT_VERIFY_FIRMWARE &vboot_ramstage_loader, #endif @@ -36,12 +36,12 @@ static const struct ramstage_loader_ops *loaders[] = { }; static void -load_ramstage(const struct ramstage_loader_ops *ops, +load_ramstage(const struct prog_loader_ops *ops, struct romstage_handoff *handoff, struct prog *ramstage) { timestamp_add_now(TS_START_COPYRAM); - if (ops->load(ramstage)) + if (ops->prepare(ramstage)) return; cache_loaded_ramstage(handoff, ramstage); @@ -68,7 +68,7 @@ static void run_ramstage_from_resume(struct romstage_handoff *handoff, void run_ramstage(void) { struct romstage_handoff *handoff; - const struct ramstage_loader_ops *ops; + const struct prog_loader_ops *ops; int i; struct prog ramstage = { .name = CONFIG_CBFS_PREFIX "/ramstage", diff --git a/src/lib/selfboot.c b/src/lib/selfboot.c index 164dce9..ac9c647 100644 --- a/src/lib/selfboot.c +++ b/src/lib/selfboot.c @@ -214,13 +214,13 @@ static int relocate_segment(unsigned long buffer, struct segment *seg) static int build_self_segment_list( struct segment *head, - struct payload *payload, uintptr_t *entry) + struct prog *payload, uintptr_t *entry) { struct segment *new; struct segment *ptr; struct cbfs_payload_segment *segment, *first_segment; struct cbfs_payload *cbfs_payload; - cbfs_payload = prog_start(&payload->prog); + cbfs_payload = prog_start(payload); memset(head, 0, sizeof(*head)); head->next = head->prev = head; first_segment = segment = &cbfs_payload->segments; @@ -311,7 +311,7 @@ static int build_self_segment_list( static int load_self_segments( struct segment *head, - struct payload *payload) + struct prog *payload) { struct segment *ptr; struct segment *last_non_empty; @@ -457,7 +457,7 @@ static int load_self_segments( return 1; } -void *selfload(struct payload *payload) +void *selfload(struct prog *payload) { uintptr_t entry = 0; struct segment head;

1 0

Patch set updated for coreboot: f260073 tegra132: implement platform_prog_run()
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/8848 -gerrit commit f2600730ea1a483abcb34bc898dd642c38d7033a Author: Aaron Durbin <adurbin(a)chromium.org> Date: Fri Mar 20 16:47:21 2015 -0500 tegra132: implement platform_prog_run() The tegra132 SoC is currently booting up on the AVP cpu which bootstraps the rest of the SoC. Upon exiting romstage it runs ramstage from its faster armv8 core. Instead of hard coding the stage loading operations use run_ramstage(). Change-Id: Ib9b3eecf376ae022f910295920a085bde6e17f9f Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/soc/nvidia/tegra132/romstage.c | 37 +++++++------------------------------ 1 file changed, 7 insertions(+), 30 deletions(-) diff --git a/src/soc/nvidia/tegra132/romstage.c b/src/soc/nvidia/tegra132/romstage.c index 9051a81..94fd845 100644 --- a/src/soc/nvidia/tegra132/romstage.c +++ b/src/soc/nvidia/tegra132/romstage.c @@ -24,6 +24,7 @@ #include <console/console.h> #include <timer.h> #include <arch/exception.h> +#include <program_loading.h> #include <soc/addressmap.h> #include <soc/sdram_configs.h> @@ -38,30 +39,8 @@ void __attribute__((weak)) romstage_mainboard_init(void) /* Default empty implementation. */ } -static void *load_ramstage(void) -{ - void *entry; - struct stopwatch sw; - - stopwatch_init(&sw); - /* - * This platform does not need to cache a loaded ramstage nor do we - * go down this path on resume. Therefore, no romstage_handoff is - * required. - */ - entry = cbfs_load_stage(CBFS_DEFAULT_MEDIA, - CONFIG_CBFS_PREFIX "/ramstage"); - - printk(BIOS_DEBUG, "Ramstage load time: %ld usecs.\n", - stopwatch_duration_usecs(&sw)); - - return entry; -} - void romstage(void) { - void *entry; - console_init(); exception_init(); @@ -99,16 +78,14 @@ void romstage(void) romstage_mainboard_init(); - entry = load_ramstage(); - - if (entry == NULL) { - printk(BIOS_INFO, "T132 romstage: error loading ramstage\n"); - clock_halt_avp(); - } - cbmemc_reinit(); - ccplex_cpu_start(entry); + run_ramstage(); +} + +void platform_prog_run(struct prog *prog) +{ + ccplex_cpu_start(prog_entry(prog)); clock_halt_avp(); }

1 0

Patch set updated for coreboot: ae3a91d coreboot: add imd library
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/8621 -gerrit commit ae3a91ddd3e220b63263e2c43ce0c9ffbfed29e1 Author: Aaron Durbin <adurbin(a)chromium.org> Date: Thu Mar 5 14:11:27 2015 -0600 coreboot: add imd library The imd (internal memory database) library provides a way to track memory regions by assigning ids to each region. The implementation is a direct descendant of dynamic cbmem. The intent is to replace the existing mechanisms which do similar things: dynamic cbmem, stage cache, etc. Differences between dynamic cbmem and imd: - All structures/objects are relative to one another. There are no absolute pointers serialized to memory. - Allow limiting the size of the idm. i.e. provide a maximum memory usage. - Allow limiting the size of the root structure for tracking entries. Change-Id: Id7438cff80d396a594d6a7330d09b45bb4fedf2e Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/include/cbmem.h | 4 +- src/include/imd.h | 126 ++++++++++++++ src/lib/Makefile.inc | 3 + src/lib/imd.c | 462 +++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 594 insertions(+), 1 deletion(-) diff --git a/src/include/cbmem.h b/src/include/cbmem.h index f605191..70ec2c8 100644 --- a/src/include/cbmem.h +++ b/src/include/cbmem.h @@ -77,6 +77,7 @@ #define CBMEM_ID_NONE 0x00000000 #define CBMEM_ID_AGESA_RUNTIME 0x41474553 #define CBMEM_ID_HOB_POINTER 0x484f4221 +#define CBMEM_ID_IMD_ROOT 0xff4017ff #ifndef __ASSEMBLER__ #include <stddef.h> @@ -119,7 +120,8 @@ struct cbmem_id_to_name { { CBMEM_ID_POWER_STATE, "POWER STATE" }, \ { CBMEM_ID_RAM_OOPS, "RAMOOPS " }, \ { CBMEM_ID_MEMINFO, "MEM INFO " }, \ - { CBMEM_ID_SPINTABLE, "SPIN TABLE " }, + { CBMEM_ID_SPINTABLE, "SPIN TABLE " }, \ + { CBMEM_ID_IMD_ROOT, "IMD ROOT " }, struct cbmem_entry; diff --git a/src/include/imd.h b/src/include/imd.h new file mode 100644 index 0000000..effa2da --- /dev/null +++ b/src/include/imd.h @@ -0,0 +1,126 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 Google, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef _IMD_H_ +#define _IMD_H_ + +#include <stdint.h> +#include <stddef.h> + +/* + * imd is an in-memory database/directory/datastore (whatever d word you + * desire). It grows downwards in memory from provided upper limit and + * root size. Each entry has a size alignment which is also provided by + * the caller. + * + * +----------------------+ <- upper_limit + * | +----| root pointer | + * | | +----------------------+ + * | | | |--------+ + * | +--->| root block |-----+ | + * | +----------------------+-----|--|--- root_size + * | | | | | + * | | | | | + * | | alloc N |<----+ | + * | +----------------------+ | + * | | | | + * | | | | + * \|/ | alloc N + 1 |<-------+ + * v +----------------------+ + * + */ + +/* + * NOTE: This API has the following calling conventions: all functions + * returning int supply 0 on success or < 0 on error. + */ + +struct imd_entry; +struct imd; + +/* + * Initialize handle to use for working with an imd. Upper limit is the + * exclusive address to start allocating down from. This function needs + * to be called at least once before any other imd related functions + * can be used. + */ +void imd_handle_init(struct imd *imd, void *upper_limit); + +/* + * Create an empty imd with a specified root_size and each entry is aligned to + * the provided entry_align. + */ +int imd_create_empty(struct imd *imd, size_t root_size, size_t entry_align); + +/* + * Recover a previously created imd. + */ +int imd_recover(struct imd *imd); + +/* Limit imd to provided max_size. */ +int imd_limit_size(struct imd *imd, size_t max_size); + +/* Lock down imd from further modifications. */ +int imd_lockdown(struct imd *imd); + +/* Fill in base address and size of region used by imd. */ +int imd_region_used(struct imd *imd, void **base, size_t *size); + +/* Add an entry to the imd. If id already exists NULL is returned. */ +const struct imd_entry *imd_entry_add(const struct imd *imd, uint32_t id, + size_t size); + +/* Locate an entry within the imd. NULL is returned when not found. */ +const struct imd_entry *imd_entry_find(const struct imd *imd, uint32_t id); + +/* Find an existing entry or add a new one. */ +const struct imd_entry *imd_entry_find_or_add(const struct imd *imd, + uint32_t id, size_t size); + +/* Returns size of entry or 0 on failure. */ +size_t imd_entry_size(const struct imd *imd, const struct imd_entry *entry); + +/* Returns pointer to region described by entry or NULL on failure. */ +void *imd_entry_at(const struct imd *imd, const struct imd_entry *entry); + +/* Attempt to remove entry from imd. */ +int imd_entry_remove(const struct imd *imd, const struct imd_entry *entry); + +/* Print the entry information provided by lookup with the specified size. */ +struct imd_lookup { + uint32_t id; + const char *name; +}; + +int imd_print_entries(const struct imd *imd, const struct imd_lookup *lookup, + size_t size); + + +/* + * The struct imd is a handle for working with an in-memory directory. + * + * NOTE: Do not directly touch any fields within this structure. An imd pointer + * is meant to be opaque, but the fields are exposed for stack allocation. + */ +struct imd { + uintptr_t limit; + void *r; +}; + +#endif /* _IMD_H_ */ diff --git a/src/lib/Makefile.inc b/src/lib/Makefile.inc index 5f149c9..736fa9b 100644 --- a/src/lib/Makefile.inc +++ b/src/lib/Makefile.inc @@ -92,6 +92,9 @@ ramstage-$(CONFIG_TERTIARY_BOARD_ID) += tristate_gpios.c romstage-y += cbmem_common.c dynamic_cbmem.c ramstage-y += cbmem_common.c dynamic_cbmem.c +romstage-y += imd.c +ramstage-y += imd.c + ramstage-y += hexdump.c romstage-y += hexdump.c diff --git a/src/lib/imd.c b/src/lib/imd.c new file mode 100644 index 0000000..620cd90 --- /dev/null +++ b/src/lib/imd.c @@ -0,0 +1,462 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 Google, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <assert.h> +#include <cbmem.h> +#include <console/console.h> +#include <imd.h> +#include <stdlib.h> +#include <string.h> + +static const uint32_t IMD_ROOT_PTR_MAGIC = 0xc0389481; +static const uint32_t IMD_ENTRY_MAGIC = ~0xc0389481; +static const size_t LIMIT_ALIGN = 4096; + +/* In-memory data structures. */ +struct imd_root_pointer { + uint32_t magic; + /* Relative to upper limit/offset. */ + int32_t root_offset; +} __attribute__((packed)); + +struct imd_entry { + uint32_t magic; + /* start is located relative to imd_root */ + int32_t start_offset; + uint32_t size; + uint32_t id; +} __attribute__((packed)); + +struct imd_root { + uint32_t max_entries; + uint32_t num_entries; + uint32_t flags; + uint32_t entry_align; + /* Used for fixing the size of an imd. Relative to the root. */ + int32_t max_offset; + struct imd_entry entries[0]; +} __attribute__((packed)); + +#define IMD_FLAG_LOCKED 1 + +static inline bool is_power_of_2(size_t v) +{ + return !!((v & -v) == v); +} + +static void *relative_pointer(void *base, ssize_t offset) +{ + intptr_t b = (intptr_t)base; + b += offset; + return (void *)b; +} + +static bool imd_root_pointer_valid(const struct imd_root_pointer *rp) +{ + return !!(rp->magic == IMD_ROOT_PTR_MAGIC); +} + +static struct imd_root *imd_root(const struct imd *imd) +{ + return imd->r; +} + +static struct imd_root_pointer *imd_root_pointer(const struct imd *imd) +{ + struct imd_root_pointer *rp; + + rp = (void *)(imd->limit - sizeof(*rp)); + + return rp; +} + +static void imd_link_root(struct imd_root_pointer *rp, struct imd_root *r) +{ + rp->magic = IMD_ROOT_PTR_MAGIC; + rp->root_offset = (int32_t)((intptr_t)r - (intptr_t)rp); +} + +static void imd_entry_assign(struct imd_entry *e, uint32_t id, + ssize_t offset, size_t size) +{ + e->magic = IMD_ENTRY_MAGIC; + e->start_offset = offset; + e->size = size; + e->id = id; +} + +static bool root_is_locked(const struct imd_root *r) +{ + return !!(r->flags & IMD_FLAG_LOCKED); +} + +static struct imd_entry *root_last_entry(struct imd_root *r) +{ + return &r->entries[r->num_entries - 1]; +} + +/* Initialize imd handle. */ +void imd_handle_init(struct imd *imd, void *upper_limit) +{ + uintptr_t limit = (uintptr_t)upper_limit; + /* Upper limit is aligned down to 4KiB */ + imd->limit = ALIGN_DOWN(limit, LIMIT_ALIGN); + imd->r = NULL; +} + +int imd_create_empty(struct imd *imd, size_t root_size, size_t entry_align) +{ + struct imd_root_pointer *rp; + struct imd_root *r; + struct imd_entry *e; + ssize_t root_offset; + size_t entries_size; + + /* root_size and entry_align should be a power of 2. */ + assert(is_power_of_2(root_size)); + assert(is_power_of_2(entry_align)); + + /* + * root_size needs to be large enough to accomodate root pointer and + * root book keeping structure. The caller needs to ensure there's + * enough room for tracking individual allocations. + */ + if (root_size < (sizeof(*rp) + sizeof(*r))) + return -1; + + /* For simplicity don't allow sizes or alignments to exceed LIMIT_ALIGN. */ + if (root_size > LIMIT_ALIGN || entry_align > LIMIT_ALIGN) + return -1; + + /* Additionally, don't handle an entry alignment > root_size. */ + if (entry_align > root_size) + return -1; + + rp = imd_root_pointer(imd); + + root_offset = root_size; + root_offset = -root_offset; + /* Set root pointer. */ + imd->r = relative_pointer((void *)imd->limit, root_offset); + r = imd_root(imd); + imd_link_root(rp, r); + + memset(r, 0, sizeof(*r)); + r->entry_align = entry_align; + + /* Calculate size left for entries. */ + entries_size = root_size; + entries_size -= sizeof(*rp); + entries_size -= sizeof(*r); + + r->max_entries = entries_size / sizeof(r->entries[0]); + + /* Fill in first entry covering the root region. */ + r->num_entries = 1; + e = &r->entries[0]; + imd_entry_assign(e, CBMEM_ID_IMD_ROOT, 0, root_size); + + printk(BIOS_DEBUG, "IMD: root @ %p %u entries.\n", r, r->max_entries); + + return 0; +} + +int imd_limit_size(struct imd *imd, size_t max_size) +{ + struct imd_root *r; + ssize_t smax_size; + size_t root_size; + + r = imd_root(imd); + if (r == NULL) + return -1; + + root_size = imd->limit - (uintptr_t)r; + + if (max_size < root_size) + return -1; + + /* Take into account the root size. */ + smax_size = max_size - root_size; + smax_size = -smax_size; + + r->max_offset = smax_size; + + return 0; +} + +int imd_recover(struct imd *imd) +{ + struct imd_root_pointer *rp; + struct imd_root *r; + uintptr_t low_limit; + size_t i; + + rp = imd_root_pointer(imd); + + if (!imd_root_pointer_valid(rp)) + return -1; + + r = relative_pointer(rp, rp->root_offset); + + /* Confirm the root and root pointer are just under the limit. */ + if (ALIGN_UP((uintptr_t)&r->entries[r->max_entries], LIMIT_ALIGN) != + imd->limit) + return -1; + + if (r->num_entries > r->max_entries) + return -1; + + /* Entry alignment should be power of 2. */ + if (!is_power_of_2(r->entry_align)) + return -1; + + low_limit = (uintptr_t)relative_pointer(r, r->max_offset); + + /* If no max_offset then lowest limit is 0. */ + if (low_limit == (uintptr_t)r) + low_limit = 0; + + for (i = 0; i < r->num_entries; i++) { + uintptr_t start_addr; + const struct imd_entry *e = &r->entries[i]; + + if (e->magic != IMD_ENTRY_MAGIC) + return -1; + + start_addr = (uintptr_t)relative_pointer(r, e->start_offset); + if (start_addr < low_limit) + return -1; + if (start_addr >= imd->limit || + (start_addr + e->size) > imd->limit) + return -1; + } + + /* Set root pointer. */ + imd->r = r; + + return 0; +} + +int imd_lockdown(struct imd *imd) +{ + struct imd_root *r; + + r = imd_root(imd); + if (r == NULL) + return -1; + + r->flags |= IMD_FLAG_LOCKED; + + return 0; +} + +int imd_region_used(struct imd *imd, void **base, size_t *size) +{ + struct imd_root *r; + struct imd_entry *e; + void *low_addr; + size_t sz_used; + size_t i; + + r = imd_root(imd); + + if (r == NULL) + return -1; + + /* Use last entry to obtain lowest address. */ + e = root_last_entry(r); + + low_addr = relative_pointer(r, e->start_offset); + + /* + * This could be calculated differently, but it's easy to just + * loop through the entries accumulating their sizes. + */ + for (i = 0, sz_used = 0; i < r->num_entries; i++) + sz_used += r->entries[i].size; + + *base = low_addr; + *size = sz_used; + + return 0; +} + +static struct imd_entry *imd_entry_add_to_root(struct imd_root *r, uint32_t id, + size_t size) +{ + struct imd_entry *entry; + struct imd_entry *last_entry; + ssize_t e_offset; + size_t used_size; + + if (r->num_entries == r->max_entries) + return NULL; + + /* Determine total size taken up by entry. */ + used_size = ALIGN_UP(size, r->entry_align); + + last_entry = root_last_entry(r); + + /* See if size overflows imd total size. */ + if (r->max_offset != 0) { + size_t remaining = last_entry->start_offset - r->max_offset; + + if (used_size > remaining) + return NULL; + } + + /* + * Determine if offset field overflows. All offsets should be lower + * than the previous one. + */ + e_offset = last_entry->start_offset; + e_offset -= (ssize_t)used_size; + if (e_offset > last_entry->start_offset) + return NULL; + + entry = root_last_entry(r) + 1; + r->num_entries++; + + imd_entry_assign(entry, id, e_offset, size); + + return entry; +} + +const struct imd_entry *imd_entry_add(const struct imd *imd, uint32_t id, + size_t size) +{ + struct imd_root *r; + + r = imd_root(imd); + + if (r == NULL) + return NULL; + + return imd_entry_add_to_root(r, id, size); +} + +const struct imd_entry *imd_entry_find(const struct imd *imd, uint32_t id) +{ + struct imd_root *r; + struct imd_entry *e; + size_t i; + + r = imd_root(imd); + + if (r == NULL) + return NULL; + + e = NULL; + /* Skip first entry covering the root. */ + for (i = 1; i < r->num_entries; i++) { + if (id != r->entries[i].id) + continue; + e = &r->entries[i]; + break; + } + + return e; +} + +const struct imd_entry *imd_entry_find_or_add(const struct imd *imd, + uint32_t id, size_t size) +{ + const struct imd_entry *e; + + e = imd_entry_find(imd, id); + + if (e != NULL) + return e; + + return imd_entry_add(imd, id, size); +} + +size_t imd_entry_size(const struct imd *imd, const struct imd_entry *entry) +{ + return entry->size; +} + +void *imd_entry_at(const struct imd *imd, const struct imd_entry *entry) +{ + struct imd_root *r; + + r = imd_root(imd); + + if (r == NULL) + return NULL; + + return relative_pointer(r, entry->start_offset); +} + +int imd_entry_remove(const struct imd *imd, const struct imd_entry *entry) +{ + struct imd_root *r; + + r = imd_root(imd); + + if (r == NULL) + return -1; + + if (root_is_locked(r)) + return -1; + + if (entry != root_last_entry(r)) + return -1; + + r->num_entries--; + + return 0; +} + +int imd_print_entries(const struct imd *imd, const struct imd_lookup *lookup, + size_t size) +{ + struct imd_root *r; + size_t i; + size_t j; + + r = imd_root(imd); + + if (r == NULL) + return -1; + + for (i = 0; i < r->num_entries; i++) { + const char *name = NULL; + const struct imd_entry *e = &r->entries[i]; + + for (j = 0; j < size; j++) { + if (lookup[j].id != e->id) + continue; + + name = lookup[j].name; + break; + } + + if (name == NULL) + printk(BIOS_DEBUG, "%08x ", e->id); + else + printk(BIOS_DEBUG, "%s", name); + printk(BIOS_DEBUG, "%2zu. ", i); + printk(BIOS_DEBUG, "%p ", imd_entry_at(imd, e)); + printk(BIOS_DEBUG, "%08zx\n", imd_entry_size(imd, e)); + } + + return 0; +}

1 0

Patch set updated for coreboot: c16a4eb coreboot: tiered imd
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/8623 -gerrit commit c16a4eb2c4152b81b649f82d46813aef0010b233 Author: Aaron Durbin <adurbin(a)chromium.org> Date: Tue Mar 24 23:14:46 2015 -0500 coreboot: tiered imd A tiered imd allows for both small and large allocations. The small allocations are packed into a large region. Utilizing a tiered imd reduces internal fragmentation within the imd. Change-Id: I0bcd6473aacbc714844815b24d77cb5c542abdd0 Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/include/cbmem.h | 4 +- src/include/imd.h | 18 ++- src/lib/imd.c | 430 ++++++++++++++++++++++++++++++++++++++-------------- 3 files changed, 335 insertions(+), 117 deletions(-) diff --git a/src/include/cbmem.h b/src/include/cbmem.h index 70ec2c8..81e5f12 100644 --- a/src/include/cbmem.h +++ b/src/include/cbmem.h @@ -78,6 +78,7 @@ #define CBMEM_ID_AGESA_RUNTIME 0x41474553 #define CBMEM_ID_HOB_POINTER 0x484f4221 #define CBMEM_ID_IMD_ROOT 0xff4017ff +#define CBMEM_ID_IMD_SMALL 0x53a11439 #ifndef __ASSEMBLER__ #include <stddef.h> @@ -121,7 +122,8 @@ struct cbmem_id_to_name { { CBMEM_ID_RAM_OOPS, "RAMOOPS " }, \ { CBMEM_ID_MEMINFO, "MEM INFO " }, \ { CBMEM_ID_SPINTABLE, "SPIN TABLE " }, \ - { CBMEM_ID_IMD_ROOT, "IMD ROOT " }, + { CBMEM_ID_IMD_ROOT, "IMD ROOT " }, \ + { CBMEM_ID_IMD_SMALL, "IMD SMALL " }, struct cbmem_entry; diff --git a/src/include/imd.h b/src/include/imd.h index effa2da..a548b66 100644 --- a/src/include/imd.h +++ b/src/include/imd.h @@ -69,6 +69,18 @@ void imd_handle_init(struct imd *imd, void *upper_limit); int imd_create_empty(struct imd *imd, size_t root_size, size_t entry_align); /* + * Create an empty imd with both large and small allocations. The small + * allocations come from a fixed imd stored internally within the large + * imd. The region allocated for tracking the smaller allocations is dependent + * on the small root_size and the large entry alignment by calculating the + * number of entries within the small imd and multiplying that by the small + * entry alignment. + */ +int imd_create_tiered_empty(struct imd *imd, + size_t lg_root_size, size_t lg_entry_align, + size_t sm_root_size, size_t sm_entry_align); + +/* * Recover a previously created imd. */ int imd_recover(struct imd *imd); @@ -118,9 +130,13 @@ int imd_print_entries(const struct imd *imd, const struct imd_lookup *lookup, * NOTE: Do not directly touch any fields within this structure. An imd pointer * is meant to be opaque, but the fields are exposed for stack allocation. */ -struct imd { +struct imdr { uintptr_t limit; void *r; }; +struct imd { + struct imdr lg; + struct imdr sm; +}; #endif /* _IMD_H_ */ diff --git a/src/lib/imd.c b/src/lib/imd.c index 620cd90..19bf481 100644 --- a/src/lib/imd.c +++ b/src/lib/imd.c @@ -26,6 +26,7 @@ static const uint32_t IMD_ROOT_PTR_MAGIC = 0xc0389481; static const uint32_t IMD_ENTRY_MAGIC = ~0xc0389481; +static const uint32_t SMALL_REGION_ID = CBMEM_ID_IMD_SMALL; static const size_t LIMIT_ALIGN = 4096; /* In-memory data structures. */ @@ -72,16 +73,16 @@ static bool imd_root_pointer_valid(const struct imd_root_pointer *rp) return !!(rp->magic == IMD_ROOT_PTR_MAGIC); } -static struct imd_root *imd_root(const struct imd *imd) +static struct imd_root *imdr_root(const struct imdr *imdr) { - return imd->r; + return imdr->r; } -static struct imd_root_pointer *imd_root_pointer(const struct imd *imd) +static struct imd_root_pointer *imdr_root_pointer(const struct imdr *imdr) { struct imd_root_pointer *rp; - rp = (void *)(imd->limit - sizeof(*rp)); + rp = (void *)(imdr->limit - sizeof(*rp)); return rp; } @@ -92,13 +93,32 @@ static void imd_link_root(struct imd_root_pointer *rp, struct imd_root *r) rp->root_offset = (int32_t)((intptr_t)r - (intptr_t)rp); } -static void imd_entry_assign(struct imd_entry *e, uint32_t id, - ssize_t offset, size_t size) +static struct imd_entry *root_last_entry(struct imd_root *r) { - e->magic = IMD_ENTRY_MAGIC; - e->start_offset = offset; - e->size = size; - e->id = id; + return &r->entries[r->num_entries - 1]; +} + +static size_t root_num_entries(size_t root_size) +{ + size_t entries_size; + + entries_size = root_size; + entries_size -= sizeof(struct imd_root_pointer); + entries_size -= sizeof(struct imd_root); + + return entries_size / sizeof(struct imd_entry); +} + +static size_t imd_root_data_left(struct imd_root *r) +{ + struct imd_entry *last_entry; + + last_entry = root_last_entry(r); + + if (r->max_offset != 0) + return last_entry->start_offset - r->max_offset; + + return ~(size_t)0; } static bool root_is_locked(const struct imd_root *r) @@ -106,27 +126,30 @@ static bool root_is_locked(const struct imd_root *r) return !!(r->flags & IMD_FLAG_LOCKED); } -static struct imd_entry *root_last_entry(struct imd_root *r) +static void imd_entry_assign(struct imd_entry *e, uint32_t id, + ssize_t offset, size_t size) { - return &r->entries[r->num_entries - 1]; + e->magic = IMD_ENTRY_MAGIC; + e->start_offset = offset; + e->size = size; + e->id = id; } -/* Initialize imd handle. */ -void imd_handle_init(struct imd *imd, void *upper_limit) +static void imdr_init(struct imdr *ir, void *upper_limit) { uintptr_t limit = (uintptr_t)upper_limit; /* Upper limit is aligned down to 4KiB */ - imd->limit = ALIGN_DOWN(limit, LIMIT_ALIGN); - imd->r = NULL; + ir->limit = ALIGN_DOWN(limit, LIMIT_ALIGN); + ir->r = NULL; } -int imd_create_empty(struct imd *imd, size_t root_size, size_t entry_align) +static int imdr_create_empty(struct imdr *imdr, size_t root_size, + size_t entry_align) { struct imd_root_pointer *rp; struct imd_root *r; struct imd_entry *e; ssize_t root_offset; - size_t entries_size; /* root_size and entry_align should be a power of 2. */ assert(is_power_of_2(root_size)); @@ -148,24 +171,20 @@ int imd_create_empty(struct imd *imd, size_t root_size, size_t entry_align) if (entry_align > root_size) return -1; - rp = imd_root_pointer(imd); + rp = imdr_root_pointer(imdr); root_offset = root_size; root_offset = -root_offset; /* Set root pointer. */ - imd->r = relative_pointer((void *)imd->limit, root_offset); - r = imd_root(imd); + imdr->r = relative_pointer((void *)imdr->limit, root_offset); + r = imdr_root(imdr); imd_link_root(rp, r); memset(r, 0, sizeof(*r)); r->entry_align = entry_align; /* Calculate size left for entries. */ - entries_size = root_size; - entries_size -= sizeof(*rp); - entries_size -= sizeof(*r); - - r->max_entries = entries_size / sizeof(r->entries[0]); + r->max_entries = root_num_entries(root_size); /* Fill in first entry covering the root region. */ r->num_entries = 1; @@ -177,38 +196,14 @@ int imd_create_empty(struct imd *imd, size_t root_size, size_t entry_align) return 0; } -int imd_limit_size(struct imd *imd, size_t max_size) -{ - struct imd_root *r; - ssize_t smax_size; - size_t root_size; - - r = imd_root(imd); - if (r == NULL) - return -1; - - root_size = imd->limit - (uintptr_t)r; - - if (max_size < root_size) - return -1; - - /* Take into account the root size. */ - smax_size = max_size - root_size; - smax_size = -smax_size; - - r->max_offset = smax_size; - - return 0; -} - -int imd_recover(struct imd *imd) +static int imdr_recover(struct imdr *imdr) { struct imd_root_pointer *rp; struct imd_root *r; uintptr_t low_limit; size_t i; - rp = imd_root_pointer(imd); + rp = imdr_root_pointer(imdr); if (!imd_root_pointer_valid(rp)) return -1; @@ -217,7 +212,7 @@ int imd_recover(struct imd *imd) /* Confirm the root and root pointer are just under the limit. */ if (ALIGN_UP((uintptr_t)&r->entries[r->max_entries], LIMIT_ALIGN) != - imd->limit) + imdr->limit) return -1; if (r->num_entries > r->max_entries) @@ -243,61 +238,76 @@ int imd_recover(struct imd *imd) start_addr = (uintptr_t)relative_pointer(r, e->start_offset); if (start_addr < low_limit) return -1; - if (start_addr >= imd->limit || - (start_addr + e->size) > imd->limit) + if (start_addr >= imdr->limit || + (start_addr + e->size) > imdr->limit) return -1; } /* Set root pointer. */ - imd->r = r; + imdr->r = r; return 0; } -int imd_lockdown(struct imd *imd) +static const struct imd_entry *imdr_entry_find(const struct imdr *imdr, + uint32_t id) { struct imd_root *r; + struct imd_entry *e; + size_t i; + + r = imdr_root(imdr); - r = imd_root(imd); if (r == NULL) - return -1; + return NULL; - r->flags |= IMD_FLAG_LOCKED; + e = NULL; + /* Skip first entry covering the root. */ + for (i = 1; i < r->num_entries; i++) { + if (id != r->entries[i].id) + continue; + e = &r->entries[i]; + break; + } - return 0; + return e; } -int imd_region_used(struct imd *imd, void **base, size_t *size) +static int imdr_limit_size(struct imdr *imdr, size_t max_size) { struct imd_root *r; - struct imd_entry *e; - void *low_addr; - size_t sz_used; - size_t i; - - r = imd_root(imd); + ssize_t smax_size; + size_t root_size; + r = imdr_root(imdr); if (r == NULL) return -1; - /* Use last entry to obtain lowest address. */ - e = root_last_entry(r); + root_size = imdr->limit - (uintptr_t)r; - low_addr = relative_pointer(r, e->start_offset); + if (max_size < root_size) + return -1; - /* - * This could be calculated differently, but it's easy to just - * loop through the entries accumulating their sizes. - */ - for (i = 0, sz_used = 0; i < r->num_entries; i++) - sz_used += r->entries[i].size; + /* Take into account the root size. */ + smax_size = max_size - root_size; + smax_size = -smax_size; - *base = low_addr; - *size = sz_used; + r->max_offset = smax_size; return 0; } +static size_t imdr_entry_size(const struct imdr *imdr, + const struct imd_entry *e) +{ + return e->size; +} + +static void *imdr_entry_at(const struct imdr *imdr, const struct imd_entry *e) +{ + return relative_pointer(imdr_root(imdr), e->start_offset); +} + static struct imd_entry *imd_entry_add_to_root(struct imd_root *r, uint32_t id, size_t size) { @@ -312,20 +322,15 @@ static struct imd_entry *imd_entry_add_to_root(struct imd_root *r, uint32_t id, /* Determine total size taken up by entry. */ used_size = ALIGN_UP(size, r->entry_align); - last_entry = root_last_entry(r); - /* See if size overflows imd total size. */ - if (r->max_offset != 0) { - size_t remaining = last_entry->start_offset - r->max_offset; - - if (used_size > remaining) - return NULL; - } + if (used_size > imd_root_data_left(r)) + return NULL; /* * Determine if offset field overflows. All offsets should be lower * than the previous one. */ + last_entry = root_last_entry(r); e_offset = last_entry->start_offset; e_offset -= (ssize_t)used_size; if (e_offset > last_entry->start_offset) @@ -339,12 +344,12 @@ static struct imd_entry *imd_entry_add_to_root(struct imd_root *r, uint32_t id, return entry; } -const struct imd_entry *imd_entry_add(const struct imd *imd, uint32_t id, - size_t size) +static const struct imd_entry *imdr_entry_add(const struct imdr *imdr, + uint32_t id, size_t size) { struct imd_root *r; - r = imd_root(imd); + r = imdr_root(imdr); if (r == NULL) return NULL; @@ -352,25 +357,202 @@ const struct imd_entry *imd_entry_add(const struct imd *imd, uint32_t id, return imd_entry_add_to_root(r, id, size); } -const struct imd_entry *imd_entry_find(const struct imd *imd, uint32_t id) +static bool imdr_has_entry(const struct imdr *imdr, const struct imd_entry *e) +{ + struct imd_root *r; + size_t idx; + + r = imdr_root(imdr); + if (r == NULL) + return false; + + /* Determine if the entry is within this root structure. */ + idx = e - &r->entries[0]; + if (idx >= r->num_entries) + return false; + + return true; +} + +static const struct imdr *imd_entry_to_imdr(const struct imd *imd, + const struct imd_entry *entry) +{ + if (imdr_has_entry(&imd->lg, entry)) + return &imd->lg; + + if (imdr_has_entry(&imd->sm, entry)) + return &imd->sm; + + return NULL; +} + +/* Initialize imd handle. */ +void imd_handle_init(struct imd *imd, void *upper_limit) +{ + imdr_init(&imd->lg, upper_limit); + imdr_init(&imd->sm, NULL); +} + +int imd_create_empty(struct imd *imd, size_t root_size, size_t entry_align) +{ + return imdr_create_empty(&imd->lg, root_size, entry_align); +} + +int imd_create_tiered_empty(struct imd *imd, + size_t lg_root_size, size_t lg_entry_align, + size_t sm_root_size, size_t sm_entry_align) +{ + size_t sm_region_size;; + const struct imd_entry *e; + struct imdr *imdr; + + imdr = &imd->lg; + + if (imdr_create_empty(imdr, lg_root_size, lg_entry_align) != 0) + return -1; + + /* Calculate the size of the small region to request. */ + sm_region_size = root_num_entries(sm_root_size) * sm_entry_align; + sm_region_size += sm_root_size; + sm_region_size = ALIGN_UP(sm_region_size, lg_entry_align); + + /* Add a new entry to the large region to cover the root and entries. */ + e = imdr_entry_add(imdr, SMALL_REGION_ID, sm_region_size); + + if (e == NULL) + goto fail; + + imd->sm.limit = (uintptr_t)imdr_entry_at(imdr, e); + imd->sm.limit += sm_region_size; + + if (imdr_create_empty(&imd->sm, sm_root_size, sm_entry_align) != 0 || + imdr_limit_size(&imd->sm, sm_region_size)) + goto fail; + + return 0; +fail: + imd_handle_init(imd, (void *)imdr->limit); + return -1; +} + +int imd_recover(struct imd *imd) +{ + const struct imd_entry *e; + uintptr_t small_upper_limit; + struct imdr *imdr; + + imdr = &imd->lg; + if (imdr_recover(imdr) != 0) + return -1; + + /* Determine if small region is region is present. */ + e = imdr_entry_find(imdr, SMALL_REGION_ID); + + if (e == NULL) + return 0; + + small_upper_limit = (uintptr_t)imdr_entry_at(imdr, e); + small_upper_limit += imdr_entry_size(imdr, e); + + imd->sm.limit = small_upper_limit; + + /* Tear down any changes on failure. */ + if (imdr_recover(&imd->sm) != 0) { + imd_handle_init(imd, (void *)imd->lg.limit); + return -1; + } + + return 0; +} + +int imd_limit_size(struct imd *imd, size_t max_size) +{ + return imdr_limit_size(&imd->lg, max_size); +} + +int imd_lockdown(struct imd *imd) +{ + struct imd_root *r; + + r = imdr_root(&imd->lg); + if (r == NULL) + return -1; + + r->flags |= IMD_FLAG_LOCKED; + + r = imdr_root(&imd->sm); + if (r != NULL) + r->flags |= IMD_FLAG_LOCKED; + + return 0; +} + +int imd_region_used(struct imd *imd, void **base, size_t *size) { struct imd_root *r; struct imd_entry *e; + void *low_addr; + size_t sz_used; size_t i; - r = imd_root(imd); + r = imdr_root(&imd->lg); if (r == NULL) - return NULL; + return -1; - e = NULL; - /* Skip first entry covering the root. */ - for (i = 1; i < r->num_entries; i++) { - if (id != r->entries[i].id) - continue; - e = &r->entries[i]; - break; - } + /* Use last entry to obtain lowest address. */ + e = root_last_entry(r); + + low_addr = relative_pointer(r, e->start_offset); + + /* + * This could be calculated differently, but it's easy to just + * loop through the entries accumulating their sizes. + */ + for (i = 0, sz_used = 0; i < r->num_entries; i++) + sz_used += r->entries[i].size; + + *base = low_addr; + *size = sz_used; + + return 0; +} + +const struct imd_entry *imd_entry_add(const struct imd *imd, uint32_t id, + size_t size) +{ + struct imd_root *r; + const struct imdr *imdr; + const struct imd_entry *e = NULL; + + /* + * Determine if requested size is less than 1/4 of small data + * region is left. + */ + imdr = &imd->sm; + r = imdr_root(imdr); + + /* No small region. Use the large region. */ + if (r == NULL) + return imdr_entry_add(&imd->lg, id, size); + else if (size <= r->entry_align || size <= imd_root_data_left(r) / 4) + e = imdr_entry_add(imdr, id, size); + + /* Fall back on large region allocation. */ + if (e == NULL) + e = imdr_entry_add(&imd->lg, id, size); + + return e; +} + +const struct imd_entry *imd_entry_find(const struct imd *imd, uint32_t id) +{ + const struct imd_entry *e; + + e = imdr_entry_find(&imd->lg, id); + + if (e == NULL) + e = imdr_entry_find(&imd->sm, id); return e; } @@ -390,26 +572,32 @@ const struct imd_entry *imd_entry_find_or_add(const struct imd *imd, size_t imd_entry_size(const struct imd *imd, const struct imd_entry *entry) { - return entry->size; + return imdr_entry_size(NULL, entry); } void *imd_entry_at(const struct imd *imd, const struct imd_entry *entry) { - struct imd_root *r; + const struct imdr *imdr; - r = imd_root(imd); + imdr = imd_entry_to_imdr(imd, entry); - if (r == NULL) + if (imdr == NULL) return NULL; - return relative_pointer(r, entry->start_offset); + return imdr_entry_at(imdr, entry); } int imd_entry_remove(const struct imd *imd, const struct imd_entry *entry) { struct imd_root *r; + const struct imdr *imdr; + + imdr = imd_entry_to_imdr(imd, entry); - r = imd_root(imd); + if (imdr == NULL) + return - 1; + + r = imdr_root(imdr); if (r == NULL) return -1; @@ -425,17 +613,14 @@ int imd_entry_remove(const struct imd *imd, const struct imd_entry *entry) return 0; } -int imd_print_entries(const struct imd *imd, const struct imd_lookup *lookup, - size_t size) +static void imdr_print_entries(const struct imdr *imdr, const char *indent, + const struct imd_lookup *lookup, size_t size) { struct imd_root *r; size_t i; size_t j; - r = imd_root(imd); - - if (r == NULL) - return -1; + r = imdr_root(imdr); for (i = 0; i < r->num_entries; i++) { const char *name = NULL; @@ -449,13 +634,28 @@ int imd_print_entries(const struct imd *imd, const struct imd_lookup *lookup, break; } + printk(BIOS_DEBUG, "%s", indent); + if (name == NULL) printk(BIOS_DEBUG, "%08x ", e->id); else printk(BIOS_DEBUG, "%s", name); printk(BIOS_DEBUG, "%2zu. ", i); - printk(BIOS_DEBUG, "%p ", imd_entry_at(imd, e)); - printk(BIOS_DEBUG, "%08zx\n", imd_entry_size(imd, e)); + printk(BIOS_DEBUG, "%p ", imdr_entry_at(imdr, e)); + printk(BIOS_DEBUG, "%08zx\n", imdr_entry_size(imdr, e)); + } +} + +int imd_print_entries(const struct imd *imd, const struct imd_lookup *lookup, + size_t size) +{ + if (imdr_root(&imd->lg) == NULL) + return -1; + + imdr_print_entries(&imd->lg, "", lookup, size); + if (imdr_root(&imd->sm) != NULL) { + printk(BIOS_DEBUG, "IMD small region:\n"); + imdr_print_entries(&imd->sm, " ", lookup, size); } return 0;

1 0

Patch set updated for coreboot: cc4e4cc baytrail: select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/8986 -gerrit commit cc4e4ccca3c896c1fa0c9788841bc3d743925876 Author: Aaron Durbin <adurbin(a)chromium.org> Date: Tue Mar 24 11:33:03 2015 -0500 baytrail: select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS This platform supports PLATFORM_HAS_EARLY_WRITABLE_GLOBALS in that CAR region can be migrated and the data can be maintained across the CAR tear down boundary. Change-Id: I232613ebb641eb9d8fc61af4ba8d2e9b66ec5e51 Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/soc/intel/baytrail/Kconfig | 1 + 1 file changed, 1 insertion(+) diff --git a/src/soc/intel/baytrail/Kconfig b/src/soc/intel/baytrail/Kconfig index 214a1ac..fbd2b01 100644 --- a/src/soc/intel/baytrail/Kconfig +++ b/src/soc/intel/baytrail/Kconfig @@ -21,6 +21,7 @@ config CPU_SPECIFIC_OPTIONS select HAVE_HARD_RESET select MMCONF_SUPPORT select MMCONF_SUPPORT_DEFAULT + select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS select RELOCATABLE_MODULES select RELOCATABLE_RAMSTAGE select PARALLEL_MP

1 0

Patch set updated for coreboot: b35657b broadwell: select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/8984 -gerrit commit b35657b908337bf66bf32ec9f6fb6e4b8e85fa96 Author: Aaron Durbin <adurbin(a)chromium.org> Date: Wed Mar 25 10:44:53 2015 -0500 broadwell: select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS This platform supports PLATFORM_HAS_EARLY_WRITABLE_GLOBALS in that CAR region can be migrated and the data can be maintained across the CAR tear down boundary. Change-Id: Iff3372fabc684bf8742e8f7fbfde9fbc105a7aa7 Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/soc/intel/broadwell/Kconfig | 1 + 1 file changed, 1 insertion(+) diff --git a/src/soc/intel/broadwell/Kconfig b/src/soc/intel/broadwell/Kconfig index c147663..c81fa6e 100644 --- a/src/soc/intel/broadwell/Kconfig +++ b/src/soc/intel/broadwell/Kconfig @@ -29,6 +29,7 @@ config CPU_SPECIFIC_OPTIONS select IOAPIC select MMCONF_SUPPORT select MMCONF_SUPPORT_DEFAULT + select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS select RELOCATABLE_MODULES select RELOCATABLE_RAMSTAGE select REG_SCRIPT

1 0

Patch set updated for coreboot: b992857 haswell: select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS
by Aaron Durbin 28 Mar '15

28 Mar '15

Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/8985 -gerrit commit b99285743e07ecc79cd28d1b53073a63edf0283b Author: Aaron Durbin <adurbin(a)chromium.org> Date: Wed Mar 25 10:45:20 2015 -0500 haswell: select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS This platform supports PLATFORM_HAS_EARLY_WRITABLE_GLOBALS in that CAR region can be migrated and the data can be maintained across the CAR tear down boundary. Change-Id: If131e26b719828647b9fe66f30fc0c87dbcb185f Signed-off-by: Aaron Durbin <adurbin(a)chromium.org> --- src/cpu/intel/haswell/Kconfig | 1 + 1 file changed, 1 insertion(+) diff --git a/src/cpu/intel/haswell/Kconfig b/src/cpu/intel/haswell/Kconfig index 741b677..7352c63 100644 --- a/src/cpu/intel/haswell/Kconfig +++ b/src/cpu/intel/haswell/Kconfig @@ -17,6 +17,7 @@ config CPU_SPECIFIC_OPTIONS select TSC_CONSTANT_RATE select SMM_TSEG select SMM_MODULES + select PLATFORM_HAS_EARLY_WRITABLE_GLOBALS select RELOCATABLE_MODULES select RELOCATABLE_RAMSTAGE select SUPPORT_CPU_UCODE_IN_CBFS

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

coreboot-gerrit March 2015