1 /* SPDX-License-Identifier: GPL-2.0-only */
2
3 #include <cbfs.h>
4 #include <cbmem.h>
5 #include <console/console.h>
6 #include <fallback.h>
7 #include <halt.h>
8 #include <lib.h>
9 #include <program_loading.h>
10 #include <reset.h>
11 #include <rmodule.h>
12 #include <romstage_common.h>
13 #include <security/vboot/vboot_common.h>
14 #include <stage_cache.h>
15 #include <symbols.h>
16 #include <timestamp.h>
17
run_romstage(void)18 void run_romstage(void)
19 {
20 if (!CONFIG(SEPARATE_ROMSTAGE)) {
21 /* Call romstage instead of loading it as a cbfs file. */
22 timestamp_add_now(TS_ROMSTAGE_START);
23 romstage_main();
24 dead_code();
25 }
26
27 struct prog romstage =
28 PROG_INIT(PROG_ROMSTAGE, CONFIG_CBFS_PREFIX "/romstage");
29
30 vboot_run_logic();
31
32 timestamp_add_now(TS_COPYROM_START);
33
34 if (ENV_X86 && CONFIG(BOOTBLOCK_NORMAL)) {
35 if (legacy_romstage_select_and_load(&romstage) != CB_SUCCESS)
36 goto fail;
37 } else {
38 if (cbfs_prog_stage_load(&romstage))
39 goto fail;
40 }
41
42 timestamp_add_now(TS_COPYROM_END);
43
44 console_time_report();
45
46 prog_run(&romstage);
47
48 fail:
49 if (CONFIG(BOOTBLOCK_CONSOLE))
50 die_with_post_code(POSTCODE_INVALID_ROM,
51 "Couldn't load romstage.\n");
52 halt();
53 }
54
prog_locate_hook(struct prog * prog)55 int __weak prog_locate_hook(struct prog *prog) { return 0; }
56
run_ramstage_from_resume(struct prog * ramstage)57 static void run_ramstage_from_resume(struct prog *ramstage)
58 {
59 /* Load the cached ramstage to runtime location. */
60 stage_cache_load_stage(STAGE_RAMSTAGE, ramstage);
61
62 ramstage->cbfs_type = CBFS_TYPE_STAGE;
63 prog_set_arg(ramstage, (void *)cbmem_top());
64
65 if (prog_entry(ramstage) != NULL) {
66 printk(BIOS_DEBUG, "Jumping to image.\n");
67 prog_run(ramstage);
68 }
69
70 printk(BIOS_ERR, "ramstage cache invalid.\n");
71 board_reset();
72 }
73
load_relocatable_ramstage(struct prog * ramstage)74 static int load_relocatable_ramstage(struct prog *ramstage)
75 {
76 struct rmod_stage_load rmod_ram = {
77 .cbmem_id = CBMEM_ID_RAMSTAGE,
78 .prog = ramstage,
79 };
80
81 return rmodule_stage_load(&rmod_ram);
82 }
preload_ramstage(void)83 void preload_ramstage(void)
84 {
85 if (!CONFIG(CBFS_PRELOAD))
86 return;
87
88 printk(BIOS_DEBUG, "Preloading ramstage\n");
89
90 cbfs_preload(CONFIG_CBFS_PREFIX "/ramstage");
91 }
run_ramstage(void)92 void __noreturn run_ramstage(void)
93 {
94 struct prog ramstage =
95 PROG_INIT(PROG_RAMSTAGE, CONFIG_CBFS_PREFIX "/ramstage");
96
97 /* Call "end of romstage" here if postcar stage doesn't exist */
98 if (ENV_POSTCAR)
99 timestamp_add_now(TS_POSTCAR_END);
100 else
101 timestamp_add_now(TS_ROMSTAGE_END);
102
103 vboot_run_logic();
104
105 /*
106 * Only x86 systems using ramstage stage cache currently take the same
107 * firmware path on resume.
108 */
109 if (ENV_X86 && resume_from_stage_cache())
110 run_ramstage_from_resume(&ramstage);
111
112 timestamp_add_now(TS_COPYRAM_START);
113
114 if (ENV_X86) {
115 if (load_relocatable_ramstage(&ramstage))
116 goto fail;
117 } else {
118 if (cbfs_prog_stage_load(&ramstage))
119 goto fail;
120 }
121
122 stage_cache_add(STAGE_RAMSTAGE, &ramstage);
123
124 timestamp_add_now(TS_COPYRAM_END);
125
126 console_time_report();
127
128 /* This overrides the arg fetched from the relocatable module */
129 prog_set_arg(&ramstage, (void *)cbmem_top());
130
131 prog_run(&ramstage);
132
133 fail:
134 die_with_post_code(POSTCODE_INVALID_ROM, "Ramstage was not loaded!\n");
135 }
136
137 #if ENV_PAYLOAD_LOADER // gc-sections should take care of this
138
139 static struct prog global_payload =
140 PROG_INIT(PROG_PAYLOAD, CONFIG_CBFS_PREFIX "/payload");
141
payload_preload(void)142 void payload_preload(void)
143 {
144 if (!CONFIG(CBFS_PRELOAD))
145 return;
146
147 cbfs_preload(global_payload.name);
148 }
149
payload_load(void)150 void payload_load(void)
151 {
152 struct prog *payload = &global_payload;
153 void *mapping;
154
155 timestamp_add_now(TS_LOAD_PAYLOAD);
156
157 if (prog_locate_hook(payload))
158 goto out;
159
160 payload->cbfs_type = CBFS_TYPE_QUERY;
161 mapping = cbfs_type_map(prog_name(payload), NULL, &payload->cbfs_type);
162
163 if (!mapping)
164 goto out;
165
166 switch (prog_cbfs_type(payload)) {
167 case CBFS_TYPE_SELF: /* Simple ELF */
168 selfload_mapped(payload, mapping, BM_MEM_RAM);
169 break;
170 case CBFS_TYPE_FIT_PAYLOAD: /* Flattened image tree */
171 if (CONFIG(PAYLOAD_FIT_SUPPORT)) {
172 fit_payload(payload, mapping);
173 break;
174 }
175 __fallthrough;
176 default:
177 die_with_post_code(POSTCODE_INVALID_ROM,
178 "Unsupported payload type %d.\n", payload->cbfs_type);
179 break;
180 }
181
182 cbfs_unmap(mapping);
183 out:
184 if (prog_entry(payload) == NULL)
185 die_with_post_code(POSTCODE_INVALID_ROM, "Payload not loaded.\n");
186 }
187
payload_run(void)188 void payload_run(void)
189 {
190 struct prog *payload = &global_payload;
191
192 /* Reset to booting from this image as late as possible */
193 boot_successful();
194
195 printk(BIOS_DEBUG, "Jumping to boot code at %p(%p)\n",
196 prog_entry(payload), prog_entry_arg(payload));
197
198 post_code(POSTCODE_ENTER_ELF_BOOT);
199
200 timestamp_add_now(TS_SELFBOOT_JUMP);
201
202 /* Before we go off to run the payload, see if
203 * we stayed within our bounds.
204 */
205 checkstack(_estack, 0);
206
207 prog_run(payload);
208 }
209
210 #endif
211