mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-15 14:43:49 +09:00
![Tom Rini](/assets/img/avatar_default.png)
When U-Boot started using SPDX tags we were among the early adopters and there weren't a lot of other examples to borrow from. So we picked the area of the file that usually had a full license text and replaced it with an appropriate SPDX-License-Identifier: entry. Since then, the Linux Kernel has adopted SPDX tags and they place it as the very first line in a file (except where shebangs are used, then it's second line) and with slightly different comment styles than us. In part due to community overlap, in part due to better tag visibility and in part for other minor reasons, switch over to that style. This commit changes all instances where we have a single declared license in the tag as both the before and after are identical in tag contents. There's also a few places where I found we did not have a tag and have introduced one. Signed-off-by: Tom Rini <trini@konsulko.com>
237 lines
7.7 KiB
C
237 lines
7.7 KiB
C
/* SPDX-License-Identifier: GPL-2.0+ */
|
|
/*
|
|
* Copyright (c) 2011-2012 The Chromium OS Authors.
|
|
*/
|
|
|
|
#ifndef __SANDBOX_STATE_H
|
|
#define __SANDBOX_STATE_H
|
|
|
|
#include <config.h>
|
|
#include <sysreset.h>
|
|
#include <stdbool.h>
|
|
#include <linux/stringify.h>
|
|
|
|
/**
|
|
* Selects the behavior of the serial terminal.
|
|
*
|
|
* If Ctrl-C is processed by U-Boot, then the only way to quit sandbox is with
|
|
* the 'reset' command, or equivalent.
|
|
*
|
|
* If the terminal is cooked, then Ctrl-C will terminate U-Boot, and the
|
|
* command line will not be quite such a faithful emulation.
|
|
*
|
|
* Options are:
|
|
*
|
|
* raw-with-sigs - Raw, but allow signals (Ctrl-C will quit)
|
|
* raw - Terminal is always raw
|
|
* cooked - Terminal is always cooked
|
|
*/
|
|
enum state_terminal_raw {
|
|
STATE_TERM_RAW_WITH_SIGS, /* Default */
|
|
STATE_TERM_RAW,
|
|
STATE_TERM_COOKED,
|
|
|
|
STATE_TERM_COUNT,
|
|
};
|
|
|
|
struct sandbox_spi_info {
|
|
const char *spec;
|
|
struct udevice *emul;
|
|
};
|
|
|
|
struct sandbox_wdt_info {
|
|
unsigned long long counter;
|
|
uint reset_count;
|
|
bool running;
|
|
};
|
|
|
|
/* The complete state of the test system */
|
|
struct sandbox_state {
|
|
const char *cmd; /* Command to execute */
|
|
bool interactive; /* Enable cmdline after execute */
|
|
bool run_distro_boot; /* Automatically run distro bootcommands */
|
|
const char *fdt_fname; /* Filename of FDT binary */
|
|
const char *parse_err; /* Error to report from parsing */
|
|
int argc; /* Program arguments */
|
|
char **argv; /* Command line arguments */
|
|
const char *jumped_fname; /* Jumped from previous U_Boot */
|
|
uint8_t *ram_buf; /* Emulated RAM buffer */
|
|
unsigned int ram_size; /* Size of RAM buffer */
|
|
const char *ram_buf_fname; /* Filename to use for RAM buffer */
|
|
bool ram_buf_rm; /* Remove RAM buffer file after read */
|
|
bool write_ram_buf; /* Write RAM buffer on exit */
|
|
const char *state_fname; /* File containing sandbox state */
|
|
void *state_fdt; /* Holds saved state for sandbox */
|
|
bool read_state; /* Read sandbox state on startup */
|
|
bool write_state; /* Write sandbox state on exit */
|
|
bool ignore_missing_state_on_read; /* No error if state missing */
|
|
bool show_lcd; /* Show LCD on start-up */
|
|
enum sysreset_t last_sysreset; /* Last system reset type */
|
|
bool sysreset_allowed[SYSRESET_COUNT]; /* Allowed system reset types */
|
|
enum state_terminal_raw term_raw; /* Terminal raw/cooked */
|
|
bool skip_delays; /* Ignore any time delays (for test) */
|
|
bool show_test_output; /* Don't suppress stdout in tests */
|
|
|
|
/* Pointer to information for each SPI bus/cs */
|
|
struct sandbox_spi_info spi[CONFIG_SANDBOX_SPI_MAX_BUS]
|
|
[CONFIG_SANDBOX_SPI_MAX_CS];
|
|
|
|
/* Information about Watchdog */
|
|
struct sandbox_wdt_info wdt;
|
|
};
|
|
|
|
/* Minimum space we guarantee in the state FDT when calling read/write*/
|
|
#define SANDBOX_STATE_MIN_SPACE 0x1000
|
|
|
|
/**
|
|
* struct sandbox_state_io - methods to saved/restore sandbox state
|
|
* @name: Name of of the device tree node, also the name of the variable
|
|
* holding this data so it should be an identifier (use underscore
|
|
* instead of minus)
|
|
* @compat: Compatible string for the node containing this state
|
|
*
|
|
* @read: Function to read state from FDT
|
|
* If data is available, then blob and node will provide access to it. If
|
|
* not (blob == NULL and node == -1) this function should set up an empty
|
|
* data set for start-of-day.
|
|
* @param blob: Pointer to device tree blob, or NULL if no data to read
|
|
* @param node: Node offset to read from
|
|
* @return 0 if OK, -ve on error
|
|
*
|
|
* @write: Function to write state to FDT
|
|
* The caller will ensure that there is a node ready for the state. The
|
|
* node may already contain the old state, in which case it should be
|
|
* overridden. There is guaranteed to be SANDBOX_STATE_MIN_SPACE bytes
|
|
* of free space, so error checking is not required for fdt_setprop...()
|
|
* calls which add up to less than this much space.
|
|
*
|
|
* For adding larger properties, use state_setprop().
|
|
*
|
|
* @param blob: Device tree blob holding state
|
|
* @param node: Node to write our state into
|
|
*
|
|
* Note that it is possible to save data as large blobs or as individual
|
|
* hierarchical properties. However, unless you intend to keep state files
|
|
* around for a long time and be able to run an old state file on a new
|
|
* sandbox, it might not be worth using individual properties for everything.
|
|
* This is certainly supported, it is just a matter of the effort you wish
|
|
* to put into the state read/write feature.
|
|
*/
|
|
struct sandbox_state_io {
|
|
const char *name;
|
|
const char *compat;
|
|
int (*write)(void *blob, int node);
|
|
int (*read)(const void *blob, int node);
|
|
};
|
|
|
|
/**
|
|
* SANDBOX_STATE_IO - Declare sandbox state to read/write
|
|
*
|
|
* Sandbox permits saving state from one run and restoring it in another. This
|
|
* allows the test system to retain state between runs and thus better
|
|
* emulate a real system. Examples of state that might be useful to save are
|
|
* the emulated GPIOs pin settings, flash memory contents and TPM private
|
|
* data. U-Boot memory contents is dealth with separately since it is large
|
|
* and it is not normally useful to save it (since a normal system does not
|
|
* preserve DRAM between runs). See the '-m' option for this.
|
|
*
|
|
* See struct sandbox_state_io above for member documentation.
|
|
*/
|
|
#define SANDBOX_STATE_IO(_name, _compat, _read, _write) \
|
|
ll_entry_declare(struct sandbox_state_io, _name, state_io) = { \
|
|
.name = __stringify(_name), \
|
|
.read = _read, \
|
|
.write = _write, \
|
|
.compat = _compat, \
|
|
}
|
|
|
|
/**
|
|
* Gets a pointer to the current state.
|
|
*
|
|
* @return pointer to state
|
|
*/
|
|
struct sandbox_state *state_get_current(void);
|
|
|
|
/**
|
|
* Read the sandbox state from the supplied device tree file
|
|
*
|
|
* This calls all registered state handlers to read in the sandbox state
|
|
* from a previous test run.
|
|
*
|
|
* @param state Sandbox state to update
|
|
* @param fname Filename of device tree file to read from
|
|
* @return 0 if OK, -ve on error
|
|
*/
|
|
int sandbox_read_state(struct sandbox_state *state, const char *fname);
|
|
|
|
/**
|
|
* Write the sandbox state to the supplied device tree file
|
|
*
|
|
* This calls all registered state handlers to write out the sandbox state
|
|
* so that it can be preserved for a future test run.
|
|
*
|
|
* If the file exists it is overwritten.
|
|
*
|
|
* @param state Sandbox state to update
|
|
* @param fname Filename of device tree file to write to
|
|
* @return 0 if OK, -ve on error
|
|
*/
|
|
int sandbox_write_state(struct sandbox_state *state, const char *fname);
|
|
|
|
/**
|
|
* Add a property to a sandbox state node
|
|
*
|
|
* This is equivalent to fdt_setprop except that it automatically enlarges
|
|
* the device tree if necessary. That means it is safe to write any amount
|
|
* of data here.
|
|
*
|
|
* This function can only be called from within struct sandbox_state_io's
|
|
* ->write method, i.e. within state I/O drivers.
|
|
*
|
|
* @param node Device tree node to write to
|
|
* @param prop_name Property to write
|
|
* @param data Data to write into property
|
|
* @param size Size of data to write into property
|
|
*/
|
|
int state_setprop(int node, const char *prop_name, const void *data, int size);
|
|
|
|
/**
|
|
* Control skipping of time delays
|
|
*
|
|
* Some tests have unnecessay time delays (e.g. USB). Allow these to be
|
|
* skipped to speed up testing
|
|
*
|
|
* @param skip_delays true to skip delays from now on, false to honour delay
|
|
* requests
|
|
*/
|
|
void state_set_skip_delays(bool skip_delays);
|
|
|
|
/**
|
|
* See if delays should be skipped
|
|
*
|
|
* @return true if delays should be skipped, false if they should be honoured
|
|
*/
|
|
bool state_get_skip_delays(void);
|
|
|
|
/**
|
|
* state_reset_for_test() - Reset ready to re-run tests
|
|
*
|
|
* This clears out any test state ready for another test run.
|
|
*/
|
|
void state_reset_for_test(struct sandbox_state *state);
|
|
|
|
/**
|
|
* Initialize the test system state
|
|
*/
|
|
int state_init(void);
|
|
|
|
/**
|
|
* Uninitialize the test system state, writing out state if configured to
|
|
* do so.
|
|
*
|
|
* @return 0 if OK, -ve on error
|
|
*/
|
|
int state_uninit(void);
|
|
|
|
#endif
|