Exemple #1
0
/*******************************************************************************
* Function Name  : EE_Format
* Description    : Erases PAGE0 and PAGE1 and writes VALID_PAGE header to PAGE0
* Input          : None
* Output         : None
* Return         : Status of the last operation (Flash write or erase) done during
*                  EEPROM formating
*******************************************************************************/
FLASH_Status EE_Format(void)
{
  FLASH_Status FlashStatus = FLASH_COMPLETE;

  /* Erase Page0 */
  FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);

  /* If erase operation was failed, a Flash error code is returned */
  if (FlashStatus != FLASH_COMPLETE)
  {
    return FlashStatus;
  }

  /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
  FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);

  /* If program operation was failed, a Flash error code is returned */
  if (FlashStatus != FLASH_COMPLETE)
  {
    return FlashStatus;
  }

  /* Erase Page1 */
  FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);

  /* Return Page1 erase operation status */
  return FlashStatus;
}
Exemple #2
0
/*************************************************
 Function:		hw_flash_erase
 Descroption:	 
 Input: 
	1.SectorAddress
 Output: 
 Return: 	
 Other:  
*************************************************/
uint32_t hw_flash_erase(uint32_t SectorAddress)
{
	#if defined(STM32L1XX_MD) || defined(STM32L1XX_HD)|| defined(STM32L1XX_MD_PLUS)
	FLASH_ClearFlag(FLASH_FLAG_PGAERR | FLASH_FLAG_OPTVERR);
	return FLASH_ErasePage(SectorAddress);
	#else
	return FLASH_ErasePage(SectorAddress);
	#endif /* STM32L1XX_XD */
}
Exemple #3
0
//================================================
static void write_mem(void)
{
	u32 addr = 0;
	u16 i = 0;
	u8 temp[4];
	u16 length = 0; 
	u32 data = 0;
	u8 crc = 0;
	FLASH_Status status = FLASH_COMPLETE;
		
	// Receive start address
	for(i=0;i<4;i++)
		temp[i] = USART_GetC();
	crc = USART_GetC();
	if(crc == (temp[0]^temp[1]^temp[2]^temp[3]))
	{
		mem_cpy(&addr,temp,4);
		USART_PutC(ACK);
		length = USART_GetC();
		length = (length<<8) | USART_GetC();
		for(i = 0;i<length;i++)
			fwBuff[i] = USART_GetC();
		crc = USART_GetC();
		// Write memmory
		FLASH_UnlockBank1();
		if(!fUpdating)
		{
			// Disable systick 
			SysTick->CTRL  &=~( SysTick_CTRL_CLKSOURCE_Msk | 
		                   SysTick_CTRL_TICKINT_Msk   | 
		                   SysTick_CTRL_ENABLE_Msk);
			status = FLASH_ErasePage(FLAG_ADDR);
			if(status == FLASH_COMPLETE)
				status = FLASH_ProgramWord(FLAG_ADDR,(u32)FLAG_UPDATING);
			fUpdating = true;
		}
		if(status == FLASH_COMPLETE)
			status = FLASH_ErasePage(addr);
		for(i = 0;i<length;i+=4)
		{
			mem_cpy(&data,&fwBuff[i],((length-i)>4?4:(length-i)));
			if(status != FLASH_COMPLETE)
				break;
			status = FLASH_ProgramWord(addr,data);			
			addr += 4;
		}
		FLASH_LockBank1();
		if(status == FLASH_COMPLETE)
			USART_PutC(ACK);
		else
			USART_PutC(NACK);
	}
	else
		USART_PutC(NACK);
}
/*******************************************************************************
* Function Name  : FLASH_If_Erase
* Description    : Erase sector
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
uint16_t FLASH_If_Erase(uint32_t SectorAddress)
{
#ifdef STM32L1XX_MD
  FLASH_ClearFlag(FLASH_FLAG_PGAERR | FLASH_FLAG_OPTVERR);
  FLASH_ErasePage(SectorAddress);
#else
  FLASH_ErasePage(SectorAddress);
#endif /* STM32L1XX_MD */
  
  return MAL_OK;
}
Exemple #5
0
void Erase_All_User_id(void)
{
	uint8_t i;
	FLASH_Unlock();
	FLASH_ErasePage(USER_ID_PAGE0_ADDR_START);
	FLASH_ErasePage(USER_ID_PAGE1_ADDR_START);
	FLASH_ErasePage(USER_ID_PAGE2_ADDR_START);
	FLASH_Lock();
	for(i=1; i<96; i++)
		lock_infor.index_map[(i-1)/MAP_SIZE] &= (~(1<<((i-1)%MAP_SIZE)));
	Index_Save();
}
Exemple #6
0
bool writeEEPROM(bool blink)
{
    FLASH_Status status;
    uint8_t chk = 0;
    const uint8_t *p;

    // prepare checksum/version constants
    _params.version = EEPROM_CONF_VERSION;
    _params.size = sizeof(params_t);
    _params.magic_be = 0xBE;
    _params.magic_ef = 0xEF;
    _params.chk = 0;

    // recalculate checksum before writing
    for (p = (const uint8_t *)&_params; p < ((const uint8_t *)&_params + sizeof(params_t)); p++)
        chk ^= *p;
    _params.chk = chk;

    // write it
    FLASH_Unlock();
    for (unsigned int tries = 3; tries; tries--)
    {
        FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);

        FLASH_ErasePage(FLASH_WRITE_ADDR);
        status = FLASH_ErasePage(FLASH_WRITE_ADDR + FLASH_PAGE_SIZE);
        for (unsigned int i = 0; i < sizeof(params_t) && status == FLASH_COMPLETE; i += 4)
            status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&_params + i));
        if (status == FLASH_COMPLETE)
            break;
    }
    FLASH_Lock();

    // Flash write failed - just die now
    if (status != FLASH_COMPLETE || !validEEPROM())
    {
        return false;
    }

    if (blink)
    {
        for (uint8_t i=0; i < 3; i++)
        {
            LED0_TOGGLE;
            delay(100);
            LED0_TOGGLE;
            delay(50);
        }
    }

    return true;
}
Exemple #7
0
void writeEEPROM(uint8_t b, uint8_t updateProfile)
{
    FLASH_Status status;
    int i, tries = 3;
    uint8_t chk = 0;
    const uint8_t *p;

    // prepare checksum/version constants
    mcfg.version = EEPROM_CONF_VERSION;
    mcfg.size = sizeof(master_t);
    mcfg.magic_be = 0xBE;
    mcfg.magic_ef = 0xEF;
    mcfg.chk = 0;

    // when updateProfile = true, we copy contents of cfg to global configuration. when false, only profile number is updated, and then that profile is loaded on readEEPROM()
    if (updateProfile) {
        // copy current in-memory profile to stored configuration
        memcpy(&mcfg.profile[mcfg.current_profile], &cfg, sizeof(config_t));
    }

    // recalculate checksum before writing
    for (p = (const uint8_t *)&mcfg; p < ((const uint8_t *)&mcfg + sizeof(master_t)); p++)
        chk ^= *p;
    mcfg.chk = chk;

    // write it
    FLASH_Unlock();
    while (tries--) {
        FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);

        FLASH_ErasePage(FLASH_WRITE_ADDR);
        status = FLASH_ErasePage(FLASH_WRITE_ADDR + FLASH_PAGE_SIZE);
        for (i = 0; i < sizeof(master_t) && status == FLASH_COMPLETE; i += 4)
            status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&mcfg + i));
        if (status == FLASH_COMPLETE)
            break;
    }
    FLASH_Lock();

    // Flash write failed - just die now
    if (status != FLASH_COMPLETE || !validEEPROM()) {
        failureMode(10);
    }

    // re-read written data
    loadAndActivateConfig();
    if (b)
        blinkLED(15, 20, 1);
}
Exemple #8
0
/**
 * Erase data on flash.
 * @note This operation is irreversible.
 * @note This operation's units is different which on many chips.
 *
 * @param addr flash address
 * @param size erase bytes size
 *
 * @return result
 */
