void fb_mmc_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes)
{
struct blk_desc *dev_desc;
disk_partition_t info;
dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n");
fastboot_fail("invalid mmc device");
return;
}
if (strcmp(cmd, CONFIG_FASTBOOT_GPT_NAME) == 0) {
printf("%s: updating MBR, Primary and Backup GPT(s)\n",
__func__);
if (is_valid_gpt_buf(dev_desc, download_buffer)) {
printf("%s: invalid GPT - refusing to write to flash\n",
__func__);
fastboot_fail("invalid GPT partition");
return;
}
if (write_mbr_and_gpt_partitions(dev_desc, download_buffer)) {
printf("%s: writing GPT partitions failed\n", __func__);
fastboot_fail(
"writing GPT partitions failed");
return;
}
printf("........ success\n");
fastboot_okay("");
return;
} else if (part_get_info_efi_by_name_or_alias(dev_desc, cmd, &info)) {
error("cannot find partition: '%s'\n", cmd);
fastboot_fail("cannot find partition");
return;
}
if (is_sparse_image(download_buffer)) {
struct fb_mmc_sparse sparse_priv;
struct sparse_storage sparse;
sparse_priv.dev_desc = dev_desc;
sparse.blksz = info.blksz;
sparse.start = info.start;
sparse.size = info.size;
sparse.write = fb_mmc_sparse_write;
sparse.reserve = fb_mmc_sparse_reserve;
printf("Flashing sparse image at offset " LBAFU "\n",
sparse.start);
sparse.priv = &sparse_priv;
write_sparse_image(&sparse, cmd, download_buffer,
download_bytes);
} else {
write_raw_image(dev_desc, &info, cmd, download_buffer,
download_bytes);
}
}
EFI_STATUS flash_partition(VOID *data, UINTN size, CHAR16 *label)
{
EFI_STATUS ret;
ret = gpt_get_partition_by_label(label, &gparti, LOGICAL_UNIT_USER);
if (EFI_ERROR(ret)) {
efi_perror(ret, L"Failed to get partition %s", label);
return ret;
}
cur_offset = gparti.part.starting_lba * gparti.bio->Media->BlockSize;
if (is_sparse_image(data, size))
ret = flash_sparse(data, size);
else
ret = flash_write(data, size);
if (EFI_ERROR(ret))
return ret;
if (!CompareGuid(&gparti.part.type, &EfiPartTypeSystemPartitionGuid))
return gpt_refresh();
return EFI_SUCCESS;
}
void fb_nand_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes)
{
struct part_info *part;
struct mtd_info *mtd = NULL;
int ret;
ret = fb_nand_lookup(cmd, &mtd, &part);
if (ret) {
error("invalid NAND device");
fastboot_fail("invalid NAND device");
return;
}
ret = board_fastboot_write_partition_setup(part->name);
if (ret)
return;
if (is_sparse_image(download_buffer)) {
struct fb_nand_sparse sparse_priv;
struct sparse_storage sparse;
sparse_priv.mtd = mtd;
sparse_priv.part = part;
sparse.blksz = mtd->writesize;
sparse.start = part->offset / sparse.blksz;
sparse.size = part->size / sparse.blksz;
sparse.write = fb_nand_sparse_write;
sparse.reserve = fb_nand_sparse_reserve;
printf("Flashing sparse image at offset " LBAFU "\n",
sparse.start);
sparse.priv = &sparse_priv;
write_sparse_image(&sparse, cmd, download_buffer,
download_bytes);
} else {
printf("Flashing raw image at offset 0x%llx\n",
part->offset);
ret = _fb_nand_write(mtd, part, download_buffer, part->offset,
download_bytes, NULL);
printf("........ wrote %u bytes to '%s'\n",
download_bytes, part->name);
}
if (ret) {
fastboot_fail("error writing the image");
return;
}
fastboot_okay("");
}
void fb_nand_flash_write(const char *partname, unsigned int session_id,
void *download_buffer, unsigned int download_bytes,
char *response)
{
struct part_info *part;
nand_info_t *nand = NULL;
int ret;
/* initialize the response buffer */
response_str = response;
ret = fb_nand_lookup(partname, response, &nand, &part);
if (ret) {
error("invalid NAND device");
fastboot_fail(response_str, "invalid NAND device");
return;
}
ret = board_fastboot_write_partition_setup(part->name);
if (ret)
return;
if (is_sparse_image(download_buffer)) {
struct fb_nand_sparse sparse_priv;
sparse_storage_t sparse;
sparse_priv.nand = nand;
sparse_priv.part = part;
sparse.block_sz = nand->writesize;
sparse.start = part->offset / sparse.block_sz;
sparse.size = part->size / sparse.block_sz;
sparse.name = part->name;
sparse.write = fb_nand_sparse_write;
ret = store_sparse_image(&sparse, &sparse_priv, session_id,
download_buffer);
} else {
printf("Flashing raw image at offset 0x%llx\n",
part->offset);
ret = _fb_nand_write(nand, part, download_buffer, part->offset,
download_bytes, NULL);
printf("........ wrote %u bytes to '%s'\n",
download_bytes, part->name);
}
if (ret) {
fastboot_fail(response_str, "error writing the image");
return;
}
fastboot_okay(response_str, "");
}
void fb_mmc_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes, char *response)
{
block_dev_desc_t *dev_desc;
disk_partition_t info;
/* initialize the response buffer */
response_str = response;
dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n");
fastboot_fail("invalid mmc device");
return;
}
if (strcmp(cmd, CONFIG_FASTBOOT_GPT_NAME) == 0) {
printf("%s: updating MBR, Primary and Backup GPT(s)\n",
__func__);
if (is_valid_gpt_buf(dev_desc, download_buffer)) {
printf("%s: invalid GPT - refusing to write to flash\n",
__func__);
fastboot_fail("invalid GPT partition");
return;
}
if (write_mbr_and_gpt_partitions(dev_desc, download_buffer)) {
printf("%s: writing GPT partitions failed\n", __func__);
fastboot_fail("writing GPT partitions failed");
return;
}
printf("........ success\n");
fastboot_okay("");
return;
} else if (get_partition_info_efi_by_name(dev_desc, cmd, &info)) {
error("cannot find partition: '%s'\n", cmd);
fastboot_fail("cannot find partition");
return;
}
if (is_sparse_image(download_buffer))
write_sparse_image(dev_desc, &info, cmd, download_buffer,
download_bytes);
else
write_raw_image(dev_desc, &info, cmd, download_buffer,
download_bytes);
}
BOOL write_to_emmc(u8* data, u32 length)
{
u64 paritition_size = 0;
u64 size_wrote = 0;
int next_flip = 0;
u32 index;
u32 pre_chksum = 0;
u32 post_chksum = 0;
int r;
while(sto_info.first_run)
{
r = get_partition_name(data, length, sto_info.partition_name);
if(r < 0)
{
display_info("\nget_partition_name() Fail");
return FALSE;
}
if((!strncmp((char*)sto_info.partition_name, (char*)"signatureFile", 16))
|| (!strncmp((char*)sto_info.partition_name, (char*)"boot", 8)))
{
//this do not need subsequent codes for normal partition.
ctx.boot_like_info.is_boot_like_image = TRUE;
ctx.boot_like_info.offset = 0;
sto_info.first_run = 0;
break;
}
index = partition_get_index((char*)sto_info.partition_name);
if(index == (u32)(-1))
{
display_info("\nBrick phone??");
return FALSE;
}
if(!is_support_flash(index))
{
display_info((char*)sto_info.partition_name);
display_info("\nDont support partition");
return FALSE;
}
paritition_size = partition_get_size(index);
dprintf(DBG_LV, "[index:%d]-[downSize:%d]\n", index, sto_info.to_write_data_len);
if (ROUND_TO_PAGE(sto_info.to_write_data_len,511) > paritition_size)
{
display_info("\nsize too large, space small.");
dprintf(DBG_LV, "size too large, space small.");
return FALSE;
}
#ifdef MTK_NEW_COMBO_EMMC_SUPPORT
sto_info.part_id = partition_get_region(index);
sto_info.unsparse_status.part_id = sto_info.part_id;
#endif
sto_info.image_base_addr = partition_get_offset(index);
sto_info.unsparse_status.image_base_addr = sto_info.image_base_addr;
sto_info.is_sparse_image = is_sparse_image(data, length);
sto_info.first_run = 0;
}
//boot like image do not need write to image at this function. it is in flash function.
if(ctx.boot_like_info.is_boot_like_image)
{
dprintf(DBG_LV, "boot like img: len: %d\n", length);
dprintf(DBG_LV, "data: %08X\n", (u32)data);
//dprintf(DBG_LV, "ctx.boot_like_info.boot_like_image_address: %08X, ctx.boot_like_info.offset %u, \n", ctx.boot_like_info.boot_like_image_address , ctx.boot_like_info.offset);
memcpy(ctx.boot_like_info.boot_like_image_address + ctx.boot_like_info.offset, data, length);
ctx.boot_like_info.offset += length;
return TRUE;
}
if(sto_info.is_sparse_image)
{
next_flip = cache_shift(ctx.flipIdxR);
sto_info.unsparse_status.buf = data;
sto_info.unsparse_status.size = length;
mmc_write_sparse_data(&sto_info.unsparse_status);
if(sto_info.unsparse_status.handle_status == S_DA_SDMMC_SPARSE_INCOMPLETE)
{
ctx.dual_cache[next_flip].padding_length = sto_info.unsparse_status.size;
memcpy(ctx.dual_cache[next_flip].padding_buf +(CACHE_PADDING_SIZE-sto_info.unsparse_status.size)
, sto_info.unsparse_status.buf
, sto_info.unsparse_status.size);
}
else if (sto_info.unsparse_status.handle_status== S_DONE)
{
ctx.dual_cache[next_flip].padding_length = 0;
}
else
{
//some error
dprintf(DBG_LV, "write_to_emmc() Failed. handle_status(%d)\n", sto_info.unsparse_status.handle_status);
display_info("\nError in write sparse image in EMMC.");
return FALSE;
}
}
else
{
#ifdef MTK_NEW_COMBO_EMMC_SUPPORT
size_wrote = emmc_write(sto_info.part_id, sto_info.image_base_addr+sto_info.bulk_image_offset , (void*)data, length);
#else
size_wrote = emmc_write(sto_info.image_base_addr+sto_info.bulk_image_offset , (void*)data, length);
#endif
if (size_wrote != length)
{
dprintf(DBG_LV, "write_to_emmc() Failed. act(%d) != want(%d)\n", (u32)size_wrote, length);
display_info("\nError in write bulk in EMMC.");
return FALSE;
}
if(sto_info.checksum_enabled)
{
pre_chksum = calc_checksum(data, (u32)length);
#ifdef MTK_NEW_COMBO_EMMC_SUPPORT
if(length != emmc_read(sto_info.part_id, sto_info.image_base_addr+sto_info.bulk_image_offset, data, length))
#else
if(length != emmc_read(sto_info.image_base_addr+sto_info.bulk_image_offset, data, length))
#endif
{
dprintf(DBG_LV, "emmc_read() Failed.\n");
display_info("\nError in Read bulk EMMC.");
return FALSE;
}
post_chksum = calc_checksum(data, (u32)length);
if(post_chksum != pre_chksum)
{
dprintf(DBG_LV, "write_to_emmc() Failed. checksum error\n");
display_info("\nWrite bulk in EMMC. Checksum Error");
return FALSE;
}
}
sto_info.bulk_image_offset += size_wrote;
}
return TRUE;
}
BOOL write_to_emmc(u8* data, u32 length)
{
u64 paritition_size = 0;
u64 size_wrote = 0;
int next_flip = 0;
u32 index;
u32 pre_chksum = 0;
u32 post_chksum = 0;
int r;
if(sto_info.first_run)
{
r = get_partition_name(data, length, sto_info.partition_name);
if(r < 0)
{
display_info("\nASSERT!! get_partition_name() Fail");
return FALSE;
}
if(!strncmp(sto_info.partition_name, "boot", 8))
{
ctx.boot_info.is_boot_image = TRUE;
ctx.boot_info.offset = 0;
}
index = partition_get_index(sto_info.partition_name);
if(index == -1)
{
display_info("\nASSERT!! Brick phone??");
return FALSE;
}
if(!is_support_flash(index))
{
display_info(sto_info.partition_name);
display_info("\nASSERT!! Dont support system??");
return FALSE;
}
paritition_size = partition_get_size(index);
dprintf(DBG_LV, "[index:%d]-[partitionSize:%lld]-[downSize:%lld]\n", index, paritition_size, sto_info.to_write_data_len);
if (ROUND_TO_PAGE(sto_info.to_write_data_len,511) > paritition_size)
{
display_info("\nsize too large, space small.");
dprintf(DBG_LV, "size too large, space small.");
return FALSE;
}
sto_info.image_base_addr = partition_get_offset(index);
sto_info.unsparse_status.image_base_addr = sto_info.image_base_addr;
sto_info.is_sparse_image = is_sparse_image(data, length);
sto_info.first_run = 0;
}
//boot image do not need write to image at this function. it is in flash function.
if(ctx.boot_info.is_boot_image)
{
dprintf(DBG_LV, "boot img: len: %d\n", length);
dprintf(DBG_LV, "data: %08X\n", data);
dprintf(DBG_LV, "ctx.boot_info.boot_image_address: %08X, ctx.boot_info.offset %u, \n", ctx.boot_info.boot_image_address , ctx.boot_info.offset);
memcpy(ctx.boot_info.boot_image_address + ctx.boot_info.offset, data, length);
ctx.boot_info.offset += length;
return TRUE;
}
if(sto_info.is_sparse_image)
{
next_flip = cache_shift(ctx.flipIdxR);
sto_info.unsparse_status.buf = data;
sto_info.unsparse_status.size = length;
mmc_write_sparse_data(&sto_info.unsparse_status);
if(sto_info.unsparse_status.handle_status == S_DA_SDMMC_SPARSE_INCOMPLETE)
{
ctx.dual_cache[next_flip].padding_length = sto_info.unsparse_status.size;
memcpy(ctx.dual_cache[next_flip].padding_buf +(CACHE_PADDING_SIZE-sto_info.unsparse_status.size)
, sto_info.unsparse_status.buf
, sto_info.unsparse_status.size);
}
else if (sto_info.unsparse_status.handle_status== S_DONE)
{
ctx.dual_cache[next_flip].padding_length = 0;
}
else
{
//some error
dprintf(DBG_LV, "write_to_emmc() Failed. handle_status(%d)\n", sto_info.unsparse_status.handle_status);
display_info("\nError in write sparse image in EMMC.");
return FALSE;
}
}
else
{
size_wrote = emmc_write(sto_info.image_base_addr+sto_info.bulk_image_offset , (void*)data, length);
if (size_wrote != length)
{
dprintf(DBG_LV, "write_to_emmc() Failed. act(%lld) != want(%lld)\n", size_wrote, length);
display_info("\nError in write bulk in EMMC.");
return FALSE;
}
if(sto_info.checksum_enabled)
{
pre_chksum = calc_checksum(data, (u32)length);
if(length != emmc_read(sto_info.image_base_addr+sto_info.bulk_image_offset, data, length))
{
dprintf(DBG_LV, "emmc_read() Failed.\n");
display_info("\nError in Read bulk EMMC.");
return FALSE;
}
post_chksum = calc_checksum(data, (u32)length);
if(post_chksum != pre_chksum)
{
dprintf(DBG_LV, "write_to_emmc() Failed. checksum error\n");
display_info("\nWrite bulk in EMMC. Checksum Error");
return FALSE;
}
}
sto_info.bulk_image_offset += size_wrote;
}
return TRUE;
}
void fb_mmc_flash_write(const char *cmd, void *download_buffer,
unsigned int download_bytes, char *response)
{
int ret;
int expected;
int pte_blk_cnt;
block_dev_desc_t *dev_desc;
disk_partition_t info;
/* initialize the response buffer */
response_str = response;
legacy_mbr *mbr;
gpt_header *primary_gpt_h;
gpt_entry *second_gpt_e;
dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n");
fastboot_fail("invalid mmc device");
return;
}
#if 0
char cmd_buf[64] = {0};
ulong mmc_part;
ulong mmc_flash_start;
if (!strncmp("to:", cmd, strlen("to:"))) {
strsep(&cmd, ":");
if (!cmd) {
error("missing variable\n");
fastboot_fail("missing var");
return;
}
mmc_part = simple_strtoul(cmd, NULL, 10);
if(mmc_part > 16){
error("Part # is too large\n");
fastboot_fail("Part # is too large");
return;
}
strsep(&cmd, ":");
if (!cmd) {
error("missing variable\n");
fastboot_fail("missing var");
return;
}
mmc_flash_start = simple_strtoul(cmd, NULL, 16);
if(mmc_flash_start != PAD_TO_BLOCKSIZE(mmc_flash_start, dev_desc)){
error("Offset must start from block size boudry\n");
fastboot_fail("Offset must start from block size boudry");
return;
}
sprintf(cmd_buf, "mmc dev %d %d", CONFIG_FASTBOOT_FLASH_MMC_DEV, mmc_part);
run_command(cmd_buf, 0);
if(dev_desc->lba != 0){
if (dev_desc->block_write(dev_desc->dev, mmc_flash_start/dev_desc->blksz, BLOCK_CNT(download_bytes, dev_desc), download_buffer) != BLOCK_CNT(download_bytes, dev_desc)){
error("flash data failed:\n");
fastboot_fail("flash data failed:");
}else{
fastboot_okay("");
}
}else{
error("Invalid mmc part\n");
fastboot_fail("Invalid mmc part");
}
/* switch back to main part */
sprintf(cmd_buf, "mmc dev %d 0", CONFIG_FASTBOOT_FLASH_MMC_DEV);
run_command(cmd_buf, 0);
}else
#endif
if (!strncmp("partition", cmd, strlen("partition"))) {
/*do sanity check of the downloader data */
expected = sizeof(legacy_mbr) + 2 * ((PAD_TO_BLOCKSIZE(sizeof(gpt_header), dev_desc) + PAD_TO_BLOCKSIZE(GPT_ENTRY_NUMBERS
* sizeof(gpt_entry), dev_desc)));
if(expected != download_bytes){
error("wrong size for download data, expected: %d\n", expected);
fastboot_fail("wrong size for download data");
return;
}
mbr = download_buffer;
primary_gpt_h = (void *)mbr + sizeof(legacy_mbr);
pte_blk_cnt = BLOCK_CNT((primary_gpt_h->num_partition_entries * sizeof(gpt_entry)), dev_desc);
second_gpt_e = primary_gpt_h + PAD_TO_BLOCKSIZE(sizeof(gpt_header), dev_desc)
+ PAD_TO_BLOCKSIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry), dev_desc);
/* Check the MBR signature */
if (le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE){
error("MBR signature is wrong:"
"0x%X != 0x%X\n",
le16_to_cpu(mbr->signature),
MSDOS_MBR_SIGNATURE);
fastboot_fail("wrong data");
return;
}
/* Check the GPT header signature */
if (le64_to_cpu(primary_gpt_h->signature) != GPT_HEADER_SIGNATURE) {
error("GUID Partition Table Header signature is wrong:"
"0x%llX != 0x%llX\n",
le64_to_cpu(primary_gpt_h->signature),
GPT_HEADER_SIGNATURE);
fastboot_fail("wrong data");
return;
}
/* Write the Legacy MBR */
if (dev_desc->block_write(dev_desc->dev, 0, 1, mbr) != 1){
printf("Write mbr failed!\n");
goto err;
}
/* Write the First GPT to the block right after the Legacy MBR */
if (dev_desc->block_write(dev_desc->dev, 1, pte_blk_cnt + 1, primary_gpt_h) != pte_blk_cnt + 1){
printf("Write primary gpt failed!\n");
goto err;
}
/*Write the Second GPT at the end of the block*/
lbaint_t second_gpt_offset = le32_to_cpu(primary_gpt_h->last_usable_lba + 1);
if(dev_desc->block_write(dev_desc->dev, second_gpt_offset,
pte_blk_cnt + 1, second_gpt_e) != pte_blk_cnt + 1){
printf("write second gpt failed!\n");
goto err;
}
#if 0
/* do sanity check of the download data */
expected = sizeof(legacy_mbr)+ 1 * (PAD_TO_BLOCKSIZE(sizeof(gpt_header), dev_desc)+PAD_TO_BLOCKSIZE(GPT_ENTRY_NUMBERS
* sizeof(gpt_entry), dev_desc));
/*if(expected != download_bytes){
error("wrong size for download data, expected: %d\n", expected);
fastboot_fail("wrong size for download data");
return;
}*/
printf("legacy_mbr is %d, gpt_header is %d, gpt_entry is %d\n",sizeof(legacy_mbr),PAD_TO_BLOCKSIZE(sizeof(gpt_header),
dev_desc),PAD_TO_BLOCKSIZE(GPT_ENTRY_NUMBERS * sizeof(gpt_entry), dev_desc));
mbr = download_buffer;
gpt_h = (void *)mbr + sizeof(legacy_mbr);
gpt_e = (void *)gpt_h+PAD_TO_BLOCKSIZE(sizeof(gpt_header), dev_desc);
/* Check the MBR signature */
if (le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE){
error("MBR signature is wrong:"
"0x%X != 0x%X\n",
le16_to_cpu(mbr->signature),
MSDOS_MBR_SIGNATURE);
fastboot_fail("wrong data");
return;
}
/* Check the GPT header signature */
if (le64_to_cpu(gpt_h->signature) != GPT_HEADER_SIGNATURE) {
error("GUID Partition Table Header signature is wrong:"
"0x%llX != 0x%llX\n",
le64_to_cpu(gpt_h->signature),
GPT_HEADER_SIGNATURE);
fastboot_fail("wrong data");
return;
}
const int pte_blk_cnt = BLOCK_CNT((gpt_h->num_partition_entries
* sizeof(gpt_entry)), dev_desc);
u32 calc_crc32;
u64 val;
printf("max lba: %x\n", (u32) dev_desc->lba);
printf("last_usable_lba is %d, my_lba is %d, pte_blk_cnt is %d\n",le32_to_cpu(gpt_h->last_usable_lba + 1),le32_to_cpu(gpt_h->my_lba),
pte_blk_cnt);
/* Write the Legacy MBR */
if (dev_desc->block_write(dev_desc->dev, 0, 1, mbr) != 1){
printf("Write mbr failed!\n");
goto err;
}
printf("last_usable_lba is %d, my_lba is %d, pte_blk_cnt is %d\n",le32_to_cpu(gpt_h->last_usable_lba + 1),le32_to_cpu(gpt_h->my_lba),
pte_blk_cnt);
/* Write the First GPT to the block right after the Legacy MBR */
if (dev_desc->block_write(dev_desc->dev, 1, 1, gpt_h) != 1){
printf("Write gpt header failed!\n");
goto err;
}
printf("last_usable_lba is %d, my_lba is %d, pte_blk_cnt is %d\n",le32_to_cpu(gpt_h->last_usable_lba + 1),le32_to_cpu(gpt_h->my_lba),
pte_blk_cnt);
if (dev_desc->block_write(dev_desc->dev, 2, pte_blk_cnt, gpt_e)
!= pte_blk_cnt){
printf("Write gpt_e failed!\n");
goto err;
}
printf("last_usable_lba is %d, my_lba is %d, pte_blk_cnt is %d\n",le32_to_cpu(gpt_h->last_usable_lba + 1),le32_to_cpu(gpt_h->my_lba),
pte_blk_cnt);
/* recalculate the values for the Second GPT Header */
printf("last_usable_lba is %d, my_lba is %d, pte_blk_cnt is %d\n",le32_to_cpu(gpt_h->last_usable_lba + 1),le32_to_cpu(gpt_h->my_lba),
pte_blk_cnt);
val = le64_to_cpu(gpt_h->my_lba);
gpt_h->my_lba = gpt_h->alternate_lba;
gpt_h->alternate_lba = cpu_to_le64(val);
gpt_h->header_crc32 = 0;
calc_crc32 = crc32(0, (const unsigned char *)gpt_h,
le32_to_cpu(gpt_h->header_size));
gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
printf("last_usable_lba is %d, my_lba is %d, pte_blk_cnt is %d\n",le32_to_cpu(gpt_h->last_usable_lba + 1),le32_to_cpu(gpt_h->my_lba),
pte_blk_cnt);
if (dev_desc->block_write(dev_desc->dev,
le32_to_cpu(gpt_h->last_usable_lba + 1),
pte_blk_cnt, gpt_e) != pte_blk_cnt){
printf("Write second gpt_e failed!\n");
goto err;
}
if (dev_desc->block_write(dev_desc->dev,
le32_to_cpu(gpt_h->my_lba), 1, gpt_h) != 1){
printf("Write second gpt_h failed!\n");
goto err;
}
#endif
printf("GPT successfully written to block device!\n");
fastboot_okay("");
return;
err:
error("flash partition data failed: '%s'\n", cmd);
fastboot_fail("cannot flash partition");
return;
}else{
ret = get_partition_info_efi_by_name(dev_desc, cmd, &info);
if (ret) {
error("cannot find partition: '%s'\n", cmd);
fastboot_fail("cannot find partition");
return;
}
if (is_sparse_image(download_buffer))
write_sparse_image(dev_desc, &info, cmd, download_buffer,
download_bytes);
else
write_raw_image(dev_desc, &info, cmd, download_buffer,
download_bytes);
}
}
