flash_a.h

Go to the documentation of this file.

/* --COPYRIGHT--,BSD
 * Copyright (c) 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:
 *
 * *  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_A_H__
#define __FLASH_A_H__

#include <stdbool.h>
#include <ti/devices/msp432p4xx/inc/msp.h>

/* Define to ensure that our current MSP432 has the FLCTL_A module. This
    definition is included in the device specific header file */
#ifdef __MCU_HAS_FLCTL_A__

//*****************************************************************************
//
//
//*****************************************************************************

//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C"
{
#endif

//*****************************************************************************
//
// Control specific variables
//
//*****************************************************************************
#define FLASH_A_BURST_PRG_BIT 0x03
#define FLASH_A_SECTOR_SIZE 4096

/* Interrupts */
#define FLASH_A_PROGRAM_ERROR         FLCTL_A_IFG_PRG_ERR
#define FLASH_A_BENCHMARK_INT         FLCTL_A_IFG_BMRK
#define FLASH_A_ERASE_COMPLETE        FLCTL_A_IFG_ERASE
#define FLASH_A_BRSTPRGM_COMPLETE     FLCTL_A_IFG_PRGB
#define FLASH_A_WRDPRGM_COMPLETE      FLCTL_A_IFG_PRG
#define FLASH_A_POSTVERIFY_FAILED     FLCTL_A_IFG_AVPST
#define FLASH_A_PREVERIFY_FAILED      FLCTL_A_IFG_AVPRE
#define FLASH_A_BRSTRDCMP_COMPLETE    FLCTL_A_IFG_RDBRST

#define FLASH_A_NORMAL_READ_MODE            FLCTL_A_BANK0_RDCTL_RD_MODE_0
#define FLASH_A_MARGIN0_READ_MODE           FLCTL_A_BANK0_RDCTL_RD_MODE_1
#define FLASH_A_MARGIN1_READ_MODE           FLCTL_A_BANK0_RDCTL_RD_MODE_2
#define FLASH_A_PROGRAM_VERIFY_READ_MODE    FLCTL_A_BANK0_RDCTL_RD_MODE_3
#define FLASH_A_ERASE_VERIFY_READ_MODE      FLCTL_A_BANK0_RDCTL_RD_MODE_4
#define FLASH_A_LEAKAGE_VERIFY_READ_MODE    FLCTL_A_BANK0_RDCTL_RD_MODE_5
#define FLASH_A_MARGIN0B_READ_MODE          FLCTL_A_BANK0_RDCTL_RD_MODE_9
#define FLASH_A_MARGIN1B_READ_MODE          FLCTL_A_BANK0_RDCTL_RD_MODE_10

#define FLASH_A_PRGBRSTCTLSTAT_BURSTSTATUS_COMPLETE FLCTL_A_PRGBRST_CTLSTAT_BURST_STATUS_7

#define FLASH_A_BANK0                 0x00
#define FLASH_A_BANK1                 0x01
#define FLASH_A_DATA_READ             0x00
#define FLASH_A_INSTRUCTION_FETCH     0x01

#define FLASH_A_MAIN_MEMORY_SPACE_BANK0     0x01
#define FLASH_A_MAIN_MEMORY_SPACE_BANK1     0x02
#define FLASH_A_INFO_MEMORY_SPACE_BANK0      0x03
#define FLASH_A_INFO_MEMORY_SPACE_BANK1      0x04

#define FLASH_A_MAIN_SPACE    FLCTL_A_RDBRST_CTLSTAT_MEM_TYPE_0
#define FLASH_A_INFO_SPACE    FLCTL_A_RDBRST_CTLSTAT_MEM_TYPE_1
#define FLASH_A_1_PATTERN FLCTL_A_RDBRST_CTLSTAT_DATA_CMP
#define FLASH_A_0_PATTERN 0x00

#define FLASH_A_SECTOR0               FLCTL_A_BANK0_MAIN_WEPROT_PROT0
#define FLASH_A_SECTOR1               FLCTL_A_BANK0_MAIN_WEPROT_PROT1
#define FLASH_A_SECTOR2               FLCTL_A_BANK0_MAIN_WEPROT_PROT2
#define FLASH_A_SECTOR3               FLCTL_A_BANK0_MAIN_WEPROT_PROT3
#define FLASH_A_SECTOR4               FLCTL_A_BANK0_MAIN_WEPROT_PROT4
#define FLASH_A_SECTOR5               FLCTL_A_BANK0_MAIN_WEPROT_PROT5
#define FLASH_A_SECTOR6               FLCTL_A_BANK0_MAIN_WEPROT_PROT6
#define FLASH_A_SECTOR7               FLCTL_A_BANK0_MAIN_WEPROT_PROT7
#define FLASH_A_SECTOR8               FLCTL_A_BANK0_MAIN_WEPROT_PROT8
#define FLASH_A_SECTOR9               FLCTL_A_BANK0_MAIN_WEPROT_PROT9
#define FLASH_A_SECTOR10              FLCTL_A_BANK0_MAIN_WEPROT_PROT10
#define FLASH_A_SECTOR11              FLCTL_A_BANK0_MAIN_WEPROT_PROT11
#define FLASH_A_SECTOR12              FLCTL_A_BANK0_MAIN_WEPROT_PROT12
#define FLASH_A_SECTOR13              FLCTL_A_BANK0_MAIN_WEPROT_PROT13
#define FLASH_A_SECTOR14              FLCTL_A_BANK0_MAIN_WEPROT_PROT14
#define FLASH_A_SECTOR15              FLCTL_A_BANK0_MAIN_WEPROT_PROT15
#define FLASH_A_SECTOR16              FLCTL_A_BANK0_MAIN_WEPROT_PROT16
#define FLASH_A_SECTOR17              FLCTL_A_BANK0_MAIN_WEPROT_PROT17
#define FLASH_A_SECTOR18              FLCTL_A_BANK0_MAIN_WEPROT_PROT18
#define FLASH_A_SECTOR19              FLCTL_A_BANK0_MAIN_WEPROT_PROT19
#define FLASH_A_SECTOR20              FLCTL_A_BANK0_MAIN_WEPROT_PROT20
#define FLASH_A_SECTOR21              FLCTL_A_BANK0_MAIN_WEPROT_PROT21
#define FLASH_A_SECTOR22              FLCTL_A_BANK0_MAIN_WEPROT_PROT22
#define FLASH_A_SECTOR23              FLCTL_A_BANK0_MAIN_WEPROT_PROT23
#define FLASH_A_SECTOR24              FLCTL_A_BANK0_MAIN_WEPROT_PROT24
#define FLASH_A_SECTOR25              FLCTL_A_BANK0_MAIN_WEPROT_PROT25
#define FLASH_A_SECTOR26              FLCTL_A_BANK0_MAIN_WEPROT_PROT26
#define FLASH_A_SECTOR27              FLCTL_A_BANK0_MAIN_WEPROT_PROT27
#define FLASH_A_SECTOR28              FLCTL_A_BANK0_MAIN_WEPROT_PROT28
#define FLASH_A_SECTOR29              FLCTL_A_BANK0_MAIN_WEPROT_PROT29
#define FLASH_A_SECTOR30              FLCTL_A_BANK0_MAIN_WEPROT_PROT30
#define FLASH_A_SECTOR31              FLCTL_A_BANK0_MAIN_WEPROT_PROT31

#define FLASH_A_NOVER     0
#define FLASH_A_BURSTPOST FLCTL_A_PRGBRST_CTLSTAT_AUTO_PST
#define FLASH_A_BURSTPRE FLCTL_A_PRGBRST_CTLSTAT_AUTO_PRE
#define FLASH_A_REGPRE FLCTL_A_PRG_CTLSTAT_VER_PRE
#define FLASH_A_REGPOST FLCTL_A_PRG_CTLSTAT_VER_PST
#define FLASH_A_FULLVER (FLCTL_A_PRGBRST_CTLSTAT_AUTO_PST |                        \
                FLCTL_A_PRGBRST_CTLSTAT_AUTO_PRE | FLCTL_A_PRG_CTLSTAT_VER_PRE \
                | FLCTL_A_PRG_CTLSTAT_VER_PST)

