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 } 409