blob: 0d7ee19bc23240698703b93254e509b0b0d6689b [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenk13a56952004-06-09 14:58:14 +00002/*
Wolfgang Denkea882ba2010-06-20 23:33:59 +02003 * (C) Copyright 2000-2010
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 *
Stuart Woodcc49cad2008-05-30 16:05:28 -04006 * (C) Copyright 2008
7 * Stuart Wood, Lab X Technologies <stuart.wood@labxtechnologies.com>
8 *
wdenk13a56952004-06-09 14:58:14 +00009 * (C) Copyright 2004
10 * Jian Zhang, Texas Instruments, jzhang@ti.com.
wdenk13a56952004-06-09 14:58:14 +000011 *
12 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
13 * Andreas Heppel <aheppel@sysgo.de>
wdenk13a56952004-06-09 14:58:14 +000014 */
15
wdenk13a56952004-06-09 14:58:14 +000016#include <common.h>
wdenk13a56952004-06-09 14:58:14 +000017#include <command.h>
Simon Glass0ac7d722019-08-01 09:47:00 -060018#include <env.h>
Simon Glassf3998fd2019-08-02 09:44:25 -060019#include <env_internal.h>
wdenk13a56952004-06-09 14:58:14 +000020#include <linux/stddef.h>
Markus Klotzbuechere443c942006-03-20 18:02:44 +010021#include <malloc.h>
Simon Glasscf92e052015-09-02 17:24:58 -060022#include <memalign.h>
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +010023#include <nand.h>
Wolfgang Denkea882ba2010-06-20 23:33:59 +020024#include <search.h>
25#include <errno.h>
Simon Glass3db71102019-11-14 12:57:16 -070026#include <u-boot/crc.h>
wdenk13a56952004-06-09 14:58:14 +000027
Simon Glass4415f1d2017-08-03 12:21:58 -060028#if defined(CONFIG_CMD_SAVEENV) && defined(CONFIG_CMD_NAND) && \
29 !defined(CONFIG_SPL_BUILD)
wdenk13a56952004-06-09 14:58:14 +000030#define CMD_SAVEENV
Martyn Welchf2fae512019-02-25 15:32:59 +000031#elif defined(CONFIG_ENV_OFFSET_REDUND) && !defined(CONFIG_SPL_BUILD)
Igor Grinbergde152b92011-11-07 01:14:10 +000032#error CONFIG_ENV_OFFSET_REDUND must have CONFIG_CMD_SAVEENV & CONFIG_CMD_NAND
wdenk13a56952004-06-09 14:58:14 +000033#endif
34
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +020035#ifndef CONFIG_ENV_RANGE
36#define CONFIG_ENV_RANGE CONFIG_ENV_SIZE
Stuart Woodcc49cad2008-05-30 16:05:28 -040037#endif
38
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020039#if defined(ENV_IS_EMBEDDED)
Rajesh Bhagatb6cba292018-11-05 18:01:10 +000040static env_t *env_ptr = &environment;
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020041#elif defined(CONFIG_NAND_ENV_DST)
Rajesh Bhagatb6cba292018-11-05 18:01:10 +000042static env_t *env_ptr = (env_t *)CONFIG_NAND_ENV_DST;
wdenk13a56952004-06-09 14:58:14 +000043#endif /* ENV_IS_EMBEDDED */
44
Wolfgang Denkd87080b2006-03-31 18:32:53 +020045DECLARE_GLOBAL_DATA_PTR;
wdenk13a56952004-06-09 14:58:14 +000046
Wolfgang Denkea882ba2010-06-20 23:33:59 +020047/*
48 * This is called before nand_init() so we can't read NAND to
49 * validate env data.
50 *
51 * Mark it OK for now. env_relocate() in env_common.c will call our
52 * relocate function which does the real validation.
Stefan Roesed12ae802006-09-12 20:19:10 +020053 *
54 * When using a NAND boot image (like sequoia_nand), the environment
Wolfgang Denkea882ba2010-06-20 23:33:59 +020055 * can be embedded or attached to the U-Boot image in NAND flash.
56 * This way the SPL loads not only the U-Boot image from NAND but
57 * also the environment.
wdenk13a56952004-06-09 14:58:14 +000058 */
Simon Glasse5bce242017-08-03 12:22:01 -060059static int env_nand_init(void)
wdenk13a56952004-06-09 14:58:14 +000060{
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020061#if defined(ENV_IS_EMBEDDED) || defined(CONFIG_NAND_ENV_DST)
Stefan Roesed12ae802006-09-12 20:19:10 +020062 int crc1_ok = 0, crc2_ok = 0;
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020063 env_t *tmp_env1;
64
65#ifdef CONFIG_ENV_OFFSET_REDUND
66 env_t *tmp_env2;
67
68 tmp_env2 = (env_t *)((ulong)env_ptr + CONFIG_ENV_SIZE);
Igor Grinbergde152b92011-11-07 01:14:10 +000069 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc;
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020070#endif
Stefan Roesed12ae802006-09-12 20:19:10 +020071 tmp_env1 = env_ptr;
Igor Grinbergde152b92011-11-07 01:14:10 +000072 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc;
Stefan Roesed12ae802006-09-12 20:19:10 +020073
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020074 if (!crc1_ok && !crc2_ok) {
Igor Grinbergde152b92011-11-07 01:14:10 +000075 gd->env_addr = 0;
Simon Glass2d7cb5b2017-08-20 04:45:15 -060076 gd->env_valid = ENV_INVALID;
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020077
78 return 0;
79 } else if (crc1_ok && !crc2_ok) {
Simon Glass203e94f2017-08-03 12:21:56 -060080 gd->env_valid = ENV_VALID;
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020081 }
82#ifdef CONFIG_ENV_OFFSET_REDUND
83 else if (!crc1_ok && crc2_ok) {
Simon Glass203e94f2017-08-03 12:21:56 -060084 gd->env_valid = ENV_REDUND;
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +020085 } else {
Stefan Roesed12ae802006-09-12 20:19:10 +020086 /* both ok - check serial */
Igor Grinbergde152b92011-11-07 01:14:10 +000087 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
Simon Glass203e94f2017-08-03 12:21:56 -060088 gd->env_valid = ENV_REDUND;
Igor Grinbergde152b92011-11-07 01:14:10 +000089 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
Simon Glass203e94f2017-08-03 12:21:56 -060090 gd->env_valid = ENV_VALID;
Igor Grinbergde152b92011-11-07 01:14:10 +000091 else if (tmp_env1->flags > tmp_env2->flags)
Simon Glass203e94f2017-08-03 12:21:56 -060092 gd->env_valid = ENV_VALID;
Igor Grinbergde152b92011-11-07 01:14:10 +000093 else if (tmp_env2->flags > tmp_env1->flags)
Simon Glass203e94f2017-08-03 12:21:56 -060094 gd->env_valid = ENV_REDUND;
Stefan Roesed12ae802006-09-12 20:19:10 +020095 else /* flags are equal - almost impossible */
Simon Glass203e94f2017-08-03 12:21:56 -060096 gd->env_valid = ENV_VALID;
Stefan Roesed12ae802006-09-12 20:19:10 +020097 }
98
Simon Glass203e94f2017-08-03 12:21:56 -060099 if (gd->env_valid == ENV_REDUND)
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +0200100 env_ptr = tmp_env2;
101 else
102#endif
Simon Glass203e94f2017-08-03 12:21:56 -0600103 if (gd->env_valid == ENV_VALID)
Stefan Roesed12ae802006-09-12 20:19:10 +0200104 env_ptr = tmp_env1;
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +0200105
106 gd->env_addr = (ulong)env_ptr->data;
107
108#else /* ENV_IS_EMBEDDED || CONFIG_NAND_ENV_DST */
Igor Grinbergde152b92011-11-07 01:14:10 +0000109 gd->env_addr = (ulong)&default_environment[0];
Simon Glass203e94f2017-08-03 12:21:56 -0600110 gd->env_valid = ENV_VALID;
Guennadi Liakhovetskib74ab732009-05-18 16:07:22 +0200111#endif /* ENV_IS_EMBEDDED || CONFIG_NAND_ENV_DST */
wdenk13a56952004-06-09 14:58:14 +0000112
Igor Grinbergde152b92011-11-07 01:14:10 +0000113 return 0;
wdenk13a56952004-06-09 14:58:14 +0000114}
115
116#ifdef CMD_SAVEENV
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100117/*
118 * The legacy NAND code saved the environment in the first NAND device i.e.,
119 * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
120 */
Jeroen Hofstee45f08d32014-10-08 22:57:35 +0200121static int writeenv(size_t offset, u_char *buf)
Stuart Woodcc49cad2008-05-30 16:05:28 -0400122{
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200123 size_t end = offset + CONFIG_ENV_RANGE;
Stuart Woodcc49cad2008-05-30 16:05:28 -0400124 size_t amount_saved = 0;
Guennadi Liakhovetskic3db8c62008-07-31 12:38:26 +0200125 size_t blocksize, len;
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500126 struct mtd_info *mtd;
Stuart Woodcc49cad2008-05-30 16:05:28 -0400127 u_char *char_ptr;
128
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500129 mtd = get_nand_dev_by_index(0);
130 if (!mtd)
131 return 1;
132
133 blocksize = mtd->erasesize;
Masahiro Yamadab4141192014-11-07 03:03:31 +0900134 len = min(blocksize, (size_t)CONFIG_ENV_SIZE);
Stuart Woodcc49cad2008-05-30 16:05:28 -0400135
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200136 while (amount_saved < CONFIG_ENV_SIZE && offset < end) {
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500137 if (nand_block_isbad(mtd, offset)) {
Stuart Woodcc49cad2008-05-30 16:05:28 -0400138 offset += blocksize;
139 } else {
140 char_ptr = &buf[amount_saved];
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500141 if (nand_write(mtd, offset, &len, char_ptr))
Stuart Woodcc49cad2008-05-30 16:05:28 -0400142 return 1;
Igor Grinbergde152b92011-11-07 01:14:10 +0000143
Stuart Woodcc49cad2008-05-30 16:05:28 -0400144 offset += blocksize;
Guennadi Liakhovetskic3db8c62008-07-31 12:38:26 +0200145 amount_saved += len;
Stuart Woodcc49cad2008-05-30 16:05:28 -0400146 }
147 }
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200148 if (amount_saved != CONFIG_ENV_SIZE)
Stuart Woodcc49cad2008-05-30 16:05:28 -0400149 return 1;
150
151 return 0;
152}
Scott Woodeef1d712011-02-08 15:25:02 -0600153
Simon Glass42a81802017-08-03 12:21:57 -0600154struct nand_env_location {
Phil Sutter2b262012013-07-19 12:20:26 +0200155 const char *name;
156 const nand_erase_options_t erase_opts;
157};
Scott Woodeef1d712011-02-08 15:25:02 -0600158
Simon Glass42a81802017-08-03 12:21:57 -0600159static int erase_and_write_env(const struct nand_env_location *location,
Phil Sutter2b262012013-07-19 12:20:26 +0200160 u_char *env_new)
wdenk13a56952004-06-09 14:58:14 +0000161{
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500162 struct mtd_info *mtd;
Phil Sutter2b262012013-07-19 12:20:26 +0200163 int ret = 0;
Markus Klotzbuechere443c942006-03-20 18:02:44 +0100164
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500165 mtd = get_nand_dev_by_index(0);
166 if (!mtd)
Tom Rini4cc96992016-08-15 13:02:15 -0400167 return 1;
168
Phil Sutter2b262012013-07-19 12:20:26 +0200169 printf("Erasing %s...\n", location->name);
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500170 if (nand_erase_opts(mtd, &location->erase_opts))
Stuart Woodcc49cad2008-05-30 16:05:28 -0400171 return 1;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200172
Phil Sutter2b262012013-07-19 12:20:26 +0200173 printf("Writing to %s... ", location->name);
174 ret = writeenv(location->erase_opts.offset, env_new);
175 puts(ret ? "FAILED!\n" : "OK\n");
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200176
Markus Klotzbuechere443c942006-03-20 18:02:44 +0100177 return ret;
178}
Phil Sutter2b262012013-07-19 12:20:26 +0200179
Simon Glasse5bce242017-08-03 12:22:01 -0600180static int env_nand_save(void)
Markus Klotzbuechere443c942006-03-20 18:02:44 +0100181{
Igor Grinbergde152b92011-11-07 01:14:10 +0000182 int ret = 0;
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400183 ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
Phil Sutter2b262012013-07-19 12:20:26 +0200184 int env_idx = 0;
Simon Glass42a81802017-08-03 12:21:57 -0600185 static const struct nand_env_location location[] = {
Phil Sutter2b262012013-07-19 12:20:26 +0200186 {
187 .name = "NAND",
188 .erase_opts = {
189 .length = CONFIG_ENV_RANGE,
190 .offset = CONFIG_ENV_OFFSET,
191 },
192 },
193#ifdef CONFIG_ENV_OFFSET_REDUND
194 {
195 .name = "redundant NAND",
196 .erase_opts = {
197 .length = CONFIG_ENV_RANGE,
198 .offset = CONFIG_ENV_OFFSET_REDUND,
199 },
200 },
201#endif
202 };
Wolfgang Denke093a242008-06-28 23:34:37 +0200203
Stuart Woodcc49cad2008-05-30 16:05:28 -0400204
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200205 if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
Stuart Woodcc49cad2008-05-30 16:05:28 -0400206 return 1;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200207
Marek Vasut7ce15262014-03-05 19:59:50 +0100208 ret = env_export(env_new);
209 if (ret)
210 return ret;
211
Phil Sutter2b262012013-07-19 12:20:26 +0200212#ifdef CONFIG_ENV_OFFSET_REDUND
Simon Glass203e94f2017-08-03 12:21:56 -0600213 env_idx = (gd->env_valid == ENV_VALID);
Phil Sutter2b262012013-07-19 12:20:26 +0200214#endif
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200215
Phil Sutter2b262012013-07-19 12:20:26 +0200216 ret = erase_and_write_env(&location[env_idx], (u_char *)env_new);
217#ifdef CONFIG_ENV_OFFSET_REDUND
218 if (!ret) {
219 /* preset other copy for next write */
Simon Glass203e94f2017-08-03 12:21:56 -0600220 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID :
221 ENV_REDUND;
Phil Sutter2b262012013-07-19 12:20:26 +0200222 return ret;
Stuart Woodcc49cad2008-05-30 16:05:28 -0400223 }
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100224
Phil Sutter2b262012013-07-19 12:20:26 +0200225 env_idx = (env_idx + 1) & 1;
226 ret = erase_and_write_env(&location[env_idx], (u_char *)env_new);
227 if (!ret)
228 printf("Warning: primary env write failed,"
229 " redundancy is lost!\n");
230#endif
231
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100232 return ret;
wdenk13a56952004-06-09 14:58:14 +0000233}
234#endif /* CMD_SAVEENV */
235
Tim Harvey9e205602015-05-14 11:48:04 -0700236#if defined(CONFIG_SPL_BUILD)
237static int readenv(size_t offset, u_char *buf)
238{
239 return nand_spl_load_image(offset, CONFIG_ENV_SIZE, buf);
240}
241#else
Jeroen Hofstee45f08d32014-10-08 22:57:35 +0200242static int readenv(size_t offset, u_char *buf)
Stuart Woodcc49cad2008-05-30 16:05:28 -0400243{
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200244 size_t end = offset + CONFIG_ENV_RANGE;
Stuart Woodcc49cad2008-05-30 16:05:28 -0400245 size_t amount_loaded = 0;
Guennadi Liakhovetskic3db8c62008-07-31 12:38:26 +0200246 size_t blocksize, len;
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500247 struct mtd_info *mtd;
Stuart Woodcc49cad2008-05-30 16:05:28 -0400248 u_char *char_ptr;
249
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500250 mtd = get_nand_dev_by_index(0);
251 if (!mtd)
Mike Frysinger962ad592010-08-11 23:42:26 -0400252 return 1;
Igor Grinbergde152b92011-11-07 01:14:10 +0000253
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500254 blocksize = mtd->erasesize;
Masahiro Yamadab4141192014-11-07 03:03:31 +0900255 len = min(blocksize, (size_t)CONFIG_ENV_SIZE);
Stuart Woodcc49cad2008-05-30 16:05:28 -0400256
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200257 while (amount_loaded < CONFIG_ENV_SIZE && offset < end) {
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500258 if (nand_block_isbad(mtd, offset)) {
Stuart Woodcc49cad2008-05-30 16:05:28 -0400259 offset += blocksize;
260 } else {
261 char_ptr = &buf[amount_loaded];
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500262 if (nand_read_skip_bad(mtd, offset,
Tom Rinic39d6a02013-03-14 05:32:50 +0000263 &len, NULL,
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500264 mtd->size, char_ptr))
Stuart Woodcc49cad2008-05-30 16:05:28 -0400265 return 1;
Igor Grinbergde152b92011-11-07 01:14:10 +0000266
Stuart Woodcc49cad2008-05-30 16:05:28 -0400267 offset += blocksize;
Guennadi Liakhovetskic3db8c62008-07-31 12:38:26 +0200268 amount_loaded += len;
Stuart Woodcc49cad2008-05-30 16:05:28 -0400269 }
270 }
Igor Grinbergde152b92011-11-07 01:14:10 +0000271
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200272 if (amount_loaded != CONFIG_ENV_SIZE)
Stuart Woodcc49cad2008-05-30 16:05:28 -0400273 return 1;
274
275 return 0;
276}
Tim Harvey9e205602015-05-14 11:48:04 -0700277#endif /* #if defined(CONFIG_SPL_BUILD) */
Stuart Woodcc49cad2008-05-30 16:05:28 -0400278
Ben Gardinerc9f73512010-07-05 13:27:07 -0400279#ifdef CONFIG_ENV_OFFSET_OOB
Scott Wood151c06e2016-05-30 13:57:54 -0500280int get_nand_env_oob(struct mtd_info *mtd, unsigned long *result)
Ben Gardinerc9f73512010-07-05 13:27:07 -0400281{
282 struct mtd_oob_ops ops;
Igor Grinbergde152b92011-11-07 01:14:10 +0000283 uint32_t oob_buf[ENV_OFFSET_SIZE / sizeof(uint32_t)];
Ben Gardinerc9f73512010-07-05 13:27:07 -0400284 int ret;
285
Igor Grinbergde152b92011-11-07 01:14:10 +0000286 ops.datbuf = NULL;
287 ops.mode = MTD_OOB_AUTO;
288 ops.ooboffs = 0;
289 ops.ooblen = ENV_OFFSET_SIZE;
290 ops.oobbuf = (void *)oob_buf;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400291
Scott Wood151c06e2016-05-30 13:57:54 -0500292 ret = mtd->read_oob(mtd, ENV_OFFSET_SIZE, &ops);
Scott Wood53504a22010-07-12 18:17:40 -0500293 if (ret) {
Ben Gardinerc9f73512010-07-05 13:27:07 -0400294 printf("error reading OOB block 0\n");
Scott Wood53504a22010-07-12 18:17:40 -0500295 return ret;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400296 }
Scott Wood53504a22010-07-12 18:17:40 -0500297
298 if (oob_buf[0] == ENV_OOB_MARKER) {
Simon Glassc5951992017-08-03 12:22:17 -0600299 *result = ovoid ob_buf[1] * mtd->erasesize;
Scott Wood53504a22010-07-12 18:17:40 -0500300 } else if (oob_buf[0] == ENV_OOB_MARKER_OLD) {
301 *result = oob_buf[1];
302 } else {
303 printf("No dynamic environment marker in OOB block 0\n");
304 return -ENOENT;
305 }
306
307 return 0;
Ben Gardinerc9f73512010-07-05 13:27:07 -0400308}
309#endif
310
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200311#ifdef CONFIG_ENV_OFFSET_REDUND
Simon Glassc5951992017-08-03 12:22:17 -0600312static int env_nand_load(void)
Markus Klotzbuechere443c942006-03-20 18:02:44 +0100313{
Simon Glassc5951992017-08-03 12:22:17 -0600314#if defined(ENV_IS_EMBEDDED)
315 return 0;
316#else
Simon Goldschmidt31f044b2018-01-31 14:47:11 +0100317 int read1_fail, read2_fail;
Fiach Antaw9d364af2017-01-25 18:53:12 +1000318 env_t *tmp_env1, *tmp_env2;
Simon Glassc5951992017-08-03 12:22:17 -0600319 int ret = 0;
wdenk13a56952004-06-09 14:58:14 +0000320
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200321 tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
322 tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);
Igor Grinbergde152b92011-11-07 01:14:10 +0000323 if (tmp_env1 == NULL || tmp_env2 == NULL) {
Wolfgang Denk15b86c32010-01-16 21:50:26 -0700324 puts("Can't allocate buffers for environment\n");
Simon Glass0ac7d722019-08-01 09:47:00 -0600325 env_set_default("malloc() failed", 0);
Simon Glassc5951992017-08-03 12:22:17 -0600326 ret = -EIO;
Igor Grinbergde152b92011-11-07 01:14:10 +0000327 goto done;
Wolfgang Denk15b86c32010-01-16 21:50:26 -0700328 }
329
Phil Sutterb76a1472013-02-21 18:21:55 +0100330 read1_fail = readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1);
331 read2_fail = readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200332
Simon Goldschmidt31f044b2018-01-31 14:47:11 +0100333 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
Marek Vasut890feec2020-07-07 20:51:35 +0200334 read2_fail, H_EXTERNAL);
Markus Klotzbuechere443c942006-03-20 18:02:44 +0100335
Igor Grinbergde152b92011-11-07 01:14:10 +0000336done:
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200337 free(tmp_env1);
338 free(tmp_env2);
Markus Klotzbuechere443c942006-03-20 18:02:44 +0100339
Simon Glassc5951992017-08-03 12:22:17 -0600340 return ret;
Markus Klotzbuechere443c942006-03-20 18:02:44 +0100341#endif /* ! ENV_IS_EMBEDDED */
342}
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200343#else /* ! CONFIG_ENV_OFFSET_REDUND */
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100344/*
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200345 * The legacy NAND code saved the environment in the first NAND
346 * device i.e., nand_dev_desc + 0. This is also the behaviour using
347 * the new NAND code.
Bartlomiej Siekaaddb2e12006-03-05 18:57:33 +0100348 */
Simon Glassc5951992017-08-03 12:22:17 -0600349static int env_nand_load(void)
wdenk13a56952004-06-09 14:58:14 +0000350{
351#if !defined(ENV_IS_EMBEDDED)
Wolfgang Denkd52fb7e2006-03-11 22:53:33 +0100352 int ret;
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400353 ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
wdenk13a56952004-06-09 14:58:14 +0000354
Ben Gardinerc9f73512010-07-05 13:27:07 -0400355#if defined(CONFIG_ENV_OFFSET_OOB)
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500356 struct mtd_info *mtd = get_nand_dev_by_index(0);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200357 /*
358 * If unable to read environment offset from NAND OOB then fall through
Ben Gardinerc9f73512010-07-05 13:27:07 -0400359 * to the normal environment reading code below
360 */
Grygorii Strashkoa94a2612017-06-26 19:12:52 -0500361 if (mtd && !get_nand_env_oob(mtd, &nand_env_oob_offset)) {
Ben Gardinerc9f73512010-07-05 13:27:07 -0400362 printf("Found Environment offset in OOB..\n");
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200363 } else {
Simon Glass0ac7d722019-08-01 09:47:00 -0600364 env_set_default("no env offset in OOB", 0);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200365 return;
366 }
Ben Gardinerc9f73512010-07-05 13:27:07 -0400367#endif
368
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400369 ret = readenv(CONFIG_ENV_OFFSET, (u_char *)buf);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200370 if (ret) {
Simon Glass0ac7d722019-08-01 09:47:00 -0600371 env_set_default("readenv() failed", 0);
Simon Glassc5951992017-08-03 12:22:17 -0600372 return -EIO;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200373 }
wdenk13a56952004-06-09 14:58:14 +0000374
Marek Vasut890feec2020-07-07 20:51:35 +0200375 return env_import(buf, 1, H_EXTERNAL);
wdenk13a56952004-06-09 14:58:14 +0000376#endif /* ! ENV_IS_EMBEDDED */
Simon Glassc5951992017-08-03 12:22:17 -0600377
378 return 0;
wdenk13a56952004-06-09 14:58:14 +0000379}
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200380#endif /* CONFIG_ENV_OFFSET_REDUND */
Simon Glass4415f1d2017-08-03 12:21:58 -0600381
382U_BOOT_ENV_LOCATION(nand) = {
383 .location = ENVL_NAND,
Simon Glassac358be2017-08-03 12:22:03 -0600384 ENV_NAME("NAND")
Simon Glasse5bce242017-08-03 12:22:01 -0600385 .load = env_nand_load,
Simon Glass4415f1d2017-08-03 12:21:58 -0600386#if defined(CMD_SAVEENV)
Simon Glasse5bce242017-08-03 12:22:01 -0600387 .save = env_save_ptr(env_nand_save),
Simon Glass4415f1d2017-08-03 12:21:58 -0600388#endif
Simon Glasse5bce242017-08-03 12:22:01 -0600389 .init = env_nand_init,
Simon Glass4415f1d2017-08-03 12:21:58 -0600390};