Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 1 | /* |
Mingkai Hu | a55fce3 | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 2 | * (C) Copyright 2008-2011 Freescale Semiconductor, Inc. |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 3 | * |
Wolfgang Denk | bd8ec7e | 2013-10-07 13:07:26 +0200 | [diff] [blame] | 4 | * SPDX-License-Identifier: GPL-2.0+ |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 5 | */ |
| 6 | |
| 7 | /* #define DEBUG */ |
| 8 | |
| 9 | #include <common.h> |
| 10 | |
| 11 | #include <command.h> |
| 12 | #include <environment.h> |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 13 | #include <fdtdec.h> |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 14 | #include <linux/stddef.h> |
| 15 | #include <malloc.h> |
Simon Glass | 2dd337a | 2015-09-02 17:24:58 -0600 | [diff] [blame] | 16 | #include <memalign.h> |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 17 | #include <mmc.h> |
Jorge Ramirez-Ortiz | 03ab46c | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 18 | #include <part.h> |
Lei Wen | 9f84f21 | 2010-11-10 07:39:23 +0800 | [diff] [blame] | 19 | #include <search.h> |
Lei Wen | ff833ed | 2010-10-13 11:07:21 +0800 | [diff] [blame] | 20 | #include <errno.h> |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 21 | |
Jorge Ramirez-Ortiz | 03ab46c | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 22 | #define __STR(X) #X |
| 23 | #define STR(X) __STR(X) |
| 24 | |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 25 | #if defined(CONFIG_ENV_SIZE_REDUND) && \ |
| 26 | (CONFIG_ENV_SIZE_REDUND != CONFIG_ENV_SIZE) |
| 27 | #error CONFIG_ENV_SIZE_REDUND should be the same as CONFIG_ENV_SIZE |
| 28 | #endif |
| 29 | |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 30 | DECLARE_GLOBAL_DATA_PTR; |
| 31 | |
Mingkai Hu | a55fce3 | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 32 | #if !defined(CONFIG_ENV_OFFSET) |
| 33 | #define CONFIG_ENV_OFFSET 0 |
| 34 | #endif |
| 35 | |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 36 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
Jorge Ramirez-Ortiz | 03ab46c | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 37 | static inline int mmc_offset_try_partition(const char *str, s64 *val) |
| 38 | { |
| 39 | disk_partition_t info; |
| 40 | struct blk_desc *desc; |
| 41 | int len, i, ret; |
| 42 | |
| 43 | ret = blk_get_device_by_str("mmc", STR(CONFIG_SYS_MMC_ENV_DEV), &desc); |
| 44 | if (ret < 0) |
| 45 | return (ret); |
| 46 | |
| 47 | for (i = 1;;i++) { |
| 48 | ret = part_get_info(desc, i, &info); |
| 49 | if (ret < 0) |
| 50 | return ret; |
| 51 | |
| 52 | if (!strncmp((const char *)info.name, str, sizeof(str))) |
| 53 | break; |
| 54 | } |
| 55 | |
| 56 | /* round up to info.blksz */ |
| 57 | len = (CONFIG_ENV_SIZE + info.blksz - 1) & ~(info.blksz - 1); |
| 58 | |
| 59 | /* use the top of the partion for the environment */ |
| 60 | *val = (info.start + info.size - 1) - len / info.blksz; |
| 61 | |
| 62 | return 0; |
| 63 | } |
| 64 | |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 65 | static inline s64 mmc_offset(int copy) |
| 66 | { |
Jorge Ramirez-Ortiz | 03ab46c | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 67 | const struct { |
| 68 | const char *offset_redund; |
| 69 | const char *partition; |
| 70 | const char *offset; |
| 71 | } dt_prop = { |
| 72 | .offset_redund = "u-boot,mmc-env-offset-redundant", |
| 73 | .partition = "u-boot,mmc-env-partition", |
| 74 | .offset = "u-boot,mmc-env-offset", |
| 75 | }; |
Philipp Tomsich | 745d8de | 2017-11-21 23:29:40 +0100 | [diff] [blame] | 76 | s64 val = 0, defvalue; |
Jorge Ramirez-Ortiz | 03ab46c | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 77 | const char *propname; |
| 78 | const char *str; |
| 79 | int err; |
| 80 | |
| 81 | /* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */ |
| 82 | str = fdtdec_get_config_string(gd->fdt_blob, dt_prop.partition); |
| 83 | if (str) { |
| 84 | /* try to place the environment at end of the partition */ |
| 85 | err = mmc_offset_try_partition(str, &val); |
| 86 | if (!err) |
| 87 | return val; |
| 88 | } |
| 89 | |
| 90 | defvalue = CONFIG_ENV_OFFSET; |
| 91 | propname = dt_prop.offset; |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 92 | |
| 93 | #if defined(CONFIG_ENV_OFFSET_REDUND) |
| 94 | if (copy) { |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 95 | defvalue = CONFIG_ENV_OFFSET_REDUND; |
Jorge Ramirez-Ortiz | 03ab46c | 2017-11-06 14:16:37 +0100 | [diff] [blame] | 96 | propname = dt_prop.offset_redund; |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 97 | } |
| 98 | #endif |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 99 | return fdtdec_get_config_int(gd->fdt_blob, propname, defvalue); |
| 100 | } |
| 101 | #else |
| 102 | static inline s64 mmc_offset(int copy) |
Mingkai Hu | a55fce3 | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 103 | { |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 104 | s64 offset = CONFIG_ENV_OFFSET; |
Stephen Warren | 24dc203 | 2013-06-11 15:14:02 -0600 | [diff] [blame] | 105 | |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 106 | #if defined(CONFIG_ENV_OFFSET_REDUND) |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 107 | if (copy) |
Stephen Warren | 24dc203 | 2013-06-11 15:14:02 -0600 | [diff] [blame] | 108 | offset = CONFIG_ENV_OFFSET_REDUND; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 109 | #endif |
Philipp Tomsich | 8ab507b | 2017-05-16 00:16:31 +0200 | [diff] [blame] | 110 | return offset; |
| 111 | } |
| 112 | #endif |
| 113 | |
| 114 | __weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr) |
| 115 | { |
| 116 | s64 offset = mmc_offset(copy); |
Stephen Warren | 24dc203 | 2013-06-11 15:14:02 -0600 | [diff] [blame] | 117 | |
| 118 | if (offset < 0) |
| 119 | offset += mmc->capacity; |
| 120 | |
| 121 | *env_addr = offset; |
| 122 | |
Mingkai Hu | a55fce3 | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 123 | return 0; |
| 124 | } |
Mingkai Hu | a55fce3 | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 125 | |
Clemens Gruber | f7b6144 | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 126 | __weak int mmc_get_env_dev(void) |
| 127 | { |
| 128 | return CONFIG_SYS_MMC_ENV_DEV; |
| 129 | } |
| 130 | |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 131 | #ifdef CONFIG_SYS_MMC_ENV_PART |
Dmitry Lifshitz | 97d2fb9 | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 132 | __weak uint mmc_get_env_part(struct mmc *mmc) |
| 133 | { |
| 134 | return CONFIG_SYS_MMC_ENV_PART; |
| 135 | } |
| 136 | |
Stephen Warren | 1e0f92a | 2015-12-07 11:38:49 -0700 | [diff] [blame] | 137 | static unsigned char env_mmc_orig_hwpart; |
| 138 | |
Dmitry Lifshitz | 97d2fb9 | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 139 | static int mmc_set_env_part(struct mmc *mmc) |
| 140 | { |
| 141 | uint part = mmc_get_env_part(mmc); |
Clemens Gruber | f7b6144 | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 142 | int dev = mmc_get_env_dev(); |
Dmitry Lifshitz | 97d2fb9 | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 143 | int ret = 0; |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 144 | |
Simon Glass | 11f2bb6 | 2016-05-01 13:52:29 -0600 | [diff] [blame] | 145 | env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart; |
| 146 | ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part); |
Stephen Warren | 1e0f92a | 2015-12-07 11:38:49 -0700 | [diff] [blame] | 147 | if (ret) |
| 148 | puts("MMC partition switch failed\n"); |
Dmitry Lifshitz | 97d2fb9 | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 149 | |
| 150 | return ret; |
| 151 | } |
| 152 | #else |
| 153 | static inline int mmc_set_env_part(struct mmc *mmc) {return 0; }; |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 154 | #endif |
| 155 | |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 156 | static const char *init_mmc_for_env(struct mmc *mmc) |
Dmitry Lifshitz | 97d2fb9 | 2014-07-30 13:19:06 +0300 | [diff] [blame] | 157 | { |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 158 | if (!mmc) |
Hans de Goede | 8764fd6 | 2015-08-15 20:05:01 +0200 | [diff] [blame] | 159 | return "!No MMC card found"; |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 160 | |
Simon Glass | 1d9907c | 2017-05-27 11:37:18 -0600 | [diff] [blame] | 161 | #ifdef CONFIG_BLK |
| 162 | struct udevice *dev; |
| 163 | |
| 164 | if (blk_get_from_parent(mmc->dev, &dev)) |
| 165 | return "!No block device"; |
| 166 | #else |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 167 | if (mmc_init(mmc)) |
Hans de Goede | 8764fd6 | 2015-08-15 20:05:01 +0200 | [diff] [blame] | 168 | return "!MMC init failed"; |
Simon Glass | 86d78c7 | 2017-04-23 20:02:04 -0600 | [diff] [blame] | 169 | #endif |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 170 | if (mmc_set_env_part(mmc)) |
Hans de Goede | 8764fd6 | 2015-08-15 20:05:01 +0200 | [diff] [blame] | 171 | return "!MMC partition switch failed"; |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 172 | |
| 173 | return NULL; |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 174 | } |
| 175 | |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 176 | static void fini_mmc_for_env(struct mmc *mmc) |
| 177 | { |
| 178 | #ifdef CONFIG_SYS_MMC_ENV_PART |
Clemens Gruber | f7b6144 | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 179 | int dev = mmc_get_env_dev(); |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 180 | |
Simon Glass | 11f2bb6 | 2016-05-01 13:52:29 -0600 | [diff] [blame] | 181 | blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart); |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 182 | #endif |
| 183 | } |
| 184 | |
Simon Glass | 082af92 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 185 | #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD) |
Igor Grinberg | ecbfb62 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 186 | static inline int write_env(struct mmc *mmc, unsigned long size, |
| 187 | unsigned long offset, const void *buffer) |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 188 | { |
| 189 | uint blk_start, blk_cnt, n; |
Simon Glass | da89892 | 2016-05-14 14:03:03 -0600 | [diff] [blame] | 190 | struct blk_desc *desc = mmc_get_blk_desc(mmc); |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 191 | |
Igor Grinberg | ecbfb62 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 192 | blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len; |
| 193 | blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len; |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 194 | |
Simon Glass | da89892 | 2016-05-14 14:03:03 -0600 | [diff] [blame] | 195 | n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer); |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 196 | |
| 197 | return (n == blk_cnt) ? 0 : -1; |
| 198 | } |
| 199 | |
Simon Glass | 082af92 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 200 | static int env_mmc_save(void) |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 201 | { |
Tom Rini | a840b8e | 2013-04-05 14:55:21 -0400 | [diff] [blame] | 202 | ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); |
Clemens Gruber | f7b6144 | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 203 | int dev = mmc_get_env_dev(); |
| 204 | struct mmc *mmc = find_mmc_device(dev); |
Igor Grinberg | ecbfb62 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 205 | u32 offset; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 206 | int ret, copy = 0; |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 207 | const char *errmsg; |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 208 | |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 209 | errmsg = init_mmc_for_env(mmc); |
| 210 | if (errmsg) { |
| 211 | printf("%s\n", errmsg); |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 212 | return 1; |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 213 | } |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 214 | |
Marek Vasut | d73c129 | 2014-03-05 19:59:50 +0100 | [diff] [blame] | 215 | ret = env_export(env_new); |
| 216 | if (ret) |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 217 | goto fini; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 218 | |
| 219 | #ifdef CONFIG_ENV_OFFSET_REDUND |
Simon Glass | 4bc2ad2 | 2017-08-03 12:21:56 -0600 | [diff] [blame] | 220 | if (gd->env_valid == ENV_VALID) |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 221 | copy = 1; |
| 222 | #endif |
| 223 | |
| 224 | if (mmc_get_env_addr(mmc, copy, &offset)) { |
| 225 | ret = 1; |
| 226 | goto fini; |
| 227 | } |
| 228 | |
Clemens Gruber | f7b6144 | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 229 | printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev); |
Stephen Warren | 42a3c44 | 2012-05-24 11:38:33 +0000 | [diff] [blame] | 230 | if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) { |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 231 | puts("failed\n"); |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 232 | ret = 1; |
| 233 | goto fini; |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 234 | } |
| 235 | |
| 236 | puts("done\n"); |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 237 | ret = 0; |
| 238 | |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 239 | #ifdef CONFIG_ENV_OFFSET_REDUND |
Simon Glass | 4bc2ad2 | 2017-08-03 12:21:56 -0600 | [diff] [blame] | 240 | gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 241 | #endif |
| 242 | |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 243 | fini: |
| 244 | fini_mmc_for_env(mmc); |
| 245 | return ret; |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 246 | } |
Simon Glass | 082af92 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 247 | #endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */ |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 248 | |
Igor Grinberg | ecbfb62 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 249 | static inline int read_env(struct mmc *mmc, unsigned long size, |
| 250 | unsigned long offset, const void *buffer) |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 251 | { |
| 252 | uint blk_start, blk_cnt, n; |
Simon Glass | da89892 | 2016-05-14 14:03:03 -0600 | [diff] [blame] | 253 | struct blk_desc *desc = mmc_get_blk_desc(mmc); |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 254 | |
Igor Grinberg | ecbfb62 | 2011-11-07 01:14:05 +0000 | [diff] [blame] | 255 | blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len; |
| 256 | blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len; |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 257 | |
Simon Glass | da89892 | 2016-05-14 14:03:03 -0600 | [diff] [blame] | 258 | n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer); |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 259 | |
| 260 | return (n == blk_cnt) ? 0 : -1; |
| 261 | } |
| 262 | |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 263 | #ifdef CONFIG_ENV_OFFSET_REDUND |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 264 | static int env_mmc_load(void) |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 265 | { |
| 266 | #if !defined(ENV_IS_EMBEDDED) |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 267 | struct mmc *mmc; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 268 | u32 offset1, offset2; |
| 269 | int read1_fail = 0, read2_fail = 0; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 270 | int ret; |
Clemens Gruber | f7b6144 | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 271 | int dev = mmc_get_env_dev(); |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 272 | const char *errmsg = NULL; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 273 | |
Markus Niebel | 6ef41fd | 2013-10-04 15:48:03 +0200 | [diff] [blame] | 274 | ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1); |
| 275 | ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1); |
| 276 | |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 277 | mmc = find_mmc_device(dev); |
| 278 | |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 279 | errmsg = init_mmc_for_env(mmc); |
| 280 | if (errmsg) { |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 281 | ret = -EIO; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 282 | goto err; |
| 283 | } |
| 284 | |
| 285 | if (mmc_get_env_addr(mmc, 0, &offset1) || |
| 286 | mmc_get_env_addr(mmc, 1, &offset2)) { |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 287 | ret = -EIO; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 288 | goto fini; |
| 289 | } |
| 290 | |
| 291 | read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1); |
| 292 | read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2); |
| 293 | |
| 294 | if (read1_fail && read2_fail) |
| 295 | puts("*** Error - No Valid Environment Area found\n"); |
| 296 | else if (read1_fail || read2_fail) |
| 297 | puts("*** Warning - some problems detected " |
| 298 | "reading environment; recovered successfully\n"); |
| 299 | |
Fiach Antaw | 0a2e176 | 2017-01-25 18:53:12 +1000 | [diff] [blame] | 300 | if (read1_fail && read2_fail) { |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 301 | errmsg = "!bad CRC"; |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 302 | ret = -EIO; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 303 | goto fini; |
Fiach Antaw | 0a2e176 | 2017-01-25 18:53:12 +1000 | [diff] [blame] | 304 | } else if (!read1_fail && read2_fail) { |
Simon Glass | 4bc2ad2 | 2017-08-03 12:21:56 -0600 | [diff] [blame] | 305 | gd->env_valid = ENV_VALID; |
Fiach Antaw | 0a2e176 | 2017-01-25 18:53:12 +1000 | [diff] [blame] | 306 | env_import((char *)tmp_env1, 1); |
| 307 | } else if (read1_fail && !read2_fail) { |
Simon Glass | 4bc2ad2 | 2017-08-03 12:21:56 -0600 | [diff] [blame] | 308 | gd->env_valid = ENV_REDUND; |
Fiach Antaw | 0a2e176 | 2017-01-25 18:53:12 +1000 | [diff] [blame] | 309 | env_import((char *)tmp_env2, 1); |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 310 | } else { |
Fiach Antaw | 0a2e176 | 2017-01-25 18:53:12 +1000 | [diff] [blame] | 311 | env_import_redund((char *)tmp_env1, (char *)tmp_env2); |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 312 | } |
| 313 | |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 314 | ret = 0; |
| 315 | |
| 316 | fini: |
| 317 | fini_mmc_for_env(mmc); |
| 318 | err: |
| 319 | if (ret) |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 320 | set_default_env(errmsg); |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 321 | |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 322 | #endif |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 323 | return ret; |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 324 | } |
| 325 | #else /* ! CONFIG_ENV_OFFSET_REDUND */ |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 326 | static int env_mmc_load(void) |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 327 | { |
| 328 | #if !defined(ENV_IS_EMBEDDED) |
Tom Rini | a840b8e | 2013-04-05 14:55:21 -0400 | [diff] [blame] | 329 | ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 330 | struct mmc *mmc; |
Mingkai Hu | a55fce3 | 2011-01-24 17:09:55 +0000 | [diff] [blame] | 331 | u32 offset; |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 332 | int ret; |
Clemens Gruber | f7b6144 | 2016-01-20 15:43:37 +0100 | [diff] [blame] | 333 | int dev = mmc_get_env_dev(); |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 334 | const char *errmsg; |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 335 | |
Tom Rini | c929f82 | 2014-03-28 12:03:34 -0400 | [diff] [blame] | 336 | mmc = find_mmc_device(dev); |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 337 | |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 338 | errmsg = init_mmc_for_env(mmc); |
| 339 | if (errmsg) { |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 340 | ret = -EIO; |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 341 | goto err; |
| 342 | } |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 343 | |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 344 | if (mmc_get_env_addr(mmc, 0, &offset)) { |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 345 | ret = -EIO; |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 346 | goto fini; |
| 347 | } |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 348 | |
Tom Rini | a840b8e | 2013-04-05 14:55:21 -0400 | [diff] [blame] | 349 | if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) { |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 350 | errmsg = "!read failed"; |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 351 | ret = -EIO; |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 352 | goto fini; |
| 353 | } |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 354 | |
Tom Rini | a840b8e | 2013-04-05 14:55:21 -0400 | [diff] [blame] | 355 | env_import(buf, 1); |
Stephen Warren | 27ee0f3 | 2012-07-30 10:55:44 +0000 | [diff] [blame] | 356 | ret = 0; |
| 357 | |
| 358 | fini: |
| 359 | fini_mmc_for_env(mmc); |
| 360 | err: |
| 361 | if (ret) |
Tim Harvey | eda75c3 | 2015-05-08 14:52:09 -0700 | [diff] [blame] | 362 | set_default_env(errmsg); |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 363 | #endif |
Simon Glass | 9977849 | 2017-08-03 12:22:17 -0600 | [diff] [blame] | 364 | return ret; |
Terry Lv | b4eceac | 2010-05-17 10:57:01 +0800 | [diff] [blame] | 365 | } |
Michael Heimpold | a1d25a3 | 2013-04-10 10:36:19 +0000 | [diff] [blame] | 366 | #endif /* CONFIG_ENV_OFFSET_REDUND */ |
Simon Glass | c10a88e | 2017-08-03 12:21:58 -0600 | [diff] [blame] | 367 | |
| 368 | U_BOOT_ENV_LOCATION(mmc) = { |
| 369 | .location = ENVL_MMC, |
Simon Glass | d8273ed | 2017-08-03 12:22:03 -0600 | [diff] [blame] | 370 | ENV_NAME("MMC") |
Simon Glass | 082af92 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 371 | .load = env_mmc_load, |
Simon Glass | c10a88e | 2017-08-03 12:21:58 -0600 | [diff] [blame] | 372 | #ifndef CONFIG_SPL_BUILD |
Simon Glass | 082af92 | 2017-08-03 12:22:01 -0600 | [diff] [blame] | 373 | .save = env_save_ptr(env_mmc_save), |
Simon Glass | c10a88e | 2017-08-03 12:21:58 -0600 | [diff] [blame] | 374 | #endif |
Simon Glass | c10a88e | 2017-08-03 12:21:58 -0600 | [diff] [blame] | 375 | }; |