static int cmd_write(const struct shell *shell, size_t argc, char *argv[]) { u32_t check_array[BUF_ARRAY_CNT]; u32_t buf_array[BUF_ARRAY_CNT]; struct device *flash_dev; u32_t w_addr; int j = 0; flash_dev = device_get_binding(FLASH_DEV_NAME); if (!flash_dev) { error(shell, "Flash driver was not found!"); return -ENODEV; } if (argc < 2) { error(shell, "Missing address."); return -EINVAL; } if (argc <= 2) { error(shell, "Type data to be written."); return -EINVAL; } for (int i = 2; i < argc && i < BUF_ARRAY_CNT; i++) { buf_array[j] = strtoul(argv[i], NULL, 16); check_array[j] = ~buf_array[j]; j++; } flash_write_protection_set(flash_dev, 0); w_addr = strtoul(argv[1], NULL, 16); if (flash_write(flash_dev, w_addr, buf_array, sizeof(buf_array[0]) * j) != 0) { error(shell, "Write internal ERROR!"); return -EIO; } print(shell, "Write OK."); flash_read(flash_dev, w_addr, check_array, sizeof(buf_array[0]) * j); if (memcmp(buf_array, check_array, sizeof(buf_array[0]) * j) == 0) { print(shell, "Verified."); } else { error(shell, "Verification ERROR!"); return -EIO; } return 0; }
/* * \brief Commit demo parameters. */ uint32_t demo_parameters_commit_changes( void ) { uint32_t ret; taskENTER_CRITICAL(); flash_init(FLASH_ACCESS_MODE_128, 6); flash_unlock(IFLASH0_ADDR, __offset_parameters__ + IFLASH0_PAGE_SIZE - 1, 0, 0); #if SAM4S /* Erase flag page */ flash_erase_page(__offset_parameters__, IFLASH_ERASE_PAGES_8); ret = flash_write((uint32_t)(__offset_parameters__), (void *)&g_demo_parameters, sizeof(demo_param_t), 0); #else ret = flash_write((uint32_t)(__offset_parameters__), (void *)&g_demo_parameters, sizeof(demo_param_t), 1); #endif taskEXIT_CRITICAL(); return ret; }
OSStatus internalFlashWrite(volatile uint32_t* flash_address, uint32_t* data ,uint32_t data_length) { platform_log_trace(); OSStatus err = kNoErr; //page write length IFLASH_PAGE_SIZE uint32_t rc ; mem_flash_op_enter(); #if SAMG55 rc = flash_write((*flash_address), data, data_length, false); #else rc = flash_write((*flash_address), data, data_length, true); #endif mem_flash_op_exit(); if (rc != FLASH_RC_OK) { platform_log("flash err: %d",rc); return kGeneralErr; } *flash_address += data_length; exit: return err; }
bool FlashStorage::write(uint32_t address, const void *data, uint32_t dataLength) { if ((uint32_t)FLASH_START + address < (uint32_t)&__flash_start__) { FLASH_DEBUG("Flash write address too low"); return false; } if ((uint32_t)FLASH_START + address + dataLength > (uint32_t)&__flash_end__) { FLASH_DEBUG("Flash write address too high"); return false; } if ((((uint32_t)FLASH_START + address) & 3) != 0) { FLASH_DEBUG("Flash start address must be on 4-byte boundary\n"); return false; } // The flash management code in the ASF is fragile and has a tendency to fail to return. Help it by disabling interrupts. efc_disable_frdy_interrupt(EFC); // should not be enabled already, but disable it just in case irqflags_t flags = cpu_irq_save(); // Unlock page uint32_t retCode = flash_unlock((uint32_t)FLASH_START + address, (uint32_t)FLASH_START + address + dataLength - 1, NULL, NULL); if (retCode != FLASH_RC_OK) { FLASH_DEBUG("Failed to unlock flash for write"); } else { // Write data retCode = flash_write((uint32_t)FLASH_START + address, data, dataLength, 1); if (retCode != FLASH_RC_OK) { FLASH_DEBUG("Flash write failed"); } else { // Lock page retCode = flash_lock((uint32_t)FLASH_START + address, (uint32_t)FLASH_START + address + dataLength - 1, NULL, NULL); if (retCode != FLASH_RC_OK) { FLASH_DEBUG("Failed to lock flash page"); } } } cpu_irq_restore(flags); return retCode == FLASH_RC_OK; }
status_code_t nvm_write_char(mem_type_t mem, uint32_t address, uint8_t data) { switch (mem) { case INT_FLASH: flash_write(address, 1, &data); break; default: return ERR_INVALID_ARG; } return STATUS_OK; }
void env_relocate_spec(void){ #if !defined(ENV_IS_EMBEDDED) || defined(CFG_ENV_ADDR_REDUND) #ifdef CFG_ENV_ADDR_REDUND if(gd->env_addr != (ulong)&(flash_addr->data)){ env_t * etmp = flash_addr; ulong ltmp = end_addr; flash_addr = flash_addr_new; flash_addr_new = etmp; end_addr = end_addr_new; end_addr_new = ltmp; } if(flash_addr_new->flags != OBSOLETE_FLAG && crc32(0, flash_addr_new->data, ENV_SIZE) == flash_addr_new->crc){ char flag = OBSOLETE_FLAG; gd->env_valid = 2; flash_write(&flag, (ulong)&(flash_addr_new->flags), sizeof(flash_addr_new->flags)); } if(flash_addr->flags != ACTIVE_FLAG && (flash_addr->flags & ACTIVE_FLAG) == ACTIVE_FLAG){ char flag = ACTIVE_FLAG; gd->env_valid = 2; flash_write(&flag, (ulong)&(flash_addr->flags), sizeof(flash_addr->flags)); } if(gd->env_valid == 2){ puts("** Warning: some problems detected reading environment, recovered successfully\n"); } #endif /* CFG_ENV_ADDR_REDUND */ memcpy(env_ptr, (void*)flash_addr, CFG_ENV_SIZE); #endif /* ! ENV_IS_EMBEDDED || CFG_ENV_ADDR_REDUND */ }
// Append value to the current area. Returns written object size on success, 0 if no space left. static unsigned cfg_write( struct config* cfg, int a, const struct cfg_type* t, void const* pval, unsigned char i, unsigned char j ) { unsigned val_sz = cfg_obj_data_size_(t, j); unsigned sz = sizeof(struct cfg_obj_header) + val_sz + sizeof(struct cfg_obj_footer); struct config_area* ar = &cfg->area[a]; BUG_ON(ar->invalid); BUG_ON(ar->used_bytes > CFG_BUFF_SIZE); if (ar->used_bytes + sz > (t ? CFG_BUFF_SIZE-CFG_RESERVED_SPACE : CFG_BUFF_SIZE)) return 0; const char* ptr = ar->storage + ar->used_bytes; struct cfg_obj_footer f; struct cfg_obj_header h; cfg_init_hdr(t, &h, i, j); flash_write((unsigned*)ptr, (unsigned const*)&h, sizeof(h)); ar->crc = crc16_up_buff(ar->crc, &h, sizeof(h)); ptr += sizeof(h); if (val_sz) { unsigned val_sz_ = cfg_obj_data_size_unaligned_(t, j); flash_write((unsigned*)ptr, (unsigned const*)pval, val_sz_); ar->crc = crc16_up_buff(ar->crc, pval, val_sz_); ptr += val_sz; if (val_sz_ & 1) ar->crc = crc16_up(ar->crc, 0xff); ar->status = ar->status < area_open ? area_dirty : area_modified; } f.crc = ar->crc; flash_write((unsigned*)ptr, (unsigned const*)&f, sizeof(f)); ar->used_bytes += sz; return sz; }
static void REGPARAM2 blizzardf0_bput(uaecptr addr, uae_u32 b) { #ifdef JIT special_mem |= S_WRITE; #endif regs.memory_waitstate_cycles += F0_WAITSTATES * 1; if (is_csmk3() || is_blizzardppc()) { if (flash_unlocked) { flash_write(flashrom, addr, b); } } else if (is_csmk2()) { addr &= 65535; addr += 65536; addr &= ~3; addr |= csmk2_flashaddressing; flash_write(flashrom, addr, b); } else if (is_csmk1()) { addr &= 65535; addr += 65536; flash_write(flashrom, addr, b); } }
status_code_t nvm_write(mem_type_t mem, uint32_t address, void *buffer, uint32_t len) { switch (mem) { case INT_FLASH: flash_write(address, len, buffer); break; default: return ERR_INVALID_ARG; } return STATUS_OK; }
static int startup_config_write_to_flash(void *addr , int len) { #ifdef HAVE_SCFG_PROTECTION unsigned int part_index = IROS_FLASH_PARTITION_INDEX_ANY; #endif char *startup_cfg_addr = NULL; int written_len = 0; if(!scfg_autosave_flag) return 0; #ifdef HAVE_SCFG_PROTECTION part_index = flash_part_id_to_part_index(SCFG_PARTION); if(active_part_index == part_index) active_part_index = flash_part_id_to_part_index(SCFG_PARTION1); else active_part_index = part_index; #endif if(active_part_index == IROS_FLASH_PARTITION_INDEX_ANY) { if(scfg_warning_flag == 0) cs_printf("write startup-cfg error!\n"); return -1; } startup_cfg_addr = flash_dev.info.super_block.part_tab[active_part_index].part_loc; if (flash_part_write_init(active_part_index, startup_cfg_addr)) { /* prepare to write flash */ startup_cfg_encrypt((char *)addr+sizeof(tlv_header_t), len-sizeof(tlv_header_t)); written_len = flash_write(startup_cfg_addr, (char *)addr, len); flash_part_write_done(active_part_index); flash_write_verify(startup_cfg_addr, (char *)addr, len); if(written_len != len) { startup_cfg_decrypt((char *)addr+sizeof(tlv_header_t), len-sizeof(tlv_header_t)); if(scfg_warning_flag == 0) cs_printf("write startup-config error\n"); return -1; } startup_cfg_decrypt((char *)addr+sizeof(tlv_header_t), len-sizeof(tlv_header_t)); if(scfg_warning_flag == 0) cs_printf("write startup-cfg successfully\n"); return 0; } else { if(scfg_warning_flag == 0) cs_printf("write startup-cfg error\n"); } return -1; }
void blackbox_write(uchar type, const char* data, uchar length) { uint32_t tick = clock_tics; // Get number of ticks (this might change during writing, so we need a local copy) flash_write_byte(BLACKBOX_FRAME_START); // Write start byte flash_write_byte(type); // Write type flash_write_byte(tick >> 24); // Write tick flash_write_byte(tick >> 16); // flash_write_byte(tick >> 8); // flash_write_byte(tick); // flash_write_byte(length); // Write length flash_write(data, length); // Write data flash_write_byte(BLACKBOX_FRAME_END); // Write end byte }
static int setZhonxName(void) { int rv; // Write Name in flash rv = flash_write(zhonxSettings.h_flash, (unsigned char *)CONFIG_ZHONX_INFO_ADDR, (unsigned char *)zhonxName, strlen(zhonxName) + 1); if (rv != FLASH_E_SUCCESS) { // TODO: handle this error } return 0; }
/*-----------------------------------------------------------*/ void task_led(void *pvParameters) { uint32_t ul_last_page_addr = LAST_PAGE_ADDRESS; uint32_t *pul_last_page = (uint32_t *) ul_last_page_addr; (void) pvParameters; // memset(&IPsave_tmp, 0, sizeof(ip_save_t)); /* Initialize flash: 6 wait states for flash writing. */ flash_init(FLASH_ACCESS_MODE_128, 6); /* Unlock page */ flash_unlock(ul_last_page_addr, ul_last_page_addr + IFLASH_PAGE_SIZE - 1, 0, 0); /* Read Flash page */ memcpy((uint8_t*)(&IPsave_tmp), (uint8_t*)pul_last_page, sizeof(ip_save_t)); // IPsave_tmp.mode = 2; if (IPsave_tmp.ip[0] == 0) { IPsave_tmp.ip[0] = 223; } if (gpio_pin_is_low(RESTKEY_GPIO) == 1) { uint32_t ul_last_page_addr = LAST_PAGE_ADDRESS; uint32_t ul_page_buffer[IFLASH_PAGE_SIZE / sizeof(uint32_t)]; IPsave_tmp.mode = 1; IPsave_tmp.ip[0] = 223; /* Copy information to FLASH buffer..*/ memcpy((uint8_t*)ul_page_buffer, (uint8_t *)(&IPsave_tmp), sizeof(ip_save_t)); /* Write page */ flash_write(ul_last_page_addr, ul_page_buffer, IFLASH_PAGE_SIZE, 1); } /* Lock page */ flash_lock(ul_last_page_addr, ul_last_page_addr + IFLASH_PAGE_SIZE - 1, 0, 0); for (;;) { gpio_toggle_pin(LED0_GPIO); vTaskDelay(1000); } }
/* Invalid standby blob XIP crc to 0xFFFFFFFF for Bug 23377 */ cs_uint32 standby_blob_crc_invalidate(void) { blob_info_desc_t *active_blob_info; blob_info_desc_t *standby_blob_info; unsigned int act_blob_idex,sty_blob_idex; cs_callback_context_t context; void *temp_ptr=NULL; act_blob_idex = current_blob_desc.blob_idx; active_blob_info = blob_info_tab[act_blob_idex]; /* if current active blob is not commited invalid standby blob crc */ if(active_blob_info->is_not_confirmed){ /* Disable watchdog enabled by loader for Bug 28609 */ cs_plat_wdt_disable(context,0,0); /* used to back up first block data*/ temp_ptr=iros_malloc(IROS_MID_SYS, flash_dev.info.super_block.block_size); if(NULL == temp_ptr){ cs_printf("Invalidate standby blob xip crc failed for no memory\n"); return CS_ERROR; } sty_blob_idex = 0x1 &(act_blob_idex + 1); /* back up standby data */ memcpy(temp_ptr,blob_info_tab[sty_blob_idex],flash_dev.info.super_block.block_size); standby_blob_info = (blob_info_desc_t *)temp_ptr; standby_blob_info->xip_crc32 = 0xffffffff; /* prepare to write flash with erase */ if (flash_part_write_init(blob_part_tab[sty_blob_idex], (char*)blob_info_tab[sty_blob_idex])) { flash_write((char *)blob_info_tab[sty_blob_idex], (char *)temp_ptr, flash_dev.info.super_block.block_size); cs_printf("Standby blob xip crc invalidated \n"); flash_part_write_done(blob_part_tab[sty_blob_idex]); } else { // cs_printf("Standby blob invalidate failed \n"); iros_free(temp_ptr); return CS_ERROR; } iros_free(temp_ptr); } return CS_OK; }
/// Clear the marker that allows the firmware to boot. /// \returns true iff successful bool storage_protect_on(void) { _Static_assert(sizeof(STORAGE_PROTECT_ON_MAGIC) == sizeof(STORAGE_PROTECT_OFF_MAGIC), "Storage protection markers must be the same length"); Allocation active; if (!find_active_storage(&active)) return false; Allocation marker_sector = next_storage(active); flash_erase_word(marker_sector); bool ret = flash_write(marker_sector, 0, sizeof(STORAGE_PROTECT_ON_MAGIC), (const uint8_t*)STORAGE_PROTECT_ON_MAGIC); return ret; }
retval_t nvram_write_blocking(const void *addr, size_t size) { // TODO this is too aggressive! improve... NVRAM_REPORT("nvram: flash_erase\n"); (void )flash_erase(nvram0, sizeof(nvram_t)); NVRAM_REPORT("nvram: flash_write\n"); if (FLASH_ERR_OK != flash_write(nvram0, addr, sizeof(nvram_t))) { return RV_ERROR; } return RV_SUCCESS; }
int flash_memset(unsigned char *ptr, const __u8 c, unsigned long size) { #ifndef CONFIG_SVINTO_SIM static unsigned char pattern[16]; int i; /* fill up pattern */ for(i = 0; i < 16; i++) pattern[i] = c; /* write as many 16-byte chunks as we can */ while(size >= 16) { flash_write(ptr, pattern, 16); size -= 16; ptr += 16; } /* and the rest */ if(size) flash_write(ptr, pattern, size); #else /* In the simulator, we simulate flash as ram, so we can use a simple memset. */ printk("flash memset, byte 0x%x dest %p size %d\n", c, ptr, size); memset(ptr, c, size); #endif return 0; }
/** * Write a page from the supplied flash buffer to flash memory * The flash buffer must have been obtained through a call to * flash_get_page_buffer, before making this call * returns > 0 number of bytes written < 0 error * Error returns: * -1 Timeout waiting for TWI to complete * -2 Timeout waiting for flash write to complete * -3 Bad page number * -4 bad flash buffer */ int flash_write_page_buffer(FOURBYTES *page, int page_num) { /* Write page to flash memory. * This function must run out of ram and while it executes no other code * (especially any flash resident) code must run. This is becuase the * flash memory is only a single plane and can not be accessed for both read * and write at the same time. */ int istate; int status; if (page_num + flash_start_page >= FLASH_MAX_PAGES) return -3; if (VINTPTR(page) != &(FLASH_BASE[page_num*FLASH_PAGE_SIZE])) return -4; /* We must disbale interrupts. However we need to try and ensure that all * current interrupt activity is complete before we do that. We talk to * the avr every 1ms and this uses interrupt driven I/O so we try to make * sure this is complete. */ // Allow any playing sound to complete sound_wait(); // Turn off timer tick call backs systick_suspend(); // Wait until next tick systick_wait_ms(1); // Force a tick to talk to the avr nxt_avr_1kHz_update(); // Wait for it to complete status = wait_twi_complete(); if (status != 0) return -1; // Now we can turn off all ints istate = interrupts_get_and_disable(); // Write the buffer to the selected page status = flash_write(page_num + flash_start_page); // Turn ints back on if (istate) interrupts_enable(); // Ensure that we are back in-sync. systick_wait_ms(1); // Allow call backs on 1ms tick systick_resume(); if (!(status & AT91C_MC_FRDY)) return -2; return FLASH_PAGE_SIZE*sizeof(U32); }
void nvWriteChars(unsigned char *data, unsigned int len) { uint off = flashutl_desc->size - NVRAM_SPACE; int err; if (flashutl_cmd->type == SFLASH) err = sflash_commit(sih, cc, off, len, data); else /* PFLASH */ err = flash_write(off, data, len); if (err) DPRINT(("nvWriteChars failed\n")); else DPRINT(("nvWriteChars succeeded\n")); }
static retval_t flash_write_direct(const subsystem_t *self, frame_t * iframe, frame_t * oframe) { void *dst, *src; uint32_t size; flash_err_t err; if (RV_SUCCESS != frame_get_u32(iframe, (uint32_t*)&dst)) return RV_NOSPACE; if (RV_SUCCESS != frame_get_u32(iframe, (uint32_t*)&src)) return RV_NOSPACE; if (RV_SUCCESS != frame_get_u32(iframe, (uint32_t*)&size)) return RV_NOSPACE; err = flash_write(dst, src, size); log_report_fmt(LOG_SS_MEMORY, "flash_write_direct(0x%08x, 0x%08x, %d) returned FLASH_ERR_#%d\n", dst, src, size, err); frame_put_u32(oframe, err); if (FLASH_ERR_OK != err) return RV_ERROR; return RV_SUCCESS; }
/****************************************************************************** * Register Roomba device on SMRTControl ******************************************************************************/ void register_device(uint8_t* device_num_addr) { /* Uninitialized flash memory is all 1*/ if (*device_num_addr == 255) { /* Register device */ uint8_t register_array[39] = {PACKET_START_BYTE, 0, 0, 0, 33}; memcpy(register_array+5, DEVICE_URL, 33); register_array[38] = PACKET_END_BYTE; UART_send_array(register_array, 39); flash_erase(device_num_addr); flash_write(device_num_addr, 0); } }
int saveenv(void){ int len, rc; ulong end_addr, flash_sect_addr; #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) ulong flash_offset; uchar env_buffer[CFG_ENV_SECT_SIZE]; #else uchar *env_buffer = (uchar *)env_ptr; #endif /* CFG_ENV_SECT_SIZE */ int rcode = 0; #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) flash_offset = ((ulong)flash_addr) & (CFG_ENV_SECT_SIZE-1); flash_sect_addr = ((ulong)flash_addr) & ~(CFG_ENV_SECT_SIZE-1); //debug("copy old content: sect_addr: %08lX env_addr: %08lX offset: %08lX\n", flash_sect_addr, (ulong)flash_addr, flash_offset); /* copy old contents to temporary buffer */ memcpy(env_buffer, (void *)flash_sect_addr, CFG_ENV_SECT_SIZE); /* copy current environment to temporary buffer */ memcpy((uchar *)((unsigned long)env_buffer + flash_offset), env_ptr, CFG_ENV_SIZE); len = CFG_ENV_SECT_SIZE; #else flash_sect_addr = (ulong)flash_addr; len = CFG_ENV_SIZE; #endif /* CFG_ENV_SECT_SIZE */ end_addr = flash_sect_addr + len - 1; if(flash_sect_erase(flash_sect_addr, end_addr)){ return(1); } rc = flash_write((char *)env_buffer, flash_sect_addr, len); if(rc != 0){ flash_perror(rc); rcode = 1; } else { //debug("done\n"); } return(rcode); }
static size_t memwrite_flash(void *dest, void *src, size_t len) { #if USE_BLOCKWRITING return rom_pwrite(src, len, (off_t)(uintptr_t)dest); // The compiler will remove everything from this point on. // -> No #elsif needed #endif /* USE_BLOCKWRITING */ size_t written = 0; unsigned short *lcldest = dest; char *lclsrc = src; unsigned short ow; char *owptr = (char*) (&ow); #if DEBUG if ((uintptr_t) dest & 1) { puts("Alignment FAIL"); } #endif //DPRINTF("Flash: %x\n", ow); //watchdog_periodic(); #if 1 != FBENCHMARK flash_setup(); #endif while ((len & ~0x1) > written) { owptr[0] = *lclsrc++; owptr[1] = *lclsrc++; #if 1 !=FBENCHMARK flash_write(lcldest, ow); #if DEBUG printf("WRT: %p, %d, %d\n", lcldest, ow, *lcldest); watchdog_periodic(); if (ow != *lcldest) { printf("PANIC!"); while (1) ; } #endif lcldest++; #endif written += 2; } #if 1 != FBENCHMARK flash_done(); IFG1 |= UTXIFG0; #endif return written; }
void rs485_handle(char *buf, uint16_t cnt) { char rsp[] = "\x01\x10\x00\x00\x00\x92\x02\x00"; switch (cnt) { case RCV_CFG_LEN: flash_write(PARAM_SAVE_ADDR, (uint8_t *)buf, cnt); parse_param(buf, cnt); clr_pulse_cnt(); for(cnt=0; cnt<8; cnt++) { xputc(rsp[cnt]); } break; case READ_CFG_LEN: if(memcmp(buf, "\x03\x03\x00\x00\x00\xA6\xC4\x52", cnt) == 0) { construct_rsp(buf, cnt); //response code in construct_rsp function. } case WRITE_UID_LEN: //format //01 10 0A dev_num rtu_num crc16 update_n_wirte_uid(buf); break; #ifdef DEBUG case 4: if(memcmp(buf, "TIME", 4) == 0) { char *time; time = read_bcd_time(); for(cnt=0; cnt<6;cnt++) { xputc((time[cnt]>>4)+'0'); xputc((time[cnt]&0x0F)+'0'); } xputs("\r\n"); } break; case 6: if(memcmp(buf, "UPLOAD", 6) == 0) { simulate_ring = 1; } break; case 10: set_time(buf); break; #endif default: break; }
void nvm_data_write(void) { uint8_t i; uint16_t *flash_ptr = (uint16_t *)CETIC_6LBR_NVM_ADDRESS; uint16_t *data = (uint16_t *)&nvm_data; flash_setup(); flash_clear((unsigned short *)flash_ptr); for(i = 0; i < CETIC_6LBR_NVM_SIZE/2; i++) { flash_write((unsigned short *)flash_ptr, *data); flash_ptr++; data++; } flash_done(); LOG6LBR_INFO("Flashing 6LBR NVM done\n"); }
int saveenv_nor(void) { u32 sect_num; u32 sect_size; u32 pos_env; u8 *tmp_buf, *tmp_pos_env; ulong from, to; /* unprotect area */ flash_info_t *info; info = &flash_info[0]; /* NOR flash is located in #1 bank */ /* find sector for saving environment variables */ pos_env = CFG_FLASH_BASE + CFG_ENV_ADDR + CFG_ENV_OFFSET; for (sect_num = 0; sect_num < info->sector_count; sect_num++) { if ((info->start[sect_num] <= pos_env) && (info->start[sect_num + 1] > pos_env)) { break; } } /* unprotect finding sector */ from = info->start[sect_num]; to = info->start[sect_num + 1] - 1; flash_protect(0, from, to, info); /* unprotect */ /* * read 64kb one sector from NOR flash to memory * because env var is inserted into unprotected sector */ sect_size = info->start[sect_num + 1] - info->start[sect_num]; tmp_buf = (u8 *)malloc(sect_size); memcpy(tmp_buf, (u8 *)info->start[sect_num], sect_size); tmp_pos_env = tmp_buf + pos_env - info->start[sect_num]; memcpy(tmp_pos_env, (u8 *)env_ptr, CFG_ENV_SIZE); /* erase unprotected sector */ flash_erase(info, sect_num, sect_num); /* write modified sector including environment variables */ flash_write(tmp_buf, (ulong)info->start[sect_num], sect_size); free(tmp_buf); printf("done\n"); return 1; }
/** * Save current using data section address to flash. * * @param cur_data_addr current using data section address * * @return result */ static FlashErrCode save_cur_using_data_addr(uint32_t cur_data_addr) { FlashErrCode result = FLASH_NO_ERR; /* erase ENV system section */ result = flash_erase(get_env_start_addr(), 4); if (result == FLASH_NO_ERR) { /* write current using data section address to flash */ result = flash_write(get_env_start_addr(), &cur_data_addr, 4); if (result == FLASH_WRITE_ERR) { FLASH_INFO("Error: Write system section fault!\n"); FLASH_INFO("Note: The ENV can not be used.\n"); } } else { FLASH_INFO("Error: Erased system section fault!\n"); FLASH_INFO("Note: The ENV can not be used\n"); } return result; }
void storage_irq_handler(void) { #if USE_INTERNAL if (!(flash_flags & FLASH_FLAG_DIRTY)) { return; } // This code uses interrupts to erase the flash /* if (flash_erase_state == 0) { flash_erase_it(flash_cache_sector_start, (const uint32_t*)CACHE_MEM_START_ADDR, flash_cache_sector_size / 4); flash_erase_state = 1; return; } if (flash_erase_state == 1) { // wait for erase // TODO add timeout #define flash_erase_done() (__HAL_FLASH_GET_FLAG(FLASH_FLAG_BSY) == RESET) if (!flash_erase_done()) { return; } flash_erase_state = 2; } */ // This code erases the flash directly, waiting for it to finish if (!(flash_flags & FLASH_FLAG_ERASED)) { flash_erase(flash_cache_sector_start, (const uint32_t*)CACHE_MEM_START_ADDR, flash_cache_sector_size / 4); flash_flags |= FLASH_FLAG_ERASED; return; } // If not a forced write, wait at least 5 seconds after last write to flush // On file close and flash unmount we get a forced write, so we can afford to wait a while if ((flash_flags & FLASH_FLAG_FORCE_WRITE) || sys_tick_has_passed(flash_tick_counter_last_write, 5000)) { // sync the cache RAM buffer by writing it to the flash page flash_write(flash_cache_sector_start, (const uint32_t*)CACHE_MEM_START_ADDR, flash_cache_sector_size / 4); // clear the flash flags now that we have a clean cache flash_flags = 0; // indicate a clean cache with LED off led_state(PYB_LED_RED, 0); } #endif }
/* erase both sectors */ bool AP_FlashStorage::erase_all(void) { write_error = false; current_sector = 0; write_offset = sizeof(struct sector_header); if (!erase_sector(0) || !erase_sector(1)) { return false; } // mark current sector as in-use struct sector_header header; header.signature = signature; header.state = SECTOR_STATE_IN_USE; return flash_write(current_sector, 0, (const uint8_t *)&header, sizeof(header)); }
static retval_t cmd_flash_write(const subsystem_t *self, frame_t * iframe, frame_t * oframe) { void *dst=0, *data; uint8_t len; flash_err_t rv; if (RV_SUCCESS != frame_get_u32(iframe, (uint32_t*)&dst)) return RV_NOSPACE; if (RV_SUCCESS != frame_get_u8(iframe, &len)) return RV_NOSPACE; if (RV_SUCCESS != frame_get_data_pointer(iframe, &data, len)) return RV_NOSPACE; frame_advance(iframe, len); rv = flash_write(dst, data, len); if (FLASH_ERR_OK != rv) { frame_put_u8(oframe, rv); return RV_ERROR; } return RV_SUCCESS; }