Simon Glass | 20bf89a | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2011-2012 The Chromium OS Authors. |
Wolfgang Denk | d79de1d | 2013-07-08 09:37:19 +0200 | [diff] [blame] | 3 | * SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | 20bf89a | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 4 | */ |
| 5 | |
| 6 | #ifndef __SANDBOX_STATE_H |
| 7 | #define __SANDBOX_STATE_H |
| 8 | |
Simon Glass | 8a3e035 | 2012-02-15 15:51:16 -0800 | [diff] [blame] | 9 | #include <config.h> |
Stephen Warren | 859f256 | 2016-05-12 12:03:35 -0600 | [diff] [blame] | 10 | #include <sysreset.h> |
Simon Glass | f498e43 | 2013-11-10 10:27:02 -0700 | [diff] [blame] | 11 | #include <stdbool.h> |
Simon Glass | d7c8d8d | 2013-11-10 10:27:04 -0700 | [diff] [blame] | 12 | #include <linux/stringify.h> |
Simon Glass | 8a3e035 | 2012-02-15 15:51:16 -0800 | [diff] [blame] | 13 | |
Simon Glass | 678ef47 | 2014-02-27 13:26:22 -0700 | [diff] [blame] | 14 | /** |
| 15 | * Selects the behavior of the serial terminal. |
| 16 | * |
| 17 | * If Ctrl-C is processed by U-Boot, then the only way to quit sandbox is with |
| 18 | * the 'reset' command, or equivalent. |
| 19 | * |
| 20 | * If the terminal is cooked, then Ctrl-C will terminate U-Boot, and the |
| 21 | * command line will not be quite such a faithful emulation. |
| 22 | * |
| 23 | * Options are: |
| 24 | * |
| 25 | * raw-with-sigs - Raw, but allow signals (Ctrl-C will quit) |
| 26 | * raw - Terminal is always raw |
| 27 | * cooked - Terminal is always cooked |
| 28 | */ |
| 29 | enum state_terminal_raw { |
| 30 | STATE_TERM_RAW_WITH_SIGS, /* Default */ |
| 31 | STATE_TERM_RAW, |
| 32 | STATE_TERM_COOKED, |
| 33 | |
| 34 | STATE_TERM_COUNT, |
| 35 | }; |
| 36 | |
Mike Frysinger | 1d8e57c | 2013-12-03 16:43:26 -0700 | [diff] [blame] | 37 | struct sandbox_spi_info { |
| 38 | const char *spec; |
Simon Glass | 95429fe | 2014-10-13 23:41:57 -0600 | [diff] [blame] | 39 | struct udevice *emul; |
Mike Frysinger | 1d8e57c | 2013-12-03 16:43:26 -0700 | [diff] [blame] | 40 | }; |
| 41 | |
maxims@google.com | daea6d4 | 2017-04-17 12:00:21 -0700 | [diff] [blame] | 42 | struct sandbox_wdt_info { |
| 43 | unsigned long long counter; |
| 44 | uint reset_count; |
| 45 | bool running; |
| 46 | }; |
| 47 | |
Simon Glass | 20bf89a | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 48 | /* The complete state of the test system */ |
| 49 | struct sandbox_state { |
| 50 | const char *cmd; /* Command to execute */ |
Simon Glass | f498e43 | 2013-11-10 10:27:02 -0700 | [diff] [blame] | 51 | bool interactive; /* Enable cmdline after execute */ |
Sjoerd Simons | 335f470 | 2015-04-30 22:16:09 +0200 | [diff] [blame] | 52 | bool run_distro_boot; /* Automatically run distro bootcommands */ |
Simon Glass | 1539343 | 2013-04-20 08:42:41 +0000 | [diff] [blame] | 53 | const char *fdt_fname; /* Filename of FDT binary */ |
Simon Glass | 8a3e035 | 2012-02-15 15:51:16 -0800 | [diff] [blame] | 54 | const char *parse_err; /* Error to report from parsing */ |
| 55 | int argc; /* Program arguments */ |
Simon Glass | e990653 | 2014-02-27 13:26:16 -0700 | [diff] [blame] | 56 | char **argv; /* Command line arguments */ |
Simon Glass | 47acfc6 | 2014-02-27 13:26:23 -0700 | [diff] [blame] | 57 | const char *jumped_fname; /* Jumped from previous U_Boot */ |
Simon Glass | 9dd10bf | 2013-11-10 10:27:03 -0700 | [diff] [blame] | 58 | uint8_t *ram_buf; /* Emulated RAM buffer */ |
| 59 | unsigned int ram_size; /* Size of RAM buffer */ |
| 60 | const char *ram_buf_fname; /* Filename to use for RAM buffer */ |
Simon Glass | 47acfc6 | 2014-02-27 13:26:23 -0700 | [diff] [blame] | 61 | bool ram_buf_rm; /* Remove RAM buffer file after read */ |
Simon Glass | 9dd10bf | 2013-11-10 10:27:03 -0700 | [diff] [blame] | 62 | bool write_ram_buf; /* Write RAM buffer on exit */ |
Simon Glass | d7c8d8d | 2013-11-10 10:27:04 -0700 | [diff] [blame] | 63 | const char *state_fname; /* File containing sandbox state */ |
| 64 | void *state_fdt; /* Holds saved state for sandbox */ |
| 65 | bool read_state; /* Read sandbox state on startup */ |
| 66 | bool write_state; /* Write sandbox state on exit */ |
| 67 | bool ignore_missing_state_on_read; /* No error if state missing */ |
Simon Glass | b9ddbf4 | 2014-02-27 13:26:19 -0700 | [diff] [blame] | 68 | bool show_lcd; /* Show LCD on start-up */ |
Stephen Warren | 859f256 | 2016-05-12 12:03:35 -0600 | [diff] [blame] | 69 | enum sysreset_t last_sysreset; /* Last system reset type */ |
| 70 | bool sysreset_allowed[SYSRESET_COUNT]; /* Allowed system reset types */ |
Simon Glass | 678ef47 | 2014-02-27 13:26:22 -0700 | [diff] [blame] | 71 | enum state_terminal_raw term_raw; /* Terminal raw/cooked */ |
Simon Glass | b25fa31 | 2015-11-08 23:47:43 -0700 | [diff] [blame] | 72 | bool skip_delays; /* Ignore any time delays (for test) */ |
Simon Glass | fe6d12a | 2015-11-08 23:47:50 -0700 | [diff] [blame] | 73 | bool show_test_output; /* Don't suppress stdout in tests */ |
Mike Frysinger | 1d8e57c | 2013-12-03 16:43:26 -0700 | [diff] [blame] | 74 | |
| 75 | /* Pointer to information for each SPI bus/cs */ |
| 76 | struct sandbox_spi_info spi[CONFIG_SANDBOX_SPI_MAX_BUS] |
| 77 | [CONFIG_SANDBOX_SPI_MAX_CS]; |
maxims@google.com | daea6d4 | 2017-04-17 12:00:21 -0700 | [diff] [blame] | 78 | |
| 79 | /* Information about Watchdog */ |
| 80 | struct sandbox_wdt_info wdt; |
Simon Glass | 20bf89a | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 81 | }; |
| 82 | |
Simon Glass | d7c8d8d | 2013-11-10 10:27:04 -0700 | [diff] [blame] | 83 | /* Minimum space we guarantee in the state FDT when calling read/write*/ |
| 84 | #define SANDBOX_STATE_MIN_SPACE 0x1000 |
| 85 | |
| 86 | /** |
| 87 | * struct sandbox_state_io - methods to saved/restore sandbox state |
| 88 | * @name: Name of of the device tree node, also the name of the variable |
| 89 | * holding this data so it should be an identifier (use underscore |
| 90 | * instead of minus) |
| 91 | * @compat: Compatible string for the node containing this state |
| 92 | * |
| 93 | * @read: Function to read state from FDT |
| 94 | * If data is available, then blob and node will provide access to it. If |
| 95 | * not (blob == NULL and node == -1) this function should set up an empty |
| 96 | * data set for start-of-day. |
| 97 | * @param blob: Pointer to device tree blob, or NULL if no data to read |
| 98 | * @param node: Node offset to read from |
| 99 | * @return 0 if OK, -ve on error |
| 100 | * |
| 101 | * @write: Function to write state to FDT |
| 102 | * The caller will ensure that there is a node ready for the state. The |
| 103 | * node may already contain the old state, in which case it should be |
| 104 | * overridden. There is guaranteed to be SANDBOX_STATE_MIN_SPACE bytes |
| 105 | * of free space, so error checking is not required for fdt_setprop...() |
| 106 | * calls which add up to less than this much space. |
| 107 | * |
| 108 | * For adding larger properties, use state_setprop(). |
| 109 | * |
| 110 | * @param blob: Device tree blob holding state |
| 111 | * @param node: Node to write our state into |
| 112 | * |
| 113 | * Note that it is possible to save data as large blobs or as individual |
| 114 | * hierarchical properties. However, unless you intend to keep state files |
| 115 | * around for a long time and be able to run an old state file on a new |
| 116 | * sandbox, it might not be worth using individual properties for everything. |
| 117 | * This is certainly supported, it is just a matter of the effort you wish |
| 118 | * to put into the state read/write feature. |
| 119 | */ |
| 120 | struct sandbox_state_io { |
| 121 | const char *name; |
| 122 | const char *compat; |
| 123 | int (*write)(void *blob, int node); |
| 124 | int (*read)(const void *blob, int node); |
| 125 | }; |
| 126 | |
| 127 | /** |
| 128 | * SANDBOX_STATE_IO - Declare sandbox state to read/write |
| 129 | * |
| 130 | * Sandbox permits saving state from one run and restoring it in another. This |
| 131 | * allows the test system to retain state between runs and thus better |
| 132 | * emulate a real system. Examples of state that might be useful to save are |
| 133 | * the emulated GPIOs pin settings, flash memory contents and TPM private |
| 134 | * data. U-Boot memory contents is dealth with separately since it is large |
| 135 | * and it is not normally useful to save it (since a normal system does not |
| 136 | * preserve DRAM between runs). See the '-m' option for this. |
| 137 | * |
| 138 | * See struct sandbox_state_io above for member documentation. |
| 139 | */ |
| 140 | #define SANDBOX_STATE_IO(_name, _compat, _read, _write) \ |
| 141 | ll_entry_declare(struct sandbox_state_io, _name, state_io) = { \ |
| 142 | .name = __stringify(_name), \ |
| 143 | .read = _read, \ |
| 144 | .write = _write, \ |
| 145 | .compat = _compat, \ |
| 146 | } |
| 147 | |
Simon Glass | 20bf89a | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 148 | /** |
Simon Glass | 20bf89a | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 149 | * Gets a pointer to the current state. |
| 150 | * |
| 151 | * @return pointer to state |
| 152 | */ |
| 153 | struct sandbox_state *state_get_current(void); |
| 154 | |
| 155 | /** |
Simon Glass | d7c8d8d | 2013-11-10 10:27:04 -0700 | [diff] [blame] | 156 | * Read the sandbox state from the supplied device tree file |
| 157 | * |
| 158 | * This calls all registered state handlers to read in the sandbox state |
| 159 | * from a previous test run. |
| 160 | * |
| 161 | * @param state Sandbox state to update |
| 162 | * @param fname Filename of device tree file to read from |
| 163 | * @return 0 if OK, -ve on error |
| 164 | */ |
| 165 | int sandbox_read_state(struct sandbox_state *state, const char *fname); |
| 166 | |
| 167 | /** |
| 168 | * Write the sandbox state to the supplied device tree file |
| 169 | * |
| 170 | * This calls all registered state handlers to write out the sandbox state |
| 171 | * so that it can be preserved for a future test run. |
| 172 | * |
| 173 | * If the file exists it is overwritten. |
| 174 | * |
| 175 | * @param state Sandbox state to update |
| 176 | * @param fname Filename of device tree file to write to |
| 177 | * @return 0 if OK, -ve on error |
| 178 | */ |
| 179 | int sandbox_write_state(struct sandbox_state *state, const char *fname); |
| 180 | |
| 181 | /** |
| 182 | * Add a property to a sandbox state node |
| 183 | * |
| 184 | * This is equivalent to fdt_setprop except that it automatically enlarges |
| 185 | * the device tree if necessary. That means it is safe to write any amount |
| 186 | * of data here. |
| 187 | * |
| 188 | * This function can only be called from within struct sandbox_state_io's |
| 189 | * ->write method, i.e. within state I/O drivers. |
| 190 | * |
| 191 | * @param node Device tree node to write to |
| 192 | * @param prop_name Property to write |
| 193 | * @param data Data to write into property |
| 194 | * @param size Size of data to write into property |
| 195 | */ |
| 196 | int state_setprop(int node, const char *prop_name, const void *data, int size); |
| 197 | |
| 198 | /** |
Simon Glass | b25fa31 | 2015-11-08 23:47:43 -0700 | [diff] [blame] | 199 | * Control skipping of time delays |
| 200 | * |
| 201 | * Some tests have unnecessay time delays (e.g. USB). Allow these to be |
| 202 | * skipped to speed up testing |
| 203 | * |
| 204 | * @param skip_delays true to skip delays from now on, false to honour delay |
| 205 | * requests |
| 206 | */ |
| 207 | void state_set_skip_delays(bool skip_delays); |
| 208 | |
| 209 | /** |
| 210 | * See if delays should be skipped |
| 211 | * |
| 212 | * @return true if delays should be skipped, false if they should be honoured |
| 213 | */ |
| 214 | bool state_get_skip_delays(void); |
| 215 | |
| 216 | /** |
Simon Glass | 36d08d82 | 2017-05-18 20:09:13 -0600 | [diff] [blame] | 217 | * state_reset_for_test() - Reset ready to re-run tests |
| 218 | * |
| 219 | * This clears out any test state ready for another test run. |
| 220 | */ |
| 221 | void state_reset_for_test(struct sandbox_state *state); |
| 222 | |
| 223 | /** |
Simon Glass | 20bf89a | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 224 | * Initialize the test system state |
| 225 | */ |
| 226 | int state_init(void); |
| 227 | |
Simon Glass | 9dd10bf | 2013-11-10 10:27:03 -0700 | [diff] [blame] | 228 | /** |
| 229 | * Uninitialize the test system state, writing out state if configured to |
| 230 | * do so. |
| 231 | * |
| 232 | * @return 0 if OK, -ve on error |
| 233 | */ |
| 234 | int state_uninit(void); |
| 235 | |
Simon Glass | 20bf89a | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 236 | #endif |