]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
8c66497e | 2 | /* |
ea882baf | 3 | * (C) Copyright 2000-2010 |
8c66497e HS |
4 | * Wolfgang Denk, DENX Software Engineering, [email protected]. |
5 | * | |
6 | * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com> | |
7 | * Andreas Heppel <[email protected]> | |
8 | * | |
9 | * (C) Copyright 2008 Atmel Corporation | |
8c66497e | 10 | */ |
9d922450 | 11 | #include <dm.h> |
0ac7d722 | 12 | #include <env.h> |
f3998fdc | 13 | #include <env_internal.h> |
5b3375ac | 14 | #include <malloc.h> |
843c9e87 | 15 | #include <spi.h> |
8c66497e | 16 | #include <spi_flash.h> |
ea882baf WD |
17 | #include <search.h> |
18 | #include <errno.h> | |
b79fdc76 | 19 | #include <uuid.h> |
90526e9f | 20 | #include <asm/cache.h> |
401d1c4f | 21 | #include <asm/global_data.h> |
19c31285 | 22 | #include <dm/device-internal.h> |
3db71108 | 23 | #include <u-boot/crc.h> |
8c66497e | 24 | |
25d90ad4 PD |
25 | #define OFFSET_INVALID (~(u32)0) |
26 | ||
7319bcaf | 27 | #ifdef CONFIG_ENV_OFFSET_REDUND |
25d90ad4 PD |
28 | #define ENV_OFFSET_REDUND CONFIG_ENV_OFFSET_REDUND |
29 | ||
eb58a7fc IG |
30 | static ulong env_offset = CONFIG_ENV_OFFSET; |
31 | static ulong env_new_offset = CONFIG_ENV_OFFSET_REDUND; | |
25d90ad4 PD |
32 | |
33 | #else | |
34 | ||
35 | #define ENV_OFFSET_REDUND OFFSET_INVALID | |
36 | ||
a3110f01 | 37 | #endif /* CONFIG_ENV_OFFSET_REDUND */ |
7319bcaf | 38 | |
8c66497e HS |
39 | DECLARE_GLOBAL_DATA_PTR; |
40 | ||
7d84ad1d VYA |
41 | __weak int spi_get_env_dev(void) |
42 | { | |
43 | #ifdef CONFIG_ENV_SPI_BUS | |
44 | return CONFIG_ENV_SPI_BUS; | |
45 | #else | |
46 | return 0; | |
47 | #endif | |
48 | } | |
49 | ||
ecf15442 | 50 | static int setup_flash_device(struct spi_flash **env_flash) |
7319bcaf | 51 | { |
56c40460 | 52 | #if CONFIG_IS_ENABLED(DM_SPI_FLASH) |
19c31285 | 53 | struct udevice *new; |
afa81a77 | 54 | int ret; |
7d84ad1d | 55 | int dev = spi_get_env_dev(); |
19c31285 | 56 | |
96907c0f | 57 | /* speed and mode will be read from DT */ |
7d84ad1d | 58 | ret = spi_flash_probe_bus_cs(dev, CONFIG_ENV_SPI_CS, |
25a17652 | 59 | &new); |
19c31285 | 60 | if (ret) { |
0ac7d722 | 61 | env_set_default("spi_flash_probe_bus_cs() failed", 0); |
c5951991 | 62 | return ret; |
19c31285 GQ |
63 | } |
64 | ||
ecf15442 | 65 | *env_flash = dev_get_uclass_priv(new); |
19c31285 | 66 | #else |
ecf15442 PD |
67 | *env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS, |
68 | CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE); | |
69 | if (!*env_flash) { | |
c8cbf170 JT |
70 | env_set_default("spi_flash_probe() failed", 0); |
71 | return -EIO; | |
7319bcaf | 72 | } |
19c31285 | 73 | #endif |
afa81a77 AF |
74 | return 0; |
75 | } | |
76 | ||
77 | #if defined(CONFIG_ENV_OFFSET_REDUND) | |
e5bce247 | 78 | static int env_sf_save(void) |
afa81a77 AF |
79 | { |
80 | env_t env_new; | |
d3716dd6 | 81 | char *saved_buffer = NULL, flag = ENV_REDUND_OBSOLETE; |
bcb44f62 | 82 | u32 saved_size = 0, saved_offset = 0, sector; |
4da7347d | 83 | u32 sect_size = CONFIG_ENV_SECT_SIZE; |
afa81a77 | 84 | int ret; |
ecf15442 | 85 | struct spi_flash *env_flash; |
afa81a77 | 86 | |
ecf15442 | 87 | ret = setup_flash_device(&env_flash); |
afa81a77 AF |
88 | if (ret) |
89 | return ret; | |
7319bcaf | 90 | |
bcb44f62 RV |
91 | if (IS_ENABLED(CONFIG_ENV_SECT_SIZE_AUTO)) |
92 | sect_size = env_flash->mtd.erasesize; | |
93 | ||
7ce1526e MV |
94 | ret = env_export(&env_new); |
95 | if (ret) | |
c5951991 | 96 | return -EIO; |
d3716dd6 | 97 | env_new.flags = ENV_REDUND_ACTIVE; |
ea882baf | 98 | |
203e94f6 | 99 | if (gd->env_valid == ENV_VALID) { |
a3110f01 SB |
100 | env_new_offset = CONFIG_ENV_OFFSET_REDUND; |
101 | env_offset = CONFIG_ENV_OFFSET; | |
102 | } else { | |
103 | env_new_offset = CONFIG_ENV_OFFSET; | |
104 | env_offset = CONFIG_ENV_OFFSET_REDUND; | |
105 | } | |
106 | ||
7319bcaf | 107 | /* Is the sector larger than the env (i.e. embedded) */ |
4da7347d RV |
108 | if (sect_size > CONFIG_ENV_SIZE) { |
109 | saved_size = sect_size - CONFIG_ENV_SIZE; | |
7319bcaf | 110 | saved_offset = env_new_offset + CONFIG_ENV_SIZE; |
7dd01744 | 111 | saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size); |
7319bcaf | 112 | if (!saved_buffer) { |
c5951991 | 113 | ret = -ENOMEM; |
7319bcaf WW |
114 | goto done; |
115 | } | |
9ba5e5bc HS |
116 | ret = spi_flash_read(env_flash, saved_offset, |
117 | saved_size, saved_buffer); | |
7319bcaf WW |
118 | if (ret) |
119 | goto done; | |
120 | } | |
121 | ||
4da7347d | 122 | sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, sect_size); |
7319bcaf WW |
123 | |
124 | puts("Erasing SPI flash..."); | |
125 | ret = spi_flash_erase(env_flash, env_new_offset, | |
4da7347d | 126 | sector * sect_size); |
7319bcaf WW |
127 | if (ret) |
128 | goto done; | |
129 | ||
130 | puts("Writing to SPI flash..."); | |
7319bcaf | 131 | |
a3110f01 | 132 | ret = spi_flash_write(env_flash, env_new_offset, |
cd0f4fa1 | 133 | CONFIG_ENV_SIZE, &env_new); |
7319bcaf WW |
134 | if (ret) |
135 | goto done; | |
136 | ||
4da7347d | 137 | if (sect_size > CONFIG_ENV_SIZE) { |
7319bcaf WW |
138 | ret = spi_flash_write(env_flash, saved_offset, |
139 | saved_size, saved_buffer); | |
140 | if (ret) | |
141 | goto done; | |
142 | } | |
143 | ||
eb58a7fc | 144 | ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags), |
cd0f4fa1 | 145 | sizeof(env_new.flags), &flag); |
a3110f01 SB |
146 | if (ret) |
147 | goto done; | |
7319bcaf | 148 | |
7319bcaf WW |
149 | puts("done\n"); |
150 | ||
203e94f6 | 151 | gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND; |
a3110f01 | 152 | |
2dc55d9e | 153 | printf("Valid environment: %d\n", (int)gd->env_valid); |
a3110f01 | 154 | |
ea5641ec | 155 | done: |
c2d00364 | 156 | spi_flash_free(env_flash); |
c2d00364 | 157 | |
7319bcaf WW |
158 | if (saved_buffer) |
159 | free(saved_buffer); | |
eb58a7fc | 160 | |
7319bcaf WW |
161 | return ret; |
162 | } | |
163 | ||
c5951991 | 164 | static int env_sf_load(void) |
7319bcaf WW |
165 | { |
166 | int ret; | |
80719938 SG |
167 | int read1_fail, read2_fail; |
168 | env_t *tmp_env1, *tmp_env2; | |
ecf15442 | 169 | struct spi_flash *env_flash; |
7319bcaf | 170 | |
7dd01744 RB |
171 | tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN, |
172 | CONFIG_ENV_SIZE); | |
173 | tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN, | |
174 | CONFIG_ENV_SIZE); | |
ea882baf | 175 | if (!tmp_env1 || !tmp_env2) { |
0ac7d722 | 176 | env_set_default("malloc() failed", 0); |
c5951991 | 177 | ret = -EIO; |
2dc55d9e | 178 | goto out; |
7319bcaf WW |
179 | } |
180 | ||
ecf15442 | 181 | ret = setup_flash_device(&env_flash); |
8fee8845 | 182 | if (ret) |
2dc55d9e | 183 | goto out; |
7319bcaf | 184 | |
9ba5e5bc HS |
185 | read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET, |
186 | CONFIG_ENV_SIZE, tmp_env1); | |
187 | read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND, | |
188 | CONFIG_ENV_SIZE, tmp_env2); | |
ea882baf | 189 | |
80719938 | 190 | ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2, |
890feeca | 191 | read2_fail, H_EXTERNAL); |
7319bcaf | 192 | |
7319bcaf | 193 | spi_flash_free(env_flash); |
7319bcaf | 194 | out: |
ea882baf WD |
195 | free(tmp_env1); |
196 | free(tmp_env2); | |
c5951991 SG |
197 | |
198 | return ret; | |
7319bcaf WW |
199 | } |
200 | #else | |
e5bce247 | 201 | static int env_sf_save(void) |
8c66497e | 202 | { |
bcb44f62 | 203 | u32 saved_size = 0, saved_offset = 0, sector; |
4da7347d | 204 | u32 sect_size = CONFIG_ENV_SECT_SIZE; |
7ce1526e | 205 | char *saved_buffer = NULL; |
eb58a7fc | 206 | int ret = 1; |
cd0f4fa1 | 207 | env_t env_new; |
ecf15442 | 208 | struct spi_flash *env_flash; |
19c31285 | 209 | |
ecf15442 | 210 | ret = setup_flash_device(&env_flash); |
afa81a77 AF |
211 | if (ret) |
212 | return ret; | |
8c66497e | 213 | |
bcb44f62 RV |
214 | if (IS_ENABLED(CONFIG_ENV_SECT_SIZE_AUTO)) |
215 | sect_size = env_flash->mtd.erasesize; | |
216 | ||
5b3375ac | 217 | /* Is the sector larger than the env (i.e. embedded) */ |
4da7347d RV |
218 | if (sect_size > CONFIG_ENV_SIZE) { |
219 | saved_size = sect_size - CONFIG_ENV_SIZE; | |
5b3375ac MF |
220 | saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE; |
221 | saved_buffer = malloc(saved_size); | |
04add62e RS |
222 | if (!saved_buffer) { |
223 | ret = -ENOMEM; | |
5b3375ac | 224 | goto done; |
04add62e | 225 | } |
eb58a7fc | 226 | |
9ba5e5bc HS |
227 | ret = spi_flash_read(env_flash, saved_offset, |
228 | saved_size, saved_buffer); | |
5b3375ac MF |
229 | if (ret) |
230 | goto done; | |
231 | } | |
232 | ||
7ce1526e MV |
233 | ret = env_export(&env_new); |
234 | if (ret) | |
a3110f01 | 235 | goto done; |
a3110f01 | 236 | |
4da7347d | 237 | sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, sect_size); |
0b2e5bbe | 238 | |
8c66497e | 239 | puts("Erasing SPI flash..."); |
a3110f01 | 240 | ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET, |
4da7347d | 241 | sector * sect_size); |
5b3375ac MF |
242 | if (ret) |
243 | goto done; | |
8c66497e HS |
244 | |
245 | puts("Writing to SPI flash..."); | |
a3110f01 | 246 | ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET, |
cd0f4fa1 | 247 | CONFIG_ENV_SIZE, &env_new); |
5b3375ac MF |
248 | if (ret) |
249 | goto done; | |
8c66497e | 250 | |
4da7347d | 251 | if (sect_size > CONFIG_ENV_SIZE) { |
a3110f01 SB |
252 | ret = spi_flash_write(env_flash, saved_offset, |
253 | saved_size, saved_buffer); | |
5b3375ac MF |
254 | if (ret) |
255 | goto done; | |
256 | } | |
257 | ||
258 | ret = 0; | |
8c66497e | 259 | puts("done\n"); |
5b3375ac | 260 | |
ea5641ec | 261 | done: |
c2d00364 | 262 | spi_flash_free(env_flash); |
c2d00364 | 263 | |
5b3375ac MF |
264 | if (saved_buffer) |
265 | free(saved_buffer); | |
eb58a7fc | 266 | |
5b3375ac | 267 | return ret; |
8c66497e HS |
268 | } |
269 | ||
c5951991 | 270 | static int env_sf_load(void) |
8c66497e HS |
271 | { |
272 | int ret; | |
5a89fa92 | 273 | char *buf = NULL; |
ecf15442 | 274 | struct spi_flash *env_flash; |
8c66497e | 275 | |
7dd01744 | 276 | buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE); |
c041c60c | 277 | if (!buf) { |
0ac7d722 | 278 | env_set_default("malloc() failed", 0); |
c5951991 | 279 | return -EIO; |
ea882baf | 280 | } |
8c66497e | 281 | |
ecf15442 | 282 | ret = setup_flash_device(&env_flash); |
c041c60c AF |
283 | if (ret) |
284 | goto out; | |
285 | ||
9ba5e5bc HS |
286 | ret = spi_flash_read(env_flash, |
287 | CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf); | |
ea882baf | 288 | if (ret) { |
0ac7d722 | 289 | env_set_default("spi_flash_read() failed", 0); |
c041c60c | 290 | goto err_read; |
ea882baf | 291 | } |
8c66497e | 292 | |
890feeca | 293 | ret = env_import(buf, 1, H_EXTERNAL); |
42a1820b | 294 | if (!ret) |
203e94f6 | 295 | gd->env_valid = ENV_VALID; |
c041c60c AF |
296 | |
297 | err_read: | |
8c66497e | 298 | spi_flash_free(env_flash); |
c041c60c AF |
299 | out: |
300 | free(buf); | |
c5951991 SG |
301 | |
302 | return ret; | |
8c66497e | 303 | } |
7319bcaf | 304 | #endif |
8c66497e | 305 | |
25d90ad4 PD |
306 | static int env_sf_erase(void) |
307 | { | |
308 | int ret; | |
309 | env_t env; | |
ecf15442 | 310 | struct spi_flash *env_flash; |
25d90ad4 | 311 | |
ecf15442 | 312 | ret = setup_flash_device(&env_flash); |
25d90ad4 PD |
313 | if (ret) |
314 | return ret; | |
315 | ||
316 | memset(&env, 0, sizeof(env_t)); | |
317 | ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, &env); | |
318 | if (ret) | |
319 | goto done; | |
320 | ||
321 | if (ENV_OFFSET_REDUND != OFFSET_INVALID) | |
322 | ret = spi_flash_write(env_flash, ENV_OFFSET_REDUND, CONFIG_ENV_SIZE, &env); | |
323 | ||
324 | done: | |
325 | spi_flash_free(env_flash); | |
25d90ad4 PD |
326 | |
327 | return ret; | |
328 | } | |
329 | ||
119c01c2 RB |
330 | __weak void *env_sf_get_env_addr(void) |
331 | { | |
f4bf81b0 | 332 | #ifndef CONFIG_SPL_BUILD |
119c01c2 | 333 | return (void *)CONFIG_ENV_ADDR; |
f4bf81b0 T |
334 | #else |
335 | return NULL; | |
119c01c2 | 336 | #endif |
f4bf81b0 | 337 | } |
119c01c2 | 338 | |
92765f45 HS |
339 | /* |
340 | * check if Environment on CONFIG_ENV_ADDR is valid. | |
341 | */ | |
342 | static int env_sf_init_addr(void) | |
b500c92b | 343 | { |
119c01c2 | 344 | env_t *env_ptr = (env_t *)env_sf_get_env_addr(); |
b500c92b | 345 | |
f4bf81b0 T |
346 | if (!env_ptr) |
347 | return -ENOENT; | |
348 | ||
b500c92b | 349 | if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) { |
9ab30d2b | 350 | gd->env_addr = (ulong)&(env_ptr->data); |
87221bd6 | 351 | gd->env_valid = ENV_VALID; |
b500c92b | 352 | } else { |
af8149e9 | 353 | gd->env_valid = ENV_INVALID; |
b500c92b AK |
354 | } |
355 | ||
356 | return 0; | |
357 | } | |
b500c92b | 358 | |
92765f45 HS |
359 | #if defined(CONFIG_ENV_SPI_EARLY) |
360 | /* | |
361 | * early load environment from SPI flash (before relocation) | |
362 | * and check if it is valid. | |
363 | */ | |
364 | static int env_sf_init_early(void) | |
365 | { | |
366 | int ret; | |
367 | int read1_fail; | |
368 | int read2_fail; | |
369 | int crc1_ok; | |
370 | env_t *tmp_env2 = NULL; | |
371 | env_t *tmp_env1; | |
ecf15442 | 372 | struct spi_flash *env_flash; |
92765f45 HS |
373 | |
374 | /* | |
375 | * if malloc is not ready yet, we cannot use | |
376 | * this part yet. | |
377 | */ | |
378 | if (!gd->malloc_limit) | |
379 | return -ENOENT; | |
380 | ||
381 | tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN, | |
382 | CONFIG_ENV_SIZE); | |
383 | if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) | |
384 | tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN, | |
385 | CONFIG_ENV_SIZE); | |
386 | ||
387 | if (!tmp_env1 || !tmp_env2) | |
388 | goto out; | |
389 | ||
ecf15442 | 390 | ret = setup_flash_device(&env_flash); |
92765f45 HS |
391 | if (ret) |
392 | goto out; | |
393 | ||
394 | read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET, | |
395 | CONFIG_ENV_SIZE, tmp_env1); | |
396 | ||
397 | if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) { | |
398 | read2_fail = spi_flash_read(env_flash, | |
399 | CONFIG_ENV_OFFSET_REDUND, | |
400 | CONFIG_ENV_SIZE, tmp_env2); | |
401 | ret = env_check_redund((char *)tmp_env1, read1_fail, | |
402 | (char *)tmp_env2, read2_fail); | |
403 | ||
b9c3052f | 404 | if (ret < 0) |
92765f45 HS |
405 | goto err_read; |
406 | ||
407 | if (gd->env_valid == ENV_VALID) | |
408 | gd->env_addr = (unsigned long)&tmp_env1->data; | |
409 | else | |
410 | gd->env_addr = (unsigned long)&tmp_env2->data; | |
411 | } else { | |
412 | if (read1_fail) | |
413 | goto err_read; | |
414 | ||
415 | crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == | |
416 | tmp_env1->crc; | |
417 | if (!crc1_ok) | |
418 | goto err_read; | |
419 | ||
420 | /* if valid -> this is our env */ | |
421 | gd->env_valid = ENV_VALID; | |
422 | gd->env_addr = (unsigned long)&tmp_env1->data; | |
423 | } | |
424 | ||
c2d00364 | 425 | spi_flash_free(env_flash); |
c2d00364 | 426 | |
92765f45 HS |
427 | return 0; |
428 | err_read: | |
429 | spi_flash_free(env_flash); | |
ecf15442 | 430 | |
92765f45 HS |
431 | free(tmp_env1); |
432 | if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) | |
433 | free(tmp_env2); | |
434 | out: | |
435 | /* env is not valid. always return 0 */ | |
436 | gd->env_valid = ENV_INVALID; | |
437 | return 0; | |
438 | } | |
439 | #endif | |
440 | ||
441 | static int env_sf_init(void) | |
442 | { | |
f4bf81b0 T |
443 | int ret = env_sf_init_addr(); |
444 | if (ret != -ENOENT) | |
445 | return ret; | |
446 | #ifdef CONFIG_ENV_SPI_EARLY | |
92765f45 HS |
447 | return env_sf_init_early(); |
448 | #endif | |
449 | /* | |
46ce9e77 HS |
450 | * return here -ENOENT, so env_init() |
451 | * can set the init bit and later if no | |
452 | * other Environment storage is defined | |
453 | * can set the default environment | |
92765f45 | 454 | */ |
46ce9e77 | 455 | return -ENOENT; |
92765f45 HS |
456 | } |
457 | ||
4415f1d1 SG |
458 | U_BOOT_ENV_LOCATION(sf) = { |
459 | .location = ENVL_SPI_FLASH, | |
22140d16 | 460 | ENV_NAME("SPIFlash") |
e5bce247 | 461 | .load = env_sf_load, |
e41f55b3 | 462 | .save = ENV_SAVE_PTR(env_sf_save), |
25d90ad4 | 463 | .erase = ENV_ERASE_PTR(env_sf_erase), |
b500c92b | 464 | .init = env_sf_init, |
4415f1d1 | 465 | }; |