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