EfErrCode ef_port_erase(uint32_t addr, size_t size) {
    EfErrCode result = EF_NO_ERR;
    FLASH_Status flash_status;
    size_t erase_pages, i;
    
    /* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */
    EF_ASSERT(addr % ERASE_MIN_SIZE == 0);
    
    /* calculate pages */
    erase_pages = size / PAGE_SIZE;
    if (size % PAGE_SIZE != 0) {
        erase_pages++;
    }

    /* start erase */
    FLASH_Unlock();
    FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    for (i = 0; i < erase_pages; i++) {
        flash_status = FLASH_ErasePage(addr + (PAGE_SIZE * i));
        if (flash_status != FLASH_COMPLETE) {
            result = EF_ERASE_ERR;
            break;
        }
    }
    FLASH_Lock();

    return result;
}
Exemple #9
0
/***********************************************************
 * 函数名:WriteflashMPeriod
 * 描述  :把interval_s从CPU写入Flash
 * 输入  : 无
 * 输出  : 无
 ***********************************************************/
void WriteflashMPeriod(void)
{
	FLASHStatus = FLASH_COMPLETE;
	MemoryProgramStatus = PASSED; 

	FLASH_Unlock();	//FLASH解锁
	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位
	NbrOfPage = (EndAddr[4] - StartAddr[4]) / FLASH_PAGE_SIZE;//页面擦除子程序
	FLASHStatus = FLASH_ErasePage(StartAddr[4] + (FLASH_PAGE_SIZE * NbrOfPage)); 
	
	FlashAddress = StartAddr[4]; 
	FLASHStatus = FLASH_ProgramWord(FlashAddress, gps_invalid);
	
	FlashAddress = FlashAddress + 4;
	FLASHStatus = FLASH_ProgramWord(FlashAddress, intervalA);
	
	FlashAddress = FlashAddress + 4;
	FLASHStatus = FLASH_ProgramWord(FlashAddress, intervalB);
	
	FlashAddress = FlashAddress + 4;
	FLASHStatus = FLASH_ProgramWord(FlashAddress, interval_num);
	
	FlashAddress = FlashAddress + 4;
//	FLASHStatus = FLASH_ProgramWord(FlashAddress, time_o);
	
	FlashAddress = FlashAddress + 4;
	FLASHStatus = FLASH_ProgramHalfWord(FlashAddress, interval_s);

	BKP_WriteBackupRegister(BKP_DR1,interval_num);
	//BKP_WriteBackupRegister(BKP_DR2,time_o);
	BKP_WriteBackupRegister(BKP_DR3,interval_s);
}
void ErasePage(uint32_t p_addr, unsigned char with_lock)
{
	FLASH_Unlock();
	FLASH_ErasePage(p_addr);
	if (with_lock)
		FLASH_Lock();
}
Exemple #11
0
uint8_t PIOS_BL_HELPER_FLASH_Start()
{
	const struct pios_board_info * bdinfo = &pios_board_info_blob;
	uint32_t pageAdress = bdinfo->fw_base;
	uint8_t fail = false;
	while ((pageAdress < (bdinfo->fw_base + bdinfo->fw_size + bdinfo->desc_size))
	       && (fail == false)) {
		for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) {
			if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) {
				fail = false;
				break;
			} else {
				fail = true;
			}
		}

