drivers/dfu/dfu_mmc.c

   1 /*
   2  * dfu.c -- DFU back-end routines
   3  *
   4  * Copyright (C) 2012 Samsung Electronics
   5  * author: Lukasz Majewski <l.majewski@samsung.com>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <common.h>
  11 #include <malloc.h>
  12 #include <errno.h>
  13 #include <div64.h>
  14 #include <dfu.h>
  15 #include <ext4fs.h>
  16 #include <fat.h>
  17 #include <mmc.h>
  18
  19 static unsigned char *dfu_file_buf;
  20 static long dfu_file_buf_len;
  21 static long dfu_file_buf_filled;
  22
  23 static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
  24                         u64 offset, void *buf, long *len)
  25 {
  26         struct mmc *mmc;
  27         u32 blk_start, blk_count, n = 0;
  28         int ret, part_num_bkp = 0;
  29
  30         mmc = find_mmc_device(dfu->data.mmc.dev_num);
  31         if (!mmc) {
  32                 error("Device MMC %d - not found!", dfu->data.mmc.dev_num);
  33                 return -ENODEV;
  34         }
  35
  36         /*
  37          * We must ensure that we work in lba_blk_size chunks, so ALIGN
  38          * this value.
  39          */
  40         *len = ALIGN(*len, dfu->data.mmc.lba_blk_size);
  41
  42         blk_start = dfu->data.mmc.lba_start +
  43                         (u32)lldiv(offset, dfu->data.mmc.lba_blk_size);
  44         blk_count = *len / dfu->data.mmc.lba_blk_size;
  45         if (blk_start + blk_count >
  46                         dfu->data.mmc.lba_start + dfu->data.mmc.lba_size) {
  47                 puts("Request would exceed designated area!\n");
  48                 return -EINVAL;
  49         }
  50
  51         if (dfu->data.mmc.hw_partition >= 0) {
  52                 part_num_bkp = mmc->block_dev.hwpart;
  53                 ret = blk_select_hwpart_devnum(IF_TYPE_MMC,
  54                                                dfu->data.mmc.dev_num,
  55                                                dfu->data.mmc.hw_partition);
  56                 if (ret)
  57                         return ret;
  58         }
  59
  60         debug("%s: %s dev: %d start: %d cnt: %d buf: 0x%p\n", __func__,
  61               op == DFU_OP_READ ? "MMC READ" : "MMC WRITE",
  62               dfu->data.mmc.dev_num, blk_start, blk_count, buf);
  63         switch (op) {
  64         case DFU_OP_READ:
  65                 n = mmc->block_dev.block_read(&mmc->block_dev, blk_start,
  66                                               blk_count, buf);
  67                 break;
  68         case DFU_OP_WRITE:
  69                 n = mmc->block_dev.block_write(&mmc->block_dev, blk_start,
  70                                                blk_count, buf);
  71                 break;
  72         default:
  73                 error("Operation not supported\n");
  74         }
  75
  76         if (n != blk_count) {
  77                 error("MMC operation failed");
  78                 if (dfu->data.mmc.hw_partition >= 0)
  79                         blk_select_hwpart_devnum(IF_TYPE_MMC,
  80                                                  dfu->data.mmc.dev_num,
  81                                                  part_num_bkp);
  82                 return -EIO;
  83         }
  84
  85         if (dfu->data.mmc.hw_partition >= 0) {
  86                 ret = blk_select_hwpart_devnum(IF_TYPE_MMC,
  87                                                dfu->data.mmc.dev_num,
  88                                                part_num_bkp);
  89                 if (ret)
  90                         return ret;
  91         }
  92
  93         return 0;
  94 }
  95
  96 static int mmc_file_buffer(struct dfu_entity *dfu, void *buf, long *len)
  97 {
  98         if (dfu_file_buf_len + *len > CONFIG_SYS_DFU_MAX_FILE_SIZE) {
  99                 dfu_file_buf_len = 0;
 100                 return -EINVAL;
 101         }
 102
 103         /* Add to the current buffer. */
 104         memcpy(dfu_file_buf + dfu_file_buf_len, buf, *len);
 105         dfu_file_buf_len += *len;
 106
 107         return 0;
 108 }
 109
 110 static int mmc_file_op(enum dfu_op op, struct dfu_entity *dfu,
 111                         void *buf, long *len)
 112 {
 113         const char *fsname, *opname;
 114         char cmd_buf[DFU_CMD_BUF_SIZE];
 115         char *str_env;
 116         int ret;
 117
 118         switch (dfu->layout) {
 119         case DFU_FS_FAT:
 120                 fsname = "fat";
 121                 break;
 122         case DFU_FS_EXT4:
 123                 fsname = "ext4";
 124                 break;
 125         default:
 126                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 127                        dfu_get_layout(dfu->layout));
 128                 return -1;
 129         }
 130
 131         switch (op) {
 132         case DFU_OP_READ:
 133                 opname = "load";
 134                 break;
 135         case DFU_OP_WRITE:
 136                 opname = "write";
 137                 break;
 138         case DFU_OP_SIZE:
 139                 opname = "size";
 140                 break;
 141         default:
 142                 return -1;
 143         }
 144
 145         sprintf(cmd_buf, "%s%s mmc %d:%d", fsname, opname,
 146                 dfu->data.mmc.dev, dfu->data.mmc.part);
 147
 148         if (op != DFU_OP_SIZE)
 149                 sprintf(cmd_buf + strlen(cmd_buf), " %p", buf);
 150
 151         sprintf(cmd_buf + strlen(cmd_buf), " %s", dfu->name);
 152
 153         if (op == DFU_OP_WRITE)
 154                 sprintf(cmd_buf + strlen(cmd_buf), " %lx", *len);
 155
 156         debug("%s: %s 0x%p\n", __func__, cmd_buf, cmd_buf);
 157
 158         ret = run_command(cmd_buf, 0);
 159         if (ret) {
 160                 puts("dfu: Read error!\n");
 161                 return ret;
 162         }
 163
 164         if (op != DFU_OP_WRITE) {
 165                 str_env = getenv("filesize");
 166                 if (str_env == NULL) {
 167                         puts("dfu: Wrong file size!\n");
 168                         return -1;
 169                 }
 170                 *len = simple_strtoul(str_env, NULL, 16);
 171         }
 172
 173         return ret;
 174 }
 175
 176 int dfu_write_medium_mmc(struct dfu_entity *dfu,
 177                 u64 offset, void *buf, long *len)
 178 {
 179         int ret = -1;
 180
 181         switch (dfu->layout) {
 182         case DFU_RAW_ADDR:
 183                 ret = mmc_block_op(DFU_OP_WRITE, dfu, offset, buf, len);
 184                 break;
 185         case DFU_FS_FAT:
 186         case DFU_FS_EXT4:
 187                 ret = mmc_file_buffer(dfu, buf, len);
 188                 break;
 189         default:
 190                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 191                        dfu_get_layout(dfu->layout));
 192         }
 193
 194         return ret;
 195 }
 196
 197 int dfu_flush_medium_mmc(struct dfu_entity *dfu)
 198 {
 199         int ret = 0;
 200
 201         if (dfu->layout != DFU_RAW_ADDR) {
 202                 /* Do stuff here. */
 203                 ret = mmc_file_op(DFU_OP_WRITE, dfu, dfu_file_buf,
 204                                 &dfu_file_buf_len);
 205
 206                 /* Now that we're done */
 207                 dfu_file_buf_len = 0;
 208         }
 209
 210         return ret;
 211 }
 212
 213 long dfu_get_medium_size_mmc(struct dfu_entity *dfu)
 214 {
 215         int ret;
 216         long len;
 217
 218         switch (dfu->layout) {
 219         case DFU_RAW_ADDR:
 220                 return dfu->data.mmc.lba_size * dfu->data.mmc.lba_blk_size;
 221         case DFU_FS_FAT:
 222         case DFU_FS_EXT4:
 223                 dfu_file_buf_filled = -1;
 224                 ret = mmc_file_op(DFU_OP_SIZE, dfu, NULL, &len);
 225                 if (ret < 0)
 226                         return ret;
 227                 if (len > CONFIG_SYS_DFU_MAX_FILE_SIZE)
 228                         return -1;
 229                 return len;
 230         default:
 231                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 232                        dfu_get_layout(dfu->layout));
 233                 return -1;
 234         }
 235 }
 236
 237 static int mmc_file_unbuffer(struct dfu_entity *dfu, u64 offset, void *buf,
 238                              long *len)
 239 {
 240         int ret;
 241         long file_len;
 242
 243         if (dfu_file_buf_filled == -1) {
 244                 ret = mmc_file_op(DFU_OP_READ, dfu, dfu_file_buf, &file_len);
 245                 if (ret < 0)
 246                         return ret;
 247                 dfu_file_buf_filled = file_len;
 248         }
 249         if (offset + *len > dfu_file_buf_filled)
 250                 return -EINVAL;
 251
 252         /* Add to the current buffer. */
 253         memcpy(buf, dfu_file_buf + offset, *len);
 254
 255         return 0;
 256 }
 257
 258 int dfu_read_medium_mmc(struct dfu_entity *dfu, u64 offset, void *buf,
 259                 long *len)
 260 {
 261         int ret = -1;
 262
 263         switch (dfu->layout) {
 264         case DFU_RAW_ADDR:
 265                 ret = mmc_block_op(DFU_OP_READ, dfu, offset, buf, len);
 266                 break;
 267         case DFU_FS_FAT:
 268         case DFU_FS_EXT4:
 269                 ret = mmc_file_unbuffer(dfu, offset, buf, len);
 270                 break;
 271         default:
 272                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 273                        dfu_get_layout(dfu->layout));
 274         }
 275
 276         return ret;
 277 }
 278
 279 void dfu_free_entity_mmc(struct dfu_entity *dfu)
 280 {
 281         if (dfu_file_buf) {
 282                 free(dfu_file_buf);
 283                 dfu_file_buf = NULL;
 284         }
 285 }
 286
 287 /*
 288  * @param s Parameter string containing space-separated arguments:
 289  *      1st:
 290  *              raw     (raw read/write)
 291  *              fat     (files)
 292  *              ext4    (^)
 293  *              part    (partition image)
 294  *      2nd and 3rd:
 295  *              lba_start and lba_size, for raw write
 296  *              mmc_dev and mmc_part, for filesystems and part
 297  *      4th (optional):
 298  *              mmcpart <num> (access to HW eMMC partitions)
 299  */
 300 int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
 301 {
 302         const char *entity_type;
 303         size_t second_arg;
 304         size_t third_arg;
 305
 306         struct mmc *mmc;
 307
 308         const char *argv[3];
 309         const char **parg = argv;
 310
 311         dfu->data.mmc.dev_num = simple_strtoul(devstr, NULL, 10);
 312
 313         for (; parg < argv + sizeof(argv) / sizeof(*argv); ++parg) {
 314                 *parg = strsep(&s, " ");
 315                 if (*parg == NULL) {
 316                         error("Invalid number of arguments.\n");
 317                         return -ENODEV;
 318                 }
 319         }
 320
 321         entity_type = argv[0];
 322         /*
 323          * Base 0 means we'll accept (prefixed with 0x or 0) base 16, 8,
 324          * with default 10.
 325          */
 326         second_arg = simple_strtoul(argv[1], NULL, 0);
 327         third_arg = simple_strtoul(argv[2], NULL, 0);
 328
 329         mmc = find_mmc_device(dfu->data.mmc.dev_num);
 330         if (mmc == NULL) {
 331                 error("Couldn't find MMC device no. %d.\n",
 332                       dfu->data.mmc.dev_num);
 333                 return -ENODEV;
 334         }
 335
 336         if (mmc_init(mmc)) {
 337                 error("Couldn't init MMC device.\n");
 338                 return -ENODEV;
 339         }
 340
 341         dfu->data.mmc.hw_partition = -EINVAL;
 342         if (!strcmp(entity_type, "raw")) {
 343                 dfu->layout                     = DFU_RAW_ADDR;
 344                 dfu->data.mmc.lba_start         = second_arg;
 345                 dfu->data.mmc.lba_size          = third_arg;
 346                 dfu->data.mmc.lba_blk_size      = mmc->read_bl_len;
 347
 348                 /*
 349                  * Check for an extra entry at dfu_alt_info env variable
 350                  * specifying the mmc HW defined partition number
 351                  */
 352                 if (s)
 353                         if (!strcmp(strsep(&s, " "), "mmcpart"))
 354                                 dfu->data.mmc.hw_partition =
 355                                         simple_strtoul(s, NULL, 0);
 356
 357         } else if (!strcmp(entity_type, "part")) {
 358                 disk_partition_t partinfo;
 359                 struct blk_desc *blk_dev = &mmc->block_dev;
 360                 int mmcdev = second_arg;
 361                 int mmcpart = third_arg;
 362
 363                 if (part_get_info(blk_dev, mmcpart, &partinfo) != 0) {
 364                         error("Couldn't find part #%d on mmc device #%d\n",
 365                               mmcpart, mmcdev);
 366                         return -ENODEV;
 367                 }
 368
 369                 dfu->layout                     = DFU_RAW_ADDR;
 370                 dfu->data.mmc.lba_start         = partinfo.start;
 371                 dfu->data.mmc.lba_size          = partinfo.size;
 372                 dfu->data.mmc.lba_blk_size      = partinfo.blksz;
 373         } else if (!strcmp(entity_type, "fat")) {
 374                 dfu->layout = DFU_FS_FAT;
 375         } else if (!strcmp(entity_type, "ext4")) {
 376                 dfu->layout = DFU_FS_EXT4;
 377         } else {
 378                 error("Memory layout (%s) not supported!\n", entity_type);
 379                 return -ENODEV;
 380         }
 381
 382         /* if it's NOT a raw write */
 383         if (strcmp(entity_type, "raw")) {
 384                 dfu->data.mmc.dev = second_arg;
 385                 dfu->data.mmc.part = third_arg;
 386         }
 387
 388         dfu->dev_type = DFU_DEV_MMC;
 389         dfu->get_medium_size = dfu_get_medium_size_mmc;
 390         dfu->read_medium = dfu_read_medium_mmc;
 391         dfu->write_medium = dfu_write_medium_mmc;
 392         dfu->flush_medium = dfu_flush_medium_mmc;
 393         dfu->inited = 0;
 394         dfu->free_entity = dfu_free_entity_mmc;
 395
 396         /* Check if file buffer is ready */
 397         if (!dfu_file_buf) {
 398                 dfu_file_buf = memalign(CONFIG_SYS_CACHELINE_SIZE,
 399                                         CONFIG_SYS_DFU_MAX_FILE_SIZE);
 400                 if (!dfu_file_buf) {
 401                         error("Could not memalign 0x%x bytes",
 402                               CONFIG_SYS_DFU_MAX_FILE_SIZE);
 403                         return -ENOMEM;
 404                 }
 405         }
 406
 407         return 0;
 408 }