static void cmd_erase(struct protocol_handle *phandle, const char *arg) { int partition_fd; char path[PATH_MAX]; D(DEBUG, "cmd_erase %s\n", arg); if (flash_find_entry(arg, path, PATH_MAX)) { fastboot_fail(phandle, "partition table doesn't exist"); return; } if (path == NULL) { fastboot_fail(phandle, "Couldn't find partition"); return; } partition_fd = flash_get_partiton(path); if (partition_fd < 0) { fastboot_fail(phandle, "partiton file does not exists"); } if (flash_erase(partition_fd)) { fastboot_fail(phandle, "failed to erase partition"); flash_close(partition_fd); return; } if (flash_close(partition_fd) < 0) { D(ERR, "could not close device %s", strerror(errno)); fastboot_fail(phandle, "failed to erase partition"); return; } fastboot_okay(phandle, ""); }
int fs_device_ftl_flash_close (efs_device_t base_dev) { int result = -1; result = flash_close (base_dev->priv.ftl_flash); base_dev->priv.ftl_flash = NULL; return result; }
static void m128rfa1_deinit(avr_t *avr, void *data) { (void)data; uart_pty_stop(&uart_pty[0]); uart_pty_stop(&uart_pty[1]); flash_close(avr->flash, avr->flashend + 1); avr->flash = NULL; }
void emu_cleanup() { exiting = true; if(debugger_input) fclose(debugger_input); // addr_cache_init is rather expensive and needs to be called once only //addr_cache_deinit(); #ifndef NO_TRANSLATION translate_deinit(); #endif memory_reset(); memory_deinitialize(); flash_close(); gdbstub_quit(); rdebug_quit(); }
int update_fw(const Value *fw_file, const Value *ec_file, int force) { int res = -EINVAL; struct flash_device *img, *spi, *ec; size_t size; char *fwid; char cur_part = vboot_get_mainfw_act(); char *version = fdt_read_string("firmware-version"); if (!version) { ALOGW("Cannot read firmware version from FDT\n"); return -EIO; } ALOGD("Running firmware: %s / partition %c\n", version, cur_part); img = flash_open("file", fw_file); if (!img) goto out_free; fwid = reinterpret_cast<char*>(fmap_read_section(img, "RW_FWID_A", &size, NULL)); if (!fwid) { ALOGD("Cannot find firmware image version\n"); goto out_close_img; } /* TODO: force update if keyblock does not match */ if (!strncmp(version, fwid, size) && !force) { ALOGI("Firmware already up-to-date: %s\n", version); free(fwid); res = 0; goto out_close_img; } free(fwid); ec = flash_open("ec", NULL); if (!ec) goto out_close_img; spi = flash_open("spi", NULL); if (!spi) goto out_close_ec; if (0) res = update_ap_fw(spi, img); if (cur_part == 'R') /* Recovery mode */ res = update_recovery_fw(spi, ec, img, ec_file); else /* Normal mode */ res = update_rw_fw(spi, img, cur_part); if (!res) /* successful update : record it */ res = 1; flash_close(spi); out_close_ec: flash_close(ec); out_close_img: flash_close(img); out_free: free(version); return res; }
static void cmd_flash(struct protocol_handle *phandle, const char *arg) { int partition; uint64_t sz; char data[BOOT_MAGIC_SIZE]; char path[PATH_MAX]; ssize_t header_sz = 0; int data_fd = 0; D(DEBUG, "cmd_flash %s\n", arg); if (try_handle_virtual_partition(phandle, arg)) { return; } if (phandle->download_fd < 0) { fastboot_fail(phandle, "no kernel file"); return; } if (flash_find_entry(arg, path, PATH_MAX)) { fastboot_fail(phandle, "partition table doesn't exist"); return; } if (flash_validate_certificate(phandle->download_fd, &data_fd) != 1) { fastboot_fail(phandle, "Access forbiden you need certificate"); return; } // TODO: Maybe its goot idea to check whether the partition is bootable if (!strcmp(arg, "boot") || !strcmp(arg, "recovery")) { if (read_data_once(data_fd, data, BOOT_MAGIC_SIZE) < BOOT_MAGIC_SIZE) { fastboot_fail(phandle, "incoming data read error, cannot read boot header"); return; } if (memcmp((void *)data, BOOT_MAGIC, BOOT_MAGIC_SIZE)) { fastboot_fail(phandle, "image is not a boot image"); return; } } partition = flash_get_partiton(path); sz = get_file_size64(data_fd); sz -= header_sz; if (sz > get_file_size64(partition)) { flash_close(partition); D(WARN, "size of file too large"); fastboot_fail(phandle, "size of file too large"); return; } D(INFO, "writing %"PRId64" bytes to '%s'\n", sz, arg); if (flash_write(partition, phandle->download_fd, sz, header_sz)) { fastboot_fail(phandle, "flash write failure"); return; } D(INFO, "partition '%s' updated\n", arg); flash_close(partition); close(data_fd); fastboot_okay(phandle, ""); }
/*! ******************************************************************************* ** ** \brief Get the number of flash sectors occupied by the boot image ** ** This function calculates the number of flash sectors occupied by the ** boot image and the leading boot block which contains some size and copy ** information as well as a variable number of register/value settings. ** ** \param device The type of boot device ** \param sectors The address of a buffer where to write the result into ** ** \return ** - GD_OK if successfull, the sectors argument contains the number of ** occupied sectors ** - non-GD_OK in case of error, see the GD_FLASH documentation for possible ** return values ** ******************************************************************************* */ GERR GD_SYS_BootImageGetSectors( GD_SYS_BOOT_DEVICE_E device, U16* sectors ) { GERR status; GD_HANDLE handle; GD_SYS_BOOT_S bootblock; U32 index; U16 u16words; U32 u32words; U32 address; U16 sector; GERR (*flash_open)(GD_HANDLE*); GERR (*flash_close)(GD_HANDLE*); GERR (*flash_get_sector)(GD_HANDLE,U32,U16*); #if !defined (SMARTMPEG_D) if( device == GD_SYS_BOOT_DEVICE_FLASH ) { flash_open = GD_FL_Open; flash_close = GD_FL_Close; flash_get_sector = GD_FL_GetSector; } else // device == GD_SYS_BOOT_DEVICE_SFLASH #endif { #if defined(SMARTMPEG_C) || defined(SMARTMPEG_M) || defined(SMARTMPEG_D) || defined(GK6105S) || defined(GK6106) flash_open = GD_SFLASH_Open; flash_close = GD_SFLASH_Close; flash_get_sector = GD_SFLASH_GetSector; #else return( GD_ERR_BAD_PARAMETER ); #endif } status = flash_open( &handle ); if( status == GD_OK ) { u16words = sizeof(bootblock) / sizeof(U16); u32words = sizeof(bootblock) / sizeof(U32); #if !defined(SMARTMPEG_D) if( device == GD_SYS_BOOT_DEVICE_FLASH ) { status = GD_FL_Read( handle, 0, (U16*)(void*)&bootblock, u16words ); } else #endif { #if defined(SMARTMPEG_C) || defined(SMARTMPEG_M) || defined(SMARTMPEG_D) || defined(GK6105S) || defined(GK6106) status = GD_SFLASH_Read( handle, 0, (U32*)(void*)&bootblock, u32words ); #else status = GD_ERR_BAD_PARAMETER; #endif } //GM_Printf( "bootblock.magic_id = 0x%08x\n", bootblock.magic_id ); //GM_Printf( "bootblock.image_words = 0x%08x\n", bootblock.image_words ); //GM_Printf( "bootblock.target_address = 0x%08x\n", bootblock.target_address ); //GM_Printf( "bootblock.start_address = 0x%08x\n", bootblock.start_address ); //for( index=0; bootblock.register_defs[index].address != 0x00000000; index++ ) //{ // GM_Printf( "bootblock.register_defs[%d] = 0x%08x:0x%08x\n", index, bootblock.register_defs[index].address, bootblock.register_defs[index].data ); //} if( status == GD_OK ) { if( ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_E1 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_E2 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_L1 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_L2 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_C1 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_C2 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_C4 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_M1 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_M2 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_M4 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_G1 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_G2 ) || ( bootblock.magic_id == GD_SYS_MAGIC_ID_SMARTMPEG_G4 ) ) { // search for the termination of register/value pairs for( index=0; bootblock.register_defs[index].address != 0x00000000; index++ ) ; u32words = 4 + ( index * ( sizeof(GD_SYS_BOOT_REG_S)/sizeof(U32) ) ) + 1; // calculate the required size in bytes for the // boot image plus the leading boot block information // containing the register/value pair settings u32words += bootblock.image_words; #if defined(SMARTMPEG_C) || defined(SMARTMPEG_M) || defined(SMARTMPEG_D) || defined(GK6105S) || defined(GK6106) if( device == GD_SYS_BOOT_DEVICE_SFLASH ) { address = u32words * sizeof(U32); } else { address = ( u32words * sizeof(U32) ) / sizeof(U16); } #else // SMARTMPEG, SMARTMPEG-L, SMARTMPEG-E address = ( u32words * sizeof(U32) ) / sizeof(U16); #endif status = flash_get_sector( handle, address, §or ); *sectors = sector + 1; } else { u32words = 0; *sectors = 0; } } } flash_close( &handle ); if( status != GD_OK ) { u32words = 0; *sectors = 0; } //GM_Printf( "first free (s)flash address = %d\n", address ); //GM_Printf( "used boot image sectors = %d\n", *sectors ); return( status ); }