flashsafe.h

Go to the documentation of this file.

/******************************************************************************
*  Filename:       flashsafe.h
*  Revised:        2015-09-21 15:19:36 +0200 (Mon, 21 Sep 2015)
*  Revision:       44629
*
*  Description:    Defines and prototypes for the Flash driver in
*                  Thread safe mode.
*
*  Copyright (c) 2015, 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.
*
******************************************************************************/

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

#ifndef __FLASHSAFE_H__
#define __FLASHSAFE_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_fcfg1.h>
#include <driverlib/interrupt.h>
#include <driverlib/debug.h>
#include <driverlib/flash.h>
#include <driverlib/rom.h>
#include <driverlib/smph.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 FlashsafeSizeGet                NOROM_FlashsafeSizeGet
    #define FlashsafeSectorSizeGet          NOROM_FlashsafeSectorSizeGet
    #define FlashsafePowerModeSet           NOROM_FlashsafePowerModeSet
    #define FlashsafePowerModeGet           NOROM_FlashsafePowerModeGet
    #define FlashsafeProtectionSet          NOROM_FlashsafeProtectionSet
    #define FlashsafeProtectionGet          NOROM_FlashsafeProtectionGet
    #define FlashsafeProtectionSave         NOROM_FlashsafeProtectionSave
    #define FlashsafeCheckFsmForError       NOROM_FlashsafeCheckFsmForError
    #define FlashsafeCheckFsmForReady       NOROM_FlashsafeCheckFsmForReady
    #define FlashsafeIntRegister            NOROM_FlashsafeIntRegister
    #define FlashsafeIntUnregister          NOROM_FlashsafeIntUnregister
    #define FlashsafeIntEnable              NOROM_FlashsafeIntEnable
    #define FlashsafeIntDisable             NOROM_FlashsafeIntDisable
    #define FlashsafeIntStatus              NOROM_FlashsafeIntStatus
    #define FlashsafeIntClear               NOROM_FlashsafeIntClear
    #define FlashsafeSectorErase            NOROM_FlashsafeSectorErase
    #define FlashsafeProgram                NOROM_FlashsafeProgram
    #define FlashsafeDisableSectorsForWrite NOROM_FlashsafeDisableSectorsForWrite
#endif

//*****************************************************************************
//
// Values that can be returned from the API functions
//
//*****************************************************************************

#define FLASHSAFE_ACCESS_DENIED 0x000000ff
#define FLASHSAFE_ACCESS_OK     0x000000ee
#define SMPH_ALLOC_FLASH   1

//*****************************************************************************
//
// 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 FlashsafeIntEnable(), FlashsafeIntDisable() and FlashsafeIntClear() and
// returned from FlashsafeIntStatus().
//
//*****************************************************************************
#define FLASH_INT_FSM_DONE      0x00400000  // FSM Done Interrupt Mask
#define FLASH_INT_RV            0x00010000  // Read Verify error Interrupt Mask

//*****************************************************************************
//
// Values passed to FlashsafeSetPowerMode() and returned from FlashsafeGetPowerMode().
//
//*****************************************************************************
#define FLASH_PWR_ACTIVE_MODE   0x00000000
#define FLASH_PWR_OFF_MODE      0x00000001
#define FLASH_PWR_DEEP_STDBY_MODE \
                                0x00000002

//*****************************************************************************
//
// Values passed to FlashsafeSetProtection() and returned from FlashsafeGetProtection().
//
//*****************************************************************************
#define FLASH_NO_PROTECT        0x00000000 // Sector not protected
#define FLASH_WRITE_PROTECT     0x00000001 // Sector erase and program
                                           // protected

