1 // SPDX-License-Identifier: GPL-2.0+
3 * (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
12 #include <env_internal.h>
14 #include <linux/stddef.h>
23 #define STR(X) __STR(X)
25 DECLARE_GLOBAL_DATA_PTR;
27 __weak int mmc_get_env_dev(void)
29 return CONFIG_SYS_MMC_ENV_DEV;
32 #if CONFIG_IS_ENABLED(OF_CONTROL)
33 static inline int mmc_offset_try_partition(const char *str, int copy, s64 *val)
35 struct disk_partition info;
36 struct blk_desc *desc;
40 snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev());
41 ret = blk_get_device_by_str("mmc", dev_str, &desc);
46 ret = part_get_info(desc, i, &info);
50 if (!strncmp((const char *)info.name, str, sizeof(str)))
54 /* round up to info.blksz */
55 len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz);
57 /* use the top of the partion for the environment */
58 *val = (info.start + info.size - (1 + copy) * len) * info.blksz;
63 static inline s64 mmc_offset(int copy)
66 const char *offset_redund;
67 const char *partition;
70 .offset_redund = "u-boot,mmc-env-offset-redundant",
71 .partition = "u-boot,mmc-env-partition",
72 .offset = "u-boot,mmc-env-offset",
74 s64 val = 0, defvalue;
79 /* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */
80 str = fdtdec_get_config_string(gd->fdt_blob, dt_prop.partition);
82 /* try to place the environment at end of the partition */
83 err = mmc_offset_try_partition(str, copy, &val);
88 defvalue = CONFIG_ENV_OFFSET;
89 propname = dt_prop.offset;
91 #if defined(CONFIG_ENV_OFFSET_REDUND)
93 defvalue = CONFIG_ENV_OFFSET_REDUND;
94 propname = dt_prop.offset_redund;
97 return fdtdec_get_config_int(gd->fdt_blob, propname, defvalue);
100 static inline s64 mmc_offset(int copy)
102 s64 offset = CONFIG_ENV_OFFSET;
104 #if defined(CONFIG_ENV_OFFSET_REDUND)
106 offset = CONFIG_ENV_OFFSET_REDUND;
112 __weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
114 s64 offset = mmc_offset(copy);
117 offset += mmc->capacity;
124 #ifdef CONFIG_SYS_MMC_ENV_PART
125 __weak uint mmc_get_env_part(struct mmc *mmc)
127 return CONFIG_SYS_MMC_ENV_PART;
130 static unsigned char env_mmc_orig_hwpart;
132 static int mmc_set_env_part(struct mmc *mmc)
134 uint part = mmc_get_env_part(mmc);
135 int dev = mmc_get_env_dev();
138 env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart;
139 ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
141 puts("MMC partition switch failed\n");
146 static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
149 static const char *init_mmc_for_env(struct mmc *mmc)
152 return "No MMC card found";
154 #if CONFIG_IS_ENABLED(BLK)
157 if (blk_get_from_parent(mmc->dev, &dev))
158 return "No block device";
161 return "MMC init failed";
163 if (mmc_set_env_part(mmc))
164 return "MMC partition switch failed";
169 static void fini_mmc_for_env(struct mmc *mmc)
171 #ifdef CONFIG_SYS_MMC_ENV_PART
172 int dev = mmc_get_env_dev();
174 blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart);
178 #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
179 static inline int write_env(struct mmc *mmc, unsigned long size,
180 unsigned long offset, const void *buffer)
182 uint blk_start, blk_cnt, n;
183 struct blk_desc *desc = mmc_get_blk_desc(mmc);
185 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
186 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
188 n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer);
190 return (n == blk_cnt) ? 0 : -1;
193 static int env_mmc_save(void)
195 ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
196 int dev = mmc_get_env_dev();
197 struct mmc *mmc = find_mmc_device(dev);
202 errmsg = init_mmc_for_env(mmc);
204 printf("%s\n", errmsg);
208 ret = env_export(env_new);
212 #ifdef CONFIG_ENV_OFFSET_REDUND
213 if (gd->env_valid == ENV_VALID)
217 if (mmc_get_env_addr(mmc, copy, &offset)) {
222 printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev);
223 if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
231 #ifdef CONFIG_ENV_OFFSET_REDUND
232 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
236 fini_mmc_for_env(mmc);
240 #if defined(CONFIG_CMD_ERASEENV)
241 static inline int erase_env(struct mmc *mmc, unsigned long size,
242 unsigned long offset)
244 uint blk_start, blk_cnt, n;
245 struct blk_desc *desc = mmc_get_blk_desc(mmc);
247 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
248 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
250 n = blk_derase(desc, blk_start, blk_cnt);
251 printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR");
253 return (n == blk_cnt) ? 0 : 1;
256 static int env_mmc_erase(void)
258 int dev = mmc_get_env_dev();
259 struct mmc *mmc = find_mmc_device(dev);
264 errmsg = init_mmc_for_env(mmc);
266 printf("%s\n", errmsg);
270 if (mmc_get_env_addr(mmc, copy, &offset))
271 return CMD_RET_FAILURE;
273 ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);
275 #ifdef CONFIG_ENV_OFFSET_REDUND
278 if (mmc_get_env_addr(mmc, copy, &offset))
279 return CMD_RET_FAILURE;
281 ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset);
286 #endif /* CONFIG_CMD_ERASEENV */
287 #endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */
289 static inline int read_env(struct mmc *mmc, unsigned long size,
290 unsigned long offset, const void *buffer)
292 uint blk_start, blk_cnt, n;
293 struct blk_desc *desc = mmc_get_blk_desc(mmc);
295 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
296 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
298 n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);
300 return (n == blk_cnt) ? 0 : -1;
303 #ifdef CONFIG_ENV_OFFSET_REDUND
304 static int env_mmc_load(void)
306 #if !defined(ENV_IS_EMBEDDED)
308 u32 offset1, offset2;
309 int read1_fail = 0, read2_fail = 0;
311 int dev = mmc_get_env_dev();
312 const char *errmsg = NULL;
314 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
315 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
317 mmc_initialize(NULL);
319 mmc = find_mmc_device(dev);
321 errmsg = init_mmc_for_env(mmc);
327 if (mmc_get_env_addr(mmc, 0, &offset1) ||
328 mmc_get_env_addr(mmc, 1, &offset2)) {
333 read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
334 read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
336 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
337 read2_fail, H_EXTERNAL);
340 fini_mmc_for_env(mmc);
343 env_set_default(errmsg, 0);
348 #else /* ! CONFIG_ENV_OFFSET_REDUND */
349 static int env_mmc_load(void)
351 #if !defined(ENV_IS_EMBEDDED)
352 ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
356 int dev = mmc_get_env_dev();
360 mmc = find_mmc_device(dev);
362 errmsg = init_mmc_for_env(mmc);
368 if (mmc_get_env_addr(mmc, 0, &offset)) {
373 if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
374 errmsg = "!read failed";
379 ret = env_import(buf, 1, H_EXTERNAL);
382 gd->env_addr = (ulong)&ep->data;
386 fini_mmc_for_env(mmc);
389 env_set_default(errmsg, 0);
393 #endif /* CONFIG_ENV_OFFSET_REDUND */
395 U_BOOT_ENV_LOCATION(mmc) = {
396 .location = ENVL_MMC,
398 .load = env_mmc_load,
399 #ifndef CONFIG_SPL_BUILD
400 .save = env_save_ptr(env_mmc_save),
401 #if defined(CONFIG_CMD_ERASEENV)
402 .erase = env_mmc_erase,