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 switch (dfu->layout) { 67 case DFU_FS_FAT: 68 sprintf(cmd_buf, "fat%s mmc %d:%d 0x%x %s %lx", 69 op == DFU_OP_READ ? "load" : "write", 70 dfu->data.mmc.dev, dfu->data.mmc.part, 71 (unsigned int) buf, dfu->name, *len); 72 break; 73 case DFU_FS_EXT4: 74 sprintf(cmd_buf, "ext4%s mmc %d:%d /%s 0x%x %ld", 75 op == DFU_OP_READ ? "load" : "write", 76 dfu->data.mmc.dev, dfu->data.mmc.part, 77 dfu->name, (unsigned int) buf, *len); 78 break; 79 default: 80 printf("%s: Layout (%s) not (yet) supported!\n", __func__, 81 dfu_get_layout(dfu->layout)); 82 } 83 84 debug("%s: %s 0x%p\n", __func__, cmd_buf, cmd_buf); 85 86 ret = run_command(cmd_buf, 0); 87 if (ret) { 88 puts("dfu: Read error!\n"); 89 return ret; 90 } 91 92 if (dfu->layout != DFU_RAW_ADDR && op == DFU_OP_READ) { 93 str_env = getenv("filesize"); 94 if (str_env == NULL) { 95 puts("dfu: Wrong file size!\n"); 96 return -1; 97 } 98 *len = simple_strtoul(str_env, NULL, 16); 99 } 100 101 return ret; 102 } 103 104 static inline int mmc_file_write(struct dfu_entity *dfu, void *buf, long *len) 105 { 106 return mmc_file_op(DFU_OP_WRITE, dfu, buf, len); 107 } 108 109 static inline int mmc_file_read(struct dfu_entity *dfu, void *buf, long *len) 110 { 111 return mmc_file_op(DFU_OP_READ, dfu, buf, len); 112 } 113 114 int dfu_write_medium_mmc(struct dfu_entity *dfu, void *buf, long *len) 115 { 116 int ret = -1; 117 118 switch (dfu->layout) { 119 case DFU_RAW_ADDR: 120 ret = mmc_block_write(dfu, buf, len); 121 break; 122 case DFU_FS_FAT: 123 case DFU_FS_EXT4: 124 ret = mmc_file_write(dfu, buf, len); 125 break; 126 default: 127 printf("%s: Layout (%s) not (yet) supported!\n", __func__, 128 dfu_get_layout(dfu->layout)); 129 } 130 131 return ret; 132 } 133 134 int dfu_read_medium_mmc(struct dfu_entity *dfu, void *buf, long *len) 135 { 136 int ret = -1; 137 138 switch (dfu->layout) { 139 case DFU_RAW_ADDR: 140 ret = mmc_block_read(dfu, buf, len); 141 break; 142 case DFU_FS_FAT: 143 case DFU_FS_EXT4: 144 ret = mmc_file_read(dfu, buf, len); 145 break; 146 default: 147 printf("%s: Layout (%s) not (yet) supported!\n", __func__, 148 dfu_get_layout(dfu->layout)); 149 } 150 151 return ret; 152 } 153 154 int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *s) 155 { 156 char *st; 157 158 dfu->dev_type = DFU_DEV_MMC; 159 st = strsep(&s, " "); 160 if (!strcmp(st, "mmc")) { 161 dfu->layout = DFU_RAW_ADDR; 162 dfu->data.mmc.lba_start = simple_strtoul(s, &s, 16); 163 dfu->data.mmc.lba_size = simple_strtoul(++s, &s, 16); 164 dfu->data.mmc.lba_blk_size = get_mmc_blk_size(dfu->dev_num); 165 } else if (!strcmp(st, "fat")) { 166 dfu->layout = DFU_FS_FAT; 167 } else if (!strcmp(st, "ext4")) { 168 dfu->layout = DFU_FS_EXT4; 169 } else { 170 printf("%s: Memory layout (%s) not supported!\n", __func__, st); 171 } 172 173 if (dfu->layout == DFU_FS_EXT4 || dfu->layout == DFU_FS_FAT) { 174 dfu->data.mmc.dev = simple_strtoul(s, &s, 10); 175 dfu->data.mmc.part = simple_strtoul(++s, &s, 10); 176 } 177 178 dfu->read_medium = dfu_read_medium_mmc; 179 dfu->write_medium = dfu_write_medium_mmc; 180 181 return 0; 182 } 183