Пример #1
0
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;
}
Пример #2
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;
}
Пример #3
0
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;
}
Пример #4
0
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;
}
Пример #5
0
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;
}
Пример #6
0
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 */
}
Пример #7
0
// 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;
}
Пример #8
0
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);
	}
}
Пример #9
0
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;
}
Пример #10
0
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;
}
Пример #11
0
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
}
Пример #12
0
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;
}
Пример #13
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);
	}
}
Пример #14
0
/* 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;  
}
Пример #15
0
/// 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;
}
Пример #17
0
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;
}
Пример #18
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);
}
Пример #19
0
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"));
}
Пример #20
0
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;
}
Пример #21
0
/******************************************************************************
* 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);
	}
}
Пример #22
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);
}
Пример #23
0
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;
}
Пример #24
0
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;
	}
Пример #25
0
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");
}
Пример #26
0
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;
}
Пример #27
0
/**
 * 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;
}
Пример #28
0
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
}
Пример #29
0
/*
  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));    
}
Пример #30
0
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;
}