#ifdef STM32F10X_HD
		pageAdress += 2048;
#elif defined (STM32F10X_MD)
		pageAdress += 1024;
#endif
	}

	return (fail == true) ? 0 : 1;
}
Exemple #12
0
//----清除全部刷卡记录-----------------------------------------------------
void clear_CardID()
{
	 char DateSt[12], TimeSt[12];

	storeaddrlist.RecordCount = 0;
	storeaddrlist.CountAddrOffset = 0;
	timeoutaddrlist.RecordCount = 0;
	timeoutaddrlist.CountAddrOffset = 0;
	LastSaveTime = GetRTC(DateSt, TimeSt);///获取当前时间,秒数 //需要优化;
	//清除记录区
  	FLASH_Unlock();
  	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
	FLASH_ErasePage(PLACELASTID); 
	FLASH_ErasePage(POINTOFSECTION);   
  	FLASH_Lock();
}
uint8_t FLASH_Start()
{
	uint32_t pageAdress;
	pageAdress = START_OF_USER_CODE;
	uint8_t fail = FALSE;
	while ((pageAdress < START_OF_USER_CODE + SIZE_OF_CODE + SIZE_OF_DESCRIPTION)
	       || (fail == TRUE)) {
		for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) {
			if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) {
				fail = FALSE;
				break;
			} else {
				fail = TRUE;
			}

		}

#ifdef STM32F10X_HD
		pageAdress += 2048;
#elif defined (STM32F10X_MD)
		pageAdress += 1024;