#define FLASH_A_COLLATED_WRITE_MODE  0x01
#define FLASH_A_IMMEDIATE_WRITE_MODE 0x02

/* Internal parameters/definitions */
#define __INFO_FLASH_A_TECH_START__  0x00200000
#define __INFO_FLASH_A_TECH_MIDDLE__ 0x00204000

typedef struct __sFlashCtl_ProtectionRegister
{
    uint32_t B0_MAIN_R0;
    uint32_t B0_MAIN_R1;
    uint32_t B0_MAIN_R2;
    uint32_t B0_MAIN_R3;
    uint32_t B0_MAIN_R4;
    uint32_t B0_MAIN_R5;
    uint32_t B0_MAIN_R6;
    uint32_t B0_MAIN_R7;
    uint32_t B1_MAIN_R0;
    uint32_t B1_MAIN_R1;
    uint32_t B1_MAIN_R2;
    uint32_t B1_MAIN_R3;
    uint32_t B1_MAIN_R4;
    uint32_t B1_MAIN_R5;
    uint32_t B1_MAIN_R6;
    uint32_t B1_MAIN_R7;
    uint32_t B0_INFO_R0;
    uint32_t B1_INFO_R0;
} __FlashCtl_ProtectionRegister;

//*****************************************************************************
//
// Prototypes for the APIs.
//
//*****************************************************************************

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_getMemoryInfo(uint32_t addr, uint32_t *bankNum,
            uint32_t *sectorNum);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_enableReadBuffering(uint_fast8_t memoryBank,
        uint_fast8_t accessMethod);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_disableReadBuffering(uint_fast8_t memoryBank,
        uint_fast8_t accessMethod);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_protectMemory(uint32_t startAddr, uint32_t endAddr);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_unprotectMemory(uint32_t startAddr, uint32_t endAddr);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_isMemoryRangeProtected(uint32_t startAddr,
        uint32_t endAddr);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_isMemoryProtected(uint32_t addr);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_verifyMemory(void* verifyAddr, uint32_t length,
    uint_fast8_t pattern);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_performMassErase(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_initiateMassErase(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_eraseSector(uint32_t addr);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_programMemory(void* src, void* dest,
        uint32_t length);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_setProgramVerification(uint32_t verificationSetting);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_clearProgramVerification(
        uint32_t verificationSetting);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_enableWordProgramming(uint32_t mode);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_disableWordProgramming(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashCtl_A_isWordProgrammingEnabled(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern bool FlashCtl_A_setReadMode(uint32_t flashBank, uint32_t readMode);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashCtl_A_getReadMode(uint32_t flashBank);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_setWaitState(uint32_t bank, uint32_t waitState);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashCtl_A_getWaitState(uint32_t bank);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_enableInterrupt(uint32_t flags);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_disableInterrupt(uint32_t flags);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashCtl_A_getEnabledInterruptStatus(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashCtl_A_getInterruptStatus(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_clearInterruptFlag(uint32_t flags);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_registerInterrupt(void (*intHandler)(void));

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_unregisterInterrupt(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void FlashCtl_A_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_A_remaskData8Post(uint8_t data, uint32_t addr);
extern uint8_t __FlashCtl_A_remaskData8Pre(uint8_t data, uint32_t addr);
extern uint32_t __FlashCtl_A_remaskData32Post(uint32_t data, uint32_t addr);
extern uint32_t __FlashCtl_A_remaskData32Pre(uint32_t data, uint32_t addr);
extern void __FlashCtl_A_remaskBurstDataPost(uint32_t addr, uint32_t size);
extern void __FlashCtl_A_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 /* __MCU_HAS_FLCTL_A__ */

#endif // __FLASH_A_H__