/*************************************************************************************************/
|
/*!
|
* \file
|
*
|
* \brief PAL Flash driver.
|
*
|
* Copyright (c) 2018-2019 Arm Ltd. All Rights Reserved.
|
*
|
* Copyright (c) 2019-2020 Packetcraft, Inc.
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
/*************************************************************************************************/
|
|
#include <string.h>
|
#include "pal_flash.h"
|
#include "mk_flash.h"
|
|
/**************************************************************************************************
|
Macros
|
**************************************************************************************************/
|
// The size of flash space available to users is 8K
|
#define MK8000_USER_TOTAL_SIZE 0x2000
|
// The starting address is 0x0407E000, 126th sector
|
#define MK8000_USER_START_ADDR 0x0407E000
|
// The end address is 0x0407FFFF
|
#define MK8000_USER_END_ADDR (MK8000_USER_START_ADDR + MK8000_USER_TOTAL_SIZE - 1)
|
|
/*! Flash block size. */
|
#define PAL_FLASH_SECTOR4K 1
|
// #define PAL_FLASH_SECTOR64K 16
|
|
#define PAL_FLASH_SECTOR4K_SIZE FLASH_SECTOR_SIZE
|
// #define PAL_FLASH_SECTOR64K_SIZE 0x10000
|
|
/*! Flash Total size. */
|
#define PAL_FLASH_TOTAL_SIZE MK8000_USER_TOTAL_SIZE
|
|
/*! Flash internal cache buffer size. Note: should be at least 2. */
|
#define PAL_FLASH_CACHE_BUF_SIZE 11
|
|
/*! Flash word size. */
|
#define PAL_FLASH_WORD_SIZE 4
|
|
/*! Aligns a value to word size. */
|
#define PAL_FLASH_WORD_ALIGN(value) (((value) + (PAL_FLASH_WORD_SIZE - 1)) & ~(PAL_FLASH_WORD_SIZE - 1))
|
/*! Validates if a value is aligned to word. */
|
#define PAL_FLASH_IS_WORD_ALIGNED(value) (((uint32_t)(value) & (PAL_FLASH_WORD_SIZE - 1)) == 0)
|
|
/*! QSPI flash commands. */
|
#define QSPI_STD_CMD_WRSR 0x01
|
#define QSPI_STD_CMD_RSTEN 0x66
|
#define QSPI_STD_CMD_RST 0x99
|
|
#ifdef DEBUG
|
|
/*! \brief Parameter check. */
|
#define PAL_FLASH_PARAM_CHECK(expr) \
|
{ \
|
if (!(expr)) \
|
{ \
|
palFlashCb.state = PAL_FLASH_STATE_ERROR; \
|
return; \
|
} \
|
}
|
|
#else
|
|
/*! \brief Parameter check (disabled). */
|
#define PAL_FLASH_PARAM_CHECK(expr)
|
|
#endif
|
|
/**************************************************************************************************
|
Local Variables
|
**************************************************************************************************/
|
|
/*! flash cache buffer. */
|
static uint32_t palFlashCacheBuf[PAL_FLASH_CACHE_BUF_SIZE];
|
static enum FLASH_DEV_T MK8000_FLASH_ID = FLASH_ID0;
|
static enum FLASH_DEV_T flash_id = FLASH_MAX_NUM;
|
|
/*! \brief Control block. */
|
static struct
|
{
|
PalFlashState_t state; /*!< State. */
|
uint32_t writeAddr; /*!< Write address. */
|
} palFlashCb;
|
|
/**************************************************************************************************
|
Global Functions
|
**************************************************************************************************/
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Initialize flash.
|
*
|
* \param[in] actCback Callback function.
|
*/
|
/*************************************************************************************************/
|
void PalFlashInit(PalFlashCback_t actCback)
|
{
|
(void)palFlashCacheBuf;
|
if (DRV_OK == flash_open(MK8000_FLASH_ID, NULL))
|
{
|
flash_id = FLASH_ID0;
|
}
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief De-initialize flash.
|
*/
|
/*************************************************************************************************/
|
void PalFlashDeInit(void)
|
{
|
flash_close(flash_id);
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Reads data from flash storage.
|
*
|
* \param[in] pBuf Pointer to memory buffer where data will be stored.
|
* \param[in] size Data size in bytes to be read.
|
* \param[in] srcAddr Word aligned address from where data is read.
|
*/
|
/*************************************************************************************************/
|
void PalFlashRead(void *pBuf, uint32_t size, uint32_t srcAddr)
|
{
|
uint32_t realAddr;
|
memset(pBuf, 0xFF, size);
|
realAddr = MK8000_USER_START_ADDR + srcAddr;
|
flash_read(flash_id, realAddr, (uint8_t *)pBuf, size);
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Writes data to flash storage.
|
*
|
* \param[in] pBuf Pointer to memory buffer from where data will be written.
|
* \param[in] size Data size in bytes to be written.
|
* \param[in] dstAddr Word aligned address to write data.
|
*/
|
/*************************************************************************************************/
|
void PalFlashWrite(const uint8_t *pBuf, uint32_t size, uint32_t dstAddr)
|
{
|
#if FLASH_WRITE_EN
|
uint32_t realAddr;
|
realAddr = MK8000_USER_START_ADDR + dstAddr;
|
flash_write_nbytes(flash_id, realAddr, pBuf, size);
|
#endif
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Erase sector.
|
*
|
* \param[in] numOfSectors Number of sectors to be erased.
|
* \param[in] startAddr Word aligned address.
|
*/
|
/*************************************************************************************************/
|
void PalFlashEraseSector(uint32_t numOfSectors, uint32_t startAddr)
|
{
|
#if FLASH_WRITE_EN
|
uint32_t realAddr;
|
realAddr = MK8000_USER_START_ADDR + startAddr;
|
if (PAL_FLASH_IS_WORD_ALIGNED(realAddr) && (numOfSectors > 0) && (numOfSectors <= (PAL_FLASH_TOTAL_SIZE / PAL_FLASH_SECTOR4K_SIZE)))
|
{
|
uint32_t sector_idx = (realAddr - FLASH_BASE) / PAL_FLASH_SECTOR4K_SIZE;
|
if ((sector_idx + numOfSectors) <= (FLASH_SIZE / PAL_FLASH_SECTOR4K_SIZE))
|
{
|
for (uint32_t i = 0; i < numOfSectors; i++, sector_idx++)
|
{
|
flash_sector_erase(flash_id, sector_idx);
|
}
|
}
|
}
|
#endif
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Erase chip. It is not recommended to use since it takes up to 240s.
|
*/
|
/*************************************************************************************************/
|
void PalFlashEraseChip(void)
|
{
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Get total size of NVM storage.
|
*
|
* \return Total size.
|
*/
|
/*************************************************************************************************/
|
uint32_t PalNvmGetTotalSize(void)
|
{
|
return PAL_FLASH_TOTAL_SIZE;
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Get sector size of NVM storage.
|
*
|
* \return Sector size.
|
*/
|
/*************************************************************************************************/
|
uint32_t PalNvmGetSectorSize(void)
|
{
|
return PAL_FLASH_SECTOR4K_SIZE;
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Get flash state.
|
*
|
* \return flash state.
|
*/
|
/*************************************************************************************************/
|
PalFlashState_t PalFlashGetState(void)
|
{
|
return palFlashCb.state;
|
}
|