#endif
	}

	return (fail == TRUE) ? 0 : 1;
}
Exemple #14
0
WORD EE_WriteVariable(WORD offset, WORD newValue)
{
    FLASH_Status stat = FLASH_COMPLETE;

    volatile WORD *pCurrentValue =   (__IO uint16_t*) (PAGE0_BASE_ADDRESS + 2 + (offset * 2));
    WORD PageStatus0             = *((__IO uint16_t*)  PAGE0_BASE_ADDRESS);
    WORD currentValue            = *pCurrentValue;

    // first check is page is valid, and if the value did change
    if(PageStatus0 == VALID_PAGE && (currentValue == newValue)) {   // page is valid, value didn't change? Good, quit
        return FLASH_COMPLETE;
    }

    // if we got here, then either page is not valid, or the value changed
    FLASH_Unlock();
    FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR); 

    stat = FLASH_ErasePage(PAGE0_BASE_ADDRESS);                         // erase page
    if(stat != FLASH_COMPLETE) {
        return stat;
    }
    
    stat = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);       // write VALID_PAGE marker
    if(stat != FLASH_COMPLETE) {
        return stat;
    }

    stat = FLASH_ProgramHalfWord((uint32_t) pCurrentValue, newValue);   // wite new vale
    if(stat != FLASH_COMPLETE) {
        return stat;
    }

    FLASH_Lock();
    return stat;
}
uint8_t PIOS_BL_HELPER_FLASH_Start()
{
    const struct pios_board_info * bdinfo = &pios_board_info_blob;
    uint32_t pageAdress = bdinfo->fw_base;
    uint8_t fail = FALSE;
    while ((pageAdress < (bdinfo->fw_base + bdinfo->fw_size + bdinfo->desc_size))
            || (fail == TRUE)) {
        for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) {
            if (FLASH_ErasePage(pageAdress) == FLASH_COMPLETE) {
                fail = FALSE;
                break;
            } else {
                fail = TRUE;
            }

        }

#ifdef STM32F10X_HD
        pageAdress += 2048;
#else /* everything else */
        pageAdress += 1024;
#endif
    }

    return (fail == TRUE) ? 0 : 1;
}
Exemple #16
0
/*************************** 
Function : Erase the internal Flash data 
Input :- start address	
- Number of page 
Output: return the FLASH status 

***************************/ 
u16 Flash_EEPROM_ErasePage( u32 Start_Address, u16 No_of_Size) 
{ 
  FLASH_Unlock(); 
  FLASHStatus=FLASH_COMPLETE; 
  FLASH_EEPROM_ProgramStatus= PASSED; 

  Flash_EEPROM_Nb_Of_Page= No_of_Size; // 
  /*Clear all the flash */ 
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR | FLASH_FLAG_OPTERR); 

  /*erase the page*/ 
  for(EraseCounter=0; EraseCounter<Flash_EEPROM_Nb_Of_Page; EraseCounter++) 
  { 
    FLASHStatus = FLASH_ErasePage(Start_Address +(FL_EEPROM_PageSize* EraseCounter)); 

    if (FLASHStatus != FLASH_COMPLETE) 
    { 
      return FLASHStatus; 
    } 
  } 

  FLASH_Lock(); 

  return FLASHStatus; 

} 
Exemple #17
0
//写多个数据到一个页
u8 STMFLASH_Write(u32 PageAddr,u16 *pBuffer,u16 NumToWrite)	
{
	
	FLASH_Status temp_status;//状态
	u16 i;
	
	FLASH_Unlock();//解锁
	
	temp_status = FLASH_ErasePage(PageAddr);//擦除一个页
	if(temp_status != FLASH_COMPLETE)
	{
		FLASH_Lock();
		return 0;
	}
	
	for(i=0;i<NumToWrite;i++)//数据写入
	{
		temp_status = FLASH_ProgramHalfWord(PageAddr+2*i,pBuffer[i]);
		if(temp_status != FLASH_COMPLETE)
		{
			FLASH_Lock();
			return 0;
		}
	}
	
	FLASH_Lock();//上锁
	return 1;
}
int StoreApInfo()
{
	rtw_wifi_config_t wifi_config;
	uint32_t address;
#ifdef STM32F10X_XL
	address = 0x08080000;	//bank2 domain
#else
	uint16_t sector_nb = FLASH_Sector_11;
	address = flash_SectorAddress(sector_nb);
#endif
	wifi_config.boot_mode = 0x77665502;
	memcpy(wifi_config.ssid, wifi_setting.ssid, strlen((char*)wifi_setting.ssid));
	wifi_config.ssid_len = strlen((char*)wifi_setting.ssid);
	wifi_config.security_type = wifi_setting.security_type;
	memcpy(wifi_config.password, wifi_setting.password, strlen((char*)wifi_setting.password));
	wifi_config.password_len= strlen((char*)wifi_setting.password);
	wifi_config.channel = wifi_setting.channel;

	printf("\n\rWritting boot mode 0x77665502 and Wi-Fi setting to flash ...");
#ifdef STM32F10X_XL
	FLASH_ErasePage(address);
#else
	flash_EraseSector(sector_nb);
#endif
	flash_Wrtie(address, (char *)&wifi_config, sizeof(rtw_wifi_config_t));

	return 0;
}
Exemple #19
0
//=====================================
void saveFont(u32 addr,u8* fontData,u16 length)
{
	u32 i = 0;
	u32 addr_temp;
	u32 data_temp = 0;
	FLASH_Status status = FLASH_COMPLETE;

	addr_temp = addr;
	// Unlock flash to rewrite to flash
	FLASH_UnlockBank1();
	// Erase pages used to store font
	for(i = 0;i<3;i++)
	{
		status = FLASH_ErasePage(addr_temp);
		addr_temp += FLASH_PAGE_SIZE;
	}
	
	// Write font data to flash
	for(i = 0;i<length;i+=4)
	{
		memcpy(&data_temp,&fontData[i],((length-i)>4?4:(length-i)));
		status = FLASH_ProgramWord(addr,data_temp);
		addr += sizeof(u32);
	}
	FLASH_LockBank1();
}
int write_whole_poweroff_info_tbl(struct poweroff_info_st *data)
{
	u32 *ps, *pd;
	int i;
	FLASH_Status status;

	if (NULL == data)
		return -RT_ERROR;

	FLASH_Unlock();
	/* Clear pending flags (if any) */
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPTERR | FLASH_FLAG_WRPRTERR |
					FLASH_FLAG_PGERR | FLASH_FLAG_BSY);

	status = FLASH_ErasePage((rt_uint32_t)POWEROFF_INFO_TBL_BASE_OF_FLASH); /* wait for complete in FLASH_ErasePage() */
	if (FLASH_COMPLETE != status)
		while(1); //return status;

	ps = (u32 *)data;
	pd = (u32 *)POWEROFF_INFO_TBL_BASE_OF_FLASH;
	for (i=0; i < RT_ALIGN(POWEROFF_INFO_TBL_SIZE_OF_FLASH, 4)/4; i++) {
		status = FLASH_ProgramWord((u32)pd, *ps); /* wait for complete in FLASH_ProgramWord()  */
		if (FLASH_COMPLETE != status)
			while(1); //return status;
		++pd;
		++ps;
	}
	FLASH_Lock();

	return FLASH_COMPLETE;
}
Exemple #21
0
/***********************************************************
 * 函数名:Write_GPS_Info
 * 描述  :把GPS信息从CPU写入Flash
 * 输入  : 无
 * 输出  : 无
 ***********************************************************/
