static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info, const char *part_name, void *buffer, unsigned int download_bytes) { lbaint_t blkcnt; lbaint_t blks; /* determine number of blocks to write */ blkcnt = ((download_bytes + (info->blksz - 1)) & ~(info->blksz - 1)); blkcnt = lldiv(blkcnt, info->blksz); if (blkcnt > info->size) { error("too large for partition: '%s'\n", part_name); fastboot_fail("too large for partition"); return; } puts("Flashing Raw Image\n"); blks = blk_dwrite(dev_desc, info->start, blkcnt, buffer); if (blks != blkcnt) { error("failed writing to device %d\n", dev_desc->devnum); fastboot_fail("failed writing to device"); return; } printf("........ wrote " LBAFU " bytes to '%s'\n", blkcnt * info->blksz, part_name); fastboot_okay(""); }
static int ums_write_sector(struct ums *ums_dev, ulong start, lbaint_t blkcnt, const void *buf) { struct blk_desc *block_dev = &ums_dev->block_dev; lbaint_t blkstart = start + ums_dev->start_sector; return blk_dwrite(block_dev, blkstart, blkcnt, buf); }
static lbaint_t fb_mmc_sparse_write(struct sparse_storage *info, lbaint_t blk, lbaint_t blkcnt, const void *buffer) { struct fb_mmc_sparse *sparse = info->priv; struct blk_desc *dev_desc = sparse->dev_desc; return blk_dwrite(dev_desc, blk, blkcnt, buffer); }
static inline int write_env(struct blk_desc *sata, unsigned long size, unsigned long offset, void *buffer) { uint blk_start, blk_cnt, n; blk_start = ALIGN(offset, sata->blksz) / sata->blksz; blk_cnt = ALIGN(size, sata->blksz) / sata->blksz; n = blk_dwrite(sata, blk_start, blk_cnt, buffer); return (n == blk_cnt) ? 0 : -1; }
static inline int write_env(struct mmc *mmc, unsigned long size, unsigned long offset, const void *buffer) { uint blk_start, blk_cnt, n; struct blk_desc *desc = mmc_get_blk_desc(mmc); blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len; blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len; n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer); return (n == blk_cnt) ? 0 : -1; }
/* usb_request complete call back to handle down load image */ static void rx_handler_dl_image(struct usb_ep *ep, struct usb_request *req) { struct f_rockusb *f_rkusb = get_rkusb(); unsigned int transfer_size = 0; const unsigned char *buffer = req->buf; unsigned int buffer_size = req->actual; transfer_size = f_rkusb->dl_size - f_rkusb->dl_bytes; if (!f_rkusb->desc) { char *type = f_rkusb->dev_type; int index = f_rkusb->dev_index; f_rkusb->desc = blk_get_dev(type, index); if (!f_rkusb->desc || f_rkusb->desc->type == DEV_TYPE_UNKNOWN) { puts("invalid mmc device\n"); rockusb_tx_write_csw(f_rkusb->tag, 0, CSW_FAIL, USB_BULK_CS_WRAP_LEN); return; } } if (req->status != 0) { printf("Bad status: %d\n", req->status); rockusb_tx_write_csw(f_rkusb->tag, 0, CSW_FAIL, USB_BULK_CS_WRAP_LEN); return; } if (buffer_size < transfer_size) transfer_size = buffer_size; memcpy((void *)f_rkusb->buf, buffer, transfer_size); f_rkusb->dl_bytes += transfer_size; int blks = 0, blkcnt = transfer_size / 512; debug("dl %x bytes, %x blks, write lba %x, dl_size:%x, dl_bytes:%x, ", transfer_size, blkcnt, f_rkusb->lba, f_rkusb->dl_size, f_rkusb->dl_bytes); blks = blk_dwrite(f_rkusb->desc, f_rkusb->lba, blkcnt, f_rkusb->buf); if (blks != blkcnt) { printf("failed writing to device %s: %d\n", f_rkusb->dev_type, f_rkusb->dev_index); rockusb_tx_write_csw(f_rkusb->tag, 0, CSW_FAIL, USB_BULK_CS_WRAP_LEN); return; } f_rkusb->lba += blkcnt; /* Check if transfer is done */ if (f_rkusb->dl_bytes >= f_rkusb->dl_size) { req->complete = rx_handler_command; req->length = EP_BUFFER_SIZE; f_rkusb->buf = f_rkusb->buf_head; printf("transfer 0x%x bytes done\n", f_rkusb->dl_size); f_rkusb->dl_size = 0; rockusb_tx_write_csw(f_rkusb->tag, 0, CSW_GOOD, USB_BULK_CS_WRAP_LEN); } else { req->length = rx_bytes_expected(ep); if (f_rkusb->buf == f_rkusb->buf_head) f_rkusb->buf = f_rkusb->buf_head + EP_BUFFER_SIZE; else f_rkusb->buf = f_rkusb->buf_head; debug("remain %x bytes, %x sectors\n", req->length, req->length / 512); } req->actual = 0; usb_ep_queue(ep, req, 0); }
static int mmc_burn_image(size_t image_size) { struct mmc *mmc; lbaint_t start_lba; lbaint_t blk_count; ulong blk_written; int err; const u8 mmc_dev_num = CONFIG_SYS_MMC_ENV_DEV; #ifdef CONFIG_BLK struct blk_desc *blk_desc; #endif mmc = find_mmc_device(mmc_dev_num); if (!mmc) { printf("No SD/MMC/eMMC card found\n"); return -ENOMEDIUM; } err = mmc_init(mmc); if (err) { printf("%s(%d) init failed\n", IS_SD(mmc) ? "SD" : "MMC", mmc_dev_num); return err; } #ifdef CONFIG_SYS_MMC_ENV_PART if (mmc->part_num != CONFIG_SYS_MMC_ENV_PART) { err = mmc_switch_part(mmc_dev_num, CONFIG_SYS_MMC_ENV_PART); if (err) { printf("MMC partition switch failed\n"); return err; } } #endif /* SD reserves LBA-0 for MBR and boots from LBA-1, * MMC/eMMC boots from LBA-0 */ start_lba = IS_SD(mmc) ? 1 : 0; #ifdef CONFIG_BLK blk_count = image_size / mmc->write_bl_len; if (image_size % mmc->write_bl_len) blk_count += 1; blk_desc = mmc_get_blk_desc(mmc); if (!blk_desc) { printf("Error - failed to obtain block descriptor\n"); return -ENODEV; } blk_written = blk_dwrite(blk_desc, start_lba, blk_count, (void *)get_load_addr()); #else blk_count = image_size / mmc->block_dev.blksz; if (image_size % mmc->block_dev.blksz) blk_count += 1; blk_written = mmc->block_dev.block_write(mmc_dev_num, start_lba, blk_count, (void *)get_load_addr()); #endif /* CONFIG_BLK */ if (blk_written != blk_count) { printf("Error - written %#lx blocks\n", blk_written); return -ENOSPC; } printf("Done!\n"); #ifdef CONFIG_SYS_MMC_ENV_PART if (mmc->part_num != CONFIG_SYS_MMC_ENV_PART) mmc_switch_part(mmc_dev_num, mmc->part_num); #endif return 0; }