1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2000-2010
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 *
6 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
7 * Andreas Heppel <aheppel@sysgo.de>
8 *
9 * (C) Copyright 2008 Atmel Corporation
10 */
11 #include <common.h>
12 #include <dm.h>
13 #include <env.h>
14 #include <env_internal.h>
15 #include <flash.h>
16 #include <malloc.h>
17 #include <spi.h>
18 #include <spi_flash.h>
19 #include <search.h>
20 #include <errno.h>
21 #include <uuid.h>
22 #include <asm/cache.h>
23 #include <asm/global_data.h>
24 #include <dm/device-internal.h>
25 #include <u-boot/crc.h>
26
27 #ifndef CONFIG_SPL_BUILD
28 #define INITENV
29 #endif
30
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 */
35
36 DECLARE_GLOBAL_DATA_PTR;
37
38 static struct spi_flash *env_flash;
39
setup_flash_device(void)40 static int setup_flash_device(void)
41 {
42 #if CONFIG_IS_ENABLED(DM_SPI_FLASH)
43 struct udevice *new;
44 int ret;
45
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,
49 &new);
50 if (ret) {
51 env_set_default("spi_flash_probe_bus_cs() failed", 0);
52 return ret;
53 }
54
55 env_flash = dev_get_uclass_priv(new);
56 #else
57 if (env_flash)
58 spi_flash_free(env_flash);
59
60 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
61 CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
62 if (!env_flash) {
63 env_set_default("spi_flash_probe() failed", 0);
64 return -EIO;
65 }
66 #endif
67 return 0;
68 }
69
70 #if defined(CONFIG_ENV_OFFSET_REDUND)
env_sf_save(void)71 static int env_sf_save(void)
72 {
73 env_t env_new;
74 char *saved_buffer = NULL, flag = ENV_REDUND_OBSOLETE;
75 u32 saved_size, saved_offset, sector;
76 int ret;
77
78 ret = setup_flash_device();
79 if (ret)
80 return ret;
81
82 ret = env_export(&env_new);
83 if (ret)
84 return -EIO;
85 env_new.flags = ENV_REDUND_ACTIVE;
86
87 if (gd->env_valid == ENV_VALID) {
88 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
89 env_offset = CONFIG_ENV_OFFSET;
90 } else {
91 env_new_offset = CONFIG_ENV_OFFSET;
92 env_offset = CONFIG_ENV_OFFSET_REDUND;
93 }
94
95 /* Is the sector larger than the env (i.e. embedded) */
96 if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
97 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
98 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
99 saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
100 if (!saved_buffer) {
101 ret = -ENOMEM;
102 goto done;
103 }
104 ret = spi_flash_read(env_flash, saved_offset,
105 saved_size, saved_buffer);
106 if (ret)
107 goto done;
108 }
109
110 sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
111
112 puts("Erasing SPI flash...");
113 ret = spi_flash_erase(env_flash, env_new_offset,
114 sector * CONFIG_ENV_SECT_SIZE);
115 if (ret)
116 goto done;
117
118 puts("Writing to SPI flash...");
119
120 ret = spi_flash_write(env_flash, env_new_offset,
121 CONFIG_ENV_SIZE, &env_new);
122 if (ret)
123 goto done;
124
125 if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
126 ret = spi_flash_write(env_flash, saved_offset,
127 saved_size, saved_buffer);
128 if (ret)
129 goto done;
130 }
131
132 ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
133 sizeof(env_new.flags), &flag);
134 if (ret)
135 goto done;
136
137 puts("done\n");
138
139 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
140
141 printf("Valid environment: %d\n", (int)gd->env_valid);
142
143 done:
144 if (saved_buffer)
145 free(saved_buffer);
146
147 return ret;
148 }
149
env_sf_load(void)150 static int env_sf_load(void)
151 {
152 int ret;
153 int read1_fail, read2_fail;
154 env_t *tmp_env1, *tmp_env2;
155
156 tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
157 CONFIG_ENV_SIZE);
158 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
159 CONFIG_ENV_SIZE);
160 if (!tmp_env1 || !tmp_env2) {
161 env_set_default("malloc() failed", 0);
162 ret = -EIO;
163 goto out;
164 }
165
166 ret = setup_flash_device();
167 if (ret)
168 goto out;
169
170 read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
171 CONFIG_ENV_SIZE, tmp_env1);
172 read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
173 CONFIG_ENV_SIZE, tmp_env2);
174
175 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
176 read2_fail, H_EXTERNAL);
177
178 spi_flash_free(env_flash);
179 env_flash = NULL;
180 out:
181 free(tmp_env1);
182 free(tmp_env2);
183
184 return ret;
185 }
186 #else
env_sf_save(void)187 static int env_sf_save(void)
188 {
189 u32 saved_size, saved_offset, sector;
190 char *saved_buffer = NULL;
191 int ret = 1;
192 env_t env_new;
193
194 ret = setup_flash_device();
195 if (ret)
196 return ret;
197
198 /* Is the sector larger than the env (i.e. embedded) */
199 if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
200 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
201 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
202 saved_buffer = malloc(saved_size);
203 if (!saved_buffer)
204 goto done;
205
206 ret = spi_flash_read(env_flash, saved_offset,
207 saved_size, saved_buffer);
208 if (ret)
209 goto done;
210 }
211
212 ret = env_export(&env_new);
213 if (ret)
214 goto done;
215
216 sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
217
218 puts("Erasing SPI flash...");
219 ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
220 sector * CONFIG_ENV_SECT_SIZE);
221 if (ret)
222 goto done;
223
224 puts("Writing to SPI flash...");
225 ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
226 CONFIG_ENV_SIZE, &env_new);
227 if (ret)
228 goto done;
229
230 if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
231 ret = spi_flash_write(env_flash, saved_offset,
232 saved_size, saved_buffer);
233 if (ret)
234 goto done;
235 }
236
237 ret = 0;
238 puts("done\n");
239
240 done:
241 if (saved_buffer)
242 free(saved_buffer);
243
244 return ret;
245 }
246
env_sf_load(void)247 static int env_sf_load(void)
248 {
249 int ret;
250 char *buf = NULL;
251
252 buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
253 if (!buf) {
254 env_set_default("malloc() failed", 0);
255 return -EIO;
256 }
257
258 ret = setup_flash_device();
259 if (ret)
260 goto out;
261
262 ret = spi_flash_read(env_flash,
263 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
264 if (ret) {
265 env_set_default("spi_flash_read() failed", 0);
266 goto err_read;
267 }
268
269 ret = env_import(buf, 1, H_EXTERNAL);
270 if (!ret)
271 gd->env_valid = ENV_VALID;
272
273 err_read:
274 spi_flash_free(env_flash);
275 env_flash = NULL;
276 out:
277 free(buf);
278
279 return ret;
280 }
281 #endif
282
283 #if CONFIG_ENV_ADDR != 0x0
env_sf_get_env_addr(void)284 __weak void *env_sf_get_env_addr(void)
285 {
286 return (void *)CONFIG_ENV_ADDR;
287 }
288 #endif
289
290 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
291 /*
292 * check if Environment on CONFIG_ENV_ADDR is valid.
293 */
env_sf_init_addr(void)294 static int env_sf_init_addr(void)
295 {
296 env_t *env_ptr = (env_t *)env_sf_get_env_addr();
297
298 if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
299 gd->env_addr = (ulong)&(env_ptr->data);
300 gd->env_valid = 1;
301 } else {
302 gd->env_addr = (ulong)&default_environment[0];
303 gd->env_valid = 1;
304 }
305
306 return 0;
307 }
308 #endif
309
310 #if defined(CONFIG_ENV_SPI_EARLY)
311 /*
312 * early load environment from SPI flash (before relocation)
313 * and check if it is valid.
314 */
env_sf_init_early(void)315 static int env_sf_init_early(void)
316 {
317 int ret;
318 int read1_fail;
319 int read2_fail;
320 int crc1_ok;
321 env_t *tmp_env2 = NULL;
322 env_t *tmp_env1;
323
324 /*
325 * if malloc is not ready yet, we cannot use
326 * this part yet.
327 */
328 if (!gd->malloc_limit)
329 return -ENOENT;
330
331 tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
332 CONFIG_ENV_SIZE);
333 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
334 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
335 CONFIG_ENV_SIZE);
336
337 if (!tmp_env1 || !tmp_env2)
338 goto out;
339
340 ret = setup_flash_device();
341 if (ret)
342 goto out;
343
344 read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
345 CONFIG_ENV_SIZE, tmp_env1);
346
347 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
348 read2_fail = spi_flash_read(env_flash,
349 CONFIG_ENV_OFFSET_REDUND,
350 CONFIG_ENV_SIZE, tmp_env2);
351 ret = env_check_redund((char *)tmp_env1, read1_fail,
352 (char *)tmp_env2, read2_fail);
353
354 if (ret == -EIO || ret == -ENOMSG)
355 goto err_read;
356
357 if (gd->env_valid == ENV_VALID)
358 gd->env_addr = (unsigned long)&tmp_env1->data;
359 else
360 gd->env_addr = (unsigned long)&tmp_env2->data;
361 } else {
362 if (read1_fail)
363 goto err_read;
364
365 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
366 tmp_env1->crc;
367 if (!crc1_ok)
368 goto err_read;
369
370 /* if valid -> this is our env */
371 gd->env_valid = ENV_VALID;
372 gd->env_addr = (unsigned long)&tmp_env1->data;
373 }
374
375 return 0;
376 err_read:
377 spi_flash_free(env_flash);
378 env_flash = NULL;
379 free(tmp_env1);
380 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
381 free(tmp_env2);
382 out:
383 /* env is not valid. always return 0 */
384 gd->env_valid = ENV_INVALID;
385 return 0;
386 }
387 #endif
388
env_sf_init(void)389 static int env_sf_init(void)
390 {
391 #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
392 return env_sf_init_addr();
393 #elif defined(CONFIG_ENV_SPI_EARLY)
394 return env_sf_init_early();
395 #endif
396 /*
397 * return here -ENOENT, so env_init()
398 * can set the init bit and later if no
399 * other Environment storage is defined
400 * can set the default environment
401 */
402 return -ENOENT;
403 }
404
405 U_BOOT_ENV_LOCATION(sf) = {
406 .location = ENVL_SPI_FLASH,
407 ENV_NAME("SPIFlash")
408 .load = env_sf_load,
409 .save = CONFIG_IS_ENABLED(SAVEENV) ? ENV_SAVE_PTR(env_sf_save) : NULL,
410 .init = env_sf_init,
411 };
412