void Write_Flash_GPS_Info(void)
{
	FLASHStatus = FLASH_COMPLETE;
	MemoryProgramStatus = PASSED;
	FLASH_Unlock();	//FLASH解锁
	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);//清标志位
	
	NbrOfPage = (EndAddr[10] - StartAddr[10]) / FLASH_PAGE_SIZE; //页面擦除子程序
	FLASHStatus = FLASH_ErasePage(StartAddr[10] + (FLASH_PAGE_SIZE * NbrOfPage));

	FlashAddress = StartAddr[10];

	FLASHStatus = FLASH_ProgramWord(FlashAddress, jingdu);
	FlashAddress = FlashAddress + 4;
	FLASHStatus = FLASH_ProgramWord(FlashAddress, weidu);
	FlashAddress = FlashAddress + 4;
	FLASHStatus = FLASH_ProgramWord(FlashAddress, sog);
	FlashAddress = FlashAddress + 4;
	FLASHStatus = FLASH_ProgramWord(FlashAddress, direction);
	
	BKP_WriteBackupRegister(BKP_DR4,(u16)(jingdu >> 16));
	BKP_WriteBackupRegister(BKP_DR5,(u16)(weidu >> 16));
	BKP_WriteBackupRegister(BKP_DR7,(u16)jingdu);
	BKP_WriteBackupRegister(BKP_DR8,(u16)weidu);
	BKP_WriteBackupRegister(BKP_DR9,sog);
	BKP_WriteBackupRegister(BKP_DR10,direction);
}
Exemple #22
0
/**
  * @brief   Main program
  * @param  None
  * @retval None
  */
