env/mmc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
   4  */
   5
   6 /* #define DEBUG */
   7
   8 #include <common.h>
   9
  10 #include <command.h>
  11 #include <env.h>
  12 #include <env_internal.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 DECLARE_GLOBAL_DATA_PTR;
  26
  27 #if !defined(CONFIG_SYS_MMC_ENV_DEV)
  28 #define CONFIG_SYS_MMC_ENV_DEV 0
  29 #endif
  30
  31 __weak int mmc_get_env_dev(void)
  32 {
  33         return CONFIG_SYS_MMC_ENV_DEV;
  34 }
  35
  36 #if CONFIG_IS_ENABLED(OF_CONTROL)
  37 static inline int mmc_offset_try_partition(const char *str, int copy, s64 *val)
  38 {
  39         struct disk_partition info;
  40         struct blk_desc *desc;
  41         int len, i, ret;
  42         char dev_str[4];
  43
  44         snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev());
  45         ret = blk_get_device_by_str("mmc", dev_str, &desc);
  46         if (ret < 0)
  47                 return (ret);
  48
  49         for (i = 1;;i++) {
  50                 ret = part_get_info(desc, i, &info);
  51                 if (ret < 0)
  52                         return ret;
  53
  54                 if (!strncmp((const char *)info.name, str, sizeof(str)))
  55                         break;
  56         }
  57
  58         /* round up to info.blksz */
  59         len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz);
  60
  61         /* use the top of the partion for the environment */
  62         *val = (info.start + info.size - (1 + copy) * len) * info.blksz;
  63
  64         return 0;
  65 }
  66
  67 static inline s64 mmc_offset(int copy)
  68 {
  69         const struct {
  70                 const char *offset_redund;
  71                 const char *partition;
  72                 const char *offset;
  73         } dt_prop = {
  74                 .offset_redund = "u-boot,mmc-env-offset-redundant",
  75                 .partition = "u-boot,mmc-env-partition",
  76                 .offset = "u-boot,mmc-env-offset",
  77         };
  78         s64 val = 0, defvalue;
  79         const char *propname;
  80         const char *str;
  81         int err;
  82
  83         /* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */
  84         str = fdtdec_get_config_string(gd->fdt_blob, dt_prop.partition);
  85         if (str) {
  86                 /* try to place the environment at end of the partition */
  87                 err = mmc_offset_try_partition(str, copy, &val);
  88                 if (!err)
  89                         return val;
  90         }
  91
  92         defvalue = CONFIG_ENV_OFFSET;
  93         propname = dt_prop.offset;
  94
  95 #if defined(CONFIG_ENV_OFFSET_REDUND)
  96         if (copy) {
  97                 defvalue = CONFIG_ENV_OFFSET_REDUND;
  98                 propname = dt_prop.offset_redund;
  99         }
 100 #endif
 101         return fdtdec_get_config_int(gd->fdt_blob, propname, defvalue);
 102 }
 103 #else
 104 static inline s64 mmc_offset(int copy)
 105 {
 106         s64 offset = CONFIG_ENV_OFFSET;
 107
 108 #if defined(CONFIG_ENV_OFFSET_REDUND)
 109         if (copy)
 110                 offset = CONFIG_ENV_OFFSET_REDUND;
 111 #endif
 112         return offset;
 113 }
 114 #endif
 115
 116 __weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
 117 {
 118         s64 offset = mmc_offset(copy);
 119
 120         if (offset < 0)
 121                 offset += mmc->capacity;
 122
 123         *env_addr = offset;
 124
 125         return 0;
 126 }
 127
 128 #ifdef CONFIG_SYS_MMC_ENV_PART
 129 __weak uint mmc_get_env_part(struct mmc *mmc)
 130 {
 131         return CONFIG_SYS_MMC_ENV_PART;
 132 }
 133
 134 static unsigned char env_mmc_orig_hwpart;
 135
 136 static int mmc_set_env_part(struct mmc *mmc)
 137 {
 138         uint part = mmc_get_env_part(mmc);
 139         int dev = mmc_get_env_dev();
 140         int ret = 0;
 141
 142         env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart;
 143         ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
 144         if (ret)
 145                 puts("MMC partition switch failed\n");
 146
 147         return ret;
 148 }
 149 #else
 150 static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
 151 #endif
 152
 153 static const char *init_mmc_for_env(struct mmc *mmc)
 154 {
 155         if (!mmc)
 156                 return "No MMC card found";
 157
 158 #if CONFIG_IS_ENABLED(BLK)
 159         struct udevice *dev;
 160
 161         if (blk_get_from_parent(mmc->dev, &dev))
 162                 return "No block device";
 163 #else
 164         if (mmc_init(mmc))
 165                 return "MMC init failed";
 166 #endif
 167         if (mmc_set_env_part(mmc))
 168                 return "MMC partition switch failed";
 169
 170         return NULL;
 171 }
 172
 173 static void fini_mmc_for_env(struct mmc *mmc)
 174 {
 175 #ifdef CONFIG_SYS_MMC_ENV_PART
 176         int dev = mmc_get_env_dev();
 177
 178         blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart);
 179 #endif
 180 }
 181
 182 #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
 183 static inline int write_env(struct mmc *mmc, unsigned long size,
 184                             unsigned long offset, const void *buffer)
 185 {
 186         uint blk_start, blk_cnt, n;
 187         struct blk_desc *desc = mmc_get_blk_desc(mmc);
 188
 189         blk_start       = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
 190         blk_cnt         = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
 191
 192         n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer);
 193
 194         return (n == blk_cnt) ? 0 : -1;
 195 }
 196
 197 static int env_mmc_save(void)
 198 {
 199         ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
 200         int dev = mmc_get_env_dev();
 201         struct mmc *mmc = find_mmc_device(dev);
 202         u32     offset;
 203         int     ret, copy = 0;
 204         const char *errmsg;
 205
 206         errmsg = init_mmc_for_env(mmc);
 207         if (errmsg) {
 208                 printf("%s\n", errmsg);
 209                 return 1;
 210         }
 211
 212         ret = env_export(env_new);
 213         if (ret)
 214                 goto fini;
 215
 216 #ifdef CONFIG_ENV_OFFSET_REDUND
 217         if (gd->env_valid == ENV_VALID)
 218                 copy = 1;
 219 #endif
 220
 221         if (mmc_get_env_addr(mmc, copy, &offset)) {
 222                 ret = 1;
 223                 goto fini;
 224         }
 225
 226         printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev);
 227         if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
 228                 puts("failed\n");
 229                 ret = 1;
 230                 goto fini;
 231         }
 232
 233         ret = 0;
 234
 235 #ifdef CONFIG_ENV_OFFSET_REDUND
 236         gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
 237 #endif
 238
 239 fini:
 240         fini_mmc_for_env(mmc);
 241         return ret;
 242 }
 243
 244 #if defined(CONFIG_CMD_ERASEENV)
 245 static inline int erase_env(struct mmc *mmc, unsigned long size,
 246                             unsigned long offset)
 247 {
 248         uint blk_start, blk_cnt, n;
 249         struct blk_desc *desc = mmc_get_blk_desc(mmc);
 250
 251         blk_start       = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
 252         blk_cnt         = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
 253
 254         n = blk_derase(desc, blk_start, blk_cnt);
 255         printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR");
 256
 257         return (n == blk_cnt) ? 0 : 1;
 258 }
 259
 260 static int env_mmc_erase(void)
 261 {
 262         int dev = mmc_get_env_dev();
 263         struct mmc *mmc = find_mmc_device(dev);
 264         int     ret, copy = 0;
 265         u32     offset;
 266         const char *errmsg;
 267
 268         errmsg = init_mmc_for_env(mmc);
 269         if (errmsg) {
 270                 printf("%s\n", errmsg);
 271                 return 1;
 272         }
 273
 274         if (mmc_get_env_addr(mmc, copy, &offset))
 275                 return CMD_RET_FAILURE;
 276
 277         ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);
 278
 279 #ifdef CONFIG_ENV_OFFSET_REDUND
 280         copy = 1;
 281
 282         if (mmc_get_env_addr(mmc, copy, &offset))
 283                 return CMD_RET_FAILURE;
 284
 285         ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset);
 286 #endif
 287
 288         return ret;
 289 }
 290 #endif /* CONFIG_CMD_ERASEENV */
 291 #endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */
 292
 293 static inline int read_env(struct mmc *mmc, unsigned long size,
 294                            unsigned long offset, const void *buffer)
 295 {
 296         uint blk_start, blk_cnt, n;
 297         struct blk_desc *desc = mmc_get_blk_desc(mmc);
 298
 299         blk_start       = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
 300         blk_cnt         = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
 301
 302         n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);
 303
 304         return (n == blk_cnt) ? 0 : -1;
 305 }
 306
 307 #ifdef CONFIG_ENV_OFFSET_REDUND
 308 static int env_mmc_load(void)
 309 {
 310 #if !defined(ENV_IS_EMBEDDED)
 311         struct mmc *mmc;
 312         u32 offset1, offset2;
 313         int read1_fail = 0, read2_fail = 0;
 314         int ret;
 315         int dev = mmc_get_env_dev();
 316         const char *errmsg = NULL;
 317
 318         ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
 319         ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
 320
 321         mmc_initialize(NULL);
 322
 323         mmc = find_mmc_device(dev);
 324
 325         errmsg = init_mmc_for_env(mmc);
 326         if (errmsg) {
 327                 ret = -EIO;
 328                 goto err;
 329         }
 330
 331         if (mmc_get_env_addr(mmc, 0, &offset1) ||
 332             mmc_get_env_addr(mmc, 1, &offset2)) {
 333                 ret = -EIO;
 334                 goto fini;
 335         }
 336
 337         read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
 338         read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
 339
 340         ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
 341                                 read2_fail);
 342
 343 fini:
 344         fini_mmc_for_env(mmc);
 345 err:
 346         if (ret)
 347                 env_set_default(errmsg, 0);
 348
 349 #endif
 350         return ret;
 351 }
 352 #else /* ! CONFIG_ENV_OFFSET_REDUND */
 353 static int env_mmc_load(void)
 354 {
 355 #if !defined(ENV_IS_EMBEDDED)
 356         ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
 357         struct mmc *mmc;
 358         u32 offset;
 359         int ret;
 360         int dev = mmc_get_env_dev();
 361         const char *errmsg;
 362         env_t *ep = NULL;
 363
 364         mmc = find_mmc_device(dev);
 365
 366         errmsg = init_mmc_for_env(mmc);
 367         if (errmsg) {
 368                 ret = -EIO;
 369                 goto err;
 370         }
 371
 372         if (mmc_get_env_addr(mmc, 0, &offset)) {
 373                 ret = -EIO;
 374                 goto fini;
 375         }
 376
 377         if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
 378                 errmsg = "!read failed";
 379                 ret = -EIO;
 380                 goto fini;
 381         }
 382
 383         ret = env_import(buf, 1);
 384         if (!ret) {
 385                 ep = (env_t *)buf;
 386                 gd->env_addr = (ulong)&ep->data;
 387         }
 388
 389 fini:
 390         fini_mmc_for_env(mmc);
 391 err:
 392         if (ret)
 393                 env_set_default(errmsg, 0);
 394 #endif
 395         return ret;
 396 }
 397 #endif /* CONFIG_ENV_OFFSET_REDUND */
 398
 399 U_BOOT_ENV_LOCATION(mmc) = {
 400         .location       = ENVL_MMC,
 401         ENV_NAME("MMC")
 402         .load           = env_mmc_load,
 403 #ifndef CONFIG_SPL_BUILD
 404         .save           = env_save_ptr(env_mmc_save),
 405 #if defined(CONFIG_CMD_ERASEENV)
 406         .erase          = env_mmc_erase,
 407 #endif
 408 #endif
 409 };