1 // SPDX-License-Identifier: GPL-2.0+
3 * (C) Copyright 2000-2010
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
6 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
7 * Andreas Heppel <aheppel@sysgo.de>
9 * (C) Copyright 2008 Atmel Corporation
14 #include <env_internal.h>
18 #include <spi_flash.h>
22 #include <asm/cache.h>
23 #include <asm/global_data.h>
24 #include <dm/device-internal.h>
25 #include <u-boot/crc.h>
27 #ifndef CONFIG_SPL_BUILD
31 #ifdef CONFIG_ENV_OFFSET_REDUND
32 static ulong env_offset = CONFIG_ENV_OFFSET;
33 static ulong env_new_offset = CONFIG_ENV_OFFSET_REDUND;
34 #endif /* CONFIG_ENV_OFFSET_REDUND */
36 DECLARE_GLOBAL_DATA_PTR;
38 static struct spi_flash *env_flash;
40 static int setup_flash_device(void)
42 #if CONFIG_IS_ENABLED(DM_SPI_FLASH)
46 /* speed and mode will be read from DT */
47 ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
48 CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE,
51 env_set_default("spi_flash_probe_bus_cs() failed", 0);
55 env_flash = dev_get_uclass_priv(new);
58 spi_flash_free(env_flash);
60 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
61 CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
63 env_set_default("spi_flash_probe() failed", 0);
70 #if defined(CONFIG_ENV_OFFSET_REDUND)
71 static int env_sf_save(void)
74 char *saved_buffer = NULL, flag = ENV_REDUND_OBSOLETE;
75 u32 saved_size = 0, saved_offset = 0, sector;
76 u32 sect_size = CONFIG_ENV_SECT_SIZE;
79 ret = setup_flash_device();
83 if (IS_ENABLED(CONFIG_ENV_SECT_SIZE_AUTO))
84 sect_size = env_flash->mtd.erasesize;
86 ret = env_export(&env_new);
89 env_new.flags = ENV_REDUND_ACTIVE;
91 if (gd->env_valid == ENV_VALID) {
92 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
93 env_offset = CONFIG_ENV_OFFSET;
95 env_new_offset = CONFIG_ENV_OFFSET;
96 env_offset = CONFIG_ENV_OFFSET_REDUND;
99 /* Is the sector larger than the env (i.e. embedded) */
100 if (sect_size > CONFIG_ENV_SIZE) {
101 saved_size = sect_size - CONFIG_ENV_SIZE;
102 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
103 saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
108 ret = spi_flash_read(env_flash, saved_offset,
109 saved_size, saved_buffer);
114 sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, sect_size);
116 puts("Erasing SPI flash...");
117 ret = spi_flash_erase(env_flash, env_new_offset,
122 puts("Writing to SPI flash...");
124 ret = spi_flash_write(env_flash, env_new_offset,
125 CONFIG_ENV_SIZE, &env_new);
129 if (sect_size > CONFIG_ENV_SIZE) {
130 ret = spi_flash_write(env_flash, saved_offset,
131 saved_size, saved_buffer);
136 ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
137 sizeof(env_new.flags), &flag);
143 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
145 printf("Valid environment: %d\n", (int)gd->env_valid);
154 static int env_sf_load(void)
157 int read1_fail, read2_fail;
158 env_t *tmp_env1, *tmp_env2;
160 tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
162 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
164 if (!tmp_env1 || !tmp_env2) {
165 env_set_default("malloc() failed", 0);
170 ret = setup_flash_device();
174 read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
175 CONFIG_ENV_SIZE, tmp_env1);
176 read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
177 CONFIG_ENV_SIZE, tmp_env2);
179 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
180 read2_fail, H_EXTERNAL);
182 spi_flash_free(env_flash);
191 static int env_sf_save(void)
193 u32 saved_size = 0, saved_offset = 0, sector;
194 u32 sect_size = CONFIG_ENV_SECT_SIZE;
195 char *saved_buffer = NULL;
199 ret = setup_flash_device();
203 if (IS_ENABLED(CONFIG_ENV_SECT_SIZE_AUTO))
204 sect_size = env_flash->mtd.erasesize;
206 /* Is the sector larger than the env (i.e. embedded) */
207 if (sect_size > CONFIG_ENV_SIZE) {
208 saved_size = sect_size - CONFIG_ENV_SIZE;
209 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
210 saved_buffer = malloc(saved_size);
214 ret = spi_flash_read(env_flash, saved_offset,
215 saved_size, saved_buffer);
220 ret = env_export(&env_new);
224 sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, sect_size);
226 puts("Erasing SPI flash...");
227 ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
232 puts("Writing to SPI flash...");
233 ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
234 CONFIG_ENV_SIZE, &env_new);
238 if (sect_size > CONFIG_ENV_SIZE) {
239 ret = spi_flash_write(env_flash, saved_offset,
240 saved_size, saved_buffer);
255 static int env_sf_load(void)
260 buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
262 env_set_default("malloc() failed", 0);
266 ret = setup_flash_device();
270 ret = spi_flash_read(env_flash,
271 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
273 env_set_default("spi_flash_read() failed", 0);
277 ret = env_import(buf, 1, H_EXTERNAL);
279 gd->env_valid = ENV_VALID;
282 spi_flash_free(env_flash);
291 #if CONFIG_ENV_ADDR != 0x0
292 __weak void *env_sf_get_env_addr(void)
294 return (void *)CONFIG_ENV_ADDR;
298 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
300 * check if Environment on CONFIG_ENV_ADDR is valid.
302 static int env_sf_init_addr(void)
304 env_t *env_ptr = (env_t *)env_sf_get_env_addr();
306 if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
307 gd->env_addr = (ulong)&(env_ptr->data);
310 gd->env_addr = (ulong)&default_environment[0];
318 #if defined(CONFIG_ENV_SPI_EARLY)
320 * early load environment from SPI flash (before relocation)
321 * and check if it is valid.
323 static int env_sf_init_early(void)
329 env_t *tmp_env2 = NULL;
333 * if malloc is not ready yet, we cannot use
336 if (!gd->malloc_limit)
339 tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
341 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
342 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
345 if (!tmp_env1 || !tmp_env2)
348 ret = setup_flash_device();
352 read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
353 CONFIG_ENV_SIZE, tmp_env1);
355 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
356 read2_fail = spi_flash_read(env_flash,
357 CONFIG_ENV_OFFSET_REDUND,
358 CONFIG_ENV_SIZE, tmp_env2);
359 ret = env_check_redund((char *)tmp_env1, read1_fail,
360 (char *)tmp_env2, read2_fail);
365 if (gd->env_valid == ENV_VALID)
366 gd->env_addr = (unsigned long)&tmp_env1->data;
368 gd->env_addr = (unsigned long)&tmp_env2->data;
373 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
378 /* if valid -> this is our env */
379 gd->env_valid = ENV_VALID;
380 gd->env_addr = (unsigned long)&tmp_env1->data;
385 spi_flash_free(env_flash);
388 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
391 /* env is not valid. always return 0 */
392 gd->env_valid = ENV_INVALID;
397 static int env_sf_init(void)
399 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
400 return env_sf_init_addr();
401 #elif defined(CONFIG_ENV_SPI_EARLY)
402 return env_sf_init_early();
405 * return here -ENOENT, so env_init()
406 * can set the init bit and later if no
407 * other Environment storage is defined
408 * can set the default environment
413 U_BOOT_ENV_LOCATION(sf) = {
414 .location = ENVL_SPI_FLASH,
417 .save = CONFIG_IS_ENABLED(SAVEENV) ? ENV_SAVE_PTR(env_sf_save) : NULL,