//*****************************************************************************
//
// Defines for values written to the FLASH_O_FSM_WR_ENA register
//
//*****************************************************************************
#define FSM_REG_WRT_ENABLE     5
#define FSM_REG_WRT_DISABLE    2

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE bool
FlashsafeSMPHTryAcquire(void)
{
    return(SMPHTryAcquire(SMPH_ALLOC_FLASH));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
FlashsafeSMPHRelease(void)
{
    SMPHRelease(SMPH_ALLOC_FLASH);
}

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

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

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafePowerModeSet(uint32_t ui32PowerMode,
                                      uint32_t ui32BankGracePeriode,
                                      uint32_t ui32PumpGracePeriode);

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

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeProtectionSet(uint32_t ui32SectorAddress,
                                       uint32_t ui32ProtectMode);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeProtectionGet(uint32_t ui32SectorAddress);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeProtectionSave(uint32_t ui32SectorAddress);

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

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

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeIntRegister(void (*pfnHandler)(void));

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

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeIntEnable(uint32_t ui32IntFlags);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeIntDisable(uint32_t ui32IntFlags);

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

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeIntClear(uint32_t ui32IntFlags);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeSectorErase(uint32_t ui32SectorAddress);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeProgram(uint8_t *pui8DataBuffer, uint32_t ui32Address,
                                 uint32_t ui32Count);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t FlashsafeDisableSectorsForWrite(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_FlashsafeSizeGet
        #undef  FlashsafeSizeGet
        #define FlashsafeSizeGet                ROM_FlashsafeSizeGet
    #endif
    #ifdef ROM_FlashsafeSectorSizeGet
        #undef  FlashsafeSectorSizeGet
        #define FlashsafeSectorSizeGet          ROM_FlashsafeSectorSizeGet
    #endif
    #ifdef ROM_FlashsafePowerModeSet
        #undef  FlashsafePowerModeSet
        #define FlashsafePowerModeSet           ROM_FlashsafePowerModeSet
    #endif
    #ifdef ROM_FlashsafePowerModeGet
        #undef  FlashsafePowerModeGet
        #define FlashsafePowerModeGet           ROM_FlashsafePowerModeGet
    #endif
    #ifdef ROM_FlashsafeProtectionSet
        #undef  FlashsafeProtectionSet
        #define FlashsafeProtectionSet          ROM_FlashsafeProtectionSet
    #endif
    #ifdef ROM_FlashsafeProtectionGet
        #undef  FlashsafeProtectionGet
        #define FlashsafeProtectionGet          ROM_FlashsafeProtectionGet
    #endif
    #ifdef ROM_FlashsafeProtectionSave
        #undef  FlashsafeProtectionSave
        #define FlashsafeProtectionSave         ROM_FlashsafeProtectionSave
    #endif
    #ifdef ROM_FlashsafeCheckFsmForError
        #undef  FlashsafeCheckFsmForError
        #define FlashsafeCheckFsmForError       ROM_FlashsafeCheckFsmForError
    #endif
    #ifdef ROM_FlashsafeCheckFsmForReady
        #undef  FlashsafeCheckFsmForReady
        #define FlashsafeCheckFsmForReady       ROM_FlashsafeCheckFsmForReady
    #endif
    #ifdef ROM_FlashsafeIntRegister
        #undef  FlashsafeIntRegister
        #define FlashsafeIntRegister            ROM_FlashsafeIntRegister
    #endif
    #ifdef ROM_FlashsafeIntUnregister
        #undef  FlashsafeIntUnregister
        #define FlashsafeIntUnregister          ROM_FlashsafeIntUnregister
    #endif
    #ifdef ROM_FlashsafeIntEnable
        #undef  FlashsafeIntEnable
        #define FlashsafeIntEnable              ROM_FlashsafeIntEnable
    #endif
    #ifdef ROM_FlashsafeIntDisable
        #undef  FlashsafeIntDisable
        #define FlashsafeIntDisable             ROM_FlashsafeIntDisable
    #endif
    #ifdef ROM_FlashsafeIntStatus
        #undef  FlashsafeIntStatus
        #define FlashsafeIntStatus              ROM_FlashsafeIntStatus
    #endif
    #ifdef ROM_FlashsafeIntClear
        #undef  FlashsafeIntClear
        #define FlashsafeIntClear               ROM_FlashsafeIntClear
    #endif
    #ifdef ROM_FlashsafeSectorErase
        #undef  FlashsafeSectorErase
        #define FlashsafeSectorErase            ROM_FlashsafeSectorErase
    #endif
    #ifdef ROM_FlashsafeProgram
        #undef  FlashsafeProgram
        #define FlashsafeProgram                ROM_FlashsafeProgram
    #endif
    #ifdef ROM_FlashsafeDisableSectorsForWrite
        #undef  FlashsafeDisableSectorsForWrite
        #define FlashsafeDisableSectorsForWrite ROM_FlashsafeDisableSectorsForWrite
    #endif
#endif

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

#endif // __FLASHSAFE_H__

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