1
2
3
4
5
6
7
8
9
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#define OFFSET_INVALID (~(u32)0)
32
33#ifdef CONFIG_ENV_OFFSET_REDUND
34#define ENV_OFFSET_REDUND CONFIG_ENV_OFFSET_REDUND
35
36static ulong env_offset = CONFIG_ENV_OFFSET;
37static ulong env_new_offset = CONFIG_ENV_OFFSET_REDUND;
38
39#else
40
41#define ENV_OFFSET_REDUND OFFSET_INVALID
42
43#endif
44
45DECLARE_GLOBAL_DATA_PTR;
46
47static int setup_flash_device(struct spi_flash **env_flash)
48{
49#if CONFIG_IS_ENABLED(DM_SPI_FLASH)
50 struct udevice *new;
51 int ret;
52
53
54 ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
55 CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE,
56 &new);
57 if (ret) {
58 env_set_default("spi_flash_probe_bus_cs() failed", 0);
59 return ret;
60 }
61
62 *env_flash = dev_get_uclass_priv(new);
63#else
64 *env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
65 CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
66 if (!*env_flash) {
67 env_set_default("spi_flash_probe() failed", 0);
68 return -EIO;
69 }
70#endif
71 return 0;
72}
73
74#if defined(CONFIG_ENV_OFFSET_REDUND)
75static int env_sf_save(void)
76{
77 env_t env_new;
78 char *saved_buffer = NULL, flag = ENV_REDUND_OBSOLETE;
79 u32 saved_size = 0, saved_offset = 0, sector;
80 u32 sect_size = CONFIG_ENV_SECT_SIZE;
81 int ret;
82 struct spi_flash *env_flash;
83
84 ret = setup_flash_device(&env_flash);
85 if (ret)
86 return ret;
87
88 if (IS_ENABLED(CONFIG_ENV_SECT_SIZE_AUTO))
89 sect_size = env_flash->mtd.erasesize;
90
91 ret = env_export(&env_new);
92 if (ret)
93 return -EIO;
94 env_new.flags = ENV_REDUND_ACTIVE;
95
96 if (gd->env_valid == ENV_VALID) {
97 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
98 env_offset = CONFIG_ENV_OFFSET;
99 } else {
100 env_new_offset = CONFIG_ENV_OFFSET;
101 env_offset = CONFIG_ENV_OFFSET_REDUND;
102 }
103
104
105 if (sect_size > CONFIG_ENV_SIZE) {
106 saved_size = sect_size - CONFIG_ENV_SIZE;
107 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
108 saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
109 if (!saved_buffer) {
110 ret = -ENOMEM;
111 goto done;
112 }
113 ret = spi_flash_read(env_flash, saved_offset,
114 saved_size, saved_buffer);
115 if (ret)
116 goto done;
117 }
118
119 sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, sect_size);
120
121 puts("Erasing SPI flash...");
122 ret = spi_flash_erase(env_flash, env_new_offset,
123 sector * sect_size);
124 if (ret)
125 goto done;
126
127 puts("Writing to SPI flash...");
128
129 ret = spi_flash_write(env_flash, env_new_offset,
130 CONFIG_ENV_SIZE, &env_new);
131 if (ret)
132 goto done;
133
134 if (sect_size > CONFIG_ENV_SIZE) {
135 ret = spi_flash_write(env_flash, saved_offset,
136 saved_size, saved_buffer);
137 if (ret)
138 goto done;
139 }
140
141 ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
142 sizeof(env_new.flags), &flag);
143 if (ret)
144 goto done;
145
146 puts("done\n");
147
148 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
149
150 printf("Valid environment: %d\n", (int)gd->env_valid);
151
152done:
153 spi_flash_free(env_flash);
154
155 if (saved_buffer)
156 free(saved_buffer);
157
158 return ret;
159}
160
161static int env_sf_load(void)
162{
163 int ret;
164 int read1_fail, read2_fail;
165 env_t *tmp_env1, *tmp_env2;
166 struct spi_flash *env_flash;
167
168 tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
169 CONFIG_ENV_SIZE);
170 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
171 CONFIG_ENV_SIZE);
172 if (!tmp_env1 || !tmp_env2) {
173 env_set_default("malloc() failed", 0);
174 ret = -EIO;
175 goto out;
176 }
177
178 ret = setup_flash_device(&env_flash);
179 if (ret)
180 goto out;
181
182 read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
183 CONFIG_ENV_SIZE, tmp_env1);
184 read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
185 CONFIG_ENV_SIZE, tmp_env2);
186
187 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
188 read2_fail, H_EXTERNAL);
189
190 spi_flash_free(env_flash);
191out:
192 free(tmp_env1);
193 free(tmp_env2);
194
195 return ret;
196}
197#else
198static int env_sf_save(void)
199{
200 u32 saved_size = 0, saved_offset = 0, sector;
201 u32 sect_size = CONFIG_ENV_SECT_SIZE;
202 char *saved_buffer = NULL;
203 int ret = 1;
204 env_t env_new;
205 struct spi_flash *env_flash;
206
207 ret = setup_flash_device(&env_flash);
208 if (ret)
209 return ret;
210
211 if (IS_ENABLED(CONFIG_ENV_SECT_SIZE_AUTO))
212 sect_size = env_flash->mtd.erasesize;
213
214
215 if (sect_size > CONFIG_ENV_SIZE) {
216 saved_size = sect_size - CONFIG_ENV_SIZE;
217 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
218 saved_buffer = malloc(saved_size);
219 if (!saved_buffer)
220 goto done;
221
222 ret = spi_flash_read(env_flash, saved_offset,
223 saved_size, saved_buffer);
224 if (ret)
225 goto done;
226 }
227
228 ret = env_export(&env_new);
229 if (ret)
230 goto done;
231
232 sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, sect_size);
233
234 puts("Erasing SPI flash...");
235 ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
236 sector * sect_size);
237 if (ret)
238 goto done;
239
240 puts("Writing to SPI flash...");
241 ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
242 CONFIG_ENV_SIZE, &env_new);
243 if (ret)
244 goto done;
245
246 if (sect_size > CONFIG_ENV_SIZE) {
247 ret = spi_flash_write(env_flash, saved_offset,
248 saved_size, saved_buffer);
249 if (ret)
250 goto done;
251 }
252
253 ret = 0;
254 puts("done\n");
255
256done:
257 spi_flash_free(env_flash);
258
259 if (saved_buffer)
260 free(saved_buffer);
261
262 return ret;
263}
264
265static int env_sf_load(void)
266{
267 int ret;
268 char *buf = NULL;
269 struct spi_flash *env_flash;
270
271 buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
272 if (!buf) {
273 env_set_default("malloc() failed", 0);
274 return -EIO;
275 }
276
277 ret = setup_flash_device(&env_flash);
278 if (ret)
279 goto out;
280
281 ret = spi_flash_read(env_flash,
282 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
283 if (ret) {
284 env_set_default("spi_flash_read() failed", 0);
285 goto err_read;
286 }
287
288 ret = env_import(buf, 1, H_EXTERNAL);
289 if (!ret)
290 gd->env_valid = ENV_VALID;
291
292err_read:
293 spi_flash_free(env_flash);
294out:
295 free(buf);
296
297 return ret;
298}
299#endif
300
301static int env_sf_erase(void)
302{
303 int ret;
304 env_t env;
305 struct spi_flash *env_flash;
306
307 ret = setup_flash_device(&env_flash);
308 if (ret)
309 return ret;
310
311 memset(&env, 0, sizeof(env_t));
312 ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, &env);
313 if (ret)
314 goto done;
315
316 if (ENV_OFFSET_REDUND != OFFSET_INVALID)
317 ret = spi_flash_write(env_flash, ENV_OFFSET_REDUND, CONFIG_ENV_SIZE, &env);
318
319done:
320 spi_flash_free(env_flash);
321
322 return ret;
323}
324
325#if CONFIG_ENV_ADDR != 0x0
326__weak void *env_sf_get_env_addr(void)
327{
328 return (void *)CONFIG_ENV_ADDR;
329}
330#endif
331
332#if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
333
334
335
336static int env_sf_init_addr(void)
337{
338 env_t *env_ptr = (env_t *)env_sf_get_env_addr();
339
340 if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
341 gd->env_addr = (ulong)&(env_ptr->data);
342 gd->env_valid = ENV_VALID;
343 } else {
344 gd->env_valid = ENV_INVALID;
345 }
346
347 return 0;
348}
349#endif
350
351#if defined(CONFIG_ENV_SPI_EARLY)
352
353
354
355
356static int env_sf_init_early(void)
357{
358 int ret;
359 int read1_fail;
360 int read2_fail;
361 int crc1_ok;
362 env_t *tmp_env2 = NULL;
363 env_t *tmp_env1;
364 struct spi_flash *env_flash;
365
366
367
368
369
370 if (!gd->malloc_limit)
371 return -ENOENT;
372
373 tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
374 CONFIG_ENV_SIZE);
375 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
376 tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
377 CONFIG_ENV_SIZE);
378
379 if (!tmp_env1 || !tmp_env2)
380 goto out;
381
382 ret = setup_flash_device(&env_flash);
383 if (ret)
384 goto out;
385
386 read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
387 CONFIG_ENV_SIZE, tmp_env1);
388
389 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
390 read2_fail = spi_flash_read(env_flash,
391 CONFIG_ENV_OFFSET_REDUND,
392 CONFIG_ENV_SIZE, tmp_env2);
393 ret = env_check_redund((char *)tmp_env1, read1_fail,
394 (char *)tmp_env2, read2_fail);
395
396 if (ret < 0)
397 goto err_read;
398
399 if (gd->env_valid == ENV_VALID)
400 gd->env_addr = (unsigned long)&tmp_env1->data;
401 else
402 gd->env_addr = (unsigned long)&tmp_env2->data;
403 } else {
404 if (read1_fail)
405 goto err_read;
406
407 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
408 tmp_env1->crc;
409 if (!crc1_ok)
410 goto err_read;
411
412
413 gd->env_valid = ENV_VALID;
414 gd->env_addr = (unsigned long)&tmp_env1->data;
415 }
416
417 spi_flash_free(env_flash);
418
419 return 0;
420err_read:
421 spi_flash_free(env_flash);
422
423 free(tmp_env1);
424 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
425 free(tmp_env2);
426out:
427
428 gd->env_valid = ENV_INVALID;
429 return 0;
430}
431#endif
432
433static int env_sf_init(void)
434{
435#if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
436 return env_sf_init_addr();
437#elif defined(CONFIG_ENV_SPI_EARLY)
438 return env_sf_init_early();
439#endif
440
441
442
443
444
445
446 return -ENOENT;
447}
448
449U_BOOT_ENV_LOCATION(sf) = {
450 .location = ENVL_SPI_FLASH,
451 ENV_NAME("SPIFlash")
452 .load = env_sf_load,
453 .save = ENV_SAVE_PTR(env_sf_save),
454 .erase = ENV_ERASE_PTR(env_sf_erase),
455 .init = env_sf_init,
456};
457
