[u-boot.git] / include / bootstage.h

/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * This file implements recording of each stage of the boot process. It is
 * intended to implement timing of each stage, reporting this information
 * to the user and passing it to the OS for logging / further analysis.
 * Note that it requires timer_get_boot_us() to be defined by the board
 *
 * Copyright (c) 2011 The Chromium OS Authors.
 */

#ifndef _BOOTSTAGE_H
#define _BOOTSTAGE_H

#include <linux/types.h>
#ifdef USE_HOSTCC
#include <linux/kconfig.h>
#endif

/* Flags for each bootstage record */
enum bootstage_flags {
	BOOTSTAGEF_ERROR	= 1 << 0,	/* Error record */
	BOOTSTAGEF_ALLOC	= 1 << 1,	/* Allocate an id */
};

/* bootstate sub-IDs used for kernel and ramdisk ranges */
enum {
	BOOTSTAGE_SUB_FORMAT,
	BOOTSTAGE_SUB_FORMAT_OK,
	BOOTSTAGE_SUB_NO_UNIT_NAME,
	BOOTSTAGE_SUB_UNIT_NAME,
	BOOTSTAGE_SUB_SUBNODE,

	BOOTSTAGE_SUB_CHECK,
	BOOTSTAGE_SUB_HASH = 5,
	BOOTSTAGE_SUB_CHECK_ARCH = 5,
	BOOTSTAGE_SUB_CHECK_ALL,
	BOOTSTAGE_SUB_GET_DATA,
	BOOTSTAGE_SUB_CHECK_ALL_OK = 7,
	BOOTSTAGE_SUB_GET_DATA_OK,
	BOOTSTAGE_SUB_LOAD,
};

/*
 * A list of boot stages that we know about. Each of these indicates the
 * state that we are at, and the action that we are about to perform. For
 * errors, we issue an error for an item when it fails. Therefore the
 * normal sequence is:
 *
 * progress action1
 * progress action2
 * progress action3
 *
 * and an error condition where action 3 failed would be:
 *
 * progress action1
 * progress action2
 * progress action3
 * error on action3
 */
enum bootstage_id {
	BOOTSTAGE_ID_START = 0,
	BOOTSTAGE_ID_CHECK_MAGIC,	/* Checking image magic */
	BOOTSTAGE_ID_CHECK_HEADER,	/* Checking image header */
	BOOTSTAGE_ID_CHECK_CHECKSUM,	/* Checking image checksum */
	BOOTSTAGE_ID_CHECK_ARCH,	/* Checking architecture */

	BOOTSTAGE_ID_CHECK_IMAGETYPE = 5,/* Checking image type */
	BOOTSTAGE_ID_DECOMP_IMAGE,	/* Decompressing image */
	BOOTSTAGE_ID_KERNEL_LOADED,	/* Kernel has been loaded */
	BOOTSTAGE_ID_DECOMP_UNIMPL = 7,	/* Odd decompression algorithm */
	BOOTSTAGE_ID_CHECK_BOOT_OS,	/* Calling OS-specific boot function */
	BOOTSTAGE_ID_BOOT_OS_RETURNED,	/* Tried to boot OS, but it returned */
	BOOTSTAGE_ID_CHECK_RAMDISK = 9,	/* Checking ram disk */

	BOOTSTAGE_ID_RD_MAGIC,		/* Checking ram disk magic */
	BOOTSTAGE_ID_RD_HDR_CHECKSUM,	/* Checking ram disk heder checksum */
	BOOTSTAGE_ID_RD_CHECKSUM,	/* Checking ram disk checksum */
	BOOTSTAGE_ID_COPY_RAMDISK = 12,	/* Copying ram disk into place */
	BOOTSTAGE_ID_RAMDISK,		/* Checking for valid ramdisk */
	BOOTSTAGE_ID_NO_RAMDISK,	/* No ram disk found (not an error) */

	BOOTSTAGE_ID_RUN_OS	= 15,	/* Exiting U-Boot, entering OS */

	BOOTSTAGE_ID_NEED_RESET = 30,
	BOOTSTAGE_ID_POST_FAIL,		/* Post failure */
	BOOTSTAGE_ID_POST_FAIL_R,	/* Post failure reported after reloc */

	/*
	 * This set is reported only by x86, and the meaning is different. In
	 * this case we are reporting completion of a particular stage.
	 * This should probably change in the x86 code (which doesn't report
	 * errors in any case), but discussion this can perhaps wait until we
	 * have a generic board implementation.
	 */
	BOOTSTAGE_ID_BOARD_INIT_R,	/* We have relocated */
	BOOTSTAGE_ID_BOARD_GLOBAL_DATA,	/* Global data is set up */

