1 /* 2 * (C) Copyright 2008-2011 Freescale Semiconductor, Inc. 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 /* #define DEBUG */ 8 9 #include <common.h> 10 11 #include <command.h> 12 #include <environment.h> 13 #include <fdtdec.h> 14 #include <linux/stddef.h> 15 #include <malloc.h> 16 #include <memalign.h> 17 #include <mmc.h> 18 #include <part.h> 19 #include <search.h> 20 #include <errno.h> 21 22 #define __STR(X) #X 23 #define STR(X) __STR(X) 24 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 30 DECLARE_GLOBAL_DATA_PTR; 31 32 #if !defined(CONFIG_ENV_OFFSET) 33 #define CONFIG_ENV_OFFSET 0 34 #endif 35 36 #if CONFIG_IS_ENABLED(OF_CONTROL) 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 65 static inline s64 mmc_offset(int copy) 66 { 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 }; 76 s64 val = 0, defvalue; 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; 92 93 #if defined(CONFIG_ENV_OFFSET_REDUND) 94 if (copy) { 95 defvalue = CONFIG_ENV_OFFSET_REDUND; 96 propname = dt_prop.offset_redund; 97 } 98 #endif 99 return fdtdec_get_config_int(gd->fdt_blob, propname, defvalue); 100 } 101 #else 102 static inline s64 mmc_offset(int copy) 103 { 104 s64 offset = CONFIG_ENV_OFFSET; 105 106 #if defined(CONFIG_ENV_OFFSET_REDUND) 107 if (copy) 108 offset = CONFIG_ENV_OFFSET_REDUND; 109 #endif 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); 117 118 if (offset < 0) 119 offset += mmc->capacity; 120 121 *env_addr = offset; 122 123 return 0; 124 } 125 126 __weak int mmc_get_env_dev(void) 127 { 128 return CONFIG_SYS_MMC_ENV_DEV; 129 } 130 131 #ifdef CONFIG_SYS_MMC_ENV_PART 132 __weak uint mmc_get_env_part(struct mmc *mmc) 133 { 134 return CONFIG_SYS_MMC_ENV_PART; 135 } 136 137 static unsigned char env_mmc_orig_hwpart; 138 139 static int mmc_set_env_part(struct mmc *mmc) 140 { 141 uint part = mmc_get_env_part(mmc); 142 int dev = mmc_get_env_dev(); 143 int ret = 0; 144 145 env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart; 146 ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part); 147 if (ret) 148 puts("MMC partition switch failed\n"); 149 150 return ret; 151 } 152 #else 153 static inline int mmc_set_env_part(struct mmc *mmc) {return 0; }; 154 #endif 155 156 static const char *init_mmc_for_env(struct mmc *mmc) 157 { 158 if (!mmc) 159 return "!No MMC card found"; 160 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 167 if (mmc_init(mmc)) 168 return "!MMC init failed"; 169 #endif 170 if (mmc_set_env_part(mmc)) 171 return "!MMC partition switch failed"; 172 173 return NULL; 174 } 175 176 static void fini_mmc_for_env(struct mmc *mmc) 177 { 178 #ifdef CONFIG_SYS_MMC_ENV_PART 179 int dev = mmc_get_env_dev(); 180 181 blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart); 182 #endif 183 } 184 185 #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD) 186 static inline int write_env(struct mmc *mmc, unsigned long size, 187 unsigned long offset, const void *buffer) 188 { 189 uint blk_start, blk_cnt, n; 190 struct blk_desc *desc = mmc_get_blk_desc(mmc); 191 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; 194 195 n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer); 196 197 return (n == blk_cnt) ? 0 : -1; 198 } 199 200 static int env_mmc_save(void) 201 { 202 ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1); 203 int dev = mmc_get_env_dev(); 204 struct mmc *mmc = find_mmc_device(dev); 205 u32 offset; 206 int ret, copy = 0; 207 const char *errmsg; 208 209 errmsg = init_mmc_for_env(mmc); 210 if (errmsg) { 211 printf("%s\n", errmsg); 212 return 1; 213 } 214 215 ret = env_export(env_new); 216 if (ret) 217 goto fini; 218 219 #ifdef CONFIG_ENV_OFFSET_REDUND 220 if (gd->env_valid == ENV_VALID) 221 copy = 1; 222 #endif 223 224 if (mmc_get_env_addr(mmc, copy, &offset)) { 225 ret = 1; 226 goto fini; 227 } 228 229 printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev); 230 if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) { 231 puts("failed\n"); 232 ret = 1; 233 goto fini; 234 } 235 236 ret = 0; 237 238 #ifdef CONFIG_ENV_OFFSET_REDUND 239 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND; 240 #endif 241 242 fini: 243 fini_mmc_for_env(mmc); 244 return ret; 245 } 246 #endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */ 247 248 static inline int read_env(struct mmc *mmc, unsigned long size, 249 unsigned long offset, const void *buffer) 250 { 251 uint blk_start, blk_cnt, n; 252 struct blk_desc *desc = mmc_get_blk_desc(mmc); 253 254 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len; 255 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len; 256 257 n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer); 258 259 return (n == blk_cnt) ? 0 : -1; 260 } 261 262 #ifdef CONFIG_ENV_OFFSET_REDUND 263 static int env_mmc_load(void) 264 { 265 #if !defined(ENV_IS_EMBEDDED) 266 struct mmc *mmc; 267 u32 offset1, offset2; 268 int read1_fail = 0, read2_fail = 0; 269 int ret; 270 int dev = mmc_get_env_dev(); 271 const char *errmsg = NULL; 272 273 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1); 274 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1); 275 276 mmc_initialize(NULL); 277 278 mmc = find_mmc_device(dev); 279 280 errmsg = init_mmc_for_env(mmc); 281 if (errmsg) { 282 ret = -EIO; 283 goto err; 284 } 285 286 if (mmc_get_env_addr(mmc, 0, &offset1) || 287 mmc_get_env_addr(mmc, 1, &offset2)) { 288 ret = -EIO; 289 goto fini; 290 } 291 292 read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1); 293 read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2); 294 295 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2, 296 read2_fail); 297 298 fini: 299 fini_mmc_for_env(mmc); 300 err: 301 if (ret) 302 set_default_env(errmsg); 303 304 #endif 305 return ret; 306 } 307 #else /* ! CONFIG_ENV_OFFSET_REDUND */ 308 static int env_mmc_load(void) 309 { 310 #if !defined(ENV_IS_EMBEDDED) 311 ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); 312 struct mmc *mmc; 313 u32 offset; 314 int ret; 315 int dev = mmc_get_env_dev(); 316 const char *errmsg; 317 318 mmc = find_mmc_device(dev); 319 320 errmsg = init_mmc_for_env(mmc); 321 if (errmsg) { 322 ret = -EIO; 323 goto err; 324 } 325 326 if (mmc_get_env_addr(mmc, 0, &offset)) { 327 ret = -EIO; 328 goto fini; 329 } 330 331 if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) { 332 errmsg = "!read failed"; 333 ret = -EIO; 334 goto fini; 335 } 336 337 ret = env_import(buf, 1); 338 339 fini: 340 fini_mmc_for_env(mmc); 341 err: 342 if (ret) 343 set_default_env(errmsg); 344 #endif 345 return ret; 346 } 347 #endif /* CONFIG_ENV_OFFSET_REDUND */ 348 349 U_BOOT_ENV_LOCATION(mmc) = { 350 .location = ENVL_MMC, 351 ENV_NAME("MMC") 352 .load = env_mmc_load, 353 #ifndef CONFIG_SPL_BUILD 354 .save = env_save_ptr(env_mmc_save), 355 #endif 356 }; 357