Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 1 | /* |
| 2 | * (C) Copyright 2002 |
| 3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 4 | * |
| 5 | * SPDX-License-Identifier: GPL-2.0+ |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 6 | */ |
| 7 | |
| 8 | #ifndef _ENVIRONMENT_H_ |
| 9 | #define _ENVIRONMENT_H_ |
| 10 | |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 11 | /************************************************************************** |
| 12 | * |
| 13 | * The "environment" is stored as a list of '\0' terminated |
| 14 | * "name=value" strings. The end of the list is marked by a double |
| 15 | * '\0'. New entries are always added at the end. Deleting an entry |
| 16 | * shifts the remaining entries to the front. Replacing an entry is a |
| 17 | * combination of deleting the old value and adding the new one. |
| 18 | * |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 19 | * The environment is preceeded by a 32 bit CRC over the data part. |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 20 | * |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 21 | ************************************************************************** |
| 22 | */ |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 23 | |
| 24 | #if defined(CONFIG_ENV_IS_IN_FLASH) |
| 25 | # ifndef CONFIG_ENV_ADDR |
| 26 | # define CONFIG_ENV_ADDR (CONFIG_SYS_FLASH_BASE + CONFIG_ENV_OFFSET) |
| 27 | # endif |
| 28 | # ifndef CONFIG_ENV_OFFSET |
| 29 | # define CONFIG_ENV_OFFSET (CONFIG_ENV_ADDR - CONFIG_SYS_FLASH_BASE) |
| 30 | # endif |
| 31 | # if !defined(CONFIG_ENV_ADDR_REDUND) && defined(CONFIG_ENV_OFFSET_REDUND) |
| 32 | # define CONFIG_ENV_ADDR_REDUND \ |
| 33 | (CONFIG_SYS_FLASH_BASE + CONFIG_ENV_OFFSET_REDUND) |
| 34 | # endif |
| 35 | # if defined(CONFIG_ENV_SECT_SIZE) || defined(CONFIG_ENV_SIZE) |
| 36 | # ifndef CONFIG_ENV_SECT_SIZE |
| 37 | # define CONFIG_ENV_SECT_SIZE CONFIG_ENV_SIZE |
| 38 | # endif |
| 39 | # ifndef CONFIG_ENV_SIZE |
| 40 | # define CONFIG_ENV_SIZE CONFIG_ENV_SECT_SIZE |
| 41 | # endif |
| 42 | # else |
| 43 | # error "Both CONFIG_ENV_SECT_SIZE and CONFIG_ENV_SIZE undefined" |
| 44 | # endif |
| 45 | # if defined(CONFIG_ENV_ADDR_REDUND) && !defined(CONFIG_ENV_SIZE_REDUND) |
| 46 | # define CONFIG_ENV_SIZE_REDUND CONFIG_ENV_SIZE |
| 47 | # endif |
| 48 | # if (CONFIG_ENV_ADDR >= CONFIG_SYS_MONITOR_BASE) && \ |
| 49 | (CONFIG_ENV_ADDR + CONFIG_ENV_SIZE) <= \ |
| 50 | (CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN) |
| 51 | # define ENV_IS_EMBEDDED |
| 52 | # endif |
| 53 | # if defined(CONFIG_ENV_ADDR_REDUND) || defined(CONFIG_ENV_OFFSET_REDUND) |
| 54 | # define CONFIG_SYS_REDUNDAND_ENVIRONMENT |
| 55 | # endif |
| 56 | # ifdef CONFIG_ENV_IS_EMBEDDED |
| 57 | # error "do not define CONFIG_ENV_IS_EMBEDDED in your board config" |
| 58 | # error "it is calculated automatically for you" |
| 59 | # endif |
| 60 | #endif /* CONFIG_ENV_IS_IN_FLASH */ |
| 61 | |
| 62 | #if defined(CONFIG_ENV_IS_IN_MMC) |
| 63 | # ifdef CONFIG_ENV_OFFSET_REDUND |
| 64 | # define CONFIG_SYS_REDUNDAND_ENVIRONMENT |
| 65 | # endif |
| 66 | #endif |
| 67 | |
| 68 | #if defined(CONFIG_ENV_IS_IN_NAND) |
| 69 | # if defined(CONFIG_ENV_OFFSET_OOB) |
| 70 | # ifdef CONFIG_ENV_OFFSET_REDUND |
| 71 | # error "CONFIG_ENV_OFFSET_REDUND is not supported when CONFIG_ENV_OFFSET_OOB" |
| 72 | # error "is set" |
| 73 | # endif |
| 74 | extern unsigned long nand_env_oob_offset; |
| 75 | # define CONFIG_ENV_OFFSET nand_env_oob_offset |
| 76 | # else |
| 77 | # ifndef CONFIG_ENV_OFFSET |
| 78 | # error "Need to define CONFIG_ENV_OFFSET when using CONFIG_ENV_IS_IN_NAND" |
| 79 | # endif |
| 80 | # ifdef CONFIG_ENV_OFFSET_REDUND |
| 81 | # define CONFIG_SYS_REDUNDAND_ENVIRONMENT |
| 82 | # endif |
| 83 | # endif /* CONFIG_ENV_OFFSET_OOB */ |
| 84 | # ifndef CONFIG_ENV_SIZE |
| 85 | # error "Need to define CONFIG_ENV_SIZE when using CONFIG_ENV_IS_IN_NAND" |
| 86 | # endif |
| 87 | #endif /* CONFIG_ENV_IS_IN_NAND */ |
| 88 | |
| 89 | #if defined(CONFIG_ENV_IS_IN_UBI) |
| 90 | # ifndef CONFIG_ENV_UBI_PART |
| 91 | # error "Need to define CONFIG_ENV_UBI_PART when using CONFIG_ENV_IS_IN_UBI" |
| 92 | # endif |
| 93 | # ifndef CONFIG_ENV_UBI_VOLUME |
| 94 | # error "Need to define CONFIG_ENV_UBI_VOLUME when using CONFIG_ENV_IS_IN_UBI" |
| 95 | # endif |
| 96 | # if defined(CONFIG_ENV_UBI_VOLUME_REDUND) |
| 97 | # define CONFIG_SYS_REDUNDAND_ENVIRONMENT |
| 98 | # endif |
| 99 | # ifndef CONFIG_ENV_SIZE |
| 100 | # error "Need to define CONFIG_ENV_SIZE when using CONFIG_ENV_IS_IN_UBI" |
| 101 | # endif |
| 102 | # ifndef CONFIG_CMD_UBI |
| 103 | # error "Need to define CONFIG_CMD_UBI when using CONFIG_ENV_IS_IN_UBI" |
| 104 | # endif |
| 105 | #endif /* CONFIG_ENV_IS_IN_UBI */ |
| 106 | |
| 107 | /* Embedded env is only supported for some flash types */ |
| 108 | #ifdef CONFIG_ENV_IS_EMBEDDED |
| 109 | # if !defined(CONFIG_ENV_IS_IN_FLASH) && \ |
| 110 | !defined(CONFIG_ENV_IS_IN_NAND) && \ |
| 111 | !defined(CONFIG_ENV_IS_IN_ONENAND) && \ |
| 112 | !defined(CONFIG_ENV_IS_IN_SPI_FLASH) |
| 113 | # error "CONFIG_ENV_IS_EMBEDDED not supported for your flash type" |
| 114 | # endif |
| 115 | #endif |
| 116 | |
| 117 | /* |
| 118 | * For the flash types where embedded env is supported, but it cannot be |
| 119 | * calculated automatically (i.e. NAND), take the board opt-in. |
| 120 | */ |
| 121 | #if defined(CONFIG_ENV_IS_EMBEDDED) && !defined(ENV_IS_EMBEDDED) |
| 122 | # define ENV_IS_EMBEDDED |
| 123 | #endif |
| 124 | |
| 125 | /* The build system likes to know if the env is embedded */ |
| 126 | #ifdef DO_DEPS_ONLY |
| 127 | # ifdef ENV_IS_EMBEDDED |
| 128 | # ifndef CONFIG_ENV_IS_EMBEDDED |
| 129 | # define CONFIG_ENV_IS_EMBEDDED |
| 130 | # endif |
| 131 | # endif |
| 132 | #endif |
| 133 | |
| 134 | #include "compiler.h" |
| 135 | |
| 136 | #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 137 | #ifndef CONFIG_ENV_BACKUP |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 138 | # define ENV_HEADER_SIZE (sizeof(uint32_t) + 1) |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 139 | #else |
| 140 | # define ENV_HEADER_SIZE (sizeof(uint32_t)) |
| 141 | #endif |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 142 | # define ACTIVE_FLAG 1 |
| 143 | # define OBSOLETE_FLAG 0 |
| 144 | #else |
| 145 | # define ENV_HEADER_SIZE (sizeof(uint32_t)) |
| 146 | #endif |
| 147 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 148 | #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE) |
| 149 | extern char *env_name_spec; |
| 150 | #endif |
| 151 | |
| 152 | #ifdef CONFIG_ENV_AES |
| 153 | /* Make sure the payload is multiple of AES block size */ |
| 154 | #define ENV_SIZE ((CONFIG_ENV_SIZE - ENV_HEADER_SIZE) & ~(16 - 1)) |
| 155 | #else |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 156 | #define ENV_SIZE (CONFIG_ENV_SIZE - ENV_HEADER_SIZE) |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 157 | #endif |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 158 | |
| 159 | typedef struct environment_s { |
| 160 | uint32_t crc; /* CRC32 over data bytes */ |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 161 | #if defined(CONFIG_SYS_REDUNDAND_ENVIRONMENT) && !defined(CONFIG_ENV_BACKUP) |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 162 | unsigned char flags; /* active/obsolete flags */ |
| 163 | #endif |
| 164 | unsigned char data[ENV_SIZE]; /* Environment data */ |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 165 | } env_t |
| 166 | #ifdef CONFIG_ENV_AES |
| 167 | /* Make sure the env is aligned to block size. */ |
| 168 | __attribute__((aligned(16))) |
| 169 | #endif |
| 170 | ; |
| 171 | enum env_valid { |
| 172 | ENV_INVALID, /* No valid environment */ |
| 173 | ENV_VALID, /* First or only environment is valid */ |
| 174 | ENV_REDUND, /* Redundant environment is valid */ |
| 175 | }; |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 176 | |
| 177 | #ifdef ENV_IS_EMBEDDED |
| 178 | extern env_t environment; |
| 179 | #endif /* ENV_IS_EMBEDDED */ |
| 180 | |
| 181 | extern const unsigned char default_environment[]; |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 182 | extern env_t *env_ptr; |
| 183 | |
| 184 | extern void env_relocate_spec(void); |
| 185 | extern unsigned char env_get_char_spec(int); |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 186 | |
| 187 | #if defined(CONFIG_NEEDS_MANUAL_RELOC) |
| 188 | extern void env_reloc(void); |
| 189 | #endif |
| 190 | |
| 191 | #ifdef CONFIG_ENV_IS_IN_MMC |
| 192 | #include <mmc.h> |
| 193 | |
| 194 | extern int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr); |
| 195 | # ifdef CONFIG_SYS_MMC_ENV_PART |
| 196 | extern uint mmc_get_env_part(struct mmc *mmc); |
| 197 | # endif |
| 198 | #endif |
| 199 | |
| 200 | #ifndef DO_DEPS_ONLY |
| 201 | |
| 202 | #include <env_attr.h> |
| 203 | #include <env_callback.h> |
| 204 | #include <env_flags.h> |
| 205 | #include <search.h> |
| 206 | |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 207 | extern struct hsearch_data env_htab; |
| 208 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 209 | /* Function that returns a character from the environment */ |
| 210 | unsigned char env_get_char(int); |
| 211 | |
| 212 | /* Function that returns a pointer to a value from the environment */ |
| 213 | const unsigned char *env_get_addr(int); |
| 214 | unsigned char env_get_char_memory(int index); |
| 215 | |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 216 | /* Function that updates CRC of the enironment */ |
| 217 | void env_crc_update(void); |
| 218 | |
| 219 | /* Look up the variable from the default environment */ |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 220 | char *getenv_default(const char *name); |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 221 | |
| 222 | /* [re]set to the default environment */ |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 223 | void set_default_env(const char *s); |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 224 | |
| 225 | /* [re]set individual variables to their value in the default environment */ |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 226 | int set_default_vars(int nvars, char * const vars[]); |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 227 | |
| 228 | /* Import from binary representation into hash table */ |
| 229 | int env_import(const char *buf, int check); |
| 230 | |
| 231 | /* Export from hash table into binary representation */ |
| 232 | int env_export(env_t *env_out); |
| 233 | |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 234 | #endif /* DO_DEPS_ONLY */ |
| 235 | |
| 236 | #endif /* _ENVIRONMENT_H_ */ |