]>
Commit | Line | Data |
---|---|---|
13a5695b | 1 | /* |
ea882baf WD |
2 | * (C) Copyright 2000-2010 |
3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
4 | * | |
cc49cade SW |
5 | * (C) Copyright 2008 |
6 | * Stuart Wood, Lab X Technologies <stuart.wood@labxtechnologies.com> | |
7 | * | |
13a5695b WD |
8 | * (C) Copyright 2004 |
9 | * Jian Zhang, Texas Instruments, jzhang@ti.com. | |
13a5695b WD |
10 | * |
11 | * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com> | |
12 | * Andreas Heppel <aheppel@sysgo.de> | |
ea882baf | 13 | * |
3765b3e7 | 14 | * SPDX-License-Identifier: GPL-2.0+ |
13a5695b WD |
15 | */ |
16 | ||
13a5695b | 17 | #include <common.h> |
13a5695b WD |
18 | #include <command.h> |
19 | #include <environment.h> | |
20 | #include <linux/stddef.h> | |
e443c944 | 21 | #include <malloc.h> |
cf92e05c | 22 | #include <memalign.h> |
addb2e16 | 23 | #include <nand.h> |
ea882baf WD |
24 | #include <search.h> |
25 | #include <errno.h> | |
13a5695b | 26 | |
bdab39d3 | 27 | #if defined(CONFIG_CMD_SAVEENV) && defined(CONFIG_CMD_NAND) |
13a5695b | 28 | #define CMD_SAVEENV |
0e8d1586 | 29 | #elif defined(CONFIG_ENV_OFFSET_REDUND) |
de152b9b | 30 | #error CONFIG_ENV_OFFSET_REDUND must have CONFIG_CMD_SAVEENV & CONFIG_CMD_NAND |
13a5695b WD |
31 | #endif |
32 | ||
de152b9b IG |
33 | #if defined(CONFIG_ENV_SIZE_REDUND) && \ |
34 | (CONFIG_ENV_SIZE_REDUND != CONFIG_ENV_SIZE) | |
0e8d1586 | 35 | #error CONFIG_ENV_SIZE_REDUND should be the same as CONFIG_ENV_SIZE |
13a5695b WD |
36 | #endif |
37 | ||
0e8d1586 JCPV |
38 | #ifndef CONFIG_ENV_RANGE |
39 | #define CONFIG_ENV_RANGE CONFIG_ENV_SIZE | |
cc49cade SW |
40 | #endif |
41 | ||
ea882baf | 42 | char *env_name_spec = "NAND"; |
13a5695b | 43 | |
b74ab737 | 44 | #if defined(ENV_IS_EMBEDDED) |
994bc671 | 45 | env_t *env_ptr = &environment; |
b74ab737 GL |
46 | #elif defined(CONFIG_NAND_ENV_DST) |
47 | env_t *env_ptr = (env_t *)CONFIG_NAND_ENV_DST; | |
13a5695b | 48 | #else /* ! ENV_IS_EMBEDDED */ |
de152b9b | 49 | env_t *env_ptr; |
13a5695b WD |
50 | #endif /* ENV_IS_EMBEDDED */ |
51 | ||
d87080b7 | 52 | DECLARE_GLOBAL_DATA_PTR; |
13a5695b | 53 | |
ea882baf WD |
54 | /* |
55 | * This is called before nand_init() so we can't read NAND to | |
56 | * validate env data. | |
57 | * | |
58 | * Mark it OK for now. env_relocate() in env_common.c will call our | |
59 | * relocate function which does the real validation. | |
d12ae808 SR |
60 | * |
61 | * When using a NAND boot image (like sequoia_nand), the environment | |
ea882baf WD |
62 | * can be embedded or attached to the U-Boot image in NAND flash. |
63 | * This way the SPL loads not only the U-Boot image from NAND but | |
64 | * also the environment. | |
13a5695b WD |
65 | */ |
66 | int env_init(void) | |
67 | { | |
b74ab737 | 68 | #if defined(ENV_IS_EMBEDDED) || defined(CONFIG_NAND_ENV_DST) |
d12ae808 | 69 | int crc1_ok = 0, crc2_ok = 0; |
b74ab737 GL |
70 | env_t *tmp_env1; |
71 | ||
72 | #ifdef CONFIG_ENV_OFFSET_REDUND | |
73 | env_t *tmp_env2; | |
d12ae808 | 74 | |
0e8d1586 | 75 | tmp_env2 = (env_t *)((ulong)env_ptr + CONFIG_ENV_SIZE); |
de152b9b | 76 | crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc; |
b74ab737 | 77 | #endif |
b74ab737 | 78 | tmp_env1 = env_ptr; |
de152b9b | 79 | crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc; |
d12ae808 | 80 | |
b74ab737 | 81 | if (!crc1_ok && !crc2_ok) { |
de152b9b IG |
82 | gd->env_addr = 0; |
83 | gd->env_valid = 0; | |
b74ab737 GL |
84 | |
85 | return 0; | |
86 | } else if (crc1_ok && !crc2_ok) { | |
d12ae808 | 87 | gd->env_valid = 1; |
b74ab737 GL |
88 | } |
89 | #ifdef CONFIG_ENV_OFFSET_REDUND | |
90 | else if (!crc1_ok && crc2_ok) { | |
d12ae808 | 91 | gd->env_valid = 2; |
b74ab737 | 92 | } else { |
d12ae808 | 93 | /* both ok - check serial */ |
de152b9b | 94 | if (tmp_env1->flags == 255 && tmp_env2->flags == 0) |
d12ae808 | 95 | gd->env_valid = 2; |
de152b9b | 96 | else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) |
d12ae808 | 97 | gd->env_valid = 1; |
de152b9b | 98 | else if (tmp_env1->flags > tmp_env2->flags) |
d12ae808 | 99 | gd->env_valid = 1; |
de152b9b | 100 | else if (tmp_env2->flags > tmp_env1->flags) |
d12ae808 SR |
101 | gd->env_valid = 2; |
102 | else /* flags are equal - almost impossible */ | |
103 | gd->env_valid = 1; | |
104 | } | |
105 | ||
b74ab737 GL |
106 | if (gd->env_valid == 2) |
107 | env_ptr = tmp_env2; | |
108 | else | |
109 | #endif | |
d12ae808 SR |
110 | if (gd->env_valid == 1) |
111 | env_ptr = tmp_env1; | |
b74ab737 GL |
112 | |
113 | gd->env_addr = (ulong)env_ptr->data; | |
114 | ||
115 | #else /* ENV_IS_EMBEDDED || CONFIG_NAND_ENV_DST */ | |
de152b9b IG |
116 | gd->env_addr = (ulong)&default_environment[0]; |
117 | gd->env_valid = 1; | |
b74ab737 | 118 | #endif /* ENV_IS_EMBEDDED || CONFIG_NAND_ENV_DST */ |
13a5695b | 119 | |
de152b9b | 120 | return 0; |
13a5695b WD |
121 | } |
122 | ||
123 | #ifdef CMD_SAVEENV | |
addb2e16 BS |
124 | /* |
125 | * The legacy NAND code saved the environment in the first NAND device i.e., | |
126 | * nand_dev_desc + 0. This is also the behaviour using the new NAND code. | |
127 | */ | |
45f08d35 | 128 | static int writeenv(size_t offset, u_char *buf) |
cc49cade | 129 | { |
0e8d1586 | 130 | size_t end = offset + CONFIG_ENV_RANGE; |
cc49cade | 131 | size_t amount_saved = 0; |
c3db8c64 | 132 | size_t blocksize, len; |
a94a2619 | 133 | struct mtd_info *mtd; |
cc49cade SW |
134 | u_char *char_ptr; |
135 | ||
a94a2619 GS |
136 | mtd = get_nand_dev_by_index(0); |
137 | if (!mtd) | |
138 | return 1; | |
139 | ||
140 | blocksize = mtd->erasesize; | |
b4141195 | 141 | len = min(blocksize, (size_t)CONFIG_ENV_SIZE); |
cc49cade | 142 | |
0e8d1586 | 143 | while (amount_saved < CONFIG_ENV_SIZE && offset < end) { |
a94a2619 | 144 | if (nand_block_isbad(mtd, offset)) { |
cc49cade SW |
145 | offset += blocksize; |
146 | } else { | |
147 | char_ptr = &buf[amount_saved]; | |
a94a2619 | 148 | if (nand_write(mtd, offset, &len, char_ptr)) |
cc49cade | 149 | return 1; |
de152b9b | 150 | |
cc49cade | 151 | offset += blocksize; |
c3db8c64 | 152 | amount_saved += len; |
cc49cade SW |
153 | } |
154 | } | |
0e8d1586 | 155 | if (amount_saved != CONFIG_ENV_SIZE) |
cc49cade SW |
156 | return 1; |
157 | ||
158 | return 0; | |
159 | } | |
eef1d719 | 160 | |
2b26201a PS |
161 | struct env_location { |
162 | const char *name; | |
163 | const nand_erase_options_t erase_opts; | |
164 | }; | |
eef1d719 | 165 | |
2b26201a PS |
166 | static int erase_and_write_env(const struct env_location *location, |
167 | u_char *env_new) | |
13a5695b | 168 | { |
a94a2619 | 169 | struct mtd_info *mtd; |
2b26201a | 170 | int ret = 0; |
cc49cade | 171 | |
a94a2619 GS |
172 | mtd = get_nand_dev_by_index(0); |
173 | if (!mtd) | |
4cc9699b TR |
174 | return 1; |
175 | ||
2b26201a | 176 | printf("Erasing %s...\n", location->name); |
a94a2619 | 177 | if (nand_erase_opts(mtd, &location->erase_opts)) |
cc49cade | 178 | return 1; |
ea882baf | 179 | |
2b26201a PS |
180 | printf("Writing to %s... ", location->name); |
181 | ret = writeenv(location->erase_opts.offset, env_new); | |
182 | puts(ret ? "FAILED!\n" : "OK\n"); | |
ea882baf | 183 | |
e443c944 MK |
184 | return ret; |
185 | } | |
2b26201a PS |
186 | |
187 | #ifdef CONFIG_ENV_OFFSET_REDUND | |
188 | static unsigned char env_flags; | |
189 | #endif | |
190 | ||
e443c944 MK |
191 | int saveenv(void) |
192 | { | |
de152b9b | 193 | int ret = 0; |
cd0f4fa1 | 194 | ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); |
2b26201a PS |
195 | int env_idx = 0; |
196 | static const struct env_location location[] = { | |
197 | { | |
198 | .name = "NAND", | |
199 | .erase_opts = { | |
200 | .length = CONFIG_ENV_RANGE, | |
201 | .offset = CONFIG_ENV_OFFSET, | |
202 | }, | |
203 | }, | |
204 | #ifdef CONFIG_ENV_OFFSET_REDUND | |
205 | { | |
206 | .name = "redundant NAND", | |
207 | .erase_opts = { | |
208 | .length = CONFIG_ENV_RANGE, | |
209 | .offset = CONFIG_ENV_OFFSET_REDUND, | |
210 | }, | |
211 | }, | |
212 | #endif | |
213 | }; | |
e093a247 | 214 | |
cc49cade | 215 | |
0e8d1586 | 216 | if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE) |
cc49cade | 217 | return 1; |
ea882baf | 218 | |
7ce1526e MV |
219 | ret = env_export(env_new); |
220 | if (ret) | |
221 | return ret; | |
222 | ||
2b26201a PS |
223 | #ifdef CONFIG_ENV_OFFSET_REDUND |
224 | env_new->flags = ++env_flags; /* increase the serial */ | |
225 | env_idx = (gd->env_valid == 1); | |
226 | #endif | |
13a5695b | 227 | |
2b26201a PS |
228 | ret = erase_and_write_env(&location[env_idx], (u_char *)env_new); |
229 | #ifdef CONFIG_ENV_OFFSET_REDUND | |
230 | if (!ret) { | |
231 | /* preset other copy for next write */ | |
232 | gd->env_valid = gd->env_valid == 2 ? 1 : 2; | |
233 | return ret; | |
cc49cade | 234 | } |
13a5695b | 235 | |
2b26201a PS |
236 | env_idx = (env_idx + 1) & 1; |
237 | ret = erase_and_write_env(&location[env_idx], (u_char *)env_new); | |
238 | if (!ret) | |
239 | printf("Warning: primary env write failed," | |
240 | " redundancy is lost!\n"); | |
241 | #endif | |
242 | ||
addb2e16 | 243 | return ret; |
13a5695b WD |
244 | } |
245 | #endif /* CMD_SAVEENV */ | |
246 | ||
9e205602 TH |
247 | #if defined(CONFIG_SPL_BUILD) |
248 | static int readenv(size_t offset, u_char *buf) | |
249 | { | |
250 | return nand_spl_load_image(offset, CONFIG_ENV_SIZE, buf); | |
251 | } | |
252 | #else | |
45f08d35 | 253 | static int readenv(size_t offset, u_char *buf) |
cc49cade | 254 | { |
0e8d1586 | 255 | size_t end = offset + CONFIG_ENV_RANGE; |
cc49cade | 256 | size_t amount_loaded = 0; |
c3db8c64 | 257 | size_t blocksize, len; |
a94a2619 | 258 | struct mtd_info *mtd; |
cc49cade SW |
259 | u_char *char_ptr; |
260 | ||
a94a2619 GS |
261 | mtd = get_nand_dev_by_index(0); |
262 | if (!mtd) | |
962ad59e | 263 | return 1; |
de152b9b | 264 | |
a94a2619 | 265 | blocksize = mtd->erasesize; |
b4141195 | 266 | len = min(blocksize, (size_t)CONFIG_ENV_SIZE); |
cc49cade | 267 | |
0e8d1586 | 268 | while (amount_loaded < CONFIG_ENV_SIZE && offset < end) { |
a94a2619 | 269 | if (nand_block_isbad(mtd, offset)) { |
cc49cade SW |
270 | offset += blocksize; |
271 | } else { | |
272 | char_ptr = &buf[amount_loaded]; | |
a94a2619 | 273 | if (nand_read_skip_bad(mtd, offset, |
c39d6a0e | 274 | &len, NULL, |
a94a2619 | 275 | mtd->size, char_ptr)) |
cc49cade | 276 | return 1; |
de152b9b | 277 | |
cc49cade | 278 | offset += blocksize; |
c3db8c64 | 279 | amount_loaded += len; |
cc49cade SW |
280 | } |
281 | } | |
de152b9b | 282 | |
0e8d1586 | 283 | if (amount_loaded != CONFIG_ENV_SIZE) |
cc49cade SW |
284 | return 1; |
285 | ||
286 | return 0; | |
287 | } | |
9e205602 | 288 | #endif /* #if defined(CONFIG_SPL_BUILD) */ |
cc49cade | 289 | |
c9f7351b | 290 | #ifdef CONFIG_ENV_OFFSET_OOB |
151c06ec | 291 | int get_nand_env_oob(struct mtd_info *mtd, unsigned long *result) |
c9f7351b BG |
292 | { |
293 | struct mtd_oob_ops ops; | |
de152b9b | 294 | uint32_t oob_buf[ENV_OFFSET_SIZE / sizeof(uint32_t)]; |
c9f7351b BG |
295 | int ret; |
296 | ||
de152b9b IG |
297 | ops.datbuf = NULL; |
298 | ops.mode = MTD_OOB_AUTO; | |
299 | ops.ooboffs = 0; | |
300 | ops.ooblen = ENV_OFFSET_SIZE; | |
301 | ops.oobbuf = (void *)oob_buf; | |
c9f7351b | 302 | |
151c06ec | 303 | ret = mtd->read_oob(mtd, ENV_OFFSET_SIZE, &ops); |
53504a27 SW |
304 | if (ret) { |
305 | printf("error reading OOB block 0\n"); | |
306 | return ret; | |
307 | } | |
c9f7351b | 308 | |
53504a27 | 309 | if (oob_buf[0] == ENV_OOB_MARKER) { |
151c06ec | 310 | *result = oob_buf[1] * mtd->erasesize; |
53504a27 SW |
311 | } else if (oob_buf[0] == ENV_OOB_MARKER_OLD) { |
312 | *result = oob_buf[1]; | |
c9f7351b | 313 | } else { |
53504a27 SW |
314 | printf("No dynamic environment marker in OOB block 0\n"); |
315 | return -ENOENT; | |
c9f7351b | 316 | } |
53504a27 SW |
317 | |
318 | return 0; | |
c9f7351b BG |
319 | } |
320 | #endif | |
321 | ||
0e8d1586 | 322 | #ifdef CONFIG_ENV_OFFSET_REDUND |
ea882baf | 323 | void env_relocate_spec(void) |
e443c944 MK |
324 | { |
325 | #if !defined(ENV_IS_EMBEDDED) | |
b76a147b | 326 | int read1_fail = 0, read2_fail = 0; |
2770bcb2 | 327 | int crc1_ok = 0, crc2_ok = 0; |
ea882baf | 328 | env_t *ep, *tmp_env1, *tmp_env2; |
e443c944 | 329 | |
ea882baf WD |
330 | tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE); |
331 | tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE); | |
de152b9b | 332 | if (tmp_env1 == NULL || tmp_env2 == NULL) { |
15b86c3d | 333 | puts("Can't allocate buffers for environment\n"); |
ea882baf | 334 | set_default_env("!malloc() failed"); |
de152b9b | 335 | goto done; |
15b86c3d WD |
336 | } |
337 | ||
b76a147b PS |
338 | read1_fail = readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1); |
339 | read2_fail = readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2); | |
ea882baf | 340 | |
b76a147b PS |
341 | if (read1_fail && read2_fail) |
342 | puts("*** Error - No Valid Environment Area found\n"); | |
343 | else if (read1_fail || read2_fail) | |
344 | puts("*** Warning - some problems detected " | |
345 | "reading environment; recovered successfully\n"); | |
e443c944 | 346 | |
a1eac57a PS |
347 | crc1_ok = !read1_fail && |
348 | (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc); | |
349 | crc2_ok = !read2_fail && | |
350 | (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc); | |
e443c944 | 351 | |
ea882baf | 352 | if (!crc1_ok && !crc2_ok) { |
ea882baf | 353 | set_default_env("!bad CRC"); |
de152b9b | 354 | goto done; |
ea882baf | 355 | } else if (crc1_ok && !crc2_ok) { |
e443c944 | 356 | gd->env_valid = 1; |
ea882baf | 357 | } else if (!crc1_ok && crc2_ok) { |
e443c944 | 358 | gd->env_valid = 2; |
ea882baf | 359 | } else { |
e443c944 | 360 | /* both ok - check serial */ |
ea882baf | 361 | if (tmp_env1->flags == 255 && tmp_env2->flags == 0) |
e443c944 | 362 | gd->env_valid = 2; |
ea882baf | 363 | else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) |
e443c944 | 364 | gd->env_valid = 1; |
ea882baf | 365 | else if (tmp_env1->flags > tmp_env2->flags) |
e443c944 | 366 | gd->env_valid = 1; |
ea882baf | 367 | else if (tmp_env2->flags > tmp_env1->flags) |
e443c944 MK |
368 | gd->env_valid = 2; |
369 | else /* flags are equal - almost impossible */ | |
370 | gd->env_valid = 1; | |
e443c944 MK |
371 | } |
372 | ||
373 | free(env_ptr); | |
ea882baf WD |
374 | |
375 | if (gd->env_valid == 1) | |
376 | ep = tmp_env1; | |
377 | else | |
378 | ep = tmp_env2; | |
379 | ||
eef1d719 | 380 | env_flags = ep->flags; |
ea882baf WD |
381 | env_import((char *)ep, 0); |
382 | ||
de152b9b | 383 | done: |
ea882baf WD |
384 | free(tmp_env1); |
385 | free(tmp_env2); | |
e443c944 MK |
386 | |
387 | #endif /* ! ENV_IS_EMBEDDED */ | |
388 | } | |
0e8d1586 | 389 | #else /* ! CONFIG_ENV_OFFSET_REDUND */ |
addb2e16 | 390 | /* |
ea882baf WD |
391 | * The legacy NAND code saved the environment in the first NAND |
392 | * device i.e., nand_dev_desc + 0. This is also the behaviour using | |
393 | * the new NAND code. | |
addb2e16 | 394 | */ |
de152b9b | 395 | void env_relocate_spec(void) |
13a5695b WD |
396 | { |
397 | #if !defined(ENV_IS_EMBEDDED) | |
d52fb7e3 | 398 | int ret; |
cd0f4fa1 | 399 | ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); |
13a5695b | 400 | |
c9f7351b | 401 | #if defined(CONFIG_ENV_OFFSET_OOB) |
a94a2619 | 402 | struct mtd_info *mtd = get_nand_dev_by_index(0); |
ea882baf WD |
403 | /* |
404 | * If unable to read environment offset from NAND OOB then fall through | |
c9f7351b BG |
405 | * to the normal environment reading code below |
406 | */ | |
a94a2619 | 407 | if (mtd && !get_nand_env_oob(mtd, &nand_env_oob_offset)) { |
c9f7351b | 408 | printf("Found Environment offset in OOB..\n"); |
ea882baf WD |
409 | } else { |
410 | set_default_env("!no env offset in OOB"); | |
411 | return; | |
412 | } | |
c9f7351b BG |
413 | #endif |
414 | ||
cd0f4fa1 | 415 | ret = readenv(CONFIG_ENV_OFFSET, (u_char *)buf); |
ea882baf WD |
416 | if (ret) { |
417 | set_default_env("!readenv() failed"); | |
418 | return; | |
419 | } | |
13a5695b | 420 | |
cd0f4fa1 | 421 | env_import(buf, 1); |
13a5695b | 422 | #endif /* ! ENV_IS_EMBEDDED */ |
13a5695b | 423 | } |
0e8d1586 | 424 | #endif /* CONFIG_ENV_OFFSET_REDUND */ |