int main(void)
{	
	RCC_Configuration();
	GPIO_Configuration();
	USART_Configuration();	
	SysTick_Config(SystemCoreClock/10);
	// Enable the LSI OSC 
 	RCC_LSICmd(ENABLE);
	// Wait till LSI is ready 
	while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) {};
	
 	IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
	// IWDG counter clock: LSI/256 
	IWDG_SetPrescaler(IWDG_Prescaler_256);
	IWDG_SetReload(0x0FFF);
	// Reload IWDG counter 
	IWDG_ReloadCounter();
	// Enable IWDG (the LSI oscillator will be enabled by hardware) 
	IWDG_Enable(); 
	
	// Write memmory
	FLASH_UnlockBank1();
	FLASH_ErasePage(FLAG_ADDR);
	FLASH_ProgramWord(FLAG_ADDR,(u32)FLAG_UPDATED);
	FLASH_LockBank1();
	
	updateFW_control();
}
Exemple #23
0
void cmd_page_erase()
{
	int adrs=BSWAP32(PacketFromPC.adrs);
	if( check_flash_adrs(adrs)) {
		FLASH_ErasePage(adrs);
	}
}
Exemple #24
0
/*******************************************************************************
* Function Name  : FLASH_If_Erase
* Description    : Erase sector
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
uint16_t FLASH_If_Erase(uint32_t Add)
{
  /* Unlock the internal flash */
  FLASH_Unlock();

  FLASH_ClearFlags();

#if defined (STM32F2XX) || defined (STM32F4XX)
  /* Disable sector write protection if it's already protected */
  uint16_t OB_WRP_Sector = FLASH_SectorToWriteProtect(FLASH_INTERNAL, Add);
  FLASH_WriteProtection_Disable(OB_WRP_Sector);

  /* Check which sector has to be erased */
  uint16_t FLASH_Sector = FLASH_SectorToErase(FLASH_INTERNAL, Add);
  FLASH_Status status = FLASH_EraseSector(FLASH_Sector, VoltageRange_3);

#elif defined(STM32F10X_CL)
  /* Call the standard Flash erase function */
  FLASH_ErasePage(Add);
