blob: 4e67180b23a0ba0449072720f9caf54d85d7be47 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Terry Lva8060352010-05-17 10:57:01 +08002/*
Mingkai Hu97039ab2011-01-24 17:09:55 +00003 * (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
Terry Lva8060352010-05-17 10:57:01 +08004 */
5
6/* #define DEBUG */
7
8#include <common.h>
9
10#include <command.h>
Simon Glass0ac7d722019-08-01 09:47:00 -060011#include <env.h>
Simon Glassf3998fd2019-08-02 09:44:25 -060012#include <env_internal.h>
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020013#include <fdtdec.h>
Terry Lva8060352010-05-17 10:57:01 +080014#include <linux/stddef.h>
15#include <malloc.h>
Simon Glasscf92e052015-09-02 17:24:58 -060016#include <memalign.h>
Terry Lva8060352010-05-17 10:57:01 +080017#include <mmc.h>
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010018#include <part.h>
Lei Wen6d1d51b2010-11-10 07:39:23 +080019#include <search.h>
Lei Wene79f4832010-10-13 11:07:21 +080020#include <errno.h>
Terry Lva8060352010-05-17 10:57:01 +080021
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010022#define __STR(X) #X
23#define STR(X) __STR(X)
24
Terry Lva8060352010-05-17 10:57:01 +080025DECLARE_GLOBAL_DATA_PTR;
26
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020027#if CONFIG_IS_ENABLED(OF_CONTROL)
Patrick Delaunay5d4f7b42020-06-15 10:38:57 +020028static inline int mmc_offset_try_partition(const char *str, int copy, s64 *val)
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010029{
Simon Glass05289792020-05-10 11:39:57 -060030 struct disk_partition info;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010031 struct blk_desc *desc;
32 int len, i, ret;
Patrick Delaunay2b2f7272020-06-15 10:38:55 +020033 char dev_str[4];
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010034
Patrick Delaunay2b2f7272020-06-15 10:38:55 +020035 snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev());
36 ret = blk_get_device_by_str("mmc", dev_str, &desc);
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010037 if (ret < 0)
38 return (ret);
39
40 for (i = 1;;i++) {
41 ret = part_get_info(desc, i, &info);
42 if (ret < 0)
43 return ret;
44
45 if (!strncmp((const char *)info.name, str, sizeof(str)))
46 break;
47 }
48
49 /* round up to info.blksz */
Patrick Delaunay76b640c2020-06-15 10:38:56 +020050 len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz);
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010051
52 /* use the top of the partion for the environment */
Patrick Delaunay5d4f7b42020-06-15 10:38:57 +020053 *val = (info.start + info.size - (1 + copy) * len) * info.blksz;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010054
55 return 0;
56}
57
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020058static inline s64 mmc_offset(int copy)
Mingkai Hu97039ab2011-01-24 17:09:55 +000059{
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010060 const struct {
61 const char *offset_redund;
62 const char *partition;
63 const char *offset;
64 } dt_prop = {
65 .offset_redund = "u-boot,mmc-env-offset-redundant",
66 .partition = "u-boot,mmc-env-partition",
67 .offset = "u-boot,mmc-env-offset",
68 };
Philipp Tomsichfd374662017-11-21 23:29:40 +010069 s64 val = 0, defvalue;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010070 const char *propname;
71 const char *str;
72 int err;
73
74 /* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */
75 str = fdtdec_get_config_string(gd->fdt_blob, dt_prop.partition);
76 if (str) {
77 /* try to place the environment at end of the partition */
Patrick Delaunay5d4f7b42020-06-15 10:38:57 +020078 err = mmc_offset_try_partition(str, copy, &val);
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010079 if (!err)
80 return val;
81 }
82
83 defvalue = CONFIG_ENV_OFFSET;
84 propname = dt_prop.offset;
Stephen Warren5c088ee2013-06-11 15:14:02 -060085
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020086#if defined(CONFIG_ENV_OFFSET_REDUND)
87 if (copy) {
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020088 defvalue = CONFIG_ENV_OFFSET_REDUND;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010089 propname = dt_prop.offset_redund;
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020090 }
91#endif
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020092 return fdtdec_get_config_int(gd->fdt_blob, propname, defvalue);
93}
94#else
95static inline s64 mmc_offset(int copy)
96{
97 s64 offset = CONFIG_ENV_OFFSET;
98
99#if defined(CONFIG_ENV_OFFSET_REDUND)
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000100 if (copy)
Stephen Warren5c088ee2013-06-11 15:14:02 -0600101 offset = CONFIG_ENV_OFFSET_REDUND;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000102#endif
Philipp Tomsichf8b8a552017-05-16 00:16:31 +0200103 return offset;
104}
105#endif
106
107__weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
108{
109 s64 offset = mmc_offset(copy);
Stephen Warren5c088ee2013-06-11 15:14:02 -0600110
111 if (offset < 0)
112 offset += mmc->capacity;
113
114 *env_addr = offset;
115
Mingkai Hu97039ab2011-01-24 17:09:55 +0000116 return 0;
117}
Mingkai Hu97039ab2011-01-24 17:09:55 +0000118
Tom Rinib9c8cca2014-03-28 12:03:34 -0400119#ifdef CONFIG_SYS_MMC_ENV_PART
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300120__weak uint mmc_get_env_part(struct mmc *mmc)
121{
122 return CONFIG_SYS_MMC_ENV_PART;
123}
124
Stephen Warren873cc1d2015-12-07 11:38:49 -0700125static unsigned char env_mmc_orig_hwpart;
126
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300127static int mmc_set_env_part(struct mmc *mmc)
128{
129 uint part = mmc_get_env_part(mmc);
Clemens Grubere92029c2016-01-20 15:43:37 +0100130 int dev = mmc_get_env_dev();
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300131 int ret = 0;
Tom Rinib9c8cca2014-03-28 12:03:34 -0400132
Simon Glass69f45cd2016-05-01 13:52:29 -0600133 env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart;
134 ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
Stephen Warren873cc1d2015-12-07 11:38:49 -0700135 if (ret)
136 puts("MMC partition switch failed\n");
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300137
138 return ret;
139}
140#else
141static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
Tom Rinib9c8cca2014-03-28 12:03:34 -0400142#endif
143
Tim Harveyc75648d2015-05-08 14:52:09 -0700144static const char *init_mmc_for_env(struct mmc *mmc)
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300145{
Tim Harveyc75648d2015-05-08 14:52:09 -0700146 if (!mmc)
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300147 return "No MMC card found";
Terry Lva8060352010-05-17 10:57:01 +0800148
Sjoerd Simonsd48b8d12018-03-22 22:53:50 +0100149#if CONFIG_IS_ENABLED(BLK)
Simon Glass01b73fe2017-05-27 11:37:18 -0600150 struct udevice *dev;
151
152 if (blk_get_from_parent(mmc->dev, &dev))
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300153 return "No block device";
Simon Glass01b73fe2017-05-27 11:37:18 -0600154#else
Tim Harveyc75648d2015-05-08 14:52:09 -0700155 if (mmc_init(mmc))
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300156 return "MMC init failed";
Simon Glasse7017a32017-04-23 20:02:04 -0600157#endif
Tim Harveyc75648d2015-05-08 14:52:09 -0700158 if (mmc_set_env_part(mmc))
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300159 return "MMC partition switch failed";
Tim Harveyc75648d2015-05-08 14:52:09 -0700160
161 return NULL;
Terry Lva8060352010-05-17 10:57:01 +0800162}
163
Stephen Warren9404a5f2012-07-30 10:55:44 +0000164static void fini_mmc_for_env(struct mmc *mmc)
165{
166#ifdef CONFIG_SYS_MMC_ENV_PART
Clemens Grubere92029c2016-01-20 15:43:37 +0100167 int dev = mmc_get_env_dev();
Tom Rinib9c8cca2014-03-28 12:03:34 -0400168
Simon Glass69f45cd2016-05-01 13:52:29 -0600169 blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart);
Stephen Warren9404a5f2012-07-30 10:55:44 +0000170#endif
171}
172
Simon Glasse5bce242017-08-03 12:22:01 -0600173#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
Igor Grinberge8db8f72011-11-07 01:14:05 +0000174static inline int write_env(struct mmc *mmc, unsigned long size,
175 unsigned long offset, const void *buffer)
Terry Lva8060352010-05-17 10:57:01 +0800176{
177 uint blk_start, blk_cnt, n;
Simon Glass5461acb2016-05-14 14:03:03 -0600178 struct blk_desc *desc = mmc_get_blk_desc(mmc);
Terry Lva8060352010-05-17 10:57:01 +0800179
Igor Grinberge8db8f72011-11-07 01:14:05 +0000180 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
181 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
Terry Lva8060352010-05-17 10:57:01 +0800182
Simon Glass5461acb2016-05-14 14:03:03 -0600183 n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer);
Terry Lva8060352010-05-17 10:57:01 +0800184
185 return (n == blk_cnt) ? 0 : -1;
186}
187
Simon Glasse5bce242017-08-03 12:22:01 -0600188static int env_mmc_save(void)
Terry Lva8060352010-05-17 10:57:01 +0800189{
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400190 ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
Clemens Grubere92029c2016-01-20 15:43:37 +0100191 int dev = mmc_get_env_dev();
192 struct mmc *mmc = find_mmc_device(dev);
Igor Grinberge8db8f72011-11-07 01:14:05 +0000193 u32 offset;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000194 int ret, copy = 0;
Tim Harveyc75648d2015-05-08 14:52:09 -0700195 const char *errmsg;
Terry Lva8060352010-05-17 10:57:01 +0800196
Tim Harveyc75648d2015-05-08 14:52:09 -0700197 errmsg = init_mmc_for_env(mmc);
198 if (errmsg) {
199 printf("%s\n", errmsg);
Mingkai Hu97039ab2011-01-24 17:09:55 +0000200 return 1;
Tim Harveyc75648d2015-05-08 14:52:09 -0700201 }
Mingkai Hu97039ab2011-01-24 17:09:55 +0000202
Marek Vasut7ce15262014-03-05 19:59:50 +0100203 ret = env_export(env_new);
204 if (ret)
Stephen Warren9404a5f2012-07-30 10:55:44 +0000205 goto fini;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000206
207#ifdef CONFIG_ENV_OFFSET_REDUND
Simon Glass203e94f2017-08-03 12:21:56 -0600208 if (gd->env_valid == ENV_VALID)
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000209 copy = 1;
210#endif
211
212 if (mmc_get_env_addr(mmc, copy, &offset)) {
213 ret = 1;
214 goto fini;
215 }
216
Clemens Grubere92029c2016-01-20 15:43:37 +0100217 printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev);
Stephen Warren4036b632012-05-24 11:38:33 +0000218 if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
Terry Lva8060352010-05-17 10:57:01 +0800219 puts("failed\n");
Stephen Warren9404a5f2012-07-30 10:55:44 +0000220 ret = 1;
221 goto fini;
Terry Lva8060352010-05-17 10:57:01 +0800222 }
223
Stephen Warren9404a5f2012-07-30 10:55:44 +0000224 ret = 0;
225
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000226#ifdef CONFIG_ENV_OFFSET_REDUND
Simon Glass203e94f2017-08-03 12:21:56 -0600227 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000228#endif
229
Stephen Warren9404a5f2012-07-30 10:55:44 +0000230fini:
231 fini_mmc_for_env(mmc);
232 return ret;
Terry Lva8060352010-05-17 10:57:01 +0800233}
Frank Wunderlich34853922019-06-29 11:36:20 +0200234
235#if defined(CONFIG_CMD_ERASEENV)
236static inline int erase_env(struct mmc *mmc, unsigned long size,
237 unsigned long offset)
238{
239 uint blk_start, blk_cnt, n;
240 struct blk_desc *desc = mmc_get_blk_desc(mmc);
241
242 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
243 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
244
245 n = blk_derase(desc, blk_start, blk_cnt);
246 printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR");
247
248 return (n == blk_cnt) ? 0 : 1;
249}
250
251static int env_mmc_erase(void)
252{
253 int dev = mmc_get_env_dev();
254 struct mmc *mmc = find_mmc_device(dev);
255 int ret, copy = 0;
256 u32 offset;
257 const char *errmsg;
258
259 errmsg = init_mmc_for_env(mmc);
260 if (errmsg) {
261 printf("%s\n", errmsg);
262 return 1;
263 }
264
265 if (mmc_get_env_addr(mmc, copy, &offset))
266 return CMD_RET_FAILURE;
267
268 ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);
269
270#ifdef CONFIG_ENV_OFFSET_REDUND
271 copy = 1;
272
273 if (mmc_get_env_addr(mmc, copy, &offset))
274 return CMD_RET_FAILURE;
275
276 ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset);
277#endif
278
279 return ret;
280}
281#endif /* CONFIG_CMD_ERASEENV */
Simon Glasse5bce242017-08-03 12:22:01 -0600282#endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */
Terry Lva8060352010-05-17 10:57:01 +0800283
Igor Grinberge8db8f72011-11-07 01:14:05 +0000284static inline int read_env(struct mmc *mmc, unsigned long size,
285 unsigned long offset, const void *buffer)
Terry Lva8060352010-05-17 10:57:01 +0800286{
287 uint blk_start, blk_cnt, n;
Simon Glass5461acb2016-05-14 14:03:03 -0600288 struct blk_desc *desc = mmc_get_blk_desc(mmc);
Terry Lva8060352010-05-17 10:57:01 +0800289
Igor Grinberge8db8f72011-11-07 01:14:05 +0000290 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
291 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
Terry Lva8060352010-05-17 10:57:01 +0800292
Simon Glass5461acb2016-05-14 14:03:03 -0600293 n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);
Terry Lva8060352010-05-17 10:57:01 +0800294
295 return (n == blk_cnt) ? 0 : -1;
296}
297
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000298#ifdef CONFIG_ENV_OFFSET_REDUND
Simon Glassc5951992017-08-03 12:22:17 -0600299static int env_mmc_load(void)
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000300{
301#if !defined(ENV_IS_EMBEDDED)
Tom Rinib9c8cca2014-03-28 12:03:34 -0400302 struct mmc *mmc;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000303 u32 offset1, offset2;
304 int read1_fail = 0, read2_fail = 0;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000305 int ret;
Clemens Grubere92029c2016-01-20 15:43:37 +0100306 int dev = mmc_get_env_dev();
Tim Harveyc75648d2015-05-08 14:52:09 -0700307 const char *errmsg = NULL;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000308
Markus Niebel452a2722013-10-04 15:48:03 +0200309 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
310 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
311
Faiz Abbas26862b42018-02-12 19:24:31 +0530312 mmc_initialize(NULL);
313
Tom Rinib9c8cca2014-03-28 12:03:34 -0400314 mmc = find_mmc_device(dev);
315
Tim Harveyc75648d2015-05-08 14:52:09 -0700316 errmsg = init_mmc_for_env(mmc);
317 if (errmsg) {
Simon Glassc5951992017-08-03 12:22:17 -0600318 ret = -EIO;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000319 goto err;
320 }
321
322 if (mmc_get_env_addr(mmc, 0, &offset1) ||
323 mmc_get_env_addr(mmc, 1, &offset2)) {
Simon Glassc5951992017-08-03 12:22:17 -0600324 ret = -EIO;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000325 goto fini;
326 }
327
328 read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
329 read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
330
Simon Goldschmidt31f044b2018-01-31 14:47:11 +0100331 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
Marek Vasut890feec2020-07-07 20:51:35 +0200332 read2_fail, H_EXTERNAL);
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000333
334fini:
335 fini_mmc_for_env(mmc);
336err:
337 if (ret)
Simon Glass0ac7d722019-08-01 09:47:00 -0600338 env_set_default(errmsg, 0);
Simon Glassc5951992017-08-03 12:22:17 -0600339
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000340#endif
Simon Glassc5951992017-08-03 12:22:17 -0600341 return ret;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000342}
343#else /* ! CONFIG_ENV_OFFSET_REDUND */
Simon Glassc5951992017-08-03 12:22:17 -0600344static int env_mmc_load(void)
Terry Lva8060352010-05-17 10:57:01 +0800345{
346#if !defined(ENV_IS_EMBEDDED)
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400347 ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
Tom Rinib9c8cca2014-03-28 12:03:34 -0400348 struct mmc *mmc;
Mingkai Hu97039ab2011-01-24 17:09:55 +0000349 u32 offset;
Stephen Warren9404a5f2012-07-30 10:55:44 +0000350 int ret;
Clemens Grubere92029c2016-01-20 15:43:37 +0100351 int dev = mmc_get_env_dev();
Tim Harveyc75648d2015-05-08 14:52:09 -0700352 const char *errmsg;
Pankit Garg0536b442019-11-19 09:49:31 +0000353 env_t *ep = NULL;
Tom Rinib9c8cca2014-03-28 12:03:34 -0400354
Tom Rinib9c8cca2014-03-28 12:03:34 -0400355 mmc = find_mmc_device(dev);
Terry Lva8060352010-05-17 10:57:01 +0800356
Tim Harveyc75648d2015-05-08 14:52:09 -0700357 errmsg = init_mmc_for_env(mmc);
358 if (errmsg) {
Simon Glassc5951992017-08-03 12:22:17 -0600359 ret = -EIO;
Stephen Warren9404a5f2012-07-30 10:55:44 +0000360 goto err;
361 }
Terry Lva8060352010-05-17 10:57:01 +0800362
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000363 if (mmc_get_env_addr(mmc, 0, &offset)) {
Simon Glassc5951992017-08-03 12:22:17 -0600364 ret = -EIO;
Stephen Warren9404a5f2012-07-30 10:55:44 +0000365 goto fini;
366 }
367
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400368 if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
Tim Harveyc75648d2015-05-08 14:52:09 -0700369 errmsg = "!read failed";
Simon Glassc5951992017-08-03 12:22:17 -0600370 ret = -EIO;
Stephen Warren9404a5f2012-07-30 10:55:44 +0000371 goto fini;
372 }
Terry Lva8060352010-05-17 10:57:01 +0800373
Marek Vasut890feec2020-07-07 20:51:35 +0200374 ret = env_import(buf, 1, H_EXTERNAL);
Pankit Garg0536b442019-11-19 09:49:31 +0000375 if (!ret) {
376 ep = (env_t *)buf;
377 gd->env_addr = (ulong)&ep->data;
378 }
Stephen Warren9404a5f2012-07-30 10:55:44 +0000379
380fini:
381 fini_mmc_for_env(mmc);
382err:
383 if (ret)
Simon Glass0ac7d722019-08-01 09:47:00 -0600384 env_set_default(errmsg, 0);
Terry Lva8060352010-05-17 10:57:01 +0800385#endif
Simon Glassc5951992017-08-03 12:22:17 -0600386 return ret;
Terry Lva8060352010-05-17 10:57:01 +0800387}
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000388#endif /* CONFIG_ENV_OFFSET_REDUND */
Simon Glass4415f1d2017-08-03 12:21:58 -0600389
390U_BOOT_ENV_LOCATION(mmc) = {
391 .location = ENVL_MMC,
Simon Glassac358be2017-08-03 12:22:03 -0600392 ENV_NAME("MMC")
Simon Glasse5bce242017-08-03 12:22:01 -0600393 .load = env_mmc_load,
Simon Glass4415f1d2017-08-03 12:21:58 -0600394#ifndef CONFIG_SPL_BUILD
Simon Glasse5bce242017-08-03 12:22:01 -0600395 .save = env_save_ptr(env_mmc_save),
Frank Wunderlich34853922019-06-29 11:36:20 +0200396#if defined(CONFIG_CMD_ERASEENV)
397 .erase = env_mmc_erase,
398#endif
Simon Glass4415f1d2017-08-03 12:21:58 -0600399#endif
Simon Glass4415f1d2017-08-03 12:21:58 -0600400};