Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 2 | /* |
Mingkai Hu | 97039ab | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 3 | * (C) Copyright 2008-2011 Freescale Semiconductor, Inc. |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 4 | */ |
| 5 | |
| 6 | /* #define DEBUG */ |
| 7 | |
| 8 | #include <common.h> |
Simon Glass | 401d1c4 | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 9 | #include <asm/global_data.h> |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 10 | |
| 11 | #include <command.h> |
Simon Glass | 0ac7d72 | 2019-08-01 09:47:00 -0600 | [diff] [blame] | 12 | #include <env.h> |
Simon Glass | f3998fd | 2019-08-02 09:44:25 -0600 | [diff] [blame] | 13 | #include <env_internal.h> |
Philipp Tomsich | f8b8a55 | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 14 | #include <fdtdec.h> |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 15 | #include <linux/stddef.h> |
| 16 | #include <malloc.h> |
Simon Glass | cf92e05 | 2015-09-02 17:24:58 -0600 | [diff] [blame] | 17 | #include <memalign.h> |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 18 | #include <mmc.h> |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 19 | #include <part.h> |
Lei Wen | 6d1d51b | 2010-11-10 07:39:23 +0800 | [diff] [blame] | 20 | #include <search.h> |
Lei Wen | e79f483 | 2010-10-13 11:07:21 +0800 | [diff] [blame] | 21 | #include <errno.h> |
Simon Glass | 7de8bd0 | 2021-08-07 07:24:01 -0600 | [diff] [blame] | 22 | #include <dm/ofnode.h> |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 23 | |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 24 | #define __STR(X) #X |
| 25 | #define STR(X) __STR(X) |
| 26 | |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 27 | DECLARE_GLOBAL_DATA_PTR; |
| 28 | |
Marek Vasut | d11d1be | 2021-10-17 19:23:36 +0200 | [diff] [blame] | 29 | /* |
| 30 | * In case the environment is redundant, stored in eMMC hardware boot |
| 31 | * partition and the environment and redundant environment offsets are |
| 32 | * identical, store the environment and redundant environment in both |
| 33 | * eMMC boot partitions, one copy in each. |
| 34 | * */ |
| 35 | #if (defined(CONFIG_SYS_REDUNDAND_ENVIRONMENT) && \ |
| 36 | (CONFIG_SYS_MMC_ENV_PART == 1) && \ |
| 37 | (CONFIG_ENV_OFFSET == CONFIG_ENV_OFFSET_REDUND)) |
| 38 | #define ENV_MMC_HWPART_REDUND |
| 39 | #endif |
| 40 | |
Philipp Tomsich | f8b8a55 | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 41 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
Patrick Delaunay | 5d4f7b4 | 2020-06-15 10:38:57 +0200 | [diff] [blame] | 42 | static inline int mmc_offset_try_partition(const char *str, int copy, s64 *val) |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 43 | { |
Simon Glass | 0528979 | 2020-05-10 11:39:57 -0600 | [diff] [blame] | 44 | struct disk_partition info; |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 45 | struct blk_desc *desc; |
| 46 | int len, i, ret; |
Patrick Delaunay | 2b2f727 | 2020-06-15 10:38:55 +0200 | [diff] [blame] | 47 | char dev_str[4]; |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 48 | |
Patrick Delaunay | 2b2f727 | 2020-06-15 10:38:55 +0200 | [diff] [blame] | 49 | snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev()); |
| 50 | ret = blk_get_device_by_str("mmc", dev_str, &desc); |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 51 | if (ret < 0) |
| 52 | return (ret); |
| 53 | |
| 54 | for (i = 1;;i++) { |
| 55 | ret = part_get_info(desc, i, &info); |
| 56 | if (ret < 0) |
| 57 | return ret; |
| 58 | |
Hoyeonjiki Kim | 2a0a577 | 2020-11-17 12:32:08 +0900 | [diff] [blame] | 59 | if (!strncmp((const char *)info.name, str, sizeof(info.name))) |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 60 | break; |
| 61 | } |
| 62 | |
| 63 | /* round up to info.blksz */ |
Patrick Delaunay | 76b640c | 2020-06-15 10:38:56 +0200 | [diff] [blame] | 64 | len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz); |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 65 | |
| 66 | /* use the top of the partion for the environment */ |
Patrick Delaunay | 5d4f7b4 | 2020-06-15 10:38:57 +0200 | [diff] [blame] | 67 | *val = (info.start + info.size - (1 + copy) * len) * info.blksz; |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 68 | |
| 69 | return 0; |
| 70 | } |
| 71 | |
Philipp Tomsich | f8b8a55 | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 72 | static inline s64 mmc_offset(int copy) |
Mingkai Hu | 97039ab | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 73 | { |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 74 | const struct { |
| 75 | const char *offset_redund; |
| 76 | const char *partition; |
| 77 | const char *offset; |
| 78 | } dt_prop = { |
| 79 | .offset_redund = "u-boot,mmc-env-offset-redundant", |
| 80 | .partition = "u-boot,mmc-env-partition", |
| 81 | .offset = "u-boot,mmc-env-offset", |
| 82 | }; |
Philipp Tomsich | fd37466 | 2017-11-21 23:29:40 +0100 | [diff] [blame] | 83 | s64 val = 0, defvalue; |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 84 | const char *propname; |
| 85 | const char *str; |
| 86 | int err; |
| 87 | |
| 88 | /* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */ |
Simon Glass | 7de8bd0 | 2021-08-07 07:24:01 -0600 | [diff] [blame] | 89 | str = ofnode_conf_read_str(dt_prop.partition); |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 90 | if (str) { |
| 91 | /* try to place the environment at end of the partition */ |
Patrick Delaunay | 5d4f7b4 | 2020-06-15 10:38:57 +0200 | [diff] [blame] | 92 | err = mmc_offset_try_partition(str, copy, &val); |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 93 | if (!err) |
| 94 | return val; |
| 95 | } |
| 96 | |
| 97 | defvalue = CONFIG_ENV_OFFSET; |
| 98 | propname = dt_prop.offset; |
Stephen Warren | 5c088ee | 2013-06-11 15:14:02 -0600 | [diff] [blame] | 99 | |
Philipp Tomsich | f8b8a55 | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 100 | #if defined(CONFIG_ENV_OFFSET_REDUND) |
| 101 | if (copy) { |
Philipp Tomsich | f8b8a55 | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 102 | defvalue = CONFIG_ENV_OFFSET_REDUND; |
Jorge Ramirez-Ortiz | c9e87ba | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 103 | propname = dt_prop.offset_redund; |
Philipp Tomsich | f8b8a55 | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 104 | } |
| 105 | #endif |
Simon Glass | 7de8bd0 | 2021-08-07 07:24:01 -0600 | [diff] [blame] | 106 | return ofnode_conf_read_int(propname, defvalue); |
Philipp Tomsich | f8b8a55 | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 107 | } |
| 108 | #else |
| 109 | static inline s64 mmc_offset(int copy) |
| 110 | { |
| 111 | s64 offset = CONFIG_ENV_OFFSET; |
| 112 | |
| 113 | #if defined(CONFIG_ENV_OFFSET_REDUND) |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 114 | if (copy) |
Stephen Warren | 5c088ee | 2013-06-11 15:14:02 -0600 | [diff] [blame] | 115 | offset = CONFIG_ENV_OFFSET_REDUND; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 116 | #endif |
Philipp Tomsich | f8b8a55 | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 117 | return offset; |
| 118 | } |
| 119 | #endif |
| 120 | |
| 121 | __weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr) |
| 122 | { |
| 123 | s64 offset = mmc_offset(copy); |
Stephen Warren | 5c088ee | 2013-06-11 15:14:02 -0600 | [diff] [blame] | 124 | |
| 125 | if (offset < 0) |
| 126 | offset += mmc->capacity; |
| 127 | |
| 128 | *env_addr = offset; |
| 129 | |
Mingkai Hu | 97039ab | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 130 | return 0; |
| 131 | } |
Mingkai Hu | 97039ab | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 132 | |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 133 | #ifdef CONFIG_SYS_MMC_ENV_PART |
Dmitry Lifshitz | 6e7b7df | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 134 | __weak uint mmc_get_env_part(struct mmc *mmc) |
| 135 | { |
| 136 | return CONFIG_SYS_MMC_ENV_PART; |
| 137 | } |
| 138 | |
Stephen Warren | 873cc1d | 2015-12-07 11:38:49 -0700 | [diff] [blame] | 139 | static unsigned char env_mmc_orig_hwpart; |
| 140 | |
Marek Vasut | d11d1be | 2021-10-17 19:23:36 +0200 | [diff] [blame] | 141 | static int mmc_set_env_part(struct mmc *mmc, uint part) |
Dmitry Lifshitz | 6e7b7df | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 142 | { |
Clemens Gruber | e92029c | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 143 | int dev = mmc_get_env_dev(); |
Dmitry Lifshitz | 6e7b7df | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 144 | int ret = 0; |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 145 | |
Simon Glass | 69f45cd | 2016-05-01 13:52:29 -0600 | [diff] [blame] | 146 | ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part); |
Stephen Warren | 873cc1d | 2015-12-07 11:38:49 -0700 | [diff] [blame] | 147 | if (ret) |
| 148 | puts("MMC partition switch failed\n"); |
Dmitry Lifshitz | 6e7b7df | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 149 | |
| 150 | return ret; |
| 151 | } |
| 152 | #else |
Marek Vasut | d11d1be | 2021-10-17 19:23:36 +0200 | [diff] [blame] | 153 | static inline int mmc_set_env_part(struct mmc *mmc, uint part) {return 0; }; |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 154 | #endif |
| 155 | |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 156 | static const char *init_mmc_for_env(struct mmc *mmc) |
Dmitry Lifshitz | 6e7b7df | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 157 | { |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 158 | if (!mmc) |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 159 | return "No MMC card found"; |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 160 | |
Sjoerd Simons | d48b8d1 | 2018-03-22 22:53:50 +0100 | [diff] [blame] | 161 | #if CONFIG_IS_ENABLED(BLK) |
Simon Glass | 01b73fe | 2017-05-27 11:37:18 -0600 | [diff] [blame] | 162 | struct udevice *dev; |
| 163 | |
| 164 | if (blk_get_from_parent(mmc->dev, &dev)) |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 165 | return "No block device"; |
Simon Glass | 01b73fe | 2017-05-27 11:37:18 -0600 | [diff] [blame] | 166 | #else |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 167 | if (mmc_init(mmc)) |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 168 | return "MMC init failed"; |
Simon Glass | e7017a3 | 2017-04-23 20:02:04 -0600 | [diff] [blame] | 169 | #endif |
Marek Vasut | d11d1be | 2021-10-17 19:23:36 +0200 | [diff] [blame] | 170 | env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart; |
| 171 | if (mmc_set_env_part(mmc, mmc_get_env_part(mmc))) |
Yaniv Levinsky | c5d548a | 2018-06-24 19:16:57 +0300 | [diff] [blame] | 172 | return "MMC partition switch failed"; |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 173 | |
| 174 | return NULL; |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 175 | } |
| 176 | |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 177 | static void fini_mmc_for_env(struct mmc *mmc) |
| 178 | { |
| 179 | #ifdef CONFIG_SYS_MMC_ENV_PART |
Clemens Gruber | e92029c | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 180 | int dev = mmc_get_env_dev(); |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 181 | |
Simon Glass | 69f45cd | 2016-05-01 13:52:29 -0600 | [diff] [blame] | 182 | blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart); |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 183 | #endif |
| 184 | } |
| 185 | |
Simon Glass | e5bce24 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 186 | #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD) |
Igor Grinberg | e8db8f7 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 187 | static inline int write_env(struct mmc *mmc, unsigned long size, |
| 188 | unsigned long offset, const void *buffer) |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 189 | { |
| 190 | uint blk_start, blk_cnt, n; |
Simon Glass | 5461acb | 2016-05-14 14:03:03 -0600 | [diff] [blame] | 191 | struct blk_desc *desc = mmc_get_blk_desc(mmc); |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 192 | |
Igor Grinberg | e8db8f7 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 193 | blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len; |
| 194 | blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len; |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 195 | |
Simon Glass | 5461acb | 2016-05-14 14:03:03 -0600 | [diff] [blame] | 196 | n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer); |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 197 | |
| 198 | return (n == blk_cnt) ? 0 : -1; |
| 199 | } |
| 200 | |
Simon Glass | e5bce24 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 201 | static int env_mmc_save(void) |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 202 | { |
Tom Rini | cd0f4fa | 2013-04-05 14:55:21 -0400 | [diff] [blame] | 203 | ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); |
Clemens Gruber | e92029c | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 204 | int dev = mmc_get_env_dev(); |
| 205 | struct mmc *mmc = find_mmc_device(dev); |
Igor Grinberg | e8db8f7 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 206 | u32 offset; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 207 | int ret, copy = 0; |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 208 | const char *errmsg; |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 209 | |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 210 | errmsg = init_mmc_for_env(mmc); |
| 211 | if (errmsg) { |
| 212 | printf("%s\n", errmsg); |
Mingkai Hu | 97039ab | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 213 | return 1; |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 214 | } |
Mingkai Hu | 97039ab | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 215 | |
Marek Vasut | 7ce1526 | 2014-03-05 19:59:50 +0100 | [diff] [blame] | 216 | ret = env_export(env_new); |
| 217 | if (ret) |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 218 | goto fini; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 219 | |
| 220 | #ifdef CONFIG_ENV_OFFSET_REDUND |
Simon Glass | 203e94f | 2017-08-03 12:21:56 -0600 | [diff] [blame] | 221 | if (gd->env_valid == ENV_VALID) |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 222 | copy = 1; |
Marek Vasut | d11d1be | 2021-10-17 19:23:36 +0200 | [diff] [blame] | 223 | |
| 224 | #ifdef ENV_MMC_HWPART_REDUND |
| 225 | ret = mmc_set_env_part(mmc, copy + 1); |
| 226 | if (ret) |
| 227 | goto fini; |
| 228 | #endif |
| 229 | |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 230 | #endif |
| 231 | |
| 232 | if (mmc_get_env_addr(mmc, copy, &offset)) { |
| 233 | ret = 1; |
| 234 | goto fini; |
| 235 | } |
| 236 | |
Clemens Gruber | e92029c | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 237 | printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev); |
Stephen Warren | 4036b63 | 2012-05-24 11:38:33 +0000 | [diff] [blame] | 238 | if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) { |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 239 | puts("failed\n"); |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 240 | ret = 1; |
| 241 | goto fini; |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 242 | } |
| 243 | |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 244 | ret = 0; |
| 245 | |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 246 | #ifdef CONFIG_ENV_OFFSET_REDUND |
Simon Glass | 203e94f | 2017-08-03 12:21:56 -0600 | [diff] [blame] | 247 | gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 248 | #endif |
| 249 | |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 250 | fini: |
| 251 | fini_mmc_for_env(mmc); |
| 252 | return ret; |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 253 | } |
Frank Wunderlich | 3485392 | 2019-06-29 11:36:20 +0200 | [diff] [blame] | 254 | |
Frank Wunderlich | 3485392 | 2019-06-29 11:36:20 +0200 | [diff] [blame] | 255 | static inline int erase_env(struct mmc *mmc, unsigned long size, |
| 256 | unsigned long offset) |
| 257 | { |
| 258 | uint blk_start, blk_cnt, n; |
| 259 | struct blk_desc *desc = mmc_get_blk_desc(mmc); |
| 260 | |
| 261 | blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len; |
| 262 | blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len; |
| 263 | |
| 264 | n = blk_derase(desc, blk_start, blk_cnt); |
| 265 | printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR"); |
| 266 | |
| 267 | return (n == blk_cnt) ? 0 : 1; |
| 268 | } |
| 269 | |
| 270 | static int env_mmc_erase(void) |
| 271 | { |
| 272 | int dev = mmc_get_env_dev(); |
| 273 | struct mmc *mmc = find_mmc_device(dev); |
| 274 | int ret, copy = 0; |
| 275 | u32 offset; |
| 276 | const char *errmsg; |
| 277 | |
| 278 | errmsg = init_mmc_for_env(mmc); |
| 279 | if (errmsg) { |
| 280 | printf("%s\n", errmsg); |
| 281 | return 1; |
| 282 | } |
| 283 | |
Marek Vasut | f47f87f | 2021-10-06 18:29:53 +0200 | [diff] [blame] | 284 | if (mmc_get_env_addr(mmc, copy, &offset)) { |
| 285 | ret = CMD_RET_FAILURE; |
| 286 | goto fini; |
| 287 | } |
Frank Wunderlich | 3485392 | 2019-06-29 11:36:20 +0200 | [diff] [blame] | 288 | |
| 289 | ret = erase_env(mmc, CONFIG_ENV_SIZE, offset); |
| 290 | |
| 291 | #ifdef CONFIG_ENV_OFFSET_REDUND |
| 292 | copy = 1; |
| 293 | |
Marek Vasut | d11d1be | 2021-10-17 19:23:36 +0200 | [diff] [blame] | 294 | #ifdef ENV_MMC_HWPART_REDUND |
| 295 | ret = mmc_set_env_part(mmc, copy + 1); |
| 296 | if (ret) |
| 297 | goto fini; |
| 298 | #endif |
| 299 | |
Marek Vasut | f47f87f | 2021-10-06 18:29:53 +0200 | [diff] [blame] | 300 | if (mmc_get_env_addr(mmc, copy, &offset)) { |
| 301 | ret = CMD_RET_FAILURE; |
| 302 | goto fini; |
| 303 | } |
Frank Wunderlich | 3485392 | 2019-06-29 11:36:20 +0200 | [diff] [blame] | 304 | |
| 305 | ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset); |
| 306 | #endif |
| 307 | |
Marek Vasut | f47f87f | 2021-10-06 18:29:53 +0200 | [diff] [blame] | 308 | fini: |
| 309 | fini_mmc_for_env(mmc); |
Frank Wunderlich | 3485392 | 2019-06-29 11:36:20 +0200 | [diff] [blame] | 310 | return ret; |
| 311 | } |
Simon Glass | e5bce24 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 312 | #endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */ |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 313 | |
Igor Grinberg | e8db8f7 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 314 | static inline int read_env(struct mmc *mmc, unsigned long size, |
| 315 | unsigned long offset, const void *buffer) |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 316 | { |
| 317 | uint blk_start, blk_cnt, n; |
Simon Glass | 5461acb | 2016-05-14 14:03:03 -0600 | [diff] [blame] | 318 | struct blk_desc *desc = mmc_get_blk_desc(mmc); |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 319 | |
Igor Grinberg | e8db8f7 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 320 | blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len; |
| 321 | blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len; |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 322 | |
Simon Glass | 5461acb | 2016-05-14 14:03:03 -0600 | [diff] [blame] | 323 | n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer); |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 324 | |
| 325 | return (n == blk_cnt) ? 0 : -1; |
| 326 | } |
| 327 | |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 328 | #ifdef CONFIG_ENV_OFFSET_REDUND |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 329 | static int env_mmc_load(void) |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 330 | { |
| 331 | #if !defined(ENV_IS_EMBEDDED) |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 332 | struct mmc *mmc; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 333 | u32 offset1, offset2; |
| 334 | int read1_fail = 0, read2_fail = 0; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 335 | int ret; |
Clemens Gruber | e92029c | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 336 | int dev = mmc_get_env_dev(); |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 337 | const char *errmsg = NULL; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 338 | |
Markus Niebel | 452a272 | 2013-10-04 15:48:03 +0200 | [diff] [blame] | 339 | ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1); |
| 340 | ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1); |
| 341 | |
Faiz Abbas | 26862b4 | 2018-02-12 19:24:31 +0530 | [diff] [blame] | 342 | mmc_initialize(NULL); |
| 343 | |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 344 | mmc = find_mmc_device(dev); |
| 345 | |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 346 | errmsg = init_mmc_for_env(mmc); |
| 347 | if (errmsg) { |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 348 | ret = -EIO; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 349 | goto err; |
| 350 | } |
| 351 | |
| 352 | if (mmc_get_env_addr(mmc, 0, &offset1) || |
| 353 | mmc_get_env_addr(mmc, 1, &offset2)) { |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 354 | ret = -EIO; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 355 | goto fini; |
| 356 | } |
| 357 | |
Marek Vasut | d11d1be | 2021-10-17 19:23:36 +0200 | [diff] [blame] | 358 | #ifdef ENV_MMC_HWPART_REDUND |
| 359 | ret = mmc_set_env_part(mmc, 1); |
| 360 | if (ret) |
| 361 | goto fini; |
| 362 | #endif |
| 363 | |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 364 | read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1); |
Marek Vasut | d11d1be | 2021-10-17 19:23:36 +0200 | [diff] [blame] | 365 | |
| 366 | #ifdef ENV_MMC_HWPART_REDUND |
| 367 | ret = mmc_set_env_part(mmc, 2); |
| 368 | if (ret) |
| 369 | goto fini; |
| 370 | #endif |
| 371 | |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 372 | read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2); |
| 373 | |
Simon Goldschmidt | 31f044b | 2018-01-31 14:47:11 +0100 | [diff] [blame] | 374 | ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2, |
Marek Vasut | 890feec | 2020-07-07 20:51:35 +0200 | [diff] [blame] | 375 | read2_fail, H_EXTERNAL); |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 376 | |
| 377 | fini: |
| 378 | fini_mmc_for_env(mmc); |
| 379 | err: |
| 380 | if (ret) |
Simon Glass | 0ac7d72 | 2019-08-01 09:47:00 -0600 | [diff] [blame] | 381 | env_set_default(errmsg, 0); |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 382 | |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 383 | #endif |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 384 | return ret; |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 385 | } |
| 386 | #else /* ! CONFIG_ENV_OFFSET_REDUND */ |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 387 | static int env_mmc_load(void) |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 388 | { |
| 389 | #if !defined(ENV_IS_EMBEDDED) |
Tom Rini | cd0f4fa | 2013-04-05 14:55:21 -0400 | [diff] [blame] | 390 | ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 391 | struct mmc *mmc; |
Mingkai Hu | 97039ab | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 392 | u32 offset; |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 393 | int ret; |
Clemens Gruber | e92029c | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 394 | int dev = mmc_get_env_dev(); |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 395 | const char *errmsg; |
Pankit Garg | 0536b44 | 2019-11-19 09:49:31 +0000 | [diff] [blame] | 396 | env_t *ep = NULL; |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 397 | |
Tom Rini | b9c8cca | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 398 | mmc = find_mmc_device(dev); |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 399 | |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 400 | errmsg = init_mmc_for_env(mmc); |
| 401 | if (errmsg) { |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 402 | ret = -EIO; |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 403 | goto err; |
| 404 | } |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 405 | |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 406 | if (mmc_get_env_addr(mmc, 0, &offset)) { |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 407 | ret = -EIO; |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 408 | goto fini; |
| 409 | } |
| 410 | |
Tom Rini | cd0f4fa | 2013-04-05 14:55:21 -0400 | [diff] [blame] | 411 | if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) { |
Tim Harvey | c75648d | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 412 | errmsg = "!read failed"; |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 413 | ret = -EIO; |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 414 | goto fini; |
| 415 | } |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 416 | |
Marek Vasut | 890feec | 2020-07-07 20:51:35 +0200 | [diff] [blame] | 417 | ret = env_import(buf, 1, H_EXTERNAL); |
Pankit Garg | 0536b44 | 2019-11-19 09:49:31 +0000 | [diff] [blame] | 418 | if (!ret) { |
| 419 | ep = (env_t *)buf; |
| 420 | gd->env_addr = (ulong)&ep->data; |
| 421 | } |
Stephen Warren | 9404a5f | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 422 | |
| 423 | fini: |
| 424 | fini_mmc_for_env(mmc); |
| 425 | err: |
| 426 | if (ret) |
Simon Glass | 0ac7d72 | 2019-08-01 09:47:00 -0600 | [diff] [blame] | 427 | env_set_default(errmsg, 0); |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 428 | #endif |
Simon Glass | c595199 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 429 | return ret; |
Terry Lv | a806035 | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 430 | } |
Michael Heimpold | d196bd8 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 431 | #endif /* CONFIG_ENV_OFFSET_REDUND */ |
Simon Glass | 4415f1d | 2017-08-03 12:21:58 -0600 | [diff] [blame] | 432 | |
| 433 | U_BOOT_ENV_LOCATION(mmc) = { |
| 434 | .location = ENVL_MMC, |
Simon Glass | ac358be | 2017-08-03 12:22:03 -0600 | [diff] [blame] | 435 | ENV_NAME("MMC") |
Simon Glass | e5bce24 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 436 | .load = env_mmc_load, |
Simon Glass | 4415f1d | 2017-08-03 12:21:58 -0600 | [diff] [blame] | 437 | #ifndef CONFIG_SPL_BUILD |
Simon Glass | e5bce24 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 438 | .save = env_save_ptr(env_mmc_save), |
Patrick Delaunay | 1af031a | 2021-02-09 11:48:50 +0100 | [diff] [blame] | 439 | .erase = ENV_ERASE_PTR(env_mmc_erase) |
Simon Glass | 4415f1d | 2017-08-03 12:21:58 -0600 | [diff] [blame] | 440 | #endif |
Simon Glass | 4415f1d | 2017-08-03 12:21:58 -0600 | [diff] [blame] | 441 | }; |