818 lines
32 KiB
C
818 lines
32 KiB
C
/******************************************************************************
|
|
* Filename: flash.h
|
|
* Revised: 2020-02-14 11:30:20 +0100 (Fri, 14 Feb 2020)
|
|
* Revision: 56760
|
|
*
|
|
* Description: Defines and prototypes for the Flash driver.
|
|
*
|
|
* Copyright (c) 2015 - 2017, Texas Instruments Incorporated
|
|
* 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 the ORGANIZATION 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.
|
|
*
|
|
******************************************************************************/
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \addtogroup system_control_group
|
|
//! @{
|
|
//! \addtogroup flash_api
|
|
//! @{
|
|
//
|
|
//*****************************************************************************
|
|
|
|
#ifndef __FLASH_H__
|
|
#define __FLASH_H__
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// If building with a C++ compiler, make all of the definitions in this header
|
|
// have a C binding.
|
|
//
|
|
//*****************************************************************************
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include "../inc/hw_types.h"
|
|
#include "../inc/hw_flash.h"
|
|
#include "../inc/hw_memmap.h"
|
|
#include "../inc/hw_ints.h"
|
|
#include "../inc/hw_aon_pmctl.h"
|
|
#include "../inc/hw_fcfg1.h"
|
|
#include "interrupt.h"
|
|
#include "debug.h"
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Support for DriverLib in ROM:
|
|
// This section renames all functions that are not "static inline", so that
|
|
// calling these functions will default to implementation in flash. At the end
|
|
// of this file a second renaming will change the defaults to implementation in
|
|
// ROM for available functions.
|
|
//
|
|
// To force use of the implementation in flash, e.g. for debugging:
|
|
// - Globally: Define DRIVERLIB_NOROM at project level
|
|
// - Per function: Use prefix "NOROM_" when calling the function
|
|
//
|
|
//*****************************************************************************
|
|
#if !defined(DOXYGEN)
|
|
#define FlashPowerModeSet NOROM_FlashPowerModeSet
|
|
#define FlashPowerModeGet NOROM_FlashPowerModeGet
|
|
#define FlashProtectionSet NOROM_FlashProtectionSet
|
|
#define FlashProtectionGet NOROM_FlashProtectionGet
|
|
#define FlashProtectionSave NOROM_FlashProtectionSave
|
|
#define FlashSectorErase NOROM_FlashSectorErase
|
|
#define FlashProgram NOROM_FlashProgram
|
|
#define FlashEfuseReadRow NOROM_FlashEfuseReadRow
|
|
#define FlashDisableSectorsForWrite NOROM_FlashDisableSectorsForWrite
|
|
#endif
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Values that can be returned from the API functions
|
|
//
|
|
//*****************************************************************************
|
|
#define FAPI_STATUS_SUCCESS 0x00000000 // Function completed successfully
|
|
#define FAPI_STATUS_FSM_BUSY 0x00000001 // FSM is Busy
|
|
#define FAPI_STATUS_FSM_READY 0x00000002 // FSM is Ready
|
|
#define FAPI_STATUS_INCORRECT_DATABUFFER_LENGTH \
|
|
0x00000003 // Incorrect parameter value
|
|
#define FAPI_STATUS_FSM_ERROR 0x00000004 // Operation failed
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Values passed to FlashIntEnable(), FlashIntDisable() and FlashIntClear() and
|
|
// returned from FlashIntStatus().
|
|
//
|
|
//*****************************************************************************
|
|
#define FLASH_INT_FSM_DONE 0x00400000 // FSM Done Interrupt Mask
|
|
#define FLASH_INT_RV 0x00010000 // Read Verify error Interrupt Mask
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Values passed to FlashSetPowerMode() and returned from FlashGetPowerMode().
|
|
//
|
|
//*****************************************************************************
|
|
#define FLASH_PWR_ACTIVE_MODE 0x00000000
|
|
#define FLASH_PWR_OFF_MODE 0x00000001
|
|
#define FLASH_PWR_DEEP_STDBY_MODE \
|
|
0x00000002
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Values passed to FlashSetProtection() and returned from FlashGetProtection().
|
|
//
|
|
//*****************************************************************************
|
|
#define FLASH_NO_PROTECT 0x00000000 // Sector not protected
|
|
#define FLASH_WRITE_PROTECT 0x00000001 // Sector erase and program
|
|
// protected
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Define used by the flash programming and erase functions
|
|
//
|
|
//*****************************************************************************
|
|
#define ADDR_OFFSET (0x1F800000 - FLASHMEM_BASE)
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Define used for access to factory configuration area.
|
|
//
|
|
//*****************************************************************************
|
|
#define FCFG1_OFFSET 0x1000
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Define for the clock frequency input to the flash module in number of MHz
|
|
//
|
|
//*****************************************************************************
|
|
#define FLASH_MODULE_CLK_FREQ 48
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Defined values for Flash State Machine commands
|
|
//
|
|
//*****************************************************************************
|
|
typedef enum
|
|
{
|
|
FAPI_PROGRAM_DATA = 0x0002, //!< Program data.
|
|
FAPI_ERASE_SECTOR = 0x0006, //!< Erase sector.
|
|
FAPI_ERASE_BANK = 0x0008, //!< Erase bank.
|
|
FAPI_VALIDATE_SECTOR = 0x000E, //!< Validate sector.
|
|
FAPI_CLEAR_STATUS = 0x0010, //!< Clear status.
|
|
FAPI_PROGRAM_RESUME = 0x0014, //!< Program resume.
|
|
FAPI_ERASE_RESUME = 0x0016, //!< Erase resume.
|
|
FAPI_CLEAR_MORE = 0x0018, //!< Clear more.
|
|
FAPI_PROGRAM_SECTOR = 0x0020, //!< Program sector.
|
|
FAPI_ERASE_OTP = 0x0030 //!< Erase OTP.
|
|
} tFlashStateCommandsType;
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Defines for values written to the FLASH_O_FSM_WR_ENA register
|
|
//
|
|
//*****************************************************************************
|
|
#define FSM_REG_WRT_ENABLE 5
|
|
#define FSM_REG_WRT_DISABLE 2
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Defines for the bank power mode field the FLASH_O_FBFALLBACK register
|
|
//
|
|
//*****************************************************************************
|
|
#define FBFALLBACK_SLEEP 0
|
|
#define FBFALLBACK_DEEP_STDBY 1
|
|
#define FBFALLBACK_ACTIVE 3
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Defines for the bank grace period and pump grace period
|
|
//
|
|
//*****************************************************************************
|
|
#define FLASH_BAGP 0x14
|
|
#define FLASH_PAGP 0x14
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Defines used by the FlashProgramPattern() function
|
|
//
|
|
//*****************************************************************************
|
|
#define PATTERN_BITS 0x20 // No of bits in data pattern to program
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Defines for the FW flag bits in the FLASH_O_FWFLAG register
|
|
//
|
|
//*****************************************************************************
|
|
#define FW_WRT_TRIMMED 0x00000001
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Defines used by the flash programming functions
|
|
//
|
|
//*****************************************************************************
|
|
typedef volatile uint8_t tFwpWriteByte;
|
|
#define FWPWRITE_BYTE_ADDRESS ((tFwpWriteByte *)((FLASH_BASE + FLASH_O_FWPWRITE0)))
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Define for efuse instruction
|
|
//
|
|
//*****************************************************************************
|
|
#define DUMPWORD_INSTR 0x04
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Define for FSM command execution
|
|
//
|
|
//*****************************************************************************
|
|
#define FLASH_CMD_EXEC 0x15
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Get size of a flash sector in number of bytes.
|
|
//!
|
|
//! This function will return the size of a flash sector in number of bytes.
|
|
//!
|
|
//! \return Returns size of a flash sector in number of bytes.
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE uint32_t
|
|
FlashSectorSizeGet(void)
|
|
{
|
|
uint32_t ui32SectorSizeInKbyte;
|
|
|
|
ui32SectorSizeInKbyte = (HWREG(FLASH_BASE + FLASH_O_FCFG_B0_SSIZE0) &
|
|
FLASH_FCFG_B0_SSIZE0_B0_SECT_SIZE_M) >>
|
|
FLASH_FCFG_B0_SSIZE0_B0_SECT_SIZE_S;
|
|
|
|
// Return flash sector size in number of bytes.
|
|
return(ui32SectorSizeInKbyte * 1024);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Get the size of the flash.
|
|
//!
|
|
//! This function returns the size of the flash main bank in number of bytes.
|
|
//!
|
|
//! \return Returns the flash size in number of bytes.
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE uint32_t
|
|
FlashSizeGet(void)
|
|
{
|
|
uint32_t ui32NoOfSectors;
|
|
|
|
// Get number of flash sectors
|
|
ui32NoOfSectors = (HWREG(FLASH_BASE + FLASH_O_FLASH_SIZE) &
|
|
FLASH_FLASH_SIZE_SECTORS_M) >>
|
|
FLASH_FLASH_SIZE_SECTORS_S;
|
|
|
|
// Return flash size in number of bytes
|
|
return(ui32NoOfSectors * FlashSectorSizeGet());
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Set power mode.
|
|
//!
|
|
//! This function will set the specified power mode.
|
|
//!
|
|
//! Any access to the bank causes a reload of the specified bank grace period
|
|
//! input value into the bank down counter. After the last access to the
|
|
//! flash bank, the down counter delays from 0 to 255 prescaled HCLK clock
|
|
//! cycles before putting the bank into one of the fallback power modes as
|
|
//! determined by \c ui32PowerMode. This value must be greater than 1 when the
|
|
//! fallback mode is not \ref FLASH_PWR_ACTIVE_MODE.
|
|
//!
|
|
//! Note: The prescaled clock used for the down counter is a clock divided by
|
|
//! 16 from input HCLK. The \c ui32BankGracePeriod parameter is ignored if
|
|
//! \c ui32PowerMode is equal to \ref FLASH_PWR_ACTIVE_MODE.
|
|
//! Any access to flash memory causes the pump grace period down counter to
|
|
//! reload with value of \c ui32PumpGracePeriod. After the bank has gone to sleep,
|
|
//! the down counter delays this number of prescaled HCLK clock cycles before
|
|
//! entering one of the charge pump fallback power modes as determined by
|
|
//! \c ui32PowerMode. The prescaled clock used for the pump grace period down
|
|
//! counter is a clock divided by 16 from input HCLK. This parameter is ignored
|
|
//! if \c ui32PowerMode is equal to \ref FLASH_PWR_ACTIVE_MODE.
|
|
//!
|
|
//! Changing the power mode of the flash module must be a part within a
|
|
//! device power mode transition requiring configuration of multiple modules.
|
|
//! Refer to documents describing the device power modes.
|
|
//!
|
|
//! \param ui32PowerMode is the wanted power mode.
|
|
//! The defined flash power modes are:
|
|
//! - \ref FLASH_PWR_ACTIVE_MODE
|
|
//! - \ref FLASH_PWR_OFF_MODE
|
|
//! - \ref FLASH_PWR_DEEP_STDBY_MODE
|
|
//! \param ui32BankGracePeriod is the starting count value for the bank grace
|
|
//! period down counter.
|
|
//! \param ui32PumpGracePeriod is the starting count value for the pump grace
|
|
//! period down counter.
|
|
//!
|
|
//! \return None
|
|
//
|
|
//*****************************************************************************
|
|
extern void FlashPowerModeSet(uint32_t ui32PowerMode,
|
|
uint32_t ui32BankGracePeriod,
|
|
uint32_t ui32PumpGracePeriod);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Get current configured power mode.
|
|
//!
|
|
//! This function will return the current configured power mode.
|
|
//!
|
|
//! \return Returns the current configured power mode.
|
|
//! The defined power modes are:
|
|
//! - \ref FLASH_PWR_ACTIVE_MODE
|
|
//! - \ref FLASH_PWR_OFF_MODE
|
|
//! - \ref FLASH_PWR_DEEP_STDBY_MODE
|
|
//
|
|
//*****************************************************************************
|
|
extern uint32_t FlashPowerModeGet(void);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Set sector protection.
|
|
//!
|
|
//! This function will set the specified protection on specified flash bank
|
|
//! sector. A sector can either have no protection or have write protection
|
|
//! which guards for both program and erase of that sector.
|
|
//! Sector protection can only be changed from \ref FLASH_NO_PROTECT to
|
|
//! \ref FLASH_WRITE_PROTECT! After write protecting a sector this sector can
|
|
//! only be set back to unprotected by a device reset.
|
|
//!
|
|
//! \param ui32SectorAddress is the start address of the sector to protect.
|
|
//! \param ui32ProtectMode is the enumerated sector protection mode.
|
|
//! - \ref FLASH_NO_PROTECT
|
|
//! - \ref FLASH_WRITE_PROTECT
|
|
//!
|
|
//! \return None
|
|
//
|
|
//*****************************************************************************
|
|
extern void FlashProtectionSet(uint32_t ui32SectorAddress,
|
|
uint32_t ui32ProtectMode);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Get sector protection.
|
|
//!
|
|
//! This return the protection mode for the specified flash bank sector.
|
|
//!
|
|
//! \param ui32SectorAddress is the start address of the desired sector.
|
|
//!
|
|
//! \return Returns the sector protection:
|
|
//! - \ref FLASH_NO_PROTECT
|
|
//! - \ref FLASH_WRITE_PROTECT
|
|
//
|
|
//*****************************************************************************
|
|
extern uint32_t FlashProtectionGet(uint32_t ui32SectorAddress);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Save sector protection to make it permanent.
|
|
//!
|
|
//! This function will save the current protection mode for the specified
|
|
//! flash bank sector.
|
|
//!
|
|
//! This function must only be executed from ROM or SRAM.
|
|
//!
|
|
//! \note A write protected sector will become permanent write
|
|
//! protected!! A device reset will not change the write protection!
|
|
//!
|
|
//! \param ui32SectorAddress is the start address of the sector to be protected.
|
|
//!
|
|
//! \return Returns the status of the sector protection:
|
|
//! - \ref FAPI_STATUS_SUCCESS : Success.
|
|
//! - \ref FAPI_STATUS_FSM_ERROR : An erase error is encountered.
|
|
//
|
|
//*****************************************************************************
|
|
extern uint32_t FlashProtectionSave(uint32_t ui32SectorAddress);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Checks if the Flash state machine has detected an error.
|
|
//!
|
|
//! This function returns the status of the Flash State Machine indicating if
|
|
//! an error is detected or not. Primary use is to check if an Erase or
|
|
//! Program operation has failed.
|
|
//!
|
|
//! \note Please note that code can not execute in flash while any part of the flash
|
|
//! is being programmed or erased. This function must be called from ROM or
|
|
//! SRAM while any part of the flash is being programmed or erased.
|
|
//!
|
|
//! \return Returns status of Flash state machine:
|
|
//! - \ref FAPI_STATUS_FSM_ERROR
|
|
//! - \ref FAPI_STATUS_SUCCESS
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE uint32_t
|
|
FlashCheckFsmForError(void)
|
|
{
|
|
if(HWREG(FLASH_BASE + FLASH_O_FMSTAT) & FLASH_FMSTAT_CSTAT)
|
|
{
|
|
return(FAPI_STATUS_FSM_ERROR);
|
|
}
|
|
else
|
|
{
|
|
return(FAPI_STATUS_SUCCESS);
|
|
}
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Checks if the Flash state machine is ready.
|
|
//!
|
|
//! This function returns the status of the Flash State Machine indicating if
|
|
//! it is ready to accept a new command or not. Primary use is to check if an
|
|
//! Erase or Program operation has finished.
|
|
//!
|
|
//! \note Please note that code can not execute in flash while any part of the flash
|
|
//! is being programmed or erased. This function must be called from ROM or
|
|
//! SRAMh while any part of the flash is being programmed or erased.
|
|
//!
|
|
//! \return Returns readiness status of Flash state machine:
|
|
//! - \ref FAPI_STATUS_FSM_READY
|
|
//! - \ref FAPI_STATUS_FSM_BUSY
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE uint32_t
|
|
FlashCheckFsmForReady(void)
|
|
{
|
|
if(HWREG(FLASH_BASE + FLASH_O_STAT) & FLASH_STAT_BUSY)
|
|
{
|
|
return(FAPI_STATUS_FSM_BUSY);
|
|
}
|
|
else
|
|
{
|
|
return(FAPI_STATUS_FSM_READY);
|
|
}
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Registers an interrupt handler for the flash interrupt in the dynamic interrupt table.
|
|
//!
|
|
//! \note Only use this function if you want to use the dynamic vector table (in SRAM)!
|
|
//!
|
|
//! This function registers a function as the interrupt handler for a specific
|
|
//! interrupt and enables the corresponding interrupt in the interrupt controller.
|
|
//!
|
|
//! Specific FLASH interrupts must be enabled via \ref FlashIntEnable(). It is the
|
|
//! interrupt handler's responsibility to clear the interrupt source.
|
|
//!
|
|
//! \param pfnHandler is a pointer to the function to be called when the flash
|
|
//! interrupt occurs.
|
|
//!
|
|
//! \return None
|
|
//!
|
|
//! \sa \ref IntRegister() for important information about registering interrupt
|
|
//! handlers.
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE void
|
|
FlashIntRegister(void (*pfnHandler)(void))
|
|
{
|
|
// Register the interrupt handler.
|
|
IntRegister(INT_FLASH, pfnHandler);
|
|
|
|
// Enable the flash interrupt.
|
|
IntEnable(INT_FLASH);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Unregisters the interrupt handler for the flash interrupt in the dynamic interrupt table.
|
|
//!
|
|
//! This function does the actual unregistering of the interrupt handler. It
|
|
//! clears the handler to be called when a FLASH interrupt occurs. This
|
|
//! function also masks off the interrupt in the interrupt controller so that
|
|
//! the interrupt handler no longer is called.
|
|
//!
|
|
//! \return None
|
|
//!
|
|
//! \sa \ref IntRegister() for important information about registering interrupt
|
|
//! handlers.
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE void
|
|
FlashIntUnregister(void)
|
|
{
|
|
// Disable the interrupts.
|
|
IntDisable(INT_FLASH);
|
|
|
|
// Unregister the interrupt handler.
|
|
IntUnregister(INT_FLASH);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Enables flash controller interrupt sources.
|
|
//!
|
|
//! This function enables the flash controller interrupt sources.
|
|
//!
|
|
//! \param ui32IntFlags is the bit mask of the interrupt sources to be enabled.
|
|
//! The parameter is the bitwise OR of any of the following:
|
|
//! - \ref FLASH_INT_FSM_DONE : FSM Done interrupt.
|
|
//! - \ref FLASH_INT_RV : Read verify error interrupt.
|
|
//!
|
|
//! \return None
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE void
|
|
FlashIntEnable(uint32_t ui32IntFlags)
|
|
{
|
|
HWREG(FLASH_BASE + FLASH_O_FSM_WR_ENA) = FSM_REG_WRT_ENABLE;
|
|
HWREG(FLASH_BASE + FLASH_O_FSM_ST_MACHINE) |= ui32IntFlags;
|
|
HWREG(FLASH_BASE + FLASH_O_FSM_WR_ENA) = FSM_REG_WRT_DISABLE;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Disables individual flash controller interrupt sources.
|
|
//!
|
|
//! This function disables the flash controller interrupt sources.
|
|
//!
|
|
//! \param ui32IntFlags is the bit mask of the interrupt sources to be disabled.
|
|
//! The parameter is the bitwise OR of any of the following:
|
|
//! - \ref FLASH_INT_FSM_DONE : FSM Done interrupt.
|
|
//! - \ref FLASH_INT_RV : Read verify error interrupt.
|
|
//!
|
|
//! \return None
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE void
|
|
FlashIntDisable(uint32_t ui32IntFlags)
|
|
{
|
|
HWREG(FLASH_BASE + FLASH_O_FSM_WR_ENA) = FSM_REG_WRT_ENABLE;
|
|
HWREG(FLASH_BASE + FLASH_O_FSM_ST_MACHINE) &= ~ui32IntFlags;
|
|
HWREG(FLASH_BASE + FLASH_O_FSM_WR_ENA) = FSM_REG_WRT_DISABLE;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Gets the current interrupt status.
|
|
//!
|
|
//! This function returns the interrupt status for the Flash.
|
|
//!
|
|
//! \return Returns the current interrupt status as values described in
|
|
//! \ref FlashIntEnable().
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE uint32_t
|
|
FlashIntStatus(void)
|
|
{
|
|
uint32_t ui32IntFlags;
|
|
|
|
ui32IntFlags = 0;
|
|
|
|
// Check if FSM_DONE interrupt status is set.
|
|
if(HWREG(FLASH_BASE + FLASH_O_FEDACSTAT) & FLASH_FEDACSTAT_FSM_DONE)
|
|
{
|
|
ui32IntFlags = FLASH_INT_FSM_DONE;
|
|
}
|
|
|
|
// Check if RVF_INT interrupt status is set.
|
|
if(HWREG(FLASH_BASE + FLASH_O_FEDACSTAT) & FLASH_FEDACSTAT_RVF_INT)
|
|
{
|
|
ui32IntFlags |= FLASH_INT_RV;
|
|
}
|
|
|
|
return(ui32IntFlags);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Clears flash controller interrupt source.
|
|
//!
|
|
//! The flash controller interrupt source is cleared, so that it no longer
|
|
//! asserts. This must be done in the interrupt handler to keep it from being
|
|
//! called again immediately upon exit.
|
|
//!
|
|
//! \note Due to write buffers and synchronizers in the system it may take several
|
|
//! clock cycles from a register write clearing an event in a module and until the
|
|
//! event is actually cleared in the NVIC of the system CPU. It is recommended to
|
|
//! clear the event source early in the interrupt service routine (ISR) to allow
|
|
//! the event clear to propagate to the NVIC before returning from the ISR.
|
|
//! At the same time, an early event clear allows new events of the same type to be
|
|
//! pended instead of ignored if the event is cleared later in the ISR.
|
|
//! It is the responsibility of the programmer to make sure that enough time has passed
|
|
//! before returning from the ISR to avoid false re-triggering of the cleared event.
|
|
//! A simple, although not necessarily optimal, way of clearing an event before
|
|
//! returning from the ISR is:
|
|
//! -# Write to clear event (interrupt source). (buffered write)
|
|
//! -# Dummy read from the event source module. (making sure the write has propagated)
|
|
//! -# Wait two system CPU clock cycles (user code or two NOPs). (allowing cleared event to propagate through any synchronizers)
|
|
//!
|
|
//! \param ui32IntFlags is the bit mask of the interrupt sources to be cleared.
|
|
//! Can be any of:
|
|
//! - \ref FLASH_INT_FSM_DONE
|
|
//! - \ref FLASH_INT_RV
|
|
//!
|
|
//! \return None
|
|
//
|
|
//*****************************************************************************
|
|
__STATIC_INLINE void
|
|
FlashIntClear(uint32_t ui32IntFlags)
|
|
{
|
|
uint32_t ui32TempVal;
|
|
|
|
ui32TempVal = 0;
|
|
|
|
if(ui32IntFlags & FLASH_INT_FSM_DONE)
|
|
{
|
|
ui32TempVal = FLASH_FEDACSTAT_FSM_DONE;
|
|
}
|
|
|
|
if(ui32IntFlags & FLASH_INT_RV)
|
|
{
|
|
ui32TempVal |= FLASH_FEDACSTAT_RVF_INT;
|
|
}
|
|
|
|
// Clear the flash interrupt source.
|
|
HWREG(FLASH_BASE + FLASH_O_FEDACSTAT) = ui32TempVal;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Erase a flash sector.
|
|
//!
|
|
//! This function will erase the specified flash sector. The function will
|
|
//! not return until the flash sector has been erased or an error condition
|
|
//! occurred. If flash top sector is erased the function will program the
|
|
//! the device security data bytes with default values. The device security
|
|
//! data located in the customer configuration area of the flash top sector,
|
|
//! must have valid values at all times. These values affect the configuration
|
|
//! of the device during boot.
|
|
//!
|
|
//! \warning Please note that code can not execute in flash while any part of the flash
|
|
//! is being programmed or erased. The application must disable interrupts that have
|
|
//! interrupt routines in flash. This function calls a ROM function which handles the
|
|
//! actual program operation.
|
|
//!
|
|
//! \param ui32SectorAddress is the starting address in flash of the sector to be
|
|
//! erased.
|
|
//!
|
|
//! \return Returns the status of the sector erase:
|
|
//! - \ref FAPI_STATUS_SUCCESS : Success.
|
|
//! - \ref FAPI_STATUS_INCORRECT_DATABUFFER_LENGTH : Invalid argument.
|
|
//! - \ref FAPI_STATUS_FSM_ERROR : A programming error is encountered.
|
|
//
|
|
//*****************************************************************************
|
|
extern uint32_t FlashSectorErase(uint32_t ui32SectorAddress);
|
|
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Programs unprotected flash sectors in the main bank.
|
|
//!
|
|
//! This function programs a sequence of bytes into the on-chip flash.
|
|
//! Programming each location consists of the result of an AND operation
|
|
//! of the new data and the existing data; in other words bits that contain
|
|
//! 1 can remain 1 or be changed to 0, but bits that are 0 cannot be changed
|
|
//! to 1. Therefore, a byte can be programmed multiple times as long as these
|
|
//! rules are followed; if a program operation attempts to change a 0 bit to
|
|
//! a 1 bit, that bit will not have its value changed.
|
|
//!
|
|
//! This function does not return until the data has been programmed or a
|
|
//! programming error occurs.
|
|
//!
|
|
//! \note It is recommended to disable cache and line buffer before programming the
|
|
//! flash. Cache and line buffer are not automatically updated if a flash program
|
|
//! causes a mismatch between new flash content and old content in cache and
|
|
//! line buffer. Remember to enable cache and line buffer when the program
|
|
//! operation completes. See \ref VIMSModeSafeSet(), \ref VIMSLineBufDisable(),
|
|
//! and \ref VIMSLineBufEnable() for more information.
|
|
//!
|
|
//! \warning Please note that code can not execute in flash while any part of the flash
|
|
//! is being programmed or erased. The application must disable interrupts that have
|
|
//! interrupt routines in flash. This function calls a ROM function which handles the
|
|
//! actual program operation.
|
|
//!
|
|
//! The \c pui8DataBuffer pointer can not point to flash.
|
|
//!
|
|
//! \param pui8DataBuffer is a pointer to the data to be programmed.
|
|
//! \param ui32Address is the starting address in flash to be programmed.
|
|
//! \param ui32Count is the number of bytes to be programmed.
|
|
//!
|
|
//! \return Returns status of the flash programming:
|
|
//! - \ref FAPI_STATUS_SUCCESS : Success.
|
|
//! - \ref FAPI_STATUS_INCORRECT_DATABUFFER_LENGTH : Too many bytes were requested.
|
|
//! - \ref FAPI_STATUS_FSM_ERROR : A programming error is encountered.
|
|
//
|
|
//*****************************************************************************
|
|
extern uint32_t FlashProgram(uint8_t *pui8DataBuffer,
|
|
uint32_t ui32Address, uint32_t ui32Count);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Reads efuse data from specified row.
|
|
//!
|
|
//! This function will read one efuse row.
|
|
//! It is assumed that any previous efuse operation has finished.
|
|
//!
|
|
//! \param pui32EfuseData is pointer to variable to be updated with efuse data.
|
|
//! \param ui32RowAddress is the efuse row number to be read. First row is row
|
|
//! number 0.
|
|
//!
|
|
//! \return Returns the status of the efuse read operation.
|
|
//! - \c false : OK status.
|
|
//! - \c true : Error status
|
|
//
|
|
//*****************************************************************************
|
|
extern bool FlashEfuseReadRow(uint32_t *pui32EfuseData,
|
|
uint32_t ui32RowAddress);
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! \brief Disables all sectors for erase and programming on the active bank.
|
|
//!
|
|
//! This function disables all sectors for erase and programming on the active
|
|
//! bank and enables the Idle Reading Power reduction mode if no low power
|
|
//! mode is configured. Furthermore, an additional level of protection from
|
|
//! erase is enabled.
|
|
//!
|
|
//! \note Please note that code can not execute in flash while any part of the flash
|
|
//! is being programmed or erased.
|
|
//!
|
|
//! \return None
|
|
//
|
|
//*****************************************************************************
|
|
extern void FlashDisableSectorsForWrite(void);
|
|
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Support for DriverLib in ROM:
|
|
// Redirect to implementation in ROM when available.
|
|
//
|
|
//*****************************************************************************
|
|
#if !defined(DRIVERLIB_NOROM) && !defined(DOXYGEN)
|
|
#include "../driverlib/rom.h"
|
|
#ifdef ROM_FlashPowerModeSet
|
|
#undef FlashPowerModeSet
|
|
#define FlashPowerModeSet ROM_FlashPowerModeSet
|
|
#endif
|
|
#ifdef ROM_FlashPowerModeGet
|
|
#undef FlashPowerModeGet
|
|
#define FlashPowerModeGet ROM_FlashPowerModeGet
|
|
#endif
|
|
#ifdef ROM_FlashProtectionSet
|
|
#undef FlashProtectionSet
|
|
#define FlashProtectionSet ROM_FlashProtectionSet
|
|
#endif
|
|
#ifdef ROM_FlashProtectionGet
|
|
#undef FlashProtectionGet
|
|
#define FlashProtectionGet ROM_FlashProtectionGet
|
|
#endif
|
|
#ifdef ROM_FlashProtectionSave
|
|
#undef FlashProtectionSave
|
|
#define FlashProtectionSave ROM_FlashProtectionSave
|
|
#endif
|
|
#ifdef ROM_FlashSectorErase
|
|
#undef FlashSectorErase
|
|
#define FlashSectorErase ROM_FlashSectorErase
|
|
#endif
|
|
#ifdef ROM_FlashProgram
|
|
#undef FlashProgram
|
|
#define FlashProgram ROM_FlashProgram
|
|
#endif
|
|
#ifdef ROM_FlashEfuseReadRow
|
|
#undef FlashEfuseReadRow
|
|
#define FlashEfuseReadRow ROM_FlashEfuseReadRow
|
|
#endif
|
|
#ifdef ROM_FlashDisableSectorsForWrite
|
|
#undef FlashDisableSectorsForWrite
|
|
#define FlashDisableSectorsForWrite ROM_FlashDisableSectorsForWrite
|
|
#endif
|
|
#endif
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Mark the end of the C bindings section for C++ compilers.
|
|
//
|
|
//*****************************************************************************
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // __FLASH_H__
|
|
|
|
//*****************************************************************************
|
|
//
|
|
//! Close the Doxygen group.
|
|
//! @}
|
|
//! @}
|
|
//
|
|
//*****************************************************************************
|