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 <mmc.h>
  16
  17 static unsigned char __aligned(CONFIG_SYS_CACHELINE_SIZE)
  18                                 dfu_file_buf[CONFIG_SYS_DFU_MAX_FILE_SIZE];
  19 static long dfu_file_buf_len;
  20
  21 static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
  22                         u64 offset, void *buf, long *len)
  23 {
  24         struct mmc *mmc = find_mmc_device(dfu->dev_num);
  25         u32 blk_start, blk_count, n = 0;
  26
  27         /*
  28          * We must ensure that we work in lba_blk_size chunks, so ALIGN
  29          * this value.
  30          */
  31         *len = ALIGN(*len, dfu->data.mmc.lba_blk_size);
  32
  33         blk_start = dfu->data.mmc.lba_start +
  34                         (u32)lldiv(offset, dfu->data.mmc.lba_blk_size);
  35         blk_count = *len / dfu->data.mmc.lba_blk_size;
  36         if (blk_start + blk_count >
  37                         dfu->data.mmc.lba_start + dfu->data.mmc.lba_size) {
  38                 puts("Request would exceed designated area!\n");
  39                 return -EINVAL;
  40         }
  41
  42         debug("%s: %s dev: %d start: %d cnt: %d buf: 0x%p\n", __func__,
  43               op == DFU_OP_READ ? "MMC READ" : "MMC WRITE", dfu->dev_num,
  44               blk_start, blk_count, buf);
  45         switch (op) {
  46         case DFU_OP_READ:
  47                 n = mmc->block_dev.block_read(dfu->dev_num, blk_start,
  48                                               blk_count, buf);
  49                 break;
  50         case DFU_OP_WRITE:
  51                 n = mmc->block_dev.block_write(dfu->dev_num, blk_start,
  52                                                blk_count, buf);
  53                 break;
  54         default:
  55                 error("Operation not supported\n");
  56         }
  57
  58         if (n != blk_count) {
  59                 error("MMC operation failed");
  60                 return -EIO;
  61         }
  62
  63         return 0;
  64 }
  65
  66 static int mmc_file_buffer(struct dfu_entity *dfu, void *buf, long *len)
  67 {
  68         if (dfu_file_buf_len + *len > CONFIG_SYS_DFU_MAX_FILE_SIZE) {
  69                 dfu_file_buf_len = 0;
  70                 return -EINVAL;
  71         }
  72
  73         /* Add to the current buffer. */
  74         memcpy(dfu_file_buf + dfu_file_buf_len, buf, *len);
  75         dfu_file_buf_len += *len;
  76
  77         return 0;
  78 }
  79
  80 static int mmc_file_op(enum dfu_op op, struct dfu_entity *dfu,
  81                         void *buf, long *len)
  82 {
  83         char cmd_buf[DFU_CMD_BUF_SIZE];
  84         char *str_env;
  85         int ret;
  86
  87         switch (dfu->layout) {
  88         case DFU_FS_FAT:
  89                 sprintf(cmd_buf, "fat%s mmc %d:%d 0x%x %s",
  90                         op == DFU_OP_READ ? "load" : "write",
  91                         dfu->data.mmc.dev, dfu->data.mmc.part,
  92                         (unsigned int) buf, dfu->name);
  93                 break;
  94         case DFU_FS_EXT4:
  95                 sprintf(cmd_buf, "ext4%s mmc %d:%d 0x%x /%s",
  96                         op == DFU_OP_READ ? "load" : "write",
  97                         dfu->data.mmc.dev, dfu->data.mmc.part,
  98                         (unsigned int) buf, dfu->name);
  99                 break;
 100         default:
 101                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 102                        dfu_get_layout(dfu->layout));
 103                 return -1;
 104         }
 105
 106         if (op == DFU_OP_WRITE)
 107                 sprintf(cmd_buf + strlen(cmd_buf), " %lx", *len);
 108
 109         debug("%s: %s 0x%p\n", __func__, cmd_buf, cmd_buf);
 110
 111         ret = run_command(cmd_buf, 0);
 112         if (ret) {
 113                 puts("dfu: Read error!\n");
 114                 return ret;
 115         }
 116
 117         if (dfu->layout != DFU_RAW_ADDR && op == DFU_OP_READ) {
 118                 str_env = getenv("filesize");
 119                 if (str_env == NULL) {
 120                         puts("dfu: Wrong file size!\n");
 121                         return -1;
 122                 }
 123                 *len = simple_strtoul(str_env, NULL, 16);
 124         }
 125
 126         return ret;
 127 }
 128
 129 int dfu_write_medium_mmc(struct dfu_entity *dfu,
 130                 u64 offset, void *buf, long *len)
 131 {
 132         int ret = -1;
 133
 134         switch (dfu->layout) {
 135         case DFU_RAW_ADDR:
 136                 ret = mmc_block_op(DFU_OP_WRITE, dfu, offset, buf, len);
 137                 break;
 138         case DFU_FS_FAT:
 139         case DFU_FS_EXT4:
 140                 ret = mmc_file_buffer(dfu, buf, len);
 141                 break;
 142         default:
 143                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 144                        dfu_get_layout(dfu->layout));
 145         }
 146
 147         return ret;
 148 }
 149
 150 int dfu_flush_medium_mmc(struct dfu_entity *dfu)
 151 {
 152         int ret = 0;
 153
 154         if (dfu->layout != DFU_RAW_ADDR) {
 155                 /* Do stuff here. */
 156                 ret = mmc_file_op(DFU_OP_WRITE, dfu, &dfu_file_buf,
 157                                 &dfu_file_buf_len);
 158
 159                 /* Now that we're done */
 160                 dfu_file_buf_len = 0;
 161         }
 162
 163         return ret;
 164 }
 165
 166 int dfu_read_medium_mmc(struct dfu_entity *dfu, u64 offset, void *buf,
 167                 long *len)
 168 {
 169         int ret = -1;
 170
 171         switch (dfu->layout) {
 172         case DFU_RAW_ADDR:
 173                 ret = mmc_block_op(DFU_OP_READ, dfu, offset, buf, len);
 174                 break;
 175         case DFU_FS_FAT:
 176         case DFU_FS_EXT4:
 177                 ret = mmc_file_op(DFU_OP_READ, dfu, buf, len);
 178                 break;
 179         default:
 180                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 181                        dfu_get_layout(dfu->layout));
 182         }
 183
 184         return ret;
 185 }
 186
 187 /*
 188  * @param s Parameter string containing space-separated arguments:
 189  *      1st:
 190  *              raw     (raw read/write)
 191  *              fat     (files)
 192  *              ext4    (^)
 193  *              part    (partition image)
 194  *      2nd and 3rd:
 195  *              lba_start and lba_size, for raw write
 196  *              mmc_dev and mmc_part, for filesystems and part
 197  */
 198 int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *s)
 199 {
 200         const char *entity_type;
 201         size_t second_arg;
 202         size_t third_arg;
 203
 204         struct mmc *mmc;
 205
 206         const char *argv[3];
 207         const char **parg = argv;
 208
 209         for (; parg < argv + sizeof(argv) / sizeof(*argv); ++parg) {
 210                 *parg = strsep(&s, " ");
 211                 if (*parg == NULL) {
 212                         error("Invalid number of arguments.\n");
 213                         return -ENODEV;
 214                 }
 215         }
 216
 217         entity_type = argv[0];
 218         /*
 219          * Base 0 means we'll accept (prefixed with 0x or 0) base 16, 8,
 220          * with default 10.
 221          */
 222         second_arg = simple_strtoul(argv[1], NULL, 0);
 223         third_arg = simple_strtoul(argv[2], NULL, 0);
 224
 225         mmc = find_mmc_device(dfu->dev_num);
 226         if (mmc == NULL) {
 227                 error("Couldn't find MMC device no. %d.\n", dfu->dev_num);
 228                 return -ENODEV;
 229         }
 230
 231         if (mmc_init(mmc)) {
 232                 error("Couldn't init MMC device.\n");
 233                 return -ENODEV;
 234         }
 235
 236         if (!strcmp(entity_type, "raw")) {
 237                 dfu->layout                     = DFU_RAW_ADDR;
 238                 dfu->data.mmc.lba_start         = second_arg;
 239                 dfu->data.mmc.lba_size          = third_arg;
 240                 dfu->data.mmc.lba_blk_size      = mmc->read_bl_len;
 241         } else if (!strcmp(entity_type, "part")) {
 242                 disk_partition_t partinfo;
 243                 block_dev_desc_t *blk_dev = &mmc->block_dev;
 244                 int mmcdev = second_arg;
 245                 int mmcpart = third_arg;
 246
 247                 if (get_partition_info(blk_dev, mmcpart, &partinfo) != 0) {
 248                         error("Couldn't find part #%d on mmc device #%d\n",
 249                               mmcpart, mmcdev);
 250                         return -ENODEV;
 251                 }
 252
 253                 dfu->layout                     = DFU_RAW_ADDR;
 254                 dfu->data.mmc.lba_start         = partinfo.start;
 255                 dfu->data.mmc.lba_size          = partinfo.size;
 256                 dfu->data.mmc.lba_blk_size      = partinfo.blksz;
 257         } else if (!strcmp(entity_type, "fat")) {
 258                 dfu->layout = DFU_FS_FAT;
 259         } else if (!strcmp(entity_type, "ext4")) {
 260                 dfu->layout = DFU_FS_EXT4;
 261         } else {
 262                 error("Memory layout (%s) not supported!\n", entity_type);
 263                 return -ENODEV;
 264         }
 265
 266         /* if it's NOT a raw write */
 267         if (strcmp(entity_type, "raw")) {
 268                 dfu->data.mmc.dev = second_arg;
 269                 dfu->data.mmc.part = third_arg;
 270         }
 271
 272         dfu->dev_type = DFU_DEV_MMC;
 273         dfu->read_medium = dfu_read_medium_mmc;
 274         dfu->write_medium = dfu_write_medium_mmc;
 275         dfu->flush_medium = dfu_flush_medium_mmc;
 276         dfu->inited = 0;
 277
 278         return 0;
 279 }