Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2011-2012 The Chromium OS Authors. |
Wolfgang Denk | 1a45966 | 2013-07-08 09:37:19 +0200 | [diff] [blame] | 3 | * SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 4 | */ |
| 5 | |
| 6 | #ifndef __SANDBOX_STATE_H |
| 7 | #define __SANDBOX_STATE_H |
| 8 | |
Simon Glass | 70db421 | 2012-02-15 15:51:16 -0800 | [diff] [blame] | 9 | #include <config.h> |
Simon Glass | c5a62d4 | 2013-11-10 10:27:02 -0700 | [diff] [blame] | 10 | #include <stdbool.h> |
Simon Glass | 1209e27 | 2013-11-10 10:27:04 -0700 | [diff] [blame] | 11 | #include <linux/stringify.h> |
Simon Glass | 70db421 | 2012-02-15 15:51:16 -0800 | [diff] [blame] | 12 | |
Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 13 | /* How we exited U-Boot */ |
| 14 | enum exit_type_id { |
| 15 | STATE_EXIT_NORMAL, |
| 16 | STATE_EXIT_COLD_REBOOT, |
| 17 | STATE_EXIT_POWER_OFF, |
| 18 | }; |
| 19 | |
Mike Frysinger | 6122813 | 2013-12-03 16:43:26 -0700 | [diff] [blame] | 20 | struct sandbox_spi_info { |
| 21 | const char *spec; |
| 22 | const struct sandbox_spi_emu_ops *ops; |
| 23 | }; |
| 24 | |
Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 25 | /* The complete state of the test system */ |
| 26 | struct sandbox_state { |
| 27 | const char *cmd; /* Command to execute */ |
Simon Glass | c5a62d4 | 2013-11-10 10:27:02 -0700 | [diff] [blame] | 28 | bool interactive; /* Enable cmdline after execute */ |
Simon Glass | f828bf2 | 2013-04-20 08:42:41 +0000 | [diff] [blame] | 29 | const char *fdt_fname; /* Filename of FDT binary */ |
Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 30 | enum exit_type_id exit_type; /* How we exited U-Boot */ |
Simon Glass | 70db421 | 2012-02-15 15:51:16 -0800 | [diff] [blame] | 31 | const char *parse_err; /* Error to report from parsing */ |
| 32 | int argc; /* Program arguments */ |
| 33 | char **argv; |
Simon Glass | 5c2859c | 2013-11-10 10:27:03 -0700 | [diff] [blame] | 34 | uint8_t *ram_buf; /* Emulated RAM buffer */ |
| 35 | unsigned int ram_size; /* Size of RAM buffer */ |
| 36 | const char *ram_buf_fname; /* Filename to use for RAM buffer */ |
| 37 | bool write_ram_buf; /* Write RAM buffer on exit */ |
Simon Glass | 1209e27 | 2013-11-10 10:27:04 -0700 | [diff] [blame] | 38 | const char *state_fname; /* File containing sandbox state */ |
| 39 | void *state_fdt; /* Holds saved state for sandbox */ |
| 40 | bool read_state; /* Read sandbox state on startup */ |
| 41 | bool write_state; /* Write sandbox state on exit */ |
| 42 | bool ignore_missing_state_on_read; /* No error if state missing */ |
Mike Frysinger | 6122813 | 2013-12-03 16:43:26 -0700 | [diff] [blame] | 43 | |
| 44 | /* Pointer to information for each SPI bus/cs */ |
| 45 | struct sandbox_spi_info spi[CONFIG_SANDBOX_SPI_MAX_BUS] |
| 46 | [CONFIG_SANDBOX_SPI_MAX_CS]; |
Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 47 | }; |
| 48 | |
Simon Glass | 1209e27 | 2013-11-10 10:27:04 -0700 | [diff] [blame] | 49 | /* Minimum space we guarantee in the state FDT when calling read/write*/ |
| 50 | #define SANDBOX_STATE_MIN_SPACE 0x1000 |
| 51 | |
| 52 | /** |
| 53 | * struct sandbox_state_io - methods to saved/restore sandbox state |
| 54 | * @name: Name of of the device tree node, also the name of the variable |
| 55 | * holding this data so it should be an identifier (use underscore |
| 56 | * instead of minus) |
| 57 | * @compat: Compatible string for the node containing this state |
| 58 | * |
| 59 | * @read: Function to read state from FDT |
| 60 | * If data is available, then blob and node will provide access to it. If |
| 61 | * not (blob == NULL and node == -1) this function should set up an empty |
| 62 | * data set for start-of-day. |
| 63 | * @param blob: Pointer to device tree blob, or NULL if no data to read |
| 64 | * @param node: Node offset to read from |
| 65 | * @return 0 if OK, -ve on error |
| 66 | * |
| 67 | * @write: Function to write state to FDT |
| 68 | * The caller will ensure that there is a node ready for the state. The |
| 69 | * node may already contain the old state, in which case it should be |
| 70 | * overridden. There is guaranteed to be SANDBOX_STATE_MIN_SPACE bytes |
| 71 | * of free space, so error checking is not required for fdt_setprop...() |
| 72 | * calls which add up to less than this much space. |
| 73 | * |
| 74 | * For adding larger properties, use state_setprop(). |
| 75 | * |
| 76 | * @param blob: Device tree blob holding state |
| 77 | * @param node: Node to write our state into |
| 78 | * |
| 79 | * Note that it is possible to save data as large blobs or as individual |
| 80 | * hierarchical properties. However, unless you intend to keep state files |
| 81 | * around for a long time and be able to run an old state file on a new |
| 82 | * sandbox, it might not be worth using individual properties for everything. |
| 83 | * This is certainly supported, it is just a matter of the effort you wish |
| 84 | * to put into the state read/write feature. |
| 85 | */ |
| 86 | struct sandbox_state_io { |
| 87 | const char *name; |
| 88 | const char *compat; |
| 89 | int (*write)(void *blob, int node); |
| 90 | int (*read)(const void *blob, int node); |
| 91 | }; |
| 92 | |
| 93 | /** |
| 94 | * SANDBOX_STATE_IO - Declare sandbox state to read/write |
| 95 | * |
| 96 | * Sandbox permits saving state from one run and restoring it in another. This |
| 97 | * allows the test system to retain state between runs and thus better |
| 98 | * emulate a real system. Examples of state that might be useful to save are |
| 99 | * the emulated GPIOs pin settings, flash memory contents and TPM private |
| 100 | * data. U-Boot memory contents is dealth with separately since it is large |
| 101 | * and it is not normally useful to save it (since a normal system does not |
| 102 | * preserve DRAM between runs). See the '-m' option for this. |
| 103 | * |
| 104 | * See struct sandbox_state_io above for member documentation. |
| 105 | */ |
| 106 | #define SANDBOX_STATE_IO(_name, _compat, _read, _write) \ |
| 107 | ll_entry_declare(struct sandbox_state_io, _name, state_io) = { \ |
| 108 | .name = __stringify(_name), \ |
| 109 | .read = _read, \ |
| 110 | .write = _write, \ |
| 111 | .compat = _compat, \ |
| 112 | } |
| 113 | |
Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 114 | /** |
| 115 | * Record the exit type to be reported by the test program. |
| 116 | * |
| 117 | * @param exit_type Exit type to record |
| 118 | */ |
| 119 | void state_record_exit(enum exit_type_id exit_type); |
| 120 | |
| 121 | /** |
| 122 | * Gets a pointer to the current state. |
| 123 | * |
| 124 | * @return pointer to state |
| 125 | */ |
| 126 | struct sandbox_state *state_get_current(void); |
| 127 | |
| 128 | /** |
Simon Glass | 1209e27 | 2013-11-10 10:27:04 -0700 | [diff] [blame] | 129 | * Read the sandbox state from the supplied device tree file |
| 130 | * |
| 131 | * This calls all registered state handlers to read in the sandbox state |
| 132 | * from a previous test run. |
| 133 | * |
| 134 | * @param state Sandbox state to update |
| 135 | * @param fname Filename of device tree file to read from |
| 136 | * @return 0 if OK, -ve on error |
| 137 | */ |
| 138 | int sandbox_read_state(struct sandbox_state *state, const char *fname); |
| 139 | |
| 140 | /** |
| 141 | * Write the sandbox state to the supplied device tree file |
| 142 | * |
| 143 | * This calls all registered state handlers to write out the sandbox state |
| 144 | * so that it can be preserved for a future test run. |
| 145 | * |
| 146 | * If the file exists it is overwritten. |
| 147 | * |
| 148 | * @param state Sandbox state to update |
| 149 | * @param fname Filename of device tree file to write to |
| 150 | * @return 0 if OK, -ve on error |
| 151 | */ |
| 152 | int sandbox_write_state(struct sandbox_state *state, const char *fname); |
| 153 | |
| 154 | /** |
| 155 | * Add a property to a sandbox state node |
| 156 | * |
| 157 | * This is equivalent to fdt_setprop except that it automatically enlarges |
| 158 | * the device tree if necessary. That means it is safe to write any amount |
| 159 | * of data here. |
| 160 | * |
| 161 | * This function can only be called from within struct sandbox_state_io's |
| 162 | * ->write method, i.e. within state I/O drivers. |
| 163 | * |
| 164 | * @param node Device tree node to write to |
| 165 | * @param prop_name Property to write |
| 166 | * @param data Data to write into property |
| 167 | * @param size Size of data to write into property |
| 168 | */ |
| 169 | int state_setprop(int node, const char *prop_name, const void *data, int size); |
| 170 | |
| 171 | /** |
Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 172 | * Initialize the test system state |
| 173 | */ |
| 174 | int state_init(void); |
| 175 | |
Simon Glass | 5c2859c | 2013-11-10 10:27:03 -0700 | [diff] [blame] | 176 | /** |
| 177 | * Uninitialize the test system state, writing out state if configured to |
| 178 | * do so. |
| 179 | * |
| 180 | * @return 0 if OK, -ve on error |
| 181 | */ |
| 182 | int state_uninit(void); |
| 183 | |
Simon Glass | 6fb6207 | 2012-02-15 15:51:15 -0800 | [diff] [blame] | 184 | #endif |