1 // SPDX-License-Identifier: GPL-2.0+
3 * (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
9 #include <asm/global_data.h>
13 #include <env_internal.h>
15 #include <linux/stddef.h>
24 #define STR(X) __STR(X)
26 DECLARE_GLOBAL_DATA_PTR;
28 #if CONFIG_IS_ENABLED(OF_CONTROL)
29 static inline int mmc_offset_try_partition(const char *str, int copy, s64 *val)
31 struct disk_partition info;
32 struct blk_desc *desc;
36 snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev());
37 ret = blk_get_device_by_str("mmc", dev_str, &desc);
42 ret = part_get_info(desc, i, &info);
46 if (!strncmp((const char *)info.name, str, sizeof(info.name)))
50 /* round up to info.blksz */
51 len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz);
53 /* use the top of the partion for the environment */
54 *val = (info.start + info.size - (1 + copy) * len) * info.blksz;
59 static inline s64 mmc_offset(int copy)
62 const char *offset_redund;
63 const char *partition;
66 .offset_redund = "u-boot,mmc-env-offset-redundant",
67 .partition = "u-boot,mmc-env-partition",
68 .offset = "u-boot,mmc-env-offset",
70 s64 val = 0, defvalue;
75 /* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */
76 str = fdtdec_get_config_string(gd->fdt_blob, dt_prop.partition);
78 /* try to place the environment at end of the partition */
79 err = mmc_offset_try_partition(str, copy, &val);
84 defvalue = CONFIG_ENV_OFFSET;
85 propname = dt_prop.offset;
87 #if defined(CONFIG_ENV_OFFSET_REDUND)
89 defvalue = CONFIG_ENV_OFFSET_REDUND;
90 propname = dt_prop.offset_redund;
93 return fdtdec_get_config_int(gd->fdt_blob, propname, defvalue);
96 static inline s64 mmc_offset(int copy)
98 s64 offset = CONFIG_ENV_OFFSET;
100 #if defined(CONFIG_ENV_OFFSET_REDUND)
102 offset = CONFIG_ENV_OFFSET_REDUND;
108 __weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
110 s64 offset = mmc_offset(copy);
113 offset += mmc->capacity;
120 #ifdef CONFIG_SYS_MMC_ENV_PART
121 __weak uint mmc_get_env_part(struct mmc *mmc)
123 return CONFIG_SYS_MMC_ENV_PART;
126 static unsigned char env_mmc_orig_hwpart;
128 static int mmc_set_env_part(struct mmc *mmc)
130 uint part = mmc_get_env_part(mmc);
131 int dev = mmc_get_env_dev();
134 env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart;
135 ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
137 puts("MMC partition switch failed\n");
142 static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
145 static const char *init_mmc_for_env(struct mmc *mmc)
148 return "No MMC card found";
150 #if CONFIG_IS_ENABLED(BLK)
153 if (blk_get_from_parent(mmc->dev, &dev))
154 return "No block device";
157 return "MMC init failed";
159 if (mmc_set_env_part(mmc))
160 return "MMC partition switch failed";
165 static void fini_mmc_for_env(struct mmc *mmc)
167 #ifdef CONFIG_SYS_MMC_ENV_PART
168 int dev = mmc_get_env_dev();
170 blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart);
174 #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
175 static inline int write_env(struct mmc *mmc, unsigned long size,
176 unsigned long offset, const void *buffer)
178 uint blk_start, blk_cnt, n;
179 struct blk_desc *desc = mmc_get_blk_desc(mmc);
181 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
182 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
184 n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer);
186 return (n == blk_cnt) ? 0 : -1;
189 static int env_mmc_save(void)
191 ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
192 int dev = mmc_get_env_dev();
193 struct mmc *mmc = find_mmc_device(dev);
198 errmsg = init_mmc_for_env(mmc);
200 printf("%s\n", errmsg);
204 ret = env_export(env_new);
208 #ifdef CONFIG_ENV_OFFSET_REDUND
209 if (gd->env_valid == ENV_VALID)
213 if (mmc_get_env_addr(mmc, copy, &offset)) {
218 printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev);
219 if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
227 #ifdef CONFIG_ENV_OFFSET_REDUND
228 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
232 fini_mmc_for_env(mmc);
236 #if defined(CONFIG_CMD_ERASEENV)
237 static inline int erase_env(struct mmc *mmc, unsigned long size,
238 unsigned long offset)
240 uint blk_start, blk_cnt, n;
241 struct blk_desc *desc = mmc_get_blk_desc(mmc);
243 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
244 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
246 n = blk_derase(desc, blk_start, blk_cnt);
247 printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR");
249 return (n == blk_cnt) ? 0 : 1;
252 static int env_mmc_erase(void)
254 int dev = mmc_get_env_dev();
255 struct mmc *mmc = find_mmc_device(dev);
260 errmsg = init_mmc_for_env(mmc);
262 printf("%s\n", errmsg);
266 if (mmc_get_env_addr(mmc, copy, &offset))
267 return CMD_RET_FAILURE;
269 ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);
271 #ifdef CONFIG_ENV_OFFSET_REDUND
274 if (mmc_get_env_addr(mmc, copy, &offset))
275 return CMD_RET_FAILURE;
277 ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset);
282 #endif /* CONFIG_CMD_ERASEENV */
283 #endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */
285 static inline int read_env(struct mmc *mmc, unsigned long size,
286 unsigned long offset, const void *buffer)
288 uint blk_start, blk_cnt, n;
289 struct blk_desc *desc = mmc_get_blk_desc(mmc);
291 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
292 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
294 n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);
296 return (n == blk_cnt) ? 0 : -1;
299 #ifdef CONFIG_ENV_OFFSET_REDUND
300 static int env_mmc_load(void)
302 #if !defined(ENV_IS_EMBEDDED)
304 u32 offset1, offset2;
305 int read1_fail = 0, read2_fail = 0;
307 int dev = mmc_get_env_dev();
308 const char *errmsg = NULL;
310 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
311 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
313 mmc_initialize(NULL);
315 mmc = find_mmc_device(dev);
317 errmsg = init_mmc_for_env(mmc);
323 if (mmc_get_env_addr(mmc, 0, &offset1) ||
324 mmc_get_env_addr(mmc, 1, &offset2)) {
329 read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
330 read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
332 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
333 read2_fail, H_EXTERNAL);
336 fini_mmc_for_env(mmc);
339 env_set_default(errmsg, 0);
344 #else /* ! CONFIG_ENV_OFFSET_REDUND */
345 static int env_mmc_load(void)
347 #if !defined(ENV_IS_EMBEDDED)
348 ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
352 int dev = mmc_get_env_dev();
356 mmc = find_mmc_device(dev);
358 errmsg = init_mmc_for_env(mmc);
364 if (mmc_get_env_addr(mmc, 0, &offset)) {
369 if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
370 errmsg = "!read failed";
375 ret = env_import(buf, 1, H_EXTERNAL);
378 gd->env_addr = (ulong)&ep->data;
382 fini_mmc_for_env(mmc);
385 env_set_default(errmsg, 0);
389 #endif /* CONFIG_ENV_OFFSET_REDUND */
391 U_BOOT_ENV_LOCATION(mmc) = {
392 .location = ENVL_MMC,
394 .load = env_mmc_load,
395 #ifndef CONFIG_SPL_BUILD
396 .save = env_save_ptr(env_mmc_save),
397 #if defined(CONFIG_CMD_ERASEENV)
398 .erase = env_mmc_erase,