	BOOTSTAGE_ID_BOARD_INIT_SEQ,	/* We completed the init sequence */
	BOOTSTAGE_ID_BOARD_FLASH,	/* We have configured flash banks */
	BOOTSTAGE_ID_BOARD_FLASH_37,	/* In case you didn't hear... */
	BOOTSTAGE_ID_BOARD_ENV,		/* Environment is relocated & ready */
	BOOTSTAGE_ID_BOARD_PCI,		/* PCI is up */

	BOOTSTAGE_ID_BOARD_INTERRUPTS,	/* Exceptions / interrupts ready */
	BOOTSTAGE_ID_BOARD_DONE,	/* Board init done, off to main loop */
	/* ^^^ here ends the x86 sequence */

	/* Boot stages related to loading a kernel from an IDE device */
	BOOTSTAGE_ID_IDE_START = 41,
	BOOTSTAGE_ID_IDE_ADDR,
	BOOTSTAGE_ID_IDE_BOOT_DEVICE,
	BOOTSTAGE_ID_IDE_TYPE,

	BOOTSTAGE_ID_IDE_PART,
	BOOTSTAGE_ID_IDE_PART_INFO,
	BOOTSTAGE_ID_IDE_PART_TYPE,
	BOOTSTAGE_ID_IDE_PART_READ,
	BOOTSTAGE_ID_IDE_FORMAT,

	BOOTSTAGE_ID_IDE_CHECKSUM,	/* 50 */
	BOOTSTAGE_ID_IDE_READ,

	/* Boot stages related to loading a kernel from an NAND device */
	BOOTSTAGE_ID_NAND_PART,
	BOOTSTAGE_ID_NAND_SUFFIX,
	BOOTSTAGE_ID_NAND_BOOT_DEVICE,
	BOOTSTAGE_ID_NAND_HDR_READ = 55,
	BOOTSTAGE_ID_NAND_AVAILABLE = 55,
	BOOTSTAGE_ID_NAND_TYPE = 57,
	BOOTSTAGE_ID_NAND_READ,

	/* Boot stages related to loading a kernel from an network device */
	BOOTSTAGE_ID_NET_CHECKSUM = 60,
	BOOTSTAGE_ID_NET_ETH_START = 64,
	BOOTSTAGE_ID_NET_ETH_INIT,

	BOOTSTAGE_ID_NET_START = 80,
	BOOTSTAGE_ID_NET_NETLOOP_OK,
	BOOTSTAGE_ID_NET_LOADED,
	BOOTSTAGE_ID_NET_DONE_ERR,
	BOOTSTAGE_ID_NET_DONE,

	BOOTSTAGE_ID_FIT_FDT_START = 90,
	/*
	 * Boot stages related to loading a FIT image. Some of these are a
	 * bit wonky.
	 */
	BOOTSTAGE_ID_FIT_KERNEL_START = 100,

	BOOTSTAGE_ID_FIT_CONFIG = 110,
	BOOTSTAGE_ID_FIT_TYPE,

	BOOTSTAGE_ID_FIT_COMPRESSION,
	BOOTSTAGE_ID_FIT_OS,
	BOOTSTAGE_ID_FIT_LOADADDR,
	BOOTSTAGE_ID_OVERWRITTEN,

	/* Next 10 IDs used by BOOTSTAGE_SUB_... */
	BOOTSTAGE_ID_FIT_RD_START = 120,	/* Ramdisk stages */

	/* Next 10 IDs used by BOOTSTAGE_SUB_... */
	BOOTSTAGE_ID_FIT_SETUP_START = 130,	/* x86 setup stages */

	BOOTSTAGE_ID_IDE_FIT_READ = 140,
	BOOTSTAGE_ID_IDE_FIT_READ_OK,

	BOOTSTAGE_ID_NAND_FIT_READ = 150,
	BOOTSTAGE_ID_NAND_FIT_READ_OK,

	BOOTSTAGE_ID_FIT_LOADABLE_START = 160,	/* for Loadable Images */

