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