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);
}
}
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);
}
int
main(int argc, char *argv[])
{
struct disk_info *dinfo = NULL;
int test = 0;
int verbose = 0;
int cnt;
if (parse_args(argc, argv, &dinfo, &test, &verbose))
return 1;
if (process_disk_config(dinfo)) {
fprintf(stderr, "Disk configuration is bad\n");
return 1;
}
if (verbose)
dump_disk_config(dinfo);
if (test)
printf("Test mode enabled. Actions will not be committed to disk!\n");
if (apply_disk_config(dinfo, test)) {
fprintf(stderr, "Could not apply disk configuration!\n");
return 1;
}
printf("Copying images to specified partition offsets\n");
/* now copy the images to their appropriate locations on disk */
for (cnt = 0; cnt < MAX_NUM_PARTS && part_file_map[cnt].pinfo; ++cnt) {
off64_t offs = part_file_map[cnt].pinfo->start_lba * dinfo->sect_size;
const char *dest_fn = dinfo->device;
if (write_raw_image(dest_fn, part_file_map[cnt].filename, offs, test)) {
fprintf(stderr, "Could not write images after editing label.\n");
return 1;
}
}
printf("File edit complete. Wrote %d images.\n", cnt);
return 0;
}
/**
* A program wich tests the epr-c-api by converting producing ENVI raster
* information from dataset.
*
* It generates a *.raw data file for all rasters included in the
* given product in the given output directory.
*
* Call: api_test <ENVISAT-Product file path> <Output directory for file exports>
*/
int main(int argc, char** argv)
{
EPR_SProductId* product_id;
int i, numGrids;
const char* product_file_path;
const char* output_dir_path;
if (argc <= 2) {
printf("Usage: api_test <envisat-product> <output-dir>");
printf(" where envisat-product is the input filename\n");
printf(" and output-dir is the output directory\n");
printf("Example:\n");
printf(" api_test \"./MER_RR__2P_TEST.N1\" \".\\output\" \n\n");
exit(1);
}
product_file_path = argv[1];
output_dir_path = argv[2];
/* Initialize the API. Set log-level to DEBUG and use default log-output (stdout) */
epr_init_api(e_log_debug, epr_log_message, NULL);
/* Open the product; an argument is a path to product data file */
product_id = epr_open_product(product_file_path);
numGrids = epr_get_num_bands(product_id);
for (i = 0; i < numGrids; i ++) {
write_raw_image(output_dir_path, product_id, epr_get_band_name(epr_get_band_id_at(product_id, i)));
}
/* Close product_id and release rest of the allocated memory */
epr_close_product(product_id);
/* Closes product reader API, release all allocated resources */
epr_close_api();
return 0;
}
int nandroid_restore(const char* backup_path, int restore_boot, int restore_system, int restore_data, int restore_cache, int restore_sdext)
{
ui_set_background(BACKGROUND_ICON_INSTALLING);
ui_show_indeterminate_progress();
yaffs_files_total = 0;
if (ensure_root_path_mounted("SDCARD:") != 0)
return print_and_error("Can't mount /sdcard\n");
char tmp[PATH_MAX];
ui_print("Checking MD5 sums...\n");
sprintf(tmp, "cd %s && md5sum -c nandroid.md5", backup_path);
if (0 != __system(tmp))
return print_and_error("MD5 mismatch!\n");
int ret;
#ifndef BOARD_RECOVERY_IGNORE_BOOTABLES
if (restore_boot)
{
ui_print("Erasing boot before restore...\n");
if (0 != (ret = format_root_device("BOOT:")))
return print_and_error("Error while formatting BOOT:!\n");
sprintf(tmp, "%s/boot.img", backup_path);
ui_print("Restoring boot image...\n");
if (0 != (ret = write_raw_image("boot", tmp))) {
ui_print("Error while flashing boot image!");
return ret;
}
}
#endif
if (restore_system) {
if (0 != (ret = nandroid_restore_partition(backup_path, "SYSTEM:")))
return ret;
// we don't want to restore the /system/etc/lagfix.conf files as they can cause problems
ensure_root_path_mounted("SYSTEM:");
__system("rm /system/etc/lagfix.conf");
__system("rm /system/etc/lagfix.conf.old");
}
if (restore_data && 0 != (ret = nandroid_restore_partition(backup_path, "DATA:")))
return ret;
#ifdef HAS_DATADATA
if (restore_data && 0 != (ret = nandroid_restore_partition(backup_path, "DATADATA:")))
return ret;
#endif
if (restore_data && 0 != (ret = nandroid_restore_partition_extended(backup_path, "SDCARD:/.android_secure", 0)))
return ret;
if (restore_cache && 0 != (ret = nandroid_restore_partition_extended(backup_path, "CACHE:", 0)))
return ret;
if (restore_sdext && 0 != (ret = nandroid_restore_partition(backup_path, "SDEXT:")))
return ret;
sync();
ui_set_background(BACKGROUND_ICON_EBCLOCKWORK);
ui_reset_progress();
ui_print("\nRestore complete!\n");
return 0;
}
// write_raw_image(file, partition)
Value* WriteRawImageFn(const char* name, State* state, int argc, Expr* argv[]) {
char* result = NULL;
char* partition;
char* filename;
if (ReadArgs(state, argv, 2, &filename, &partition) < 0) {
return NULL;
}
if (strlen(partition) == 0) {
ErrorAbort(state, "partition argument to %s can't be empty", name);
goto done;
}
if (strlen(filename) == 0) {
ErrorAbort(state, "file argument to %s can't be empty", name);
goto done;
}
#ifdef BOARD_USES_BMLUTILS
if (0 == write_raw_image(name, filename)) {
result = partition;
}
result = strdup("Failure");
#else
mtd_scan_partitions();
const MtdPartition* mtd = mtd_find_partition_by_name(partition);
if (mtd == NULL) {
fprintf(stderr, "%s: no mtd partition named \"%s\"\n", name, partition);
result = strdup("");
goto MMC;
}
MtdWriteContext* ctx = mtd_write_partition(mtd);
if (ctx == NULL) {
fprintf(stderr, "%s: can't write mtd partition \"%s\"\n",
name, partition);
result = strdup("");
goto done;
}
bool success;
FILE* f = fopen(filename, "rb");
if (f == NULL) {
fprintf(stderr, "%s: can't open %s: %s\n",
name, filename, strerror(errno));
result = strdup("");
goto done;
}
success = true;
char* buffer = malloc(BUFSIZ);
int read;
while (success && (read = fread(buffer, 1, BUFSIZ, f)) > 0) {
int wrote = mtd_write_data(ctx, buffer, read);
success = success && (wrote == read);
if (!success) {
fprintf(stderr, "mtd_write_data to %s failed: %s\n",
partition, strerror(errno));
}
}
free(buffer);
fclose(f);
if (mtd_erase_blocks(ctx, -1) == -1) {
fprintf(stderr, "%s: error erasing blocks of %s\n", name, partition);
}
if (mtd_write_close(ctx) != 0) {
fprintf(stderr, "%s: error closing write of %s\n", name, partition);
}
printf("%s %s partition from %s\n",
success ? "wrote" : "failed to write", partition, filename);
result = success ? partition : strdup("");
goto done;
MMC:
mmc_scan_partitions();
const MmcPartition* mmc = mmc_find_partition_by_name(partition);
if (mmc == NULL) {
fprintf(stderr, "%s: no mmc partition named \"%s\"\n", name, partition);
result = strdup("");
goto done;
}
if (mmc_raw_copy(mmc, filename)) {
fprintf(stderr, "%s: error erasing mmc partition named \"%s\"\n", name, partition);
result = strdup("");
goto done;
}
result = partition;
#endif
done:
if (result != partition) free(partition);
free(filename);
return StringValue(result);
}
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);
}
}
