mirror of https://github.com/ARMmbed/mbed-os.git
207 lines
6.8 KiB
C
207 lines
6.8 KiB
C
/* mbed Microcontroller Library
|
|
*******************************************************************************
|
|
* Copyright (c) 2018, STMicroelectronics
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. Neither the name of STMicroelectronics nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*******************************************************************************
|
|
*/
|
|
|
|
#if DEVICE_FLASH
|
|
#include "flash_api.h"
|
|
#include "flash_data.h"
|
|
#include "platform/mbed_critical.h"
|
|
|
|
static uint32_t GetSector(uint32_t Address);
|
|
static uint32_t GetSectorSize(uint32_t Sector);
|
|
|
|
int32_t flash_init(flash_t *obj)
|
|
{
|
|
/* Clear pending flags (if any) */
|
|
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGSERR | FLASH_FLAG_WRPERR);
|
|
return 0;
|
|
}
|
|
|
|
int32_t flash_free(flash_t *obj)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
int32_t flash_erase_sector(flash_t *obj, uint32_t address)
|
|
{
|
|
/* Variable used for Erase procedure */
|
|
FLASH_EraseInitTypeDef EraseInitStruct;
|
|
uint32_t SectorId;
|
|
uint32_t SectorError = 0;
|
|
int32_t status = 0;
|
|
|
|
if ((address >= (FLASH_BASE + FLASH_SIZE)) || (address < FLASH_BASE)) {
|
|
return -1;
|
|
}
|
|
|
|
if (HAL_FLASH_Unlock() != HAL_OK) {
|
|
return -1;
|
|
}
|
|
|
|
/* Get the 1st sector to erase */
|
|
SectorId = GetSector(address);
|
|
|
|
/* Fill EraseInit structure */
|
|
EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
|
|
EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_3;
|
|
EraseInitStruct.Sector = SectorId;
|
|
EraseInitStruct.NbSectors = 1;
|
|
|
|
if (address < ADDR_FLASH_SECTOR_0_BANK2) {
|
|
EraseInitStruct.Banks = FLASH_BANK_1;
|
|
if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK) {
|
|
status = -1;
|
|
}
|
|
} else {
|
|
EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
|
|
EraseInitStruct.Banks = FLASH_BANK_2;
|
|
if (HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) != HAL_OK) {
|
|
status = -1;
|
|
}
|
|
}
|
|
|
|
HAL_FLASH_Lock();
|
|
|
|
return status;
|
|
}
|
|
|
|
int32_t flash_program_page(flash_t *obj, uint32_t address, const uint8_t *data,
|
|
uint32_t size)
|
|
{
|
|
uint32_t StartAddress = 0;
|
|
int32_t status = 0;
|
|
|
|
if ((address >= (FLASH_BASE + FLASH_SIZE)) || (address < FLASH_BASE)) {
|
|
return -1;
|
|
}
|
|
|
|
if ((size % 32) != 0) {
|
|
/* H7 flash devices can only be programmed 256bits/32 bytes at a time */
|
|
return -1;
|
|
}
|
|
|
|
if (HAL_FLASH_Unlock() != HAL_OK) {
|
|
return -1;
|
|
}
|
|
|
|
StartAddress = address;
|
|
while ((address < (StartAddress + size)) && (status == 0)) {
|
|
if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, address, (uint32_t)data) == HAL_OK) {
|
|
address = address + 32;
|
|
data = data + 32;
|
|
} else {
|
|
status = -1;
|
|
}
|
|
}
|
|
|
|
HAL_FLASH_Lock();
|
|
|
|
return status;
|
|
}
|
|
|
|
uint32_t flash_get_sector_size(const flash_t *obj, uint32_t address)
|
|
{
|
|
if ((address >= (FLASH_BASE + FLASH_SIZE)) || (address < FLASH_BASE)) {
|
|
return MBED_FLASH_INVALID_SIZE;
|
|
}
|
|
return (GetSectorSize(GetSector(address)));
|
|
}
|
|
|
|
uint32_t flash_get_page_size(const flash_t *obj)
|
|
{
|
|
return (32);
|
|
}
|
|
|
|
uint32_t flash_get_start_address(const flash_t *obj)
|
|
{
|
|
return FLASH_BASE;
|
|
}
|
|
|
|
uint32_t flash_get_size(const flash_t *obj)
|
|
{
|
|
return FLASH_SIZE;
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the sector of a given address
|
|
* @param Address: Flash address
|
|
* @retval The sector of a given address
|
|
*/
|
|
static uint32_t GetSector(uint32_t Address)
|
|
{
|
|
uint32_t sector = 0;
|
|
|
|
if (((Address < ADDR_FLASH_SECTOR_1_BANK1) && (Address >= ADDR_FLASH_SECTOR_0_BANK1)) || \
|
|
((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2))) {
|
|
sector = FLASH_SECTOR_0;
|
|
} else if (((Address < ADDR_FLASH_SECTOR_2_BANK1) && (Address >= ADDR_FLASH_SECTOR_1_BANK1)) || \
|
|
((Address < ADDR_FLASH_SECTOR_2_BANK2) && (Address >= ADDR_FLASH_SECTOR_1_BANK2))) {
|
|
sector = FLASH_SECTOR_1;
|
|
} else if (((Address < ADDR_FLASH_SECTOR_3_BANK1) && (Address >= ADDR_FLASH_SECTOR_2_BANK1)) || \
|
|
((Address < ADDR_FLASH_SECTOR_3_BANK2) && (Address >= ADDR_FLASH_SECTOR_2_BANK2))) {
|
|
sector = FLASH_SECTOR_2;
|
|
} else if (((Address < ADDR_FLASH_SECTOR_4_BANK1) && (Address >= ADDR_FLASH_SECTOR_3_BANK1)) || \
|
|
((Address < ADDR_FLASH_SECTOR_4_BANK2) && (Address >= ADDR_FLASH_SECTOR_3_BANK2))) {
|
|
sector = FLASH_SECTOR_3;
|
|
} else if (((Address < ADDR_FLASH_SECTOR_5_BANK1) && (Address >= ADDR_FLASH_SECTOR_4_BANK1)) || \
|
|
((Address < ADDR_FLASH_SECTOR_5_BANK2) && (Address >= ADDR_FLASH_SECTOR_4_BANK2))) {
|
|
sector = FLASH_SECTOR_4;
|
|
} else if (((Address < ADDR_FLASH_SECTOR_6_BANK1) && (Address >= ADDR_FLASH_SECTOR_5_BANK1)) || \
|
|
((Address < ADDR_FLASH_SECTOR_6_BANK2) && (Address >= ADDR_FLASH_SECTOR_5_BANK2))) {
|
|
sector = FLASH_SECTOR_5;
|
|
} else if (((Address < ADDR_FLASH_SECTOR_7_BANK1) && (Address >= ADDR_FLASH_SECTOR_6_BANK1)) || \
|
|
((Address < ADDR_FLASH_SECTOR_7_BANK2) && (Address >= ADDR_FLASH_SECTOR_6_BANK2))) {
|
|
sector = FLASH_SECTOR_6;
|
|
} else {
|
|
sector = FLASH_SECTOR_7;
|
|
}
|
|
|
|
return sector;
|
|
}
|
|
|
|
/**
|
|
* @brief Gets sector Size
|
|
* @param None
|
|
* @retval The size of a given sector
|
|
*/
|
|
static uint32_t GetSectorSize(uint32_t Sector)
|
|
{
|
|
return (uint32_t)(128 * 1024); // 128 KB
|
|
}
|
|
|
|
uint8_t flash_get_erase_value(const flash_t *obj)
|
|
{
|
|
(void)obj;
|
|
|
|
return 0xFF;
|
|
}
|
|
|
|
#endif
|