| /* |
| * ------------------------------------------- |
| * MSP432 DriverLib - v3_10_00_09 |
| * ------------------------------------------- |
| * |
| * --COPYRIGHT--,BSD,BSD |
| * Copyright (c) 2014, 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: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * * 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. |
| * |
| * * Neither the name of Texas Instruments Incorporated 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 OWNER 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. |
| * --/COPYRIGHT--*/ |
| #ifndef __FLASH_H__ |
| #define __FLASH_H__ |
| |
| //***************************************************************************** |
| // |
| //! \addtogroup flash_api |
| //! @{ |
| // |
| //***************************************************************************** |
| |
| //***************************************************************************** |
| // |
| // If building with a C++ compiler, make all of the definitions in this header |
| // have a C binding. |
| // |
| //***************************************************************************** |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| |
| #include <msp.h> |
| #include <stdbool.h> |
| |
| //***************************************************************************** |
| // |
| // Control specific variables |
| // |
| //***************************************************************************** |
| #define FLASH_BURST_PRG_BIT 0x03 |
| |
| /* Interrupts */ |
| #define FLASH_PROGRAM_ERROR FLCTL_IFG_PRG_ERR |
| #define FLASH_BENCHMARK_INT FLCTL_IFG_BMRK |
| #define FLASH_ERASE_COMPLETE FLCTL_IFG_ERASE |
| #define FLASH_BRSTPRGM_COMPLETE FLCTL_IFG_PRGB |
| #define FLASH_WRDPRGM_COMPLETE FLCTL_IFG_PRG |
| #define FLASH_POSTVERIFY_FAILED FLCTL_IFG_AVPST |
| #define FLASH_PREVERIFY_FAILED FLCTL_IFG_AVPRE |
| #define FLASH_BRSTRDCMP_COMPLETE FLCTL_IFG_RDBRST |
| |
| #define FLASH_NORMAL_READ_MODE FLCTL_BANK0_RDCTL_RD_MODE_0 |
| #define FLASH_MARGIN0_READ_MODE FLCTL_BANK0_RDCTL_RD_MODE_1 |
| #define FLASH_MARGIN1_READ_MODE FLCTL_BANK0_RDCTL_RD_MODE_2 |
| #define FLASH_PROGRAM_VERIFY_READ_MODE FLCTL_BANK0_RDCTL_RD_MODE_3 |
| #define FLASH_ERASE_VERIFY_READ_MODE FLCTL_BANK0_RDCTL_RD_MODE_4 |
| #define FLASH_LEAKAGE_VERIFY_READ_MODE FLCTL_BANK0_RDCTL_RD_MODE_5 |
| #define FLASH_MARGIN0B_READ_MODE FLCTL_BANK0_RDCTL_RD_MODE_9 |
| #define FLASH_MARGIN1B_READ_MODE FLCTL_BANK0_RDCTL_RD_MODE_10 |
| |
| #define FLASH_PRGBRSTCTLSTAT_BURSTSTATUS_COMPLETE FLCTL_PRGBRST_CTLSTAT_BURST_STATUS_7 |
| |
| #define FLASH_BANK0 0x00 |
| #define FLASH_BANK1 0x01 |
| #define FLASH_DATA_READ 0x00 |
| #define FLASH_INSTRUCTION_FETCH 0x01 |
| |
| #define FLASH_MAIN_MEMORY_SPACE_BANK0 0x01 |
| #define FLASH_MAIN_MEMORY_SPACE_BANK1 0x02 |
| #define FLASH_INFO_MEMORY_SPACE_BANK0 0x03 |
| #define FLASH_INFO_MEMORY_SPACE_BANK1 0x04 |
| |
| #define FLASH_MAIN_SPACE FLCTL_RDBRST_CTLSTAT_MEM_TYPE_0 |
| #define FLASH_INFO_SPACE FLCTL_RDBRST_CTLSTAT_MEM_TYPE_1 |
| #define FLASH_1_PATTERN FLCTL_RDBRST_CTLSTAT_DATA_CMP |
| #define FLASH_0_PATTERN 0x00 |
| |
| #define FLASH_SECTOR0 FLCTL_BANK0_MAIN_WEPROT_PROT0 |
| #define FLASH_SECTOR1 FLCTL_BANK0_MAIN_WEPROT_PROT1 |
| #define FLASH_SECTOR2 FLCTL_BANK0_MAIN_WEPROT_PROT2 |
| #define FLASH_SECTOR3 FLCTL_BANK0_MAIN_WEPROT_PROT3 |
| #define FLASH_SECTOR4 FLCTL_BANK0_MAIN_WEPROT_PROT4 |
| #define FLASH_SECTOR5 FLCTL_BANK0_MAIN_WEPROT_PROT5 |
| #define FLASH_SECTOR6 FLCTL_BANK0_MAIN_WEPROT_PROT6 |
| #define FLASH_SECTOR7 FLCTL_BANK0_MAIN_WEPROT_PROT7 |
| #define FLASH_SECTOR8 FLCTL_BANK0_MAIN_WEPROT_PROT8 |
| #define FLASH_SECTOR9 FLCTL_BANK0_MAIN_WEPROT_PROT9 |
| #define FLASH_SECTOR10 FLCTL_BANK0_MAIN_WEPROT_PROT10 |
| #define FLASH_SECTOR11 FLCTL_BANK0_MAIN_WEPROT_PROT11 |
| #define FLASH_SECTOR12 FLCTL_BANK0_MAIN_WEPROT_PROT12 |
| #define FLASH_SECTOR13 FLCTL_BANK0_MAIN_WEPROT_PROT13 |
| #define FLASH_SECTOR14 FLCTL_BANK0_MAIN_WEPROT_PROT14 |
| #define FLASH_SECTOR15 FLCTL_BANK0_MAIN_WEPROT_PROT15 |
| #define FLASH_SECTOR16 FLCTL_BANK0_MAIN_WEPROT_PROT16 |
| #define FLASH_SECTOR17 FLCTL_BANK0_MAIN_WEPROT_PROT17 |
| #define FLASH_SECTOR18 FLCTL_BANK0_MAIN_WEPROT_PROT18 |
| #define FLASH_SECTOR19 FLCTL_BANK0_MAIN_WEPROT_PROT19 |
| #define FLASH_SECTOR20 FLCTL_BANK0_MAIN_WEPROT_PROT20 |
| #define FLASH_SECTOR21 FLCTL_BANK0_MAIN_WEPROT_PROT21 |
| #define FLASH_SECTOR22 FLCTL_BANK0_MAIN_WEPROT_PROT22 |
| #define FLASH_SECTOR23 FLCTL_BANK0_MAIN_WEPROT_PROT23 |
| #define FLASH_SECTOR24 FLCTL_BANK0_MAIN_WEPROT_PROT24 |
| #define FLASH_SECTOR25 FLCTL_BANK0_MAIN_WEPROT_PROT25 |
| #define FLASH_SECTOR26 FLCTL_BANK0_MAIN_WEPROT_PROT26 |
| #define FLASH_SECTOR27 FLCTL_BANK0_MAIN_WEPROT_PROT27 |
| #define FLASH_SECTOR28 FLCTL_BANK0_MAIN_WEPROT_PROT28 |
| #define FLASH_SECTOR29 FLCTL_BANK0_MAIN_WEPROT_PROT29 |
| #define FLASH_SECTOR30 FLCTL_BANK0_MAIN_WEPROT_PROT30 |
| #define FLASH_SECTOR31 FLCTL_BANK0_MAIN_WEPROT_PROT31 |
| |
| #define FLASH_NOVER 0 |
| #define FLASH_BURSTPOST FLCTL_PRGBRST_CTLSTAT_AUTO_PST |
| #define FLASH_BURSTPRE FLCTL_PRGBRST_CTLSTAT_AUTO_PRE |
| #define FLASH_REGPRE FLCTL_PRG_CTLSTAT_VER_PRE |
| #define FLASH_REGPOST FLCTL_PRG_CTLSTAT_VER_PST |
| #define FLASH_FULLVER (FLCTL_PRGBRST_CTLSTAT_AUTO_PST | \ |
| FLCTL_PRGBRST_CTLSTAT_AUTO_PRE | FLCTL_PRG_CTLSTAT_VER_PRE \ |
| | FLCTL_PRG_CTLSTAT_VER_PST) |
| |
| #define FLASH_COLLATED_WRITE_MODE 0x01 |
| #define FLASH_IMMEDIATE_WRITE_MODE 0x02 |
| |
| #define __INFO_FLASH_TECH_START__ 0x00200000 |
| #define __INFO_FLASH_TECH_MIDDLE__ 0x00202000 |
| |
| |
| //***************************************************************************** |
| // |
| // Prototypes for the APIs. |
| // |
| //***************************************************************************** |
| |
| //***************************************************************************** |
| // |
| //! Calculates the flash bank and sector number given an address. Stores the |
| //! results into the two pointers given as parameters. The user must provide |
| //! a valid memory address (an address in SRAM for example will give an invalid |
| //! result). |
| //! |
| //! \param addr Address to calculate the bank/sector information for |
| //! |
| //! \param sectorNum The sector number will be stored in here after the function |
| //! completes. |
| //! |
| //! \param sectorNum The bank number will be stored in here after the function |
| //! completes. |
| //! |
| //! \note For simplicity, this API only works with address in MAIN flash memory. |
| //! For calculating the sector/bank number of an address in info memory, |
| //! please refer to your device datasheet/ |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_getMemoryInfo(uint32_t addr, uint32_t *sectorNum, |
| uint32_t *bankNum); |
| |
| //***************************************************************************** |
| // |
| //! Enables read buffering on accesses to a specified bank of flash memory |
| //! |
| //! \param memoryBank is the value of the memory bank to enable read |
| //! buffering. Must be only one of the following values: |
| //! - \b FLASH_BANK0, |
| //! - \b FLASH_BANK1 |
| //! |
| //! \param accessMethod is the value of the access type to enable read |
| //! buffering. Must be only one of the following values: |
| //! - \b FLASH_DATA_READ, |
| //! - \b FLASH_INSTRUCTION_FETCH |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_enableReadBuffering(uint_fast8_t memoryBank, |
| uint_fast8_t accessMethod); |
| |
| //***************************************************************************** |
| // |
| //! Disables read buffering on accesses to a specified bank of flash memory |
| //! |
| //! \param memoryBank is the value of the memory bank to disable read |
| //! buffering. Must be only one of the following values: |
| //! - \b FLASH_BANK0, |
| //! - \b FLASH_BANK1 |
| //! |
| //! \param accessMethod is the value of the access type to disable read |
| //! buffering. Must ne only one of the following values: |
| //! - \b FLASH_DATA_READ, |
| //! - \b FLASH_INSTRUCTION_FETCH |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_disableReadBuffering(uint_fast8_t memoryBank, |
| uint_fast8_t accessMethod); |
| |
| //***************************************************************************** |
| // |
| //! Disables program protection on the given sector mask. This setting can be |
| //! applied on a sector-wise bases on a given memory space (INFO or MAIN). |
| //! |
| //! \param memorySpace is the value of the memory bank to disable program |
| //! protection. Must be only one of the following values: |
| //! - \b FLASH_MAIN_MEMORY_SPACE_BANK0, |
| //! - \b FLASH_MAIN_MEMORY_SPACE_BANK1, |
| //! - \b FLASH_INFO_MEMORY_SPACE_BANK0, |
| //! - \b FLASH_INFO_MEMORY_SPACE_BANK1 |
| //! |
| //! \param sectorMask is a bit mask of the sectors to disable program |
| //! protection. Must be a bitfield of the following values: |
| //! - \b FLASH_SECTOR0, |
| //! - \b FLASH_SECTOR1, |
| //! - \b FLASH_SECTOR2, |
| //! - \b FLASH_SECTOR3, |
| //! - \b FLASH_SECTOR4, |
| //! - \b FLASH_SECTOR5, |
| //! - \b FLASH_SECTOR6, |
| //! - \b FLASH_SECTOR7, |
| //! - \b FLASH_SECTOR8, |
| //! - \b FLASH_SECTOR9, |
| //! - \b FLASH_SECTOR10, |
| //! - \b FLASH_SECTOR11, |
| //! - \b FLASH_SECTOR12, |
| //! - \b FLASH_SECTOR13, |
| //! - \b FLASH_SECTOR14, |
| //! - \b FLASH_SECTOR15, |
| //! - \b FLASH_SECTOR16, |
| //! - \b FLASH_SECTOR17, |
| //! - \b FLASH_SECTOR18, |
| //! - \b FLASH_SECTOR19, |
| //! - \b FLASH_SECTOR20, |
| //! - \b FLASH_SECTOR21, |
| //! - \b FLASH_SECTOR22, |
| //! - \b FLASH_SECTOR23, |
| //! - \b FLASH_SECTOR24, |
| //! - \b FLASH_SECTOR25, |
| //! - \b FLASH_SECTOR26, |
| //! - \b FLASH_SECTOR27, |
| //! - \b FLASH_SECTOR28, |
| //! - \b FLASH_SECTOR29, |
| //! - \b FLASH_SECTOR30, |
| //! - \b FLASH_SECTOR31 |
| //! |
| //! \note Flash sector sizes are 4KB and the number of sectors may vary |
| //! depending on the specific device. Also, for INFO memory space, only sectors |
| //! \b FLASH_SECTOR0 and \b FLASH_SECTOR1 will exist. |
| //! |
| //! \note Not all devices will contain a dedicated INFO memory. Please check the |
| //! device datasheet to see if your device has INFO memory available for use. |
| //! For devices without INFO memory, any operation related to the INFO memory |
| //! will be ignored by the hardware. |
| //! |
| //! \return true if sector protection disabled false otherwise. |
| // |
| //***************************************************************************** |
| extern bool FlashCtl_unprotectSector(uint_fast8_t memorySpace, |
| uint32_t sectorMask); |
| |
| //***************************************************************************** |
| // |
| //! Enables program protection on the given sector mask. This setting can be |
| //! applied on a sector-wise bases on a given memory space (INFO or MAIN). |
| //! |
| //! \param memorySpace is the value of the memory bank to enable program |
| //! protection. Must be only one of the following values: |
| //! - \b FLASH_MAIN_MEMORY_SPACE_BANK0, |
| //! - \b FLASH_MAIN_MEMORY_SPACE_BANK1, |
| //! - \b FLASH_INFO_MEMORY_SPACE_BANK0, |
| //! - \b FLASH_INFO_MEMORY_SPACE_BANK1 |
| //! |
| //! \param sectorMask is a bit mask of the sectors to enable program |
| //! protection. Must be a bitfield of the following values: |
| //! - \b FLASH_SECTOR0, |
| //! - \b FLASH_SECTOR1, |
| //! - \b FLASH_SECTOR2, |
| //! - \b FLASH_SECTOR3, |
| //! - \b FLASH_SECTOR4, |
| //! - \b FLASH_SECTOR5, |
| //! - \b FLASH_SECTOR6, |
| //! - \b FLASH_SECTOR7, |
| //! - \b FLASH_SECTOR8, |
| //! - \b FLASH_SECTOR9, |
| //! - \b FLASH_SECTOR10, |
| //! - \b FLASH_SECTOR11, |
| //! - \b FLASH_SECTOR12, |
| //! - \b FLASH_SECTOR13, |
| //! - \b FLASH_SECTOR14, |
| //! - \b FLASH_SECTOR15, |
| //! - \b FLASH_SECTOR16, |
| //! - \b FLASH_SECTOR17, |
| //! - \b FLASH_SECTOR18, |
| //! - \b FLASH_SECTOR19, |
| //! - \b FLASH_SECTOR20, |
| //! - \b FLASH_SECTOR21, |
| //! - \b FLASH_SECTOR22, |
| //! - \b FLASH_SECTOR23, |
| //! - \b FLASH_SECTOR24, |
| //! - \b FLASH_SECTOR25, |
| //! - \b FLASH_SECTOR26, |
| //! - \b FLASH_SECTOR27, |
| //! - \b FLASH_SECTOR28, |
| //! - \b FLASH_SECTOR29, |
| //! - \b FLASH_SECTOR30, |
| //! - \b FLASH_SECTOR31 |
| //! |
| //! \note Flash sector sizes are 4KB and the number of sectors may vary |
| //! depending on the specific device. Also, for INFO memory space, only sectors |
| //! \b FLASH_SECTOR0 and \b FLASH_SECTOR1 will exist. |
| //! |
| //! \note Not all devices will contain a dedicated INFO memory. Please check the |
| //! device datasheet to see if your device has INFO memory available for use. |
| //! For devices without INFO memory, any operation related to the INFO memory |
| //! will be ignored by the hardware. |
| //! |
| //! \return true if sector protection enabled false otherwise. |
| // |
| //***************************************************************************** |
| extern bool FlashCtl_protectSector(uint_fast8_t memorySpace, |
| uint32_t sectorMask); |
| |
| //***************************************************************************** |
| // |
| //! Returns the sector protection for given sector mask and memory space |
| //! |
| //! \param memorySpace is the value of the memory bank to check for program |
| //! protection. Must be only one of the following values: |
| //! - \b FLASH_MAIN_MEMORY_SPACE_BANK0, |
| //! - \b FLASH_MAIN_MEMORY_SPACE_BANK1, |
| //! - \b FLASH_INFO_MEMORY_SPACE_BANK0, |
| //! - \b FLASH_INFO_MEMORY_SPACE_BANK1 |
| //! |
| //! \param sector is the sector to check for program protection. |
| //! Must be one of the following values: |
| //! - \b FLASH_SECTOR0, |
| //! - \b FLASH_SECTOR1, |
| //! - \b FLASH_SECTOR2, |
| //! - \b FLASH_SECTOR3, |
| //! - \b FLASH_SECTOR4, |
| //! - \b FLASH_SECTOR5, |
| //! - \b FLASH_SECTOR6, |
| //! - \b FLASH_SECTOR7, |
| //! - \b FLASH_SECTOR8, |
| //! - \b FLASH_SECTOR9, |
| //! - \b FLASH_SECTOR10, |
| //! - \b FLASH_SECTOR11, |
| //! - \b FLASH_SECTOR12, |
| //! - \b FLASH_SECTOR13, |
| //! - \b FLASH_SECTOR14, |
| //! - \b FLASH_SECTOR15, |
| //! - \b FLASH_SECTOR16, |
| //! - \b FLASH_SECTOR17, |
| //! - \b FLASH_SECTOR18, |
| //! - \b FLASH_SECTOR19, |
| //! - \b FLASH_SECTOR20, |
| //! - \b FLASH_SECTOR21, |
| //! - \b FLASH_SECTOR22, |
| //! - \b FLASH_SECTOR23, |
| //! - \b FLASH_SECTOR24, |
| //! - \b FLASH_SECTOR25, |
| //! - \b FLASH_SECTOR26, |
| //! - \b FLASH_SECTOR27, |
| //! - \b FLASH_SECTOR28, |
| //! - \b FLASH_SECTOR29, |
| //! - \b FLASH_SECTOR30, |
| //! - \b FLASH_SECTOR31 |
| //! |
| //! Note that flash sector sizes are 4KB and the number of sectors may vary |
| //! depending on the specific device. Also, for INFO memory space, only sectors |
| //! FLASH_SECTOR0 and FLASH_SECTOR1 will exist. |
| //! |
| //! \note Not all devices will contain a dedicated INFO memory. Please check the |
| //! device datasheet to see if your device has INFO memory available for use. |
| //! For devices without INFO memory, any operation related to the INFO memory |
| //! will be ignored by the hardware. |
| //! |
| //! \return true if sector protection enabled false otherwise. |
| // |
| //***************************************************************************** |
| extern bool FlashCtl_isSectorProtected(uint_fast8_t memorySpace, |
| uint32_t sector); |
| |
| //***************************************************************************** |
| // |
| //! Verifies a given segment of memory based off either a high (1) or low (0) |
| //! state. |
| //! |
| //! \param verifyAddr Start address where verification will begin |
| //! |
| //! \param length Length in bytes to verify based off the pattern |
| //! |
| //! \param pattern The pattern which verification will check versus. This can |
| //! either be a low pattern (each register will be checked versus a pattern |
| //! of 32 zeros, or a high pattern (each register will be checked versus a |
| //! pattern of 32 ones). Valid values are: FLASH_0_PATTERN, FLASH_1_PATTERN |
| //! |
| //! \note There are no sector/boundary restrictions for this function, |
| //! however it is encouraged to proved a start address aligned on 32-bit |
| //! boundaries. Providing an unaligned address will result in unaligned data |
| //! accesses and detriment efficiency. |
| //! |
| //! \note This function is blocking and will not exit until operation has |
| //! either completed or failed due to an error. Furthermore, given the |
| //! complex verification requirements of the flash controller, master |
| //! interrupts are disabled throughout execution of this function. The original |
| //! interrupt context is saved at the start of execution and restored prior |
| //! to exit of the API. |
| //! |
| //! \note Due to the hardware limitations of the flash controller, this |
| //! function cannot verify a memory adress in the same flash bank that it |
| //! is executing from. If using the ROM version of this API (by using the |
| //! (ROM_ or MAP_ prefixes) this is a don't care, however if this API resides |
| //! in flash then special care needs to be taken to ensure no code execution |
| //! or reads happen in the flash bank being programmed while this API is |
| //! being executed. |
| //! |
| //! \return true if memory verification is successful, false otherwise. |
| // |
| //***************************************************************************** |
| extern bool FlashCtl_verifyMemory(void* verifyAddr, uint32_t length, |
| uint_fast8_t pattern); |
| |
| //***************************************************************************** |
| // |
| //! Performs a mass erase on all unprotected flash sectors. Protected sectors |
| //! are ignored. |
| //! |
| //! \note This function is blocking and will not exit until operation has |
| //! either completed or failed due to an error. Furthermore, given the |
| //! complex verification requirements of the flash controller, master |
| //! interrupts are disabled throughout execution of this function. The original |
| //! interrupt context is saved at the start of execution and restored prior |
| //! to exit of the API. |
| //! |
| //! \note Due to the hardware limitations of the flash controller, this |
| //! function cannot erase a memory adress in the same flash bank that it |
| //! is executing from. If using the ROM version of this API (by using the |
| //! (ROM_ or MAP_ prefixes) this is a don't care, however if this API resides |
| //! in flash then special care needs to be taken to ensure no code execution |
| //! or reads happen in the flash bank being programmed while this API is |
| //! being executed. |
| //! |
| //! \return true if mass erase completes successfully, false otherwise |
| // |
| //***************************************************************************** |
| extern bool FlashCtl_performMassErase(void); |
| |
| //***************************************************************************** |
| // |
| //! Initiates a mass erase and returns control back to the program. This is a |
| //! non-blocking function, however it is the user's responsibility to perform |
| //! the necessary verification requirements after the interrupt is set to |
| //! signify completion. |
| //! |
| //! \return None |
| // |
| //***************************************************************************** |
| extern void FlashCtl_initiateMassErase(void); |
| |
| //***************************************************************************** |
| // |
| //! Erases a sector of MAIN or INFO flash memory. |
| //! |
| //! \param addr The start of the sector to erase. Note that with flash, |
| //! the minimum allowed size that can be erased is a flash sector |
| //! (which is 4KB on the MSP432 family). If an address is provided to |
| //! this function which is not on a 4KB boundary, the entire sector |
| //! will still be erased. |
| //! |
| //! \note This function is blocking and will not exit until operation has |
| //! either completed or failed due to an error. Furthermore, given the |
| //! complex verification requirements of the flash controller, master |
| //! interrupts are disabled throughout execution of this function. The original |
| //! interrupt context is saved at the start of execution and restored prior |
| //! to exit of the API. |
| //! |
| //! \note Due to the hardware limitations of the flash controller, this |
| //! function cannot erase a memory adress in the same flash bank that it |
| //! is executing from. If using the ROM version of this API (by using the |
| //! (ROM_ or MAP_ prefixes) this is a don't care, however if this API resides |
| //! in flash then special care needs to be taken to ensure no code execution |
| //! or reads happen in the flash bank being programmed while this API is |
| //! being executed. |
| //! |
| //! \return true if sector erase is successful, false otherwise. |
| // |
| //***************************************************************************** |
| extern bool FlashCtl_eraseSector(uint32_t addr); |
| |
| //***************************************************************************** |
| // |
| //! Program a portion of flash memory with the provided data |
| //! |
| //! \param src Pointer to the data source to program into flash |
| //! |
| //! \param dest Pointer to the destination in flash to program |
| //! |
| //! \param length Length in bytes to program |
| //! |
| //! \note There are no sector/boundary restrictions for this function, |
| //! however it is encouraged to proved a start address aligned on 32-bit |
| //! boundaries. Providing an unaligned address will result in unaligned data |
| //! accesses and detriment efficiency. |
| //! |
| //! \note This function is blocking and will not exit until operation has |
| //! either completed or failed due to an error. Furthermore, given the |
| //! complex verification requirements of the flash controller, master |
| //! interrupts are disabled throughout execution of this function. The original |
| //! interrupt context is saved at the start of execution and restored prior |
| //! to exit of the API. |
| //! |
| //! \note Due to the hardware limitations of the flash controller, this |
| //! function cannot program a memory adress in the same flash bank that it |
| //! is executing from. If using the ROM version of this API (by using the |
| //! (ROM_ or MAP_ prefixes) this is a don't care, however if this API resides |
| //! in flash then special care needs to be taken to ensure no code execution |
| //! or reads happen in the flash bank being programmed while this API is |
| //! being executed. |
| //! |
| //! \return Whether or not the program succeeded |
| // |
| //***************************************************************************** |
| extern bool FlashCtl_programMemory(void* src, void* dest, uint32_t length); |
| |
| //***************************************************************************** |
| // |
| //! Setups pre/post verification of burst and regular flash programming |
| //! instructions. Note that this API is for advanced users that are programming |
| //! their own flash drivers. The program/erase APIs are not affected by this |
| //! setting and take care of the verification requirements. |
| //! |
| //! \param verificationSetting Verification setting to set. This value can |
| //! be a bitwise OR of the following values: |
| //! - \b FLASH_BURSTPOST, |
| //! - \b FLASH_BURSTPRE, |
| //! - \b FLASH_REGPRE, |
| //! - \b FLASH_REGPOST |
| //! - \b FLASH_NOVER No verification enabled |
| //! - \b FLASH_FULLVER Full verification enabled |
| //! |
| //! \return none |
| // |
| //***************************************************************************** |
| extern void FlashCtl_setProgramVerification(uint32_t verificationSetting); |
| |
| //***************************************************************************** |
| // |
| //! Clears pre/post verification of burst and regular flash programming |
| //! instructions. Note that this API is for advanced users that are programming |
| //! their own flash drivers. The program/erase APIs are not affected by this |
| //! setting and take care of the verification requirements. |
| //! |
| //! \param verificationSetting Verification setting to clear. This value can |
| //! be a bitwise OR of the following values: |
| //! - \b FLASH_BURSTPOST, |
| //! - \b FLASH_BURSTPRE, |
| //! - \b FLASH_REGPRE, |
| //! - \b FLASH_REGPOST |
| //! - \b FLASH_NOVER No verification enabled |
| //! - \b FLASH_FULLVER Full verification enabled |
| //! |
| //! \return none |
| // |
| //***************************************************************************** |
| extern void FlashCtl_clearProgramVerification(uint32_t verificationSetting); |
| |
| //***************************************************************************** |
| // |
| //! Enables word programming of flash memory. |
| //! |
| //! This function will enable word programming of the flash memory and set the |
| //! mode of behavior when the flash write occurs. |
| //! |
| //! \param mode The mode specifies the behavior of the flash controller when |
| //! programming words to flash. In \b FLASH_IMMEDIATE_WRITE_MODE, the |
| //! program operation happens immediately on the write to flash while |
| //! in \b FLASH_COLLATED_WRITE_MODE the write will be delayed until a full |
| //! 128-bits have been collated. Possible values include: |
| //! - \b FLASH_IMMEDIATE_WRITE_MODE |
| //! - \b FLASH_COLLATED_WRITE_MODE |
| //! |
| //! |
| //! Refer to the user's guide for further documentation. |
| //! |
| //! \return none |
| // |
| //***************************************************************************** |
| extern void FlashCtl_enableWordProgramming(uint32_t mode); |
| |
| //***************************************************************************** |
| // |
| //! Disables word programming of flash memory. |
| //! |
| //! Refer to FlashCtl_enableWordProgramming and the user's guide for description |
| //! on the difference between full word and immediate programming |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_disableWordProgramming(void); |
| |
| //***************************************************************************** |
| // |
| //! Returns if word programming mode is enabled (and if it is, the specific mode) |
| //! |
| //! Refer to FlashCtl_enableWordProgramming and the user's guide for description |
| //! on the difference between full word and immediate programming |
| //! |
| //! \return a zero value if word programming is disabled, |
| //! - \b FLASH_IMMEDIATE_WRITE_MODE |
| //! - \b FLASH_COLLATED_WRITE_MODE |
| //! |
| // |
| //***************************************************************************** |
| extern uint32_t FlashCtl_isWordProgrammingEnabled(void); |
| |
| //***************************************************************************** |
| // |
| //! Sets the flash read mode to be used by default flash read operations. |
| //! Note that the proper wait states must be set prior to entering this |
| //! function. |
| //! |
| //! \param flashBank Flash bank to set read mode for. Valid values are: |
| //! - \b FLASH_BANK0 |
| //! - \b FLASH_BANK1 |
| //! |
| //! \param readMode The read mode to set. Valid values are: |
| //! - \b FLASH_NORMAL_READ_MODE, |
| //! - \b FLASH_MARGIN0_READ_MODE, |
| //! - \b FLASH_MARGIN1_READ_MODE, |
| //! - \b FLASH_PROGRAM_VERIFY_READ_MODE, |
| //! - \b FLASH_ERASE_VERIFY_READ_MODE, |
| //! - \b FLASH_LEAKAGE_VERIFY_READ_MODE, |
| //! - \b FLASH_MARGIN0B_READ_MODE, |
| //! - \b FLASH_MARGIN1B_READ_MODE |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern bool FlashCtl_setReadMode(uint32_t flashBank, uint32_t readMode); |
| |
| //***************************************************************************** |
| // |
| //! Gets the flash read mode to be used by default flash read operations. |
| //! |
| //! \param flashBank Flash bank to set read mode for. Valid values are: |
| //! - \b FLASH_BANK0 |
| //! - \b FLASH_BANK1 |
| //! |
| //! \return Returns the read mode to set. Valid values are: |
| //! - \b FLASH_NORMAL_READ_MODE, |
| //! - \b FLASH_MARGIN0_READ_MODE, |
| //! - \b FLASH_MARGIN1_READ_MODE, |
| //! - \b FLASH_PROGRAM_VERIFY_READ_MODE, |
| //! - \b FLASH_ERASE_VERIFY_READ_MODE, |
| //! - \b FLASH_LEAKAGE_VERIFY_READ_MODE, |
| //! - \b FLASH_MARGIN0B_READ_MODE, |
| //! - \b FLASH_MARGIN1B_READ_MODE |
| //! |
| // |
| //***************************************************************************** |
| extern uint32_t FlashCtl_getReadMode(uint32_t flashBank); |
| |
| //***************************************************************************** |
| // |
| //! Changes the number of wait states that are used by the flash controller |
| //! for read operations. When changing frequency ranges of the clock, this |
| //! functions must be used in order to allow for readable flash memory. |
| //! |
| //! \param waitState The number of wait states to set. Note that only |
| //! bits 0-3 are used. |
| //! |
| //! \param flashBank Flash bank to set wait state for. Valid values are: |
| //! - \b FLASH_BANK0 |
| //! - \b FLASH_BANK1 |
| //! |
| // |
| //***************************************************************************** |
| extern void FlashCtl_setWaitState(uint32_t bank, uint32_t waitState); |
| |
| //***************************************************************************** |
| // |
| //! Returns the set number of flash wait states for the given flash bank. |
| //! |
| //! \param flashBank Flash bank to set wait state for. Valid values are: |
| //! - \b FLASH_BANK0 |
| //! - \b FLASH_BANK1 |
| //! |
| //! \return The wait state setting for the specified flash bank |
| // |
| //***************************************************************************** |
| extern uint32_t FlashCtl_getWaitState(uint32_t bank); |
| |
| //***************************************************************************** |
| // |
| //! Enables individual flash control interrupt sources. |
| //! |
| //! \param flags is a bit mask of the interrupt sources to be enabled. Must |
| //! be a logical OR of: |
| //! - \b FLASH_PROGRAM_ERROR, |
| //! - \b FLASH_BENCHMARK_INT, |
| //! - \b FLASH_ERASE_COMPLETE, |
| //! - \b FLASH_BRSTPRGM_COMPLETE, |
| //! - \b FLASH_WRDPRGM_COMPLETE, |
| //! - \b FLASH_POSTVERIFY_FAILED, |
| //! - \b FLASH_PREVERIFY_FAILED, |
| //! - \b FLASH_BRSTRDCMP_COMPLETE |
| //! |
| //! This function enables the indicated flash system interrupt sources. Only |
| //! the sources that are enabled can be reflected to the processor interrupt; |
| //! disabled sources have no effect on the processor. |
| //! |
| //! \note The interrupt sources vary based on the part in use. |
| //! Please consult the data sheet for the part you are using to determine |
| //! which interrupt sources are available. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_enableInterrupt(uint32_t flags); |
| |
| //***************************************************************************** |
| // |
| //! Disables individual flash system interrupt sources. |
| //! |
| //! \param flags is a bit mask of the interrupt sources to be disabled. Must |
| //! be a logical OR of: |
| //! - \b FLASH_PROGRAM_ERROR, |
| //! - \b FLASH_BENCHMARK_INT, |
| //! - \b FLASH_ERASE_COMPLETE, |
| //! - \b FLASH_BRSTPRGM_COMPLETE, |
| //! - \b FLASH_WRDPRGM_COMPLETE, |
| //! - \b FLASH_POSTVERIFY_FAILED, |
| //! - \b FLASH_PREVERIFY_FAILED, |
| //! - \b FLASH_BRSTRDCMP_COMPLETE |
| //! |
| //! This function disables the indicated flash system interrupt sources. |
| //! Only the sources that are enabled can be reflected to the processor |
| //! interrupt; disabled sources have no effect on the processor. |
| //! |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_disableInterrupt(uint32_t flags); |
| |
| //***************************************************************************** |
| // |
| //! Gets the current interrupt status masked with the enabled interrupts. |
| //! This function is useful to call in ISRs to get a list |
| //! of pending interrupts that are actually enabled and could have caused the |
| //! ISR. |
| //! |
| //! \return The current interrupt status, enumerated as a bit field of |
| //! - \b FLASH_PROGRAM_ERROR, |
| //! - \b FLASH_BENCHMARK_INT, |
| //! - \b FLASH_ERASE_COMPLETE, |
| //! - \b FLASH_BRSTPRGM_COMPLETE, |
| //! - \b FLASH_WRDPRGM_COMPLETE, |
| //! - \b FLASH_POSTVERIFY_FAILED, |
| //! - \b FLASH_PREVERIFY_FAILED, |
| //! - \b FLASH_BRSTRDCMP_COMPLETE |
| //! |
| //! \note The interrupt sources vary based on the part in use. |
| //! Please consult the data sheet for the part you are using to determine |
| //! which interrupt sources are available. |
| // |
| //***************************************************************************** |
| extern uint32_t FlashCtl_getEnabledInterruptStatus(void); |
| |
| //***************************************************************************** |
| // |
| //! Gets the current interrupt status. |
| //! |
| //! \return The current interrupt status, enumerated as a bit field of: |
| //! - \b FLASH_PROGRAM_ERROR, |
| //! - \b FLASH_BENCHMARK_INT, |
| //! - \b FLASH_ERASE_COMPLETE, |
| //! - \b FLASH_BRSTPRGM_COMPLETE, |
| //! - \b FLASH_WRDPRGM_COMPLETE, |
| //! - \b FLASH_POSTVERIFY_FAILED, |
| //! - \b FLASH_PREVERIFY_FAILED, |
| //! - \b FLASH_BRSTRDCMP_COMPLETE |
| //! |
| //! \note The interrupt sources vary based on the part in use. |
| //! Please consult the data sheet for the part you are using to determine |
| //! which interrupt sources are available. |
| // |
| //***************************************************************************** |
| extern uint32_t FlashCtl_getInterruptStatus(void); |
| |
| //***************************************************************************** |
| // |
| //! Clears flash system interrupt sources. |
| //! |
| //! \param flags is a bit mask of the interrupt sources to be cleared. Must |
| //! be a logical OR of: |
| //! - \b FLASH_PROGRAM_ERROR, |
| //! - \b FLASH_BENCHMARK_INT, |
| //! - \b FLASH_ERASE_COMPLETE, |
| //! - \b FLASH_BRSTPRGM_COMPLETE, |
| //! - \b FLASH_WRDPRGM_COMPLETE, |
| //! - \b FLASH_POSTVERIFY_FAILED, |
| //! - \b FLASH_PREVERIFY_FAILED, |
| //! - \b FLASH_BRSTRDCMP_COMPLETE |
| //! |
| //! The specified flash system interrupt sources are cleared, so that they no |
| //! longer assert. This function must be called in the interrupt handler to |
| //! keep it from being called again immediately upon exit. |
| //! |
| //! \note Because there is a write buffer in the Cortex-M processor, it may |
| //! take several clock cycles before the interrupt source is actually cleared. |
| //! Therefore, it is recommended that the interrupt source be cleared early in |
| //! the interrupt handler (as opposed to the very last action) to avoid |
| //! returning from the interrupt handler before the interrupt source is |
| //! actually cleared. Failure to do so may result in the interrupt handler |
| //! being immediately reentered (because the interrupt controller still sees |
| //! the interrupt source asserted). |
| //! |
| //! \note The interrupt sources vary based on the part in use. |
| //! Please consult the data sheet for the part you are using to determine |
| //! which interrupt sources are available. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_clearInterruptFlag(uint32_t flags); |
| |
| //***************************************************************************** |
| // |
| //! Registers an interrupt handler for flash clock system interrupt. |
| //! |
| //! \param intHandler is a pointer to the function to be called when the clock |
| //! system interrupt occurs. |
| //! |
| //! This function registers the handler to be called when a clock system |
| //! interrupt occurs. This function enables the global interrupt in the |
| //! interrupt controller; specific flash controller interrupts must be enabled |
| //! via FlashCtl_enableInterrupt(). It is the interrupt handler's |
| //! responsibility to clear the interrupt source via |
| //! FlashCtl_clearInterruptFlag(). |
| //! |
| //! \sa Interrupt_registerInterrupt() for important information about |
| //! registering interrupt handlers. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_registerInterrupt(void (*intHandler)(void)); |
| |
| //***************************************************************************** |
| // |
| //! Unregisters the interrupt handler for the flash system. |
| //! |
| //! This function unregisters the handler to be called when a clock system |
| //! interrupt occurs. This function also masks off the interrupt in the |
| //! interrupt controller so that the interrupt handler no longer is called. |
| //! |
| //! \sa Interrupt_registerInterrupt() for important information about |
| //! registering interrupt handlers. |
| //! |
| //! \return None. |
| // |
| //***************************************************************************** |
| extern void FlashCtl_unregisterInterrupt(void); |
| |
| |
| //***************************************************************************** |
| // |
| //! Initiates a sector erase of MAIN or INFO flash memory. Note that this |
| //! function simply initaites the sector erase, but does no verification |
| //! which is required by the flash controller. The user must manually set |
| //! and enable interrupts on the flash controller to fire on erase completion |
| //! and then use the FlashCtl_verifyMemory function to verify that the sector |
| //! was actually erased |
| //! |
| //! \param addr The start of the sector to erase. Note that with flash, |
| //! the minimum allowed size that can be erased is a flash sector |
| //! (which is 4KB on the MSP432 family). If an address is provided to |
| //! this function which is not on a 4KB boundary, the entire sector |
| //! will still be erased. |
| //! |
| //! \return None |
| // |
| //***************************************************************************** |
| extern void FlashCtl_initiateSectorErase(uint32_t addr); |
| |
| |
| /* The following functions are advanced functions that are used by the flash |
| * driver to remask a failed bit in the event of a post or pre verification |
| * failure. They are meant to be advanced functions and should not be used |
| * by the majority of users (unless you are writing your own flash driver). |
| */ |
| extern uint8_t __FlashCtl_remaskData8Post(uint8_t data, uint32_t addr); |
| extern uint8_t __FlashCtl_remaskData8Pre(uint8_t data, uint32_t addr); |
| extern uint32_t __FlashCtl_remaskData32Post(uint32_t data, uint32_t addr); |
| extern uint32_t __FlashCtl_remaskData32Pre(uint32_t data, uint32_t addr); |
| extern void __FlashCtl_remaskBurstDataPost(uint32_t addr, uint32_t size); |
| extern void __FlashCtl_remaskBurstDataPre(uint32_t addr, uint32_t size); |
| |
| //***************************************************************************** |
| // |
| // Mark the end of the C bindings section for C++ compilers. |
| // |
| //***************************************************************************** |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| //***************************************************************************** |
| // |
| // Close the Doxygen group. |
| //! @} |
| // |
| //***************************************************************************** |
| |
| #endif // __FLASH_H__ |