	BOOTSTAGE_ID_FIT_SPL_START = 170,	/* for SPL Images */
	/*
	 * These boot stages are new, higher level, and not directly related
	 * to the old boot progress numbers. They are useful for recording
	 * rough boot timing information.
	 */
	BOOTSTAGE_ID_AWAKE,
	BOOTSTAGE_ID_START_TPL,
	BOOTSTAGE_ID_END_TPL,
	BOOTSTAGE_ID_START_SPL,
	BOOTSTAGE_ID_END_SPL,
	BOOTSTAGE_ID_START_VPL,
	BOOTSTAGE_ID_END_VPL,
	BOOTSTAGE_ID_START_UBOOT_F,
	BOOTSTAGE_ID_START_UBOOT_R,
	BOOTSTAGE_ID_USB_START,
	BOOTSTAGE_ID_ETH_START,
	BOOTSTAGE_ID_BOOTP_START,
	BOOTSTAGE_ID_BOOTP_STOP,
	BOOTSTAGE_ID_BOOTM_START,
	BOOTSTAGE_ID_BOOTM_HANDOFF,
	BOOTSTAGE_ID_MAIN_LOOP,
	BOOTSTAGE_ID_ENTER_CLI_LOOP,
	BOOTSTAGE_KERNELREAD_START,
	BOOTSTAGE_KERNELREAD_STOP,
	BOOTSTAGE_ID_BOARD_INIT,
	BOOTSTAGE_ID_BOARD_INIT_DONE,

	BOOTSTAGE_ID_CPU_AWAKE,
	BOOTSTAGE_ID_MAIN_CPU_AWAKE,
	BOOTSTAGE_ID_MAIN_CPU_READY,

	BOOTSTAGE_ID_ACCUM_LCD,
	BOOTSTAGE_ID_ACCUM_SCSI,
	BOOTSTAGE_ID_ACCUM_SPI,
	BOOTSTAGE_ID_ACCUM_DECOMP,
	BOOTSTAGE_ID_ACCUM_OF_LIVE,
	BOOTSTAGE_ID_FPGA_INIT,
	BOOTSTAGE_ID_ACCUM_DM_SPL,
	BOOTSTAGE_ID_ACCUM_DM_F,
	BOOTSTAGE_ID_ACCUM_DM_R,
	BOOTSTAGE_ID_ACCUM_FSP_M,
	BOOTSTAGE_ID_ACCUM_FSP_S,
	BOOTSTAGE_ID_ACCUM_MMAP_SPI,

	/* a few spare for the user, from here */
	BOOTSTAGE_ID_USER,
	BOOTSTAGE_ID_ALLOC,
};

/*
 * Return the time since boot in microseconds, This is needed for bootstage
 * and should be defined in CPU- or board-specific code. If undefined then
 * you will get a link error.
 */
ulong timer_get_boot_us(void);

#if defined(USE_HOSTCC) || !CONFIG_IS_ENABLED(SHOW_BOOT_PROGRESS)
#define show_boot_progress(val) do {} while (0)
#else
/**
 * Board code can implement show_boot_progress() if needed.
 *
 * @param val	Progress state (enum bootstage_id), or -id if an error
 *		has occurred.
 */
void show_boot_progress(int val);
#endif

#if !defined(USE_HOSTCC)
#if CONFIG_IS_ENABLED(BOOTSTAGE)
#define ENABLE_BOOTSTAGE
#endif
#endif

#ifdef ENABLE_BOOTSTAGE

#include <mapmem.h>

/* This is the full bootstage implementation */

/**
 * Relocate existing bootstage records
 *
 * Call this after relocation has happened and after malloc has been initted.
 * We need to copy any pointers in bootstage records that were added pre-
 * relocation, since memory can be overwritten later.
 * Return: Always returns 0, to indicate success
 */
int bootstage_relocate(void);

/**
 * Add a new bootstage record
 *
 * @param id	Bootstage ID to use (ignored if flags & BOOTSTAGEF_ALLOC)
 * @param name	Name of record, or NULL for none
 * @param flags	Flags (BOOTSTAGEF_...)
 * @param mark	Time to record in this record, in microseconds
 */
ulong bootstage_add_record(enum bootstage_id id, const char *name,
			   int flags, ulong mark);

/**
 * Mark a time stamp for the current boot stage.
 */
#define bootstage_mark(id)	bootstage_mark_name(id, __func__)
#define bootstage_error(id)	bootstage_error_name(id, __func__)

/**
 * bootstage_mark_name - record bootstage with passing id and name
 * @id: Bootstage id to record this timestamp against
 * @name: Textual name to display for this id in the report
 *
 * Return: recorded time stamp
 */
ulong bootstage_mark_name(enum bootstage_id id, const char *name);

/**
 * bootstage_error_name - record bootstage error with passing id and name
 * @id: Bootstage id to record this timestamp against
 * @name: Textual name to display for this id in the report
 *
 * Return: recorded time stamp
 */
ulong bootstage_error_name(enum bootstage_id id, const char *name);

/**
 * Mark a time stamp in the given function and line number
 *
 * See BOOTSTAGE_MARKER() for a convenient macro.
 *
 * @param file		Filename to record (NULL if none)
 * @param func		Function name to record
 * @param linenum	Line number to record
 * Return: recorded time stamp
 */