#endif /* STM32F2XX */

  /* Lock the internal flash */
  FLASH_Lock();

  if (status != FLASH_COMPLETE) return MAL_FAIL;

  return MAL_OK;
}
Exemple #25
0
Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length)
{
	Fls_AddressType pageStart = 0;
	Fls_AddressType erased = 0;
	u32 page = 0;
	u32 pageIndex;

	/* Unlock the Flash Program Erase controller */
	FLASH_Unlock();
	/* Clear All pending flags */
	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);

	/* Find first sector. */
	page = (TargetAddress - flsConfigPtr->FlsSectorList[0].FlsSectorStartaddress) / flsConfigPtr->FlsSectorList[0].FlsPageSize;
	pageStart = flsConfigPtr->FlsSectorList[0].FlsSectorStartaddress + page * flsConfigPtr->FlsSectorList[0].FlsPageSize;
	//page = Length / flsConfigPtr->FlsSectorList[0].FlsPageSize;

	/* Erase the pages... */
	for (pageIndex = page; erased < Length; pageIndex++)
	{
		volatile FLASH_Status status = FLASH_BUSY;
		while(status != FLASH_COMPLETE){
			status = FLASH_ErasePage((uint32_t)pageStart);
		}
		erased += flsConfigPtr->FlsSectorList[0].FlsPageSize;
		pageStart += flsConfigPtr->FlsSectorList[0].FlsPageSize;
	}

	return E_OK;
}
static int32_t PIOS_Flash_Internal_EraseSector(uintptr_t flash_id, uint32_t addr)
{
	struct pios_internal_flash_dev * flash_dev = (struct pios_internal_flash_dev *)flash_id;

	if (!PIOS_Flash_Internal_Validate(flash_dev))
		return -1;

#if defined(PIOS_INCLUDE_WDG)
	PIOS_WDG_Clear();
#endif

	uint32_t sector_start;
	uint32_t sector_size;
	if (!PIOS_Flash_Internal_GetSectorInfo(addr,
						&sector_start,
						&sector_size)) {
		/* We're asking for an invalid flash address */
		return -2;
	}

	FLASH_Status ret = FLASH_ErasePage(sector_start);
	if (ret != FLASH_COMPLETE)
		return -3;

	return 0;
}
Exemple #27
0
void writeParams(uint8_t b)
{
    FLASH_Status status;
    uint32_t i;
    uint8_t chk = 0;
    const uint8_t *p;

    cfg.version    = EEPROM_CONF_VERSION;
    cfg.size       = sizeof(config_t);
    cfg.magic_be   = 0xBE;
    cfg.magic_ef   = 0xEF;
    cfg.chk        = 0;
    for (p = (const uint8_t *)&cfg; p < ((const uint8_t *)&cfg + sizeof(config_t)); p++) chk ^= *p; // recalculate checksum before writing
    cfg.chk = chk;
    FLASH_Unlock();                                                                       // write it
    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
  
    for (i = 0; i < FLASH_PAGES_FORCONFIG; i++)                                           // Erase the pages here
    {
        while (FLASH_ErasePage(FLASH_WRITE_ADDR + (i * FLASH_PAGE_SIZE)) != FLASH_COMPLETE);
    }

    for (i = 0; i < sizeof(config_t); i += 4)                                             // Write that config now.
    {
        status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *) ((char *) &cfg + i));
        if (status != FLASH_COMPLETE) break;                                              // TODO: fail
    }
    FLASH_Lock();
    readEEPROM();
    if (b) blinkLED(15, 20, 1);
}
Exemple #28
0
void writeParams(void)
{
    FLASH_Status status;
    uint32_t i;
    uint8_t chk = 0;
    const uint8_t *p;
    
    cfg.version = EEPROM_CONF_VERSION;
    cfg.size = sizeof(config_t);
    cfg.magic_be = 0xBE;
    cfg.magic_ef = 0xEF;
    cfg.chk = 0;
    // recalculate checksum before writing
    for (p = (const uint8_t *)&cfg; p < ((const uint8_t *)&cfg + sizeof(config_t)); ++p)
        chk ^= *p;
    cfg.chk = chk;
    
    // write it
    FLASH_Unlock();
    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);

    if (FLASH_ErasePage(FLASH_WRITE_ADDR) == FLASH_COMPLETE) {
        for (i = 0; i < sizeof(config_t); i += 4) {
            status = FLASH_ProgramWord(FLASH_WRITE_ADDR + i, *(uint32_t *)((char *)&cfg + i));
            if (status != FLASH_COMPLETE)
                while(1);//break; // TODO: fail
        }
    }

    FLASH_Lock();

    readEEPROM();
}
Exemple #29
0
void Erase_All_id(void)
{
		uint8_t i;
	
	FLASH_Unlock();
	FLASH_ErasePage(USER_ID_PAGE0_ADDR_START);
	FLASH_ErasePage(USER_ID_PAGE1_ADDR_START);
	FLASH_ErasePage(USER_ID_PAGE2_ADDR_START);
	FLASH_ErasePage(ADMIN_ID_PAGE4_ADDR_START);
	FLASH_Lock();
	
	lock_infor.work_mode = NORMAL;
	for(i=0; i<4; i++)
		lock_infor.index_map[i]=0;
	Index_Save();
}
Exemple #30
0
// write to a specified page in flash
// page_addr: the page address that write to
void write_embedded_flash_with_addr_len(uint32_t page_addr, uint8_t *buf, uint16_t len) {
	uint32_t saddr = page_addr;			// start address for the page to write
	uint32_t eaddr = saddr+len;	// end addrees for that page
	uint32_t *pbuf = (uint32_t*)buf;

	// Unlock the Flash Program Erase controller
	FLASH_Unlock();

	// Clear All pending flags 
	FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_SIZERR);

	// Erase the FLASH pages 
	FLASHStatus = FLASH_ErasePage(saddr);
	
	// write buf to that page
	while((saddr < eaddr) && (FLASHStatus == FLASH_COMPLETE)) {
		FLASHStatus = FLASH_FastProgramWord(saddr, *(pbuf));	//problem
		saddr = saddr + 4;
		pbuf++;
	}

	if (FLASHStatus != FLASH_COMPLETE) {
		HardFault_Handler();//enter_unexpected();  do something here;
	}


	// Lock flash
	FLASH_Lock();
}