blob: da84cddd74f0c151a5d9a617fd3820129eb89bdf [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>
Simon Glass401d1c42020-10-30 21:38:53 -06009#include <asm/global_data.h>
Terry Lva8060352010-05-17 10:57:01 +080010
11#include <command.h>
Simon Glass0ac7d722019-08-01 09:47:00 -060012#include <env.h>
Simon Glassf3998fd2019-08-02 09:44:25 -060013#include <env_internal.h>
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020014#include <fdtdec.h>
Terry Lva8060352010-05-17 10:57:01 +080015#include <linux/stddef.h>
16#include <malloc.h>
Simon Glasscf92e052015-09-02 17:24:58 -060017#include <memalign.h>
Terry Lva8060352010-05-17 10:57:01 +080018#include <mmc.h>
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010019#include <part.h>
Lei Wen6d1d51b2010-11-10 07:39:23 +080020#include <search.h>
Lei Wene79f4832010-10-13 11:07:21 +080021#include <errno.h>
Simon Glass7de8bd02021-08-07 07:24:01 -060022#include <dm/ofnode.h>
Terry Lva8060352010-05-17 10:57:01 +080023
Patrick Delaunayf7e07a72022-11-10 11:48:58 +010024#define ENV_MMC_INVALID_OFFSET ((s64)-1)
25
Patrick Delaunayd2103e22022-11-10 11:49:01 +010026#if defined(CONFIG_ENV_MMC_USE_DT)
27/* ENV offset is invalid when not defined in Device Tree */
28#define ENV_MMC_OFFSET ENV_MMC_INVALID_OFFSET
29#define ENV_MMC_OFFSET_REDUND ENV_MMC_INVALID_OFFSET
30
31#else
Patrick Delaunayf7e07a72022-11-10 11:48:58 +010032/* Default ENV offset when not defined in Device Tree */
33#define ENV_MMC_OFFSET CONFIG_ENV_OFFSET
34
35#if defined(CONFIG_ENV_OFFSET_REDUND)
36#define ENV_MMC_OFFSET_REDUND CONFIG_ENV_OFFSET_REDUND
37#else
38#define ENV_MMC_OFFSET_REDUND ENV_MMC_INVALID_OFFSET
39#endif
Patrick Delaunayd2103e22022-11-10 11:49:01 +010040#endif
Patrick Delaunayf7e07a72022-11-10 11:48:58 +010041
Terry Lva8060352010-05-17 10:57:01 +080042DECLARE_GLOBAL_DATA_PTR;
43
Marek Vasutd11d1be2021-10-17 19:23:36 +020044/*
45 * In case the environment is redundant, stored in eMMC hardware boot
46 * partition and the environment and redundant environment offsets are
47 * identical, store the environment and redundant environment in both
48 * eMMC boot partitions, one copy in each.
49 * */
50#if (defined(CONFIG_SYS_REDUNDAND_ENVIRONMENT) && \
51 (CONFIG_SYS_MMC_ENV_PART == 1) && \
52 (CONFIG_ENV_OFFSET == CONFIG_ENV_OFFSET_REDUND))
Patrick Delaunay46c90162022-11-10 11:48:59 +010053#define ENV_MMC_HWPART_REDUND 1
Marek Vasutd11d1be2021-10-17 19:23:36 +020054#endif
55
Philipp Tomsichf8b8a552017-05-16 00:16:31 +020056#if CONFIG_IS_ENABLED(OF_CONTROL)
Patrick Delaunay5d4f7b42020-06-15 10:38:57 +020057static inline int mmc_offset_try_partition(const char *str, int copy, s64 *val)
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010058{
Simon Glass05289792020-05-10 11:39:57 -060059 struct disk_partition info;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010060 struct blk_desc *desc;
61 int len, i, ret;
Patrick Delaunay2b2f7272020-06-15 10:38:55 +020062 char dev_str[4];
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010063
Patrick Delaunay2b2f7272020-06-15 10:38:55 +020064 snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev());
65 ret = blk_get_device_by_str("mmc", dev_str, &desc);
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010066 if (ret < 0)
67 return (ret);
68
69 for (i = 1;;i++) {
70 ret = part_get_info(desc, i, &info);
71 if (ret < 0)
72 return ret;
73
Patrick Delaunay80105d82022-11-10 11:49:03 +010074 if (str && !strncmp((const char *)info.name, str, sizeof(info.name)))
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010075 break;
Patrick Delaunay80105d82022-11-10 11:49:03 +010076#ifdef CONFIG_PARTITION_TYPE_GUID
77 if (!str) {
78 const efi_guid_t env_guid = PARTITION_U_BOOT_ENVIRONMENT;
79 efi_guid_t type_guid;
80
81 uuid_str_to_bin(info.type_guid, type_guid.b, UUID_STR_FORMAT_GUID);
82 if (!memcmp(&env_guid, &type_guid, sizeof(efi_guid_t)))
83 break;
84 }
85#endif
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010086 }
87
88 /* round up to info.blksz */
Patrick Delaunay76b640c2020-06-15 10:38:56 +020089 len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz);
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010090
91 /* use the top of the partion for the environment */
Patrick Delaunay5d4f7b42020-06-15 10:38:57 +020092 *val = (info.start + info.size - (1 + copy) * len) * info.blksz;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010093
94 return 0;
95}
96
Marek Vasut5b4acb02023-02-09 13:30:10 +010097static inline s64 mmc_offset(struct mmc *mmc, int copy)
Mingkai Hu97039ab2011-01-24 17:09:55 +000098{
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +010099 const struct {
100 const char *offset_redund;
101 const char *partition;
102 const char *offset;
103 } dt_prop = {
104 .offset_redund = "u-boot,mmc-env-offset-redundant",
105 .partition = "u-boot,mmc-env-partition",
106 .offset = "u-boot,mmc-env-offset",
107 };
Philipp Tomsichfd374662017-11-21 23:29:40 +0100108 s64 val = 0, defvalue;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +0100109 const char *propname;
110 const char *str;
Marek Vasut5b4acb02023-02-09 13:30:10 +0100111 int hwpart = 0;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +0100112 int err;
113
Marek Vasut5b4acb02023-02-09 13:30:10 +0100114 if (IS_ENABLED(CONFIG_SYS_MMC_ENV_PART))
115 hwpart = mmc_get_env_part(mmc);
116
Emmanuel Di Fede9e706762023-06-14 12:05:28 +0200117#if defined(CONFIG_ENV_MMC_PARTITION)
118 str = CONFIG_ENV_MMC_PARTITION;
119#else
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +0100120 /* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */
Simon Glass7de8bd02021-08-07 07:24:01 -0600121 str = ofnode_conf_read_str(dt_prop.partition);
Emmanuel Di Fede9e706762023-06-14 12:05:28 +0200122#endif
123
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +0100124 if (str) {
125 /* try to place the environment at end of the partition */
Patrick Delaunay5d4f7b42020-06-15 10:38:57 +0200126 err = mmc_offset_try_partition(str, copy, &val);
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +0100127 if (!err)
128 return val;
Patrick Delaunay52e9aa32022-11-10 11:49:04 +0100129 debug("env partition '%s' not found (%d)", str, err);
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +0100130 }
131
Patrick Delaunay80105d82022-11-10 11:49:03 +0100132 /* try the GPT partition with "U-Boot ENV" TYPE GUID */
Marek Vasut5b4acb02023-02-09 13:30:10 +0100133 if (IS_ENABLED(CONFIG_PARTITION_TYPE_GUID) && hwpart == 0) {
Patrick Delaunay80105d82022-11-10 11:49:03 +0100134 err = mmc_offset_try_partition(NULL, copy, &val);
135 if (!err)
136 return val;
137 }
138
Patrick Delaunayf7e07a72022-11-10 11:48:58 +0100139 defvalue = ENV_MMC_OFFSET;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +0100140 propname = dt_prop.offset;
Stephen Warren5c088ee2013-06-11 15:14:02 -0600141
Patrick Delaunay46c90162022-11-10 11:48:59 +0100142 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT) && copy) {
Patrick Delaunayf7e07a72022-11-10 11:48:58 +0100143 defvalue = ENV_MMC_OFFSET_REDUND;
Jorge Ramirez-Ortizc9e87ba2017-11-06 14:16:37 +0100144 propname = dt_prop.offset_redund;
Philipp Tomsichf8b8a552017-05-16 00:16:31 +0200145 }
Patrick Delaunay46c90162022-11-10 11:48:59 +0100146
Simon Glass7de8bd02021-08-07 07:24:01 -0600147 return ofnode_conf_read_int(propname, defvalue);
Philipp Tomsichf8b8a552017-05-16 00:16:31 +0200148}
149#else
Marek Vasut5b4acb02023-02-09 13:30:10 +0100150static inline s64 mmc_offset(struct mmc *mmc, int copy)
Philipp Tomsichf8b8a552017-05-16 00:16:31 +0200151{
Patrick Delaunayf7e07a72022-11-10 11:48:58 +0100152 s64 offset = ENV_MMC_OFFSET;
Philipp Tomsichf8b8a552017-05-16 00:16:31 +0200153
Patrick Delaunay46c90162022-11-10 11:48:59 +0100154 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT) && copy)
Patrick Delaunayf7e07a72022-11-10 11:48:58 +0100155 offset = ENV_MMC_OFFSET_REDUND;
Patrick Delaunay46c90162022-11-10 11:48:59 +0100156
Philipp Tomsichf8b8a552017-05-16 00:16:31 +0200157 return offset;
158}
159#endif
160
161__weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
162{
Marek Vasut5b4acb02023-02-09 13:30:10 +0100163 s64 offset = mmc_offset(mmc, copy);
Stephen Warren5c088ee2013-06-11 15:14:02 -0600164
Patrick Delaunayf7e07a72022-11-10 11:48:58 +0100165 if (offset == ENV_MMC_INVALID_OFFSET) {
166 printf("Invalid ENV offset in MMC, copy=%d\n", copy);
167 return -ENOENT;
168 }
169
Stephen Warren5c088ee2013-06-11 15:14:02 -0600170 if (offset < 0)
171 offset += mmc->capacity;
172
173 *env_addr = offset;
174
Mingkai Hu97039ab2011-01-24 17:09:55 +0000175 return 0;
176}
Mingkai Hu97039ab2011-01-24 17:09:55 +0000177
Tom Rinib9c8cca2014-03-28 12:03:34 -0400178#ifdef CONFIG_SYS_MMC_ENV_PART
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300179__weak uint mmc_get_env_part(struct mmc *mmc)
180{
181 return CONFIG_SYS_MMC_ENV_PART;
182}
183
Stephen Warren873cc1d2015-12-07 11:38:49 -0700184static unsigned char env_mmc_orig_hwpart;
185
Marek Vasutd11d1be2021-10-17 19:23:36 +0200186static int mmc_set_env_part(struct mmc *mmc, uint part)
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300187{
Clemens Grubere92029c2016-01-20 15:43:37 +0100188 int dev = mmc_get_env_dev();
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300189 int ret = 0;
Tom Rinib9c8cca2014-03-28 12:03:34 -0400190
Simon Glasse33a5c62022-08-11 19:34:59 -0600191 ret = blk_select_hwpart_devnum(UCLASS_MMC, dev, part);
Stephen Warren873cc1d2015-12-07 11:38:49 -0700192 if (ret)
193 puts("MMC partition switch failed\n");
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300194
195 return ret;
196}
Patrick Delaunay46c90162022-11-10 11:48:59 +0100197
198static bool mmc_set_env_part_init(struct mmc *mmc)
199{
200 env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart;
201 if (mmc_set_env_part(mmc, mmc_get_env_part(mmc)))
202 return false;
203
204 return true;
205}
206
207static int mmc_set_env_part_restore(struct mmc *mmc)
208{
209 return mmc_set_env_part(mmc, env_mmc_orig_hwpart);
210}
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300211#else
Marek Vasutd11d1be2021-10-17 19:23:36 +0200212static inline int mmc_set_env_part(struct mmc *mmc, uint part) {return 0; };
Patrick Delaunay46c90162022-11-10 11:48:59 +0100213static bool mmc_set_env_part_init(struct mmc *mmc) {return true; }
214static inline int mmc_set_env_part_restore(struct mmc *mmc) {return 0; };
Tom Rinib9c8cca2014-03-28 12:03:34 -0400215#endif
216
Tim Harveyc75648d2015-05-08 14:52:09 -0700217static const char *init_mmc_for_env(struct mmc *mmc)
Dmitry Lifshitz6e7b7df2014-07-30 13:19:06 +0300218{
Tim Harveyc75648d2015-05-08 14:52:09 -0700219 if (!mmc)
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300220 return "No MMC card found";
Terry Lva8060352010-05-17 10:57:01 +0800221
Sjoerd Simonsd48b8d12018-03-22 22:53:50 +0100222#if CONFIG_IS_ENABLED(BLK)
Simon Glass01b73fe2017-05-27 11:37:18 -0600223 struct udevice *dev;
224
225 if (blk_get_from_parent(mmc->dev, &dev))
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300226 return "No block device";
Simon Glass01b73fe2017-05-27 11:37:18 -0600227#else
Tim Harveyc75648d2015-05-08 14:52:09 -0700228 if (mmc_init(mmc))
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300229 return "MMC init failed";
Simon Glasse7017a32017-04-23 20:02:04 -0600230#endif
Patrick Delaunay46c90162022-11-10 11:48:59 +0100231 if (!mmc_set_env_part_init(mmc))
Yaniv Levinskyc5d548a2018-06-24 19:16:57 +0300232 return "MMC partition switch failed";
Tim Harveyc75648d2015-05-08 14:52:09 -0700233
234 return NULL;
Terry Lva8060352010-05-17 10:57:01 +0800235}
236
Stephen Warren9404a5f2012-07-30 10:55:44 +0000237static void fini_mmc_for_env(struct mmc *mmc)
238{
Patrick Delaunay46c90162022-11-10 11:48:59 +0100239 mmc_set_env_part_restore(mmc);
Stephen Warren9404a5f2012-07-30 10:55:44 +0000240}
241
Simon Glasse5bce242017-08-03 12:22:01 -0600242#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
Igor Grinberge8db8f72011-11-07 01:14:05 +0000243static inline int write_env(struct mmc *mmc, unsigned long size,
244 unsigned long offset, const void *buffer)
Terry Lva8060352010-05-17 10:57:01 +0800245{
246 uint blk_start, blk_cnt, n;
Simon Glass5461acb2016-05-14 14:03:03 -0600247 struct blk_desc *desc = mmc_get_blk_desc(mmc);
Terry Lva8060352010-05-17 10:57:01 +0800248
Igor Grinberge8db8f72011-11-07 01:14:05 +0000249 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
250 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
Terry Lva8060352010-05-17 10:57:01 +0800251
Simon Glass5461acb2016-05-14 14:03:03 -0600252 n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer);
Terry Lva8060352010-05-17 10:57:01 +0800253
254 return (n == blk_cnt) ? 0 : -1;
255}
256
Simon Glasse5bce242017-08-03 12:22:01 -0600257static int env_mmc_save(void)
Terry Lva8060352010-05-17 10:57:01 +0800258{
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400259 ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
Clemens Grubere92029c2016-01-20 15:43:37 +0100260 int dev = mmc_get_env_dev();
261 struct mmc *mmc = find_mmc_device(dev);
Igor Grinberge8db8f72011-11-07 01:14:05 +0000262 u32 offset;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000263 int ret, copy = 0;
Tim Harveyc75648d2015-05-08 14:52:09 -0700264 const char *errmsg;
Terry Lva8060352010-05-17 10:57:01 +0800265
Tim Harveyc75648d2015-05-08 14:52:09 -0700266 errmsg = init_mmc_for_env(mmc);
267 if (errmsg) {
268 printf("%s\n", errmsg);
Mingkai Hu97039ab2011-01-24 17:09:55 +0000269 return 1;
Tim Harveyc75648d2015-05-08 14:52:09 -0700270 }
Mingkai Hu97039ab2011-01-24 17:09:55 +0000271
Marek Vasut7ce15262014-03-05 19:59:50 +0100272 ret = env_export(env_new);
273 if (ret)
Stephen Warren9404a5f2012-07-30 10:55:44 +0000274 goto fini;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000275
Patrick Delaunay46c90162022-11-10 11:48:59 +0100276 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
277 if (gd->env_valid == ENV_VALID)
278 copy = 1;
Marek Vasutd11d1be2021-10-17 19:23:36 +0200279
Patrick Delaunay46c90162022-11-10 11:48:59 +0100280 if (IS_ENABLED(ENV_MMC_HWPART_REDUND)) {
281 ret = mmc_set_env_part(mmc, copy + 1);
282 if (ret)
283 goto fini;
284 }
Ye Liccd05422023-01-31 14:41:58 +0800285 }
Marek Vasutd11d1be2021-10-17 19:23:36 +0200286
Ye Liccd05422023-01-31 14:41:58 +0800287 if (mmc_get_env_addr(mmc, copy, &offset)) {
288 ret = 1;
289 goto fini;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000290 }
291
Clemens Grubere92029c2016-01-20 15:43:37 +0100292 printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev);
Stephen Warren4036b632012-05-24 11:38:33 +0000293 if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
Terry Lva8060352010-05-17 10:57:01 +0800294 puts("failed\n");
Stephen Warren9404a5f2012-07-30 10:55:44 +0000295 ret = 1;
296 goto fini;
Terry Lva8060352010-05-17 10:57:01 +0800297 }
298
Stephen Warren9404a5f2012-07-30 10:55:44 +0000299 ret = 0;
300
Patrick Delaunay46c90162022-11-10 11:48:59 +0100301 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
302 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000303
Stephen Warren9404a5f2012-07-30 10:55:44 +0000304fini:
305 fini_mmc_for_env(mmc);
Patrick Delaunay46c90162022-11-10 11:48:59 +0100306
Stephen Warren9404a5f2012-07-30 10:55:44 +0000307 return ret;
Terry Lva8060352010-05-17 10:57:01 +0800308}
Frank Wunderlich34853922019-06-29 11:36:20 +0200309
Frank Wunderlich34853922019-06-29 11:36:20 +0200310static inline int erase_env(struct mmc *mmc, unsigned long size,
311 unsigned long offset)
312{
313 uint blk_start, blk_cnt, n;
314 struct blk_desc *desc = mmc_get_blk_desc(mmc);
Patrick Delaunayd7226702022-02-15 16:23:23 +0100315 u32 erase_size;
Frank Wunderlich34853922019-06-29 11:36:20 +0200316
Patrick Delaunayd7226702022-02-15 16:23:23 +0100317 erase_size = mmc->erase_grp_size * desc->blksz;
318 blk_start = ALIGN_DOWN(offset, erase_size) / desc->blksz;
319 blk_cnt = ALIGN(size, erase_size) / desc->blksz;
Frank Wunderlich34853922019-06-29 11:36:20 +0200320
321 n = blk_derase(desc, blk_start, blk_cnt);
Patrick Delaunayd7226702022-02-15 16:23:23 +0100322 printf("%d blocks erased at 0x%x: %s\n", n, blk_start,
323 (n == blk_cnt) ? "OK" : "ERROR");
Frank Wunderlich34853922019-06-29 11:36:20 +0200324
325 return (n == blk_cnt) ? 0 : 1;
326}
327
328static int env_mmc_erase(void)
329{
330 int dev = mmc_get_env_dev();
331 struct mmc *mmc = find_mmc_device(dev);
332 int ret, copy = 0;
333 u32 offset;
334 const char *errmsg;
335
336 errmsg = init_mmc_for_env(mmc);
337 if (errmsg) {
338 printf("%s\n", errmsg);
339 return 1;
340 }
341
Marek Vasutf47f87f2021-10-06 18:29:53 +0200342 if (mmc_get_env_addr(mmc, copy, &offset)) {
343 ret = CMD_RET_FAILURE;
344 goto fini;
345 }
Frank Wunderlich34853922019-06-29 11:36:20 +0200346
Patrick Delaunayd7226702022-02-15 16:23:23 +0100347 printf("\n");
Frank Wunderlich34853922019-06-29 11:36:20 +0200348 ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);
349
Patrick Delaunay46c90162022-11-10 11:48:59 +0100350 if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
351 copy = 1;
Frank Wunderlich34853922019-06-29 11:36:20 +0200352
Patrick Delaunay46c90162022-11-10 11:48:59 +0100353 if (IS_ENABLED(ENV_MMC_HWPART_REDUND)) {
354 ret = mmc_set_env_part(mmc, copy + 1);
355 if (ret)
356 goto fini;
357 }
Marek Vasutd11d1be2021-10-17 19:23:36 +0200358
Patrick Delaunay46c90162022-11-10 11:48:59 +0100359 if (mmc_get_env_addr(mmc, copy, &offset)) {
360 ret = CMD_RET_FAILURE;
361 goto fini;
362 }
363
364 ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset);
Marek Vasutf47f87f2021-10-06 18:29:53 +0200365 }
Frank Wunderlich34853922019-06-29 11:36:20 +0200366
Marek Vasutf47f87f2021-10-06 18:29:53 +0200367fini:
368 fini_mmc_for_env(mmc);
Frank Wunderlich34853922019-06-29 11:36:20 +0200369 return ret;
370}
Simon Glasse5bce242017-08-03 12:22:01 -0600371#endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */
Terry Lva8060352010-05-17 10:57:01 +0800372
Igor Grinberge8db8f72011-11-07 01:14:05 +0000373static inline int read_env(struct mmc *mmc, unsigned long size,
374 unsigned long offset, const void *buffer)
Terry Lva8060352010-05-17 10:57:01 +0800375{
376 uint blk_start, blk_cnt, n;
Simon Glass5461acb2016-05-14 14:03:03 -0600377 struct blk_desc *desc = mmc_get_blk_desc(mmc);
Terry Lva8060352010-05-17 10:57:01 +0800378
Igor Grinberge8db8f72011-11-07 01:14:05 +0000379 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
380 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
Terry Lva8060352010-05-17 10:57:01 +0800381
Simon Glass5461acb2016-05-14 14:03:03 -0600382 n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);
Terry Lva8060352010-05-17 10:57:01 +0800383
384 return (n == blk_cnt) ? 0 : -1;
385}
386
Patrick Delaunay85660502022-11-10 11:49:00 +0100387#if defined(ENV_IS_EMBEDDED)
Simon Glassc5951992017-08-03 12:22:17 -0600388static int env_mmc_load(void)
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000389{
Patrick Delaunay85660502022-11-10 11:49:00 +0100390 return 0;
391}
392#elif defined(CONFIG_SYS_REDUNDAND_ENVIRONMENT)
393static int env_mmc_load(void)
394{
Tom Rinib9c8cca2014-03-28 12:03:34 -0400395 struct mmc *mmc;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000396 u32 offset1, offset2;
397 int read1_fail = 0, read2_fail = 0;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000398 int ret;
Clemens Grubere92029c2016-01-20 15:43:37 +0100399 int dev = mmc_get_env_dev();
Tim Harveyc75648d2015-05-08 14:52:09 -0700400 const char *errmsg = NULL;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000401
Markus Niebel452a2722013-10-04 15:48:03 +0200402 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
403 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
404
Faiz Abbas26862b42018-02-12 19:24:31 +0530405 mmc_initialize(NULL);
406
Tom Rinib9c8cca2014-03-28 12:03:34 -0400407 mmc = find_mmc_device(dev);
408
Tim Harveyc75648d2015-05-08 14:52:09 -0700409 errmsg = init_mmc_for_env(mmc);
410 if (errmsg) {
Simon Glassc5951992017-08-03 12:22:17 -0600411 ret = -EIO;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000412 goto err;
413 }
414
415 if (mmc_get_env_addr(mmc, 0, &offset1) ||
416 mmc_get_env_addr(mmc, 1, &offset2)) {
Simon Glassc5951992017-08-03 12:22:17 -0600417 ret = -EIO;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000418 goto fini;
419 }
420
Patrick Delaunay46c90162022-11-10 11:48:59 +0100421 if (IS_ENABLED(ENV_MMC_HWPART_REDUND)) {
422 ret = mmc_set_env_part(mmc, 1);
423 if (ret)
424 goto fini;
425 }
Marek Vasutd11d1be2021-10-17 19:23:36 +0200426
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000427 read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
Marek Vasutd11d1be2021-10-17 19:23:36 +0200428
Patrick Delaunay46c90162022-11-10 11:48:59 +0100429 if (IS_ENABLED(ENV_MMC_HWPART_REDUND)) {
430 ret = mmc_set_env_part(mmc, 2);
431 if (ret)
432 goto fini;
433 }
Marek Vasutd11d1be2021-10-17 19:23:36 +0200434
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000435 read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
436
Simon Goldschmidt31f044b2018-01-31 14:47:11 +0100437 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
Marek Vasut890feec2020-07-07 20:51:35 +0200438 read2_fail, H_EXTERNAL);
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000439
440fini:
441 fini_mmc_for_env(mmc);
442err:
443 if (ret)
Simon Glass0ac7d722019-08-01 09:47:00 -0600444 env_set_default(errmsg, 0);
Simon Glassc5951992017-08-03 12:22:17 -0600445
Simon Glassc5951992017-08-03 12:22:17 -0600446 return ret;
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000447}
Patrick Delaunay46c90162022-11-10 11:48:59 +0100448#else /* ! CONFIG_SYS_REDUNDAND_ENVIRONMENT */
Simon Glassc5951992017-08-03 12:22:17 -0600449static int env_mmc_load(void)
Terry Lva8060352010-05-17 10:57:01 +0800450{
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400451 ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
Tom Rinib9c8cca2014-03-28 12:03:34 -0400452 struct mmc *mmc;
Mingkai Hu97039ab2011-01-24 17:09:55 +0000453 u32 offset;
Stephen Warren9404a5f2012-07-30 10:55:44 +0000454 int ret;
Clemens Grubere92029c2016-01-20 15:43:37 +0100455 int dev = mmc_get_env_dev();
Tim Harveyc75648d2015-05-08 14:52:09 -0700456 const char *errmsg;
Pankit Garg0536b442019-11-19 09:49:31 +0000457 env_t *ep = NULL;
Tom Rinib9c8cca2014-03-28 12:03:34 -0400458
Tom Rinib9c8cca2014-03-28 12:03:34 -0400459 mmc = find_mmc_device(dev);
Terry Lva8060352010-05-17 10:57:01 +0800460
Tim Harveyc75648d2015-05-08 14:52:09 -0700461 errmsg = init_mmc_for_env(mmc);
462 if (errmsg) {
Simon Glassc5951992017-08-03 12:22:17 -0600463 ret = -EIO;
Stephen Warren9404a5f2012-07-30 10:55:44 +0000464 goto err;
465 }
Terry Lva8060352010-05-17 10:57:01 +0800466
Michael Heimpoldd196bd82013-04-10 10:36:19 +0000467 if (mmc_get_env_addr(mmc, 0, &offset)) {
Simon Glassc5951992017-08-03 12:22:17 -0600468 ret = -EIO;
Stephen Warren9404a5f2012-07-30 10:55:44 +0000469 goto fini;
470 }
471
Tom Rinicd0f4fa2013-04-05 14:55:21 -0400472 if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
Tim Harveyc75648d2015-05-08 14:52:09 -0700473 errmsg = "!read failed";
Simon Glassc5951992017-08-03 12:22:17 -0600474 ret = -EIO;
Stephen Warren9404a5f2012-07-30 10:55:44 +0000475 goto fini;
476 }
Terry Lva8060352010-05-17 10:57:01 +0800477
Marek Vasut890feec2020-07-07 20:51:35 +0200478 ret = env_import(buf, 1, H_EXTERNAL);
Pankit Garg0536b442019-11-19 09:49:31 +0000479 if (!ret) {
480 ep = (env_t *)buf;
481 gd->env_addr = (ulong)&ep->data;
482 }
Stephen Warren9404a5f2012-07-30 10:55:44 +0000483
484fini:
485 fini_mmc_for_env(mmc);
486err:
487 if (ret)
Simon Glass0ac7d722019-08-01 09:47:00 -0600488 env_set_default(errmsg, 0);
Patrick Delaunay85660502022-11-10 11:49:00 +0100489
Simon Glassc5951992017-08-03 12:22:17 -0600490 return ret;
Terry Lva8060352010-05-17 10:57:01 +0800491}
Patrick Delaunay46c90162022-11-10 11:48:59 +0100492#endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */
Simon Glass4415f1d2017-08-03 12:21:58 -0600493
494U_BOOT_ENV_LOCATION(mmc) = {
495 .location = ENVL_MMC,
Simon Glassac358be2017-08-03 12:22:03 -0600496 ENV_NAME("MMC")
Simon Glasse5bce242017-08-03 12:22:01 -0600497 .load = env_mmc_load,
Simon Glassf7fac5e2023-11-18 14:04:51 -0700498#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
Simon Glasse5bce242017-08-03 12:22:01 -0600499 .save = env_save_ptr(env_mmc_save),
Patrick Delaunay1af031a2021-02-09 11:48:50 +0100500 .erase = ENV_ERASE_PTR(env_mmc_erase)
Simon Glass4415f1d2017-08-03 12:21:58 -0600501#endif
Simon Glass4415f1d2017-08-03 12:21:58 -0600502};