ulong bootstage_mark_code(const char *file, const char *func,
			  int linenum);

/**
 * Mark the start of a bootstage activity. The end will be marked later with
 * bootstage_accum() and at that point we accumulate the time taken. Calling
 * this function turns the given id into a accumulator rather than and
 * absolute mark in time. Accumulators record the total amount of time spent
 * in an activty during boot.
 *
 * @param id	Bootstage id to record this timestamp against
 * @param name	Textual name to display for this id in the report (maybe NULL)
 * Return: start timestamp in microseconds
 */
uint32_t bootstage_start(enum bootstage_id id, const char *name);

/**
 * Mark the end of a bootstage activity
 *
 * After previously marking the start of an activity with bootstage_start(),
 * call this function to mark the end. You can call these functions in pairs
 * as many times as you like.
 *
 * @param id	Bootstage id to record this timestamp against
 * Return: time spent in this iteration of the activity (i.e. the time now
 *		less the start time recorded in the last bootstage_start() call
 *		with this id.
 */
uint32_t bootstage_accum(enum bootstage_id id);

/* Print a report about boot time */
void bootstage_report(void);

/**
 * Add bootstage information to the device tree
 *
 * Return: 0 if ok, -ve on error
 */
int bootstage_fdt_add_report(void);

/**
 * Stash bootstage data into memory
 *
 * @param base	Base address of memory buffer
 * @param size	Size of memory buffer
 * Return: 0 if stashed ok, -1 if out of space
 */
int bootstage_stash(void *base, int size);

/**
 * Read bootstage data from memory
 *
 * Bootstage data is read from memory and placed in the bootstage table
 * in the user records.
 *
 * @param base	Base address of memory buffer
 * @param size	Size of memory buffer (-1 if unknown)
 * Return: 0 if unstashed ok, -ENOENT if bootstage info not found, -ENOSPC if
 *	there is not space for read the stashed data, or other error if
 *	something else went wrong
 */
int bootstage_unstash(const void *base, int size);

/**
 * bootstage_get_size() - Get the size of the bootstage data
 *
 * Return: size of boostage data in bytes
 */
int bootstage_get_size(void);

/**
 * bootstage_init() - Prepare bootstage for use
 *
 * @first: true if this is the first time bootstage is set up. This causes it
 *	to add a 'reset' record with a time of 0.
 */
int bootstage_init(bool first);

#else
static inline ulong bootstage_add_record(enum bootstage_id id,
		const char *name, int flags, ulong mark)
{
	return 0;
}

/*
 * This is a dummy implementation which just calls show_boot_progress(),
 * and won't even do that unless CONFIG_SHOW_BOOT_PROGRESS is defined
 */

static inline int bootstage_relocate(void)
{
	return 0;
}

static inline ulong bootstage_mark(enum bootstage_id id)
{
	show_boot_progress(id);
	return 0;
}

static inline ulong bootstage_error(enum bootstage_id id)
{
	show_boot_progress(-id);
	return 0;
}

static inline ulong bootstage_mark_name(enum bootstage_id id, const char *name)
{
	show_boot_progress(id);
	return 0;
}

static inline ulong bootstage_mark_code(const char *file, const char *func,
					int linenum)
{
	return 0;
}

static inline uint32_t bootstage_start(enum bootstage_id id, const char *name)
{
	return 0;
}

static inline uint32_t bootstage_accum(enum bootstage_id id)
{
	return 0;
}

static inline int bootstage_stash(void *base, int size)
{
	return 0;	/* Pretend to succeed */
}

static inline int bootstage_unstash(const void *base, int size)
{
	return 0;	/* Pretend to succeed */
}

static inline int bootstage_get_size(void)
{
	return 0;
}

static inline int bootstage_init(bool first)
{
	return 0;
}

#endif /* ENABLE_BOOTSTAGE */

/* helpers for SPL */
int _bootstage_stash_default(void);
int _bootstage_unstash_default(void);

static inline int bootstage_stash_default(void)
{
	if (CONFIG_IS_ENABLED(BOOTSTAGE) && IS_ENABLED(CONFIG_BOOTSTAGE_STASH))
		return _bootstage_stash_default();

	return 0;
}

static inline int bootstage_unstash_default(void)
{
	if (CONFIG_IS_ENABLED(BOOTSTAGE) && IS_ENABLED(CONFIG_BOOTSTAGE_STASH))
		return _bootstage_unstash_default();

	return 0;
}

/* Helper macro for adding a bootstage to a line of code */
#define BOOTSTAGE_MARKER()	\
		bootstage_mark_code(__FILE__, __func__, __LINE__)

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