]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * This file implements recording of each stage of the boot process. It is | |
3 | * intended to implement timing of each stage, reporting this information | |
4 | * to the user and passing it to the OS for logging / further analysis. | |
5 | * Note that it requires timer_get_boot_us() to be defined by the board | |
6 | * | |
7 | * Copyright (c) 2011 The Chromium OS Authors. | |
8 | * | |
9 | * SPDX-License-Identifier: GPL-2.0+ | |
10 | */ | |
11 | ||
12 | #ifndef _BOOTSTAGE_H | |
13 | #define _BOOTSTAGE_H | |
14 | ||
15 | /* Flags for each bootstage record */ | |
16 | enum bootstage_flags { | |
17 | BOOTSTAGEF_ERROR = 1 << 0, /* Error record */ | |
18 | BOOTSTAGEF_ALLOC = 1 << 1, /* Allocate an id */ | |
19 | }; | |
20 | ||
21 | /* bootstate sub-IDs used for kernel and ramdisk ranges */ | |
22 | enum { | |
23 | BOOTSTAGE_SUB_FORMAT, | |
24 | BOOTSTAGE_SUB_FORMAT_OK, | |
25 | BOOTSTAGE_SUB_NO_UNIT_NAME, | |
26 | BOOTSTAGE_SUB_UNIT_NAME, | |
27 | BOOTSTAGE_SUB_SUBNODE, | |
28 | ||
29 | BOOTSTAGE_SUB_CHECK, | |
30 | BOOTSTAGE_SUB_HASH = 5, | |
31 | BOOTSTAGE_SUB_CHECK_ARCH = 5, | |
32 | BOOTSTAGE_SUB_CHECK_ALL, | |
33 | BOOTSTAGE_SUB_GET_DATA, | |
34 | BOOTSTAGE_SUB_CHECK_ALL_OK = 7, | |
35 | BOOTSTAGE_SUB_GET_DATA_OK, | |
36 | BOOTSTAGE_SUB_LOAD, | |
37 | }; | |
38 | ||
39 | /* | |
40 | * A list of boot stages that we know about. Each of these indicates the | |
41 | * state that we are at, and the action that we are about to perform. For | |
42 | * errors, we issue an error for an item when it fails. Therefore the | |
43 | * normal sequence is: | |
44 | * | |
45 | * progress action1 | |
46 | * progress action2 | |
47 | * progress action3 | |
48 | * | |
49 | * and an error condition where action 3 failed would be: | |
50 | * | |
51 | * progress action1 | |
52 | * progress action2 | |
53 | * progress action3 | |
54 | * error on action3 | |
55 | */ | |
56 | enum bootstage_id { | |
57 | BOOTSTAGE_ID_START = 0, | |
58 | BOOTSTAGE_ID_CHECK_MAGIC, /* Checking image magic */ | |
59 | BOOTSTAGE_ID_CHECK_HEADER, /* Checking image header */ | |
60 | BOOTSTAGE_ID_CHECK_CHECKSUM, /* Checking image checksum */ | |
61 | BOOTSTAGE_ID_CHECK_ARCH, /* Checking architecture */ | |
62 | ||
63 | BOOTSTAGE_ID_CHECK_IMAGETYPE = 5,/* Checking image type */ | |
64 | BOOTSTAGE_ID_DECOMP_IMAGE, /* Decompressing image */ | |
65 | BOOTSTAGE_ID_KERNEL_LOADED, /* Kernel has been loaded */ | |
66 | BOOTSTAGE_ID_DECOMP_UNIMPL = 7, /* Odd decompression algorithm */ | |
67 | BOOTSTAGE_ID_CHECK_BOOT_OS, /* Calling OS-specific boot function */ | |
68 | BOOTSTAGE_ID_BOOT_OS_RETURNED, /* Tried to boot OS, but it returned */ | |
69 | BOOTSTAGE_ID_CHECK_RAMDISK = 9, /* Checking ram disk */ | |
70 | ||
71 | BOOTSTAGE_ID_RD_MAGIC, /* Checking ram disk magic */ | |
72 | BOOTSTAGE_ID_RD_HDR_CHECKSUM, /* Checking ram disk heder checksum */ | |
73 | BOOTSTAGE_ID_RD_CHECKSUM, /* Checking ram disk checksum */ | |
74 | BOOTSTAGE_ID_COPY_RAMDISK = 12, /* Copying ram disk into place */ | |
75 | BOOTSTAGE_ID_RAMDISK, /* Checking for valid ramdisk */ | |
76 | BOOTSTAGE_ID_NO_RAMDISK, /* No ram disk found (not an error) */ | |
77 | ||
78 | BOOTSTAGE_ID_RUN_OS = 15, /* Exiting U-Boot, entering OS */ | |
79 | ||
80 | BOOTSTAGE_ID_NEED_RESET = 30, | |
81 | BOOTSTAGE_ID_POST_FAIL, /* Post failure */ | |
82 | BOOTSTAGE_ID_POST_FAIL_R, /* Post failure reported after reloc */ | |
83 | ||
84 | /* | |
85 | * This set is reported only by x86, and the meaning is different. In | |
86 | * this case we are reporting completion of a particular stage. | |
87 | * This should probably change in the x86 code (which doesn't report | |
88 | * errors in any case), but discussion this can perhaps wait until we | |
89 | * have a generic board implementation. | |
90 | */ | |
91 | BOOTSTAGE_ID_BOARD_INIT_R, /* We have relocated */ | |
92 | BOOTSTAGE_ID_BOARD_GLOBAL_DATA, /* Global data is set up */ | |
93 | ||
94 | BOOTSTAGE_ID_BOARD_INIT_SEQ, /* We completed the init sequence */ | |
95 | BOOTSTAGE_ID_BOARD_FLASH, /* We have configured flash banks */ | |
96 | BOOTSTAGE_ID_BOARD_FLASH_37, /* In case you didn't hear... */ | |
97 | BOOTSTAGE_ID_BOARD_ENV, /* Environment is relocated & ready */ | |
98 | BOOTSTAGE_ID_BOARD_PCI, /* PCI is up */ | |
99 | ||
100 | BOOTSTAGE_ID_BOARD_INTERRUPTS, /* Exceptions / interrupts ready */ | |
101 | BOOTSTAGE_ID_BOARD_DONE, /* Board init done, off to main loop */ | |
102 | /* ^^^ here ends the x86 sequence */ | |
103 | ||
104 | /* Boot stages related to loading a kernel from an IDE device */ | |
105 | BOOTSTAGE_ID_IDE_START = 41, | |
106 | BOOTSTAGE_ID_IDE_ADDR, | |
107 | BOOTSTAGE_ID_IDE_BOOT_DEVICE, | |
108 | BOOTSTAGE_ID_IDE_TYPE, | |
109 | ||
110 | BOOTSTAGE_ID_IDE_PART, | |
111 | BOOTSTAGE_ID_IDE_PART_INFO, | |
112 | BOOTSTAGE_ID_IDE_PART_TYPE, | |
113 | BOOTSTAGE_ID_IDE_PART_READ, | |
114 | BOOTSTAGE_ID_IDE_FORMAT, | |
115 | ||
116 | BOOTSTAGE_ID_IDE_CHECKSUM, /* 50 */ | |
117 | BOOTSTAGE_ID_IDE_READ, | |
118 | ||
119 | /* Boot stages related to loading a kernel from an NAND device */ | |
120 | BOOTSTAGE_ID_NAND_PART, | |
121 | BOOTSTAGE_ID_NAND_SUFFIX, | |
122 | BOOTSTAGE_ID_NAND_BOOT_DEVICE, | |
123 | BOOTSTAGE_ID_NAND_HDR_READ = 55, | |
124 | BOOTSTAGE_ID_NAND_AVAILABLE = 55, | |
125 | BOOTSTAGE_ID_NAND_TYPE = 57, | |
126 | BOOTSTAGE_ID_NAND_READ, | |
127 | ||
128 | /* Boot stages related to loading a kernel from an network device */ | |
129 | BOOTSTAGE_ID_NET_CHECKSUM = 60, | |
130 | BOOTSTAGE_ID_NET_ETH_START = 64, | |
131 | BOOTSTAGE_ID_NET_ETH_INIT, | |
132 | ||
133 | BOOTSTAGE_ID_NET_START = 80, | |
134 | BOOTSTAGE_ID_NET_NETLOOP_OK, | |
135 | BOOTSTAGE_ID_NET_LOADED, | |
136 | BOOTSTAGE_ID_NET_DONE_ERR, | |
137 | BOOTSTAGE_ID_NET_DONE, | |
138 | ||
139 | BOOTSTAGE_ID_FIT_FDT_START = 90, | |
140 | /* | |
141 | * Boot stages related to loading a FIT image. Some of these are a | |
142 | * bit wonky. | |
143 | */ | |
144 | BOOTSTAGE_ID_FIT_KERNEL_START = 100, | |
145 | ||
146 | BOOTSTAGE_ID_FIT_CONFIG = 110, | |
147 | BOOTSTAGE_ID_FIT_TYPE, | |
148 | BOOTSTAGE_ID_FIT_KERNEL_INFO, | |
149 | ||
150 | BOOTSTAGE_ID_FIT_COMPRESSION, | |
151 | BOOTSTAGE_ID_FIT_OS, | |
152 | BOOTSTAGE_ID_FIT_LOADADDR, | |
153 | BOOTSTAGE_ID_OVERWRITTEN, | |
154 | ||
155 | /* Next 10 IDs used by BOOTSTAGE_SUB_... */ | |
156 | BOOTSTAGE_ID_FIT_RD_START = 120, /* Ramdisk stages */ | |
157 | ||
158 | /* Next 10 IDs used by BOOTSTAGE_SUB_... */ | |
159 | BOOTSTAGE_ID_FIT_SETUP_START = 130, /* x86 setup stages */ | |
160 | ||
161 | BOOTSTAGE_ID_IDE_FIT_READ = 140, | |
162 | BOOTSTAGE_ID_IDE_FIT_READ_OK, | |
163 | ||
164 | BOOTSTAGE_ID_NAND_FIT_READ = 150, | |
165 | BOOTSTAGE_ID_NAND_FIT_READ_OK, | |
166 | ||
167 | BOOTSTAGE_ID_FIT_LOADABLE_START = 160, /* for Loadable Images */ | |
168 | /* | |
169 | * These boot stages are new, higher level, and not directly related | |
170 | * to the old boot progress numbers. They are useful for recording | |
171 | * rough boot timing information. | |
172 | */ | |
173 | BOOTSTAGE_ID_AWAKE, | |
174 | BOOTSTAGE_ID_START_SPL, | |
175 | BOOTSTAGE_ID_END_SPL, | |
176 | BOOTSTAGE_ID_START_UBOOT_F, | |
177 | BOOTSTAGE_ID_START_UBOOT_R, | |
178 | BOOTSTAGE_ID_USB_START, | |
179 | BOOTSTAGE_ID_ETH_START, | |
180 | BOOTSTAGE_ID_BOOTP_START, | |
181 | BOOTSTAGE_ID_BOOTP_STOP, | |
182 | BOOTSTAGE_ID_BOOTM_START, | |
183 | BOOTSTAGE_ID_BOOTM_HANDOFF, | |
184 | BOOTSTAGE_ID_MAIN_LOOP, | |
185 | BOOTSTAGE_KERNELREAD_START, | |
186 | BOOTSTAGE_KERNELREAD_STOP, | |
187 | BOOTSTAGE_ID_BOARD_INIT, | |
188 | BOOTSTAGE_ID_BOARD_INIT_DONE, | |
189 | ||
190 | BOOTSTAGE_ID_CPU_AWAKE, | |
191 | BOOTSTAGE_ID_MAIN_CPU_AWAKE, | |
192 | BOOTSTAGE_ID_MAIN_CPU_READY, | |
193 | ||
194 | BOOTSTAGE_ID_ACCUM_LCD, | |
195 | BOOTSTAGE_ID_ACCUM_SCSI, | |
196 | BOOTSTAGE_ID_ACCUM_SPI, | |
197 | BOOTSTAGE_ID_ACCUM_DECOMP, | |
198 | BOOTSTAGE_ID_ACCUM_OF_LIVE, | |
199 | BOOTSTAGE_ID_FPGA_INIT, | |
200 | BOOTSTATE_ID_ACCUM_DM_SPL, | |
201 | BOOTSTATE_ID_ACCUM_DM_F, | |
202 | BOOTSTATE_ID_ACCUM_DM_R, | |
203 | ||
204 | /* a few spare for the user, from here */ | |
205 | BOOTSTAGE_ID_USER, | |
206 | BOOTSTAGE_ID_ALLOC, | |
207 | }; | |
208 | ||
209 | /* | |
210 | * Return the time since boot in microseconds, This is needed for bootstage | |
211 | * and should be defined in CPU- or board-specific code. If undefined then | |
212 | * you will get a link error. | |
213 | */ | |
214 | ulong timer_get_boot_us(void); | |
215 | ||
216 | #if defined(USE_HOSTCC) | |
217 | #define show_boot_progress(val) do {} while (0) | |
218 | #else | |
219 | /** | |
220 | * Board code can implement show_boot_progress() if needed. | |
221 | * | |
222 | * @param val Progress state (enum bootstage_id), or -id if an error | |
223 | * has occurred. | |
224 | */ | |
225 | void show_boot_progress(int val); | |
226 | #endif | |
227 | ||
228 | #if !defined(USE_HOSTCC) | |
229 | #if CONFIG_IS_ENABLED(BOOTSTAGE) | |
230 | #define ENABLE_BOOTSTAGE | |
231 | #endif | |
232 | #endif | |
233 | ||
234 | #ifdef ENABLE_BOOTSTAGE | |
235 | ||
236 | /* This is the full bootstage implementation */ | |
237 | ||
238 | /** | |
239 | * Relocate existing bootstage records | |
240 | * | |
241 | * Call this after relocation has happened and after malloc has been initted. | |
242 | * We need to copy any pointers in bootstage records that were added pre- | |
243 | * relocation, since memory can be overwritten later. | |
244 | * @return Always returns 0, to indicate success | |
245 | */ | |
246 | int bootstage_relocate(void); | |
247 | ||
248 | /** | |
249 | * Add a new bootstage record | |
250 | * | |
251 | * @param id Bootstage ID to use (ignored if flags & BOOTSTAGEF_ALLOC) | |
252 | * @param name Name of record, or NULL for none | |
253 | * @param flags Flags (BOOTSTAGEF_...) | |
254 | * @param mark Time to record in this record, in microseconds | |
255 | */ | |
256 | ulong bootstage_add_record(enum bootstage_id id, const char *name, | |
257 | int flags, ulong mark); | |
258 | ||
259 | /** | |
260 | * Mark a time stamp for the current boot stage. | |
261 | */ | |
262 | ulong bootstage_mark(enum bootstage_id id); | |
263 | ||
264 | ulong bootstage_error(enum bootstage_id id); | |
265 | ||
266 | ulong bootstage_mark_name(enum bootstage_id id, const char *name); | |
267 | ||
268 | /** | |
269 | * Mark a time stamp in the given function and line number | |
270 | * | |
271 | * See BOOTSTAGE_MARKER() for a convenient macro. | |
272 | * | |
273 | * @param file Filename to record (NULL if none) | |
274 | * @param func Function name to record | |
275 | * @param linenum Line number to record | |
276 | * @return recorded time stamp | |
277 | */ | |
278 | ulong bootstage_mark_code(const char *file, const char *func, | |
279 | int linenum); | |
280 | ||
281 | /** | |
282 | * Mark the start of a bootstage activity. The end will be marked later with | |
283 | * bootstage_accum() and at that point we accumulate the time taken. Calling | |
284 | * this function turns the given id into a accumulator rather than and | |
285 | * absolute mark in time. Accumulators record the total amount of time spent | |
286 | * in an activty during boot. | |
287 | * | |
288 | * @param id Bootstage id to record this timestamp against | |
289 | * @param name Textual name to display for this id in the report (maybe NULL) | |
290 | * @return start timestamp in microseconds | |
291 | */ | |
292 | uint32_t bootstage_start(enum bootstage_id id, const char *name); | |
293 | ||
294 | /** | |
295 | * Mark the end of a bootstage activity | |
296 | * | |
297 | * After previously marking the start of an activity with bootstage_start(), | |
298 | * call this function to mark the end. You can call these functions in pairs | |
299 | * as many times as you like. | |
300 | * | |
301 | * @param id Bootstage id to record this timestamp against | |
302 | * @return time spent in this iteration of the activity (i.e. the time now | |
303 | * less the start time recorded in the last bootstage_start() call | |
304 | * with this id. | |
305 | */ | |
306 | uint32_t bootstage_accum(enum bootstage_id id); | |
307 | ||
308 | /* Print a report about boot time */ | |
309 | void bootstage_report(void); | |
310 | ||
311 | /** | |
312 | * Add bootstage information to the device tree | |
313 | * | |
314 | * @return 0 if ok, -ve on error | |
315 | */ | |
316 | int bootstage_fdt_add_report(void); | |
317 | ||
318 | /** | |
319 | * Stash bootstage data into memory | |
320 | * | |
321 | * @param base Base address of memory buffer | |
322 | * @param size Size of memory buffer | |
323 | * @return 0 if stashed ok, -1 if out of space | |
324 | */ | |
325 | int bootstage_stash(void *base, int size); | |
326 | ||
327 | /** | |
328 | * Read bootstage data from memory | |
329 | * | |
330 | * Bootstage data is read from memory and placed in the bootstage table | |
331 | * in the user records. | |
332 | * | |
333 | * @param base Base address of memory buffer | |
334 | * @param size Size of memory buffer (-1 if unknown) | |
335 | * @return 0 if unstashed ok, -ENOENT if bootstage info not found, -ENOSPC if | |
336 | * there is not space for read the stacked data, or other error if | |
337 | * something else went wrong | |
338 | */ | |
339 | int bootstage_unstash(const void *base, int size); | |
340 | ||
341 | /** | |
342 | * bootstage_get_size() - Get the size of the bootstage data | |
343 | * | |
344 | * @return size of boostage data in bytes | |
345 | */ | |
346 | int bootstage_get_size(void); | |
347 | ||
348 | /** | |
349 | * bootstage_init() - Prepare bootstage for use | |
350 | * | |
351 | * @first: true if this is the first time bootstage is set up. This causes it | |
352 | * to add a 'reset' record with a time of 0. | |
353 | */ | |
354 | int bootstage_init(bool first); | |
355 | ||
356 | #else | |
357 | static inline ulong bootstage_add_record(enum bootstage_id id, | |
358 | const char *name, int flags, ulong mark) | |
359 | { | |
360 | return 0; | |
361 | } | |
362 | ||
363 | /* | |
364 | * This is a dummy implementation which just calls show_boot_progress(), | |
365 | * and won't even do that unless CONFIG_SHOW_BOOT_PROGRESS is defined | |
366 | */ | |
367 | ||
368 | static inline int bootstage_relocate(void) | |
369 | { | |
370 | return 0; | |
371 | } | |
372 | ||
373 | static inline ulong bootstage_mark(enum bootstage_id id) | |
374 | { | |
375 | show_boot_progress(id); | |
376 | return 0; | |
377 | } | |
378 | ||
379 | static inline ulong bootstage_error(enum bootstage_id id) | |
380 | { | |
381 | show_boot_progress(-id); | |
382 | return 0; | |
383 | } | |
384 | ||
385 | static inline ulong bootstage_mark_name(enum bootstage_id id, const char *name) | |
386 | { | |
387 | show_boot_progress(id); | |
388 | return 0; | |
389 | } | |
390 | ||
391 | static inline ulong bootstage_mark_code(const char *file, const char *func, | |
392 | int linenum) | |
393 | { | |
394 | return 0; | |
395 | } | |
396 | ||
397 | static inline uint32_t bootstage_start(enum bootstage_id id, const char *name) | |
398 | { | |
399 | return 0; | |
400 | } | |
401 | ||
402 | static inline uint32_t bootstage_accum(enum bootstage_id id) | |
403 | { | |
404 | return 0; | |
405 | } | |
406 | ||
407 | static inline int bootstage_stash(void *base, int size) | |
408 | { | |
409 | return 0; /* Pretend to succeed */ | |
410 | } | |
411 | ||
412 | static inline int bootstage_unstash(const void *base, int size) | |
413 | { | |
414 | return 0; /* Pretend to succeed */ | |
415 | } | |
416 | ||
417 | static inline int bootstage_get_size(void) | |
418 | { | |
419 | return 0; | |
420 | } | |
421 | ||
422 | static inline int bootstage_init(bool first) | |
423 | { | |
424 | return 0; | |
425 | } | |
426 | ||
427 | #endif /* ENABLE_BOOTSTAGE */ | |
428 | ||
429 | /* Helper macro for adding a bootstage to a line of code */ | |
430 | #define BOOTSTAGE_MARKER() \ | |
431 | bootstage_mark_code(__FILE__, __func__, __LINE__) | |
432 | ||
433 | #endif |