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  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <common.h>
  23 #include <malloc.h>
  24 #include <dfu.h>
  25
  26 enum dfu_mmc_op {
  27         DFU_OP_READ = 1,
  28         DFU_OP_WRITE,
  29 };
  30
  31 static int mmc_block_op(enum dfu_mmc_op op, struct dfu_entity *dfu,
  32                         void *buf, long *len)
  33 {
  34         char cmd_buf[DFU_CMD_BUF_SIZE];
  35
  36         sprintf(cmd_buf, "mmc %s 0x%x %x %x",
  37                 op == DFU_OP_READ ? "read" : "write",
  38                 (unsigned int) buf,
  39                 dfu->data.mmc.lba_start,
  40                 dfu->data.mmc.lba_size);
  41
  42         if (op == DFU_OP_READ)
  43                 *len = dfu->data.mmc.lba_blk_size * dfu->data.mmc.lba_size;
  44
  45         debug("%s: %s 0x%p\n", __func__, cmd_buf, cmd_buf);
  46         return run_command(cmd_buf, 0);
  47 }
  48
  49 static inline int mmc_block_write(struct dfu_entity *dfu, void *buf, long *len)
  50 {
  51         return mmc_block_op(DFU_OP_WRITE, dfu, buf, len);
  52 }
  53
  54 static inline int mmc_block_read(struct dfu_entity *dfu, void *buf, long *len)
  55 {
  56         return mmc_block_op(DFU_OP_READ, dfu, buf, len);
  57 }
  58
  59 static int mmc_file_op(enum dfu_mmc_op op, struct dfu_entity *dfu,
  60                         void *buf, long *len)
  61 {
  62         char cmd_buf[DFU_CMD_BUF_SIZE];
  63         char *str_env;
  64         int ret;
  65
  66         sprintf(cmd_buf, "fat%s mmc %d:%d 0x%x %s %lx",
  67                 op == DFU_OP_READ ? "load" : "write",
  68                 dfu->data.mmc.dev, dfu->data.mmc.part,
  69                 (unsigned int) buf, dfu->name, *len);
  70
  71         debug("%s: %s 0x%p\n", __func__, cmd_buf, cmd_buf);
  72
  73         ret = run_command(cmd_buf, 0);
  74         if (ret) {
  75                 puts("dfu: Read error!\n");
  76                 return ret;
  77         }
  78
  79         if (dfu->layout != DFU_RAW_ADDR) {
  80                 str_env = getenv("filesize");
  81                 if (str_env == NULL) {
  82                         puts("dfu: Wrong file size!\n");
  83                         return -1;
  84                 }
  85                 *len = simple_strtoul(str_env, NULL, 16);
  86         }
  87
  88         return ret;
  89 }
  90
  91 static inline int mmc_file_write(struct dfu_entity *dfu, void *buf, long *len)
  92 {
  93         return mmc_file_op(DFU_OP_WRITE, dfu, buf, len);
  94 }
  95
  96 static inline int mmc_file_read(struct dfu_entity *dfu, void *buf, long *len)
  97 {
  98         return mmc_file_op(DFU_OP_READ, dfu, buf, len);
  99 }
 100
 101 int dfu_write_medium_mmc(struct dfu_entity *dfu, void *buf, long *len)
 102 {
 103         int ret = -1;
 104
 105         switch (dfu->layout) {
 106         case DFU_RAW_ADDR:
 107                 ret = mmc_block_write(dfu, buf, len);
 108                 break;
 109         case DFU_FS_FAT:
 110                 ret = mmc_file_write(dfu, buf, len);
 111                 break;
 112         default:
 113                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 114                        dfu_get_layout(dfu->layout));
 115         }
 116
 117         return ret;
 118 }
 119
 120 int dfu_read_medium_mmc(struct dfu_entity *dfu, void *buf, long *len)
 121 {
 122         int ret = -1;
 123
 124         switch (dfu->layout) {
 125         case DFU_RAW_ADDR:
 126                 ret = mmc_block_read(dfu, buf, len);
 127                 break;
 128         case DFU_FS_FAT:
 129                 ret = mmc_file_read(dfu, buf, len);
 130                 break;
 131         default:
 132                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 133                        dfu_get_layout(dfu->layout));
 134         }
 135
 136         return ret;
 137 }
 138
 139 int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *s)
 140 {
 141         char *st;
 142
 143         dfu->dev_type = DFU_DEV_MMC;
 144         st = strsep(&s, " ");
 145         if (!strcmp(st, "mmc")) {
 146                 dfu->layout = DFU_RAW_ADDR;
 147                 dfu->data.mmc.lba_start = simple_strtoul(s, &s, 16);
 148                 dfu->data.mmc.lba_size = simple_strtoul(++s, &s, 16);
 149                 dfu->data.mmc.lba_blk_size = get_mmc_blk_size(dfu->dev_num);
 150         } else if (!strcmp(st, "fat")) {
 151                 dfu->layout = DFU_FS_FAT;
 152                 dfu->data.mmc.dev = simple_strtoul(s, &s, 10);
 153                 dfu->data.mmc.part = simple_strtoul(++s, &s, 10);
 154         } else {
 155                 printf("%s: Memory layout (%s) not supported!\n", __func__, st);
 156         }
 157
 158         dfu->read_medium = dfu_read_medium_mmc;
 159         dfu->write_medium = dfu_write_medium_mmc;
 160
 161         return 0;
 162 }