[flash.h] Flash

Functions
static uint32_t	FlashSectorSizeGet (void)
	Get size of a flash sector in number of bytes. More...
static uint32_t	FlashSizeGet (void)
	Get the size of the flash. More...
void	FlashPowerModeSet (uint32_t ui32PowerMode, uint32_t ui32BankGracePeriod, uint32_t ui32PumpGracePeriod)
	Set power mode. More...
uint32_t	FlashPowerModeGet (void)
	Get current configured power mode. More...
void	FlashProtectionSet (uint32_t ui32SectorAddress, uint32_t ui32ProtectMode)
	Set sector protection. More...
uint32_t	FlashProtectionGet (uint32_t ui32SectorAddress)
	Get sector protection. More...
uint32_t	FlashProtectionSave (uint32_t ui32SectorAddress)
	Save sector protection to make it permanent. More...
static uint32_t	FlashCheckFsmForError (void)
	Checks if the Flash state machine has detected an error. More...
static uint32_t	FlashCheckFsmForReady (void)
	Checks if the Flash state machine is ready. More...
static void	FlashIntRegister (void(*pfnHandler)(void))
	Registers an interrupt handler for the flash interrupt in the dynamic interrupt table. More...
static void	FlashIntUnregister (void)
	Unregisters the interrupt handler for the flash interrupt in the dynamic interrupt table. More...
static void	FlashIntEnable (uint32_t ui32IntFlags)
	Enables flash controller interrupt sources. More...
static void	FlashIntDisable (uint32_t ui32IntFlags)
	Disables individual flash controller interrupt sources. More...
static uint32_t	FlashIntStatus (void)
	Gets the current interrupt status. More...
static void	FlashIntClear (uint32_t ui32IntFlags)
	Clears flash controller interrupt source. More...
uint32_t	FlashSectorErase (uint32_t ui32SectorAddress)
	Erase a flash sector. More...
uint32_t	FlashProgram (uint8_t *pui8DataBuffer, uint32_t ui32Address, uint32_t ui32Count)
	Programs unprotected flash sectors in the main bank. More...
uint32_t	FlashProgram4X (uint8_t *pui8DataBuffer, uint32_t ui32Address, uint32_t ui32Count)
uint32_t	FlashProgramNowait (uint32_t ui32StartAddress, uint8_t *pui8DataBuffer, uint8_t ui8NoOfBytes)
	Starts programming within unprotected main bank flash sector and returns. More...
bool	FlashEfuseReadRow (uint32_t *pui32EfuseData, uint32_t ui32RowAddress)
	Reads efuse data from specified row. More...
void	FlashDisableSectorsForWrite (void)
	Disables all sectors for erase and programming on the active bank. More...

Enumerations
enum	tFlashStateCommandsType {   FAPI_PROGRAM_FOURWORD = 0x0021, FAPI_PROGRAM_TWOWORD = 0x0011, FAPI_PROGRAM_ONEWORD = 0x0001, FAPI_ERASE_SECTOR = 0x0042,   FAPI_ERASE_BANK = 0x0052, FAPI_CLEAR_STATUS = 0x0005, FAPI_READVERIFY = 0x0003 }
	Defined values for Flash State Machine commands. More...

Detailed Description

Function Documentation

FlashCheckFsmForError()

static uint32_t FlashCheckFsmForError ( void  )

inlinestatic

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.

Returns

Returns status of Flash state machine:

• FAPI_STATUS_FSM_ERROR
• FAPI_STATUS_SUCCESS

Referenced by FlashProgram(), FlashProgram4X(), and FlashSectorErase().

{
    if(HWREG(NVMNW_BASE + NVMNW_O_STATCMD) & NVMNW_STATCMD_CMDPASS_M)
    {
        return(FAPI_STATUS_SUCCESS);
    }
    else
    {
        return(FAPI_STATUS_FSM_ERROR);
    }
}

FlashCheckFsmForReady()

static uint32_t FlashCheckFsmForReady ( void  )

inlinestatic

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.

Returns

Returns readiness status of Flash state machine:

• FAPI_STATUS_FSM_READY
• FAPI_STATUS_FSM_BUSY

Referenced by FlashProgram(), FlashProgram4X(), and FlashSectorErase().

{
    if(HWREG(NVMNW_BASE + NVMNW_O_STATCMD) & NVMNW_STATCMD_CMDDONE_M)
    {
        return(FAPI_STATUS_FSM_READY);
    }
    else
    {
        return(FAPI_STATUS_FSM_BUSY);
    }
}

FlashDisableSectorsForWrite()

void FlashDisableSectorsForWrite

(

void

)

Disables all sectors for erase and programming on the active bank.

This function is depreciated

Returns

None

Referenced by FlashIntClear().

{
    // depreciated
    return;
}

FlashEfuseReadRow()

bool FlashEfuseReadRow	(	uint32_t *	pui32EfuseData,
		uint32_t	ui32RowAddress
	)

Reads efuse data from specified row.

This function will read one efuse row. It is assumed that any previous efuse operation has finished.

Parameters

pui32EfuseData	is pointer to variable to be updated with efuse data.
ui32RowAddress	is the efuse row number to be read. First row is row number 0.

Returns

Returns the status of the efuse read operation.

• false : OK status.
• true : Error status

Referenced by FlashIntClear().

{
    bool bStatus;

    // Make sure the clock for the efuse is enabled
    HWREG(FLASH_BASE + FLASH_O_CFG) &= ~FLASH_CFG_DIS_EFUSECLK;

    // Set timing for EFUSE read operations.
    HWREG(FLASH_BASE + FLASH_O_EFUSEREAD) |= ((5 << FLASH_EFUSEREAD_READCLOCK_S) &
            FLASH_EFUSEREAD_READCLOCK_M);

    // Clear status register.
    HWREG(FLASH_BASE + FLASH_O_EFUSEERROR) = 0;

    // Select the FuseROM block 0.
    HWREG(FLASH_BASE + FLASH_O_EFUSEADDR) = 0x00000000;

    // Start the read operation.
    HWREG(FLASH_BASE + FLASH_O_EFUSE) =
        (DUMPWORD_INSTR << FLASH_EFUSE_INSTRUCTION_S) |
        (ui32RowAddress & FLASH_EFUSE_DUMPWORD_M);

    // Wait for operation to finish.
    while(!(HWREG(FLASH_BASE + FLASH_O_EFUSEERROR) & FLASH_EFUSEERROR_DONE))
    {
    }

    // Check if error reported.
    if(HWREG(FLASH_BASE + FLASH_O_EFUSEERROR) & FLASH_EFUSEERROR_CODE_M)
    {
        // Set error status.
        bStatus = 1;

        // Clear data.
        *pui32EfuseData = 0;
    }
    else
    {
        // Set ok status.
        bStatus = 0;

        // No error. Get data from data register.
        *pui32EfuseData = HWREG(FLASH_BASE + FLASH_O_DATALOWER);
    }

    // Disable the efuse clock to conserve power
    HWREG(FLASH_BASE + FLASH_O_CFG) |= FLASH_CFG_DIS_EFUSECLK;

    // Return the data.
    return(bStatus);

}

FlashIntClear()

static void FlashIntClear ( uint32_t  ui32IntFlags )

inlinestatic

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:

1. Write to clear event (interrupt source). (buffered write)
2. Dummy read from the event source module. (making sure the write has propagated)
3. Wait two system CPU clock cycles (user code or two NOPs). (allowing cleared event to propagate through any synchronizers)

Parameters

ui32IntFlags

is the bit mask of the interrupt sources to be cleared. Can be any of: FLASH_INT_FSM_DONE FLASH_INT_RV

Returns

None

{
    HWREG(NVMNW_BASE  + NVMNW_O_ICLR) = NVMNW_ICLR_DONE_CLR;
}

Here is the call graph for this function:

FlashIntDisable()

static void FlashIntDisable ( uint32_t  ui32IntFlags )

inlinestatic

Disables individual flash controller interrupt sources.

This function disables the flash controller interrupt sources.

Parameters

ui32IntFlags

is the bit mask of the interrupt sources to be disabled. The parameter is the bitwise OR of any of the following: FLASH_INT_FSM_DONE : FSM Done interrupt. FLASH_INT_RV : Read verify error interrupt.

Returns

None

{
    HWREG(NVMNW_BASE  + NVMNW_O_IMASK) = NVMNW_IMASK_DONE_DISABLED;
}

FlashIntEnable()

static void FlashIntEnable ( uint32_t  ui32IntFlags )

inlinestatic

Enables flash controller interrupt sources.

This function enables the flash controller interrupt sources.

Parameters

ui32IntFlags

is the bit mask of the interrupt sources to be enabled. The parameter is the bitwise OR of any of the following: FLASH_INT_FSM_DONE : FSM Done interrupt. FLASH_INT_RV : Read verify error interrupt.

Returns

None

{
    HWREG(NVMNW_BASE  + NVMNW_O_IMASK) = NVMNW_IMASK_DONE_ENABLED;
}

FlashIntRegister()

static void FlashIntRegister ( void(*)(void)  pfnHandler )

inlinestatic

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 FlashIntEnable(). It is the interrupt handler's responsibility to clear the interrupt source.

Parameters

pfnHandler

is a pointer to the function to be called when the flash interrupt occurs.

Returns

None

See also

IntRegister() for important information about registering interrupt handlers.

{
    // Register the interrupt handler.
    IntRegister(INT_FLASH, pfnHandler);

    // Enable the flash interrupt.
    IntEnable(INT_FLASH);
}

Here is the call graph for this function:

FlashIntStatus()

static uint32_t FlashIntStatus ( void  )

inlinestatic

Gets the current interrupt status.

This function returns the interrupt status for the Flash.

Returns

Returns the current interrupt status as values described in FlashIntEnable().

{
    uint32_t ui32IntFlags;

    ui32IntFlags = 0;
    if (HWREG(NVMNW_BASE  + NVMNW_O_RIS) & NVMNW_RIS_DONE_M)
    {
        ui32IntFlags = NVMNW_RIS_DONE_SET;
    }
    else
    {
        ui32IntFlags = NVMNW_RIS_DONE_CLR;
    }
    return(ui32IntFlags);
}

FlashIntUnregister()

static void FlashIntUnregister ( void  )

inlinestatic

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.

Returns

None

See also

IntRegister() for important information about registering interrupt handlers.

{
    // Disable the interrupts.
    IntDisable(INT_FLASH);

    // Unregister the interrupt handler.
    IntUnregister(INT_FLASH);
}

Here is the call graph for this function:

FlashPowerModeGet()

uint32_t FlashPowerModeGet

(

void

)

Get current configured power mode.

This function is depreciated

Returns

Returns the current configured power mode. The defined power modes are:

• FLASH_PWR_ACTIVE_MODE
• FLASH_PWR_OFF_MODE
• FLASH_PWR_DEEP_STDBY_MODE (Not to be used. This mode is deprecated.)

Referenced by FlashSizeGet().

{
    // depreciated
    return (FAPI_STATUS_NOSUPPORT_ERROR);
}

FlashPowerModeSet()

void FlashPowerModeSet	(	uint32_t	ui32PowerMode,
		uint32_t	ui32BankGracePeriod,
		uint32_t	ui32PumpGracePeriod
	)

Set power mode.

This function is depreciated

Parameters

ui32PowerMode	is the wanted power mode. The defined flash power modes are: FLASH_PWR_ACTIVE_MODE FLASH_PWR_OFF_MODE FLASH_PWR_DEEP_STDBY_MODE (Not to be used. This mode is deprecated.)
ui32BankGracePeriod	is the starting count value for the bank grace period down counter.
ui32PumpGracePeriod	is the starting count value for the pump grace period down counter.

Returns

None

Referenced by FlashSizeGet().

{
    // depreciaed
    return ;
}

FlashProgram()

uint32_t FlashProgram	(	uint8_t *	pui8DataBuffer,
		uint32_t	ui32Address,
		uint32_t	ui32Count
	)

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 VIMSModeSafeSet(), VIMSLineBufDisable(), and 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 pui8DataBuffer pointer can not point to flash.

Parameters

pui8DataBuffer	is a pointer to the data to be programmed.
ui32Address	is the starting address in flash to be programmed.
ui32Count	is the number of bytes to be programmed.

Returns

Returns status of the flash programming:

• FAPI_STATUS_SUCCESS : Success.
• FAPI_STATUS_INCORRECT_DATABUFFER_LENGTH : Too many bytes were requested.
• FAPI_STATUS_FSM_ERROR : A programming error is encountered.

Referenced by FlashIntClear(), FlashProtectionSave(), and FlashSectorErase().

{
    // The below code part constitutes the variant of the FlashProgram() function
    // that is located in ROM. The source code of this variant is not visible in
    // internal or external driverlib. The source code is only compiled during a ROM
    // build.
    // The two above code parts (seperated by compile switches) constitute wrapper
    // functions which both call this ROM variant of the function.
    // The ROM variant is called by referrencing it directly through the ROM API table.
    uint32_t ui32StartIndex;
    uint32_t ui32StopIndex;
    uint8_t ui8BankWidth;
    uint8_t ui8NoOfBytes;
    uint32_t ui32ErrorReturn;
    uint32_t ui32SectorNum;
    uint32_t ui32BankNum;
    uint32_t ui32Region;
    uint32_t bank0Size;
    uint32_t ui32NoOfSectorsBank0;
    tFlashStateCommandsType StateMachineCmd;
    uint32_t sectorSize;

    sectorSize = FlashSectorSizeGet();

    // Check the arguments.
    // onlt main region and non-main CCFG
    ui32BankNum = 0;
    if  ( (ui32Address + ui32Count) <= (FLASHMEM_BASE + FlashSizeGet()) )
    {
        bank0Size = ((HWREG(NVMNW_BASE + NVMNW_O_BANK0INFO0) &
                       NVMNW_BANK0INFO0_MAINSIZE_M) >>
                       NVMNW_BANK0INFO0_MAINSIZE_S) * sectorSize;

        if (ui32Address >= bank0Size)
            ui32BankNum = 1;

        // address is in the main region
        ui32Region = NVMNW_CMDCTL_REGIONSEL_MAIN ;

        ui32NoOfSectorsBank0 = (HWREG(NVMNW_BASE + NVMNW_O_BANK0INFO0) &
                                NVMNW_BANK0INFO0_MAINSIZE_M) >>
                                NVMNW_BANK0INFO0_MAINSIZE_S;
    }
    else if ( ( ui32Address >= (CCFG_BASE_DEFAULT) ) &&
              ( (ui32Address + ui32Count) <= (CCFG_BASE_DEFAULT + sectorSize) ) )
    {
        // the address is CCFG in non-main region (bank 0)
        ui32Region = NVMNW_CMDCTL_REGIONSEL_NONMAIN ;
        ui32BankNum = 0;

    }
    else if ( ( ui32Address >= (FCFG1_BASE) ) &&
              ( (ui32Address + ui32Count) <= (FCFG1_BASE + sectorSize) ) )
    {
        // the address is FCFG1 in non-main region, ( bank 1 )
        ui32Region = NVMNW_CMDCTL_REGIONSEL_NONMAIN ;
        ui32BankNum = 1;

    }
    else
    {   // address is wrong
        return FAPI_STATUS_ADDRESS_ERROR;
    }

    // Set the status to indicate success.
    ui32ErrorReturn = FAPI_STATUS_SUCCESS;

    // Find flash bank width in number of bytes.
    ui8BankWidth = (((HWREG(NVMNW_BASE + NVMNW_O_GBLINFO1) &
                      NVMNW_GBLINFO1_DATAWIDTH_M ) >>
                      NVMNW_GBLINFO1_DATAWIDTH_S) >> 3);

    // dataIndex =0 for all modes (1X,2X,4X)
    HWREG(NVMNW_BASE + NVMNW_O_CMDDATAINDEX) = 0x0000;

    while ( ui32Count)
    {
        // Clear the Status register.
        IssueFsmCommand(FAPI_CLEAR_STATUS);

        // set up WEPROT register
        // based on the flash address to figure out WEPROT register for each state machine command
        if ( ui32Region == NVMNW_CMDCTL_REGIONSEL_MAIN)
        {   // for main region
            // based on the flash address, get the sector number on fly
            ui32SectorNum = (ui32Address - FLASHMEM_BASE) / sectorSize;

            // for main flash region
            // Unprotect sector to be erased.
            // sectorNum = sectorAddr / sectorSize
            // if sectorNum < 256 (number of sector in bank0)
            //  set bankNum =0
            // else set bankNum =1
            //
            // if sectorNum<32, it is the first 32 sector, it is 2K protect, use the rgister A
            //      registerA = 1<<sectorNum
            // if sector>=32 and sector<256, select bank0, registerB
            //      registerB = 1<< ( (sectorNum-32)/8 + 4)
            //  if (sector>256)
            //      select Bank=1, registerB = 1<< (sectorNum-256)/8
            //

            // set up Dynamic Write/Erase Protect to unprotect mode (clear the bit)
            if ( ui32SectorNum < 32)
            {
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTA) &= ~(1 << ui32SectorNum);
            }
            else if ( ui32SectorNum < ui32NoOfSectorsBank0)
            {
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTB) &=  ~( 1 << ((ui32SectorNum-32)/8 + 4));
            }
            else
            {
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTB) &= ~( 1 << ((ui32SectorNum - ui32NoOfSectorsBank0)/8));
            }

            // set up the command address, translate to Flash word adress
            // address is relative to each bank, translate to Flash word address
            HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = (ui32Address & ( bank0Size -1) )>> 4;
        }
        else
        {   // for NON-main region (CCFG) and FCFG1
            if ( ui32BankNum == 0)
            {
                // the address is CCFG in non-main region
                ui32SectorNum = (ui32Address - CCFG_BASE_DEFAULT) / sectorSize;
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTNM) &=  ~( 1 << (ui32SectorNum ));

                // set up the command address, translate to Flash word adress
                // address is relative to each bank, translate to Flash word address
                HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = (ui32Address - CCFG_BASE_DEFAULT )>> 4;
            }
            else
            {
                // the address is FCFG1 in non-main region
                ui32SectorNum = (ui32Address - FCFG1_BASE) / sectorSize;
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTNM) &=  ~( 1 << (ui32SectorNum ));

                // set up the command address, translate to Flash word adress
                // address is relative to each bank, translate to Flash word address
                HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = (ui32Address - FCFG1_BASE )>> 4;

            }
        }

        // set up NW control register
        /*
            21   enable data verification for 1T only
            19   Stair Step Erase =0
            18   erase mask disable 0
            17   Program mask disable (0)
            16   ECC override (no ECC) 0
            15   address translate overrid =1
            14   post verify enable (1)
            13   preverify enable (1)
            12:9 regionsel = 1 (main region)/Non-Main
            8:4  bank selection = 0 or 1
            3:0  N/A (only for mode change)
        */

        HWREG(NVMNW_BASE + NVMNW_O_CMDCTL) = (NVMNW_CMDCTL_BANKSEL_BANK0 <<(ui32BankNum)) |
                                              NVMNW_CMDCTL_DATAVEREN |
                                              (ui32Region) |
                                              NVMNW_CMDCTL_ADDRXLATEOVR_OVERRIDE |
                                              NVMNW_CMDCTL_POSTVEREN_ENABLE |
                                              NVMNW_CMDCTL_PREVEREN_ENABLE ;

        // based on the ui32Address alignment and ui32Count to figure oue
        // 1. if ui32Address is 4X Flashword aligned and ui32Count>=4X flashword
        //      goto 4X program mode
        // 2. if ui32Address is 2X Flashword aligned and ui32Count>=2X flashword
        //      goto 2X program mode
        // 3. otherwise
        //      goto 1X program mode (default mode)

        if ( (( ui32Address & ( FLASHWORDSIZE_FOUR -1 ) ) == 0x00 ) &&
             ( ui32Count >= FLASHWORDSIZE_FOUR ) )
        {   // 4X program mode
            ui8NoOfBytes = FlashCopyMultiFlashWordToHW (pui8DataBuffer,ui32Address,FLASHWORDSIZE_FOUR);

            StateMachineCmd = FAPI_PROGRAM_FOURWORD;
        }
        else if ( (( ui32Address & ( FLASHWORDSIZE_TWO -1 ) ) == 0x00 ) &&
                  ( ui32Count >= FLASHWORDSIZE_TWO ) )
        {   // 2X program mode
            ui8NoOfBytes = FlashCopyMultiFlashWordToHW (pui8DataBuffer,ui32Address,FLASHWORDSIZE_TWO);

            StateMachineCmd = FAPI_PROGRAM_TWOWORD;
        }
        else
        {   // 1X program mode

            // Setup the start position within the write data registers.
            ui32StartIndex = ui32Address & (uint32_t)(ui8BankWidth - 1);

            // setup number of bytes to program
            ui8NoOfBytes = ui8BankWidth - ui32StartIndex;
            if(ui8NoOfBytes > ui32Count)
            {
                ui8NoOfBytes = ui32Count;
            }

            // Setup the stop position within the write data registers.
            ui32StopIndex = ui32StartIndex + (uint32_t)(ui8NoOfBytes - 1);

            // Write each byte to the Flash Data registers
            FlashCopyOneFlashWordToHW(pui8DataBuffer,ui32Address,
                                       ui32StartIndex,ui32StopIndex);
            StateMachineCmd = FAPI_PROGRAM_ONEWORD;
        }

        // Issue the Program command to the FSM.
        IssueFsmCommand(StateMachineCmd);

        // Wait until the word has been programmed.
        while(FlashCheckFsmForReady() == FAPI_STATUS_FSM_BUSY)
        {
        }

        // Exit if an access violation occurred.
        ui32ErrorReturn = FlashCheckFsmForError();
        if(ui32ErrorReturn != FAPI_STATUS_SUCCESS)
        {
            break;
        }

        // Prepare for next data burst.
        ui32Count       -= ui8NoOfBytes;
        ui32Address     += ui8NoOfBytes;
        pui8DataBuffer  += ui8NoOfBytes;

        // Check if next data burst require change of target bank
        if( (ui32Region == NVMNW_CMDCTL_REGIONSEL_MAIN) &&
            (ui32BankNum == 0) && (ui32Address >= bank0Size))
        {
            // Change target bank.
            ui32BankNum = 1;
        }

    }

    // Return status of operation.
    return(ui32ErrorReturn);
}

Here is the call graph for this function:

FlashProgram4X()

uint32_t FlashProgram4X	(	uint8_t *	pui8DataBuffer,
		uint32_t	ui32Address,
		uint32_t	ui32Count
	)

Referenced by FlashIntClear().

                                                                                           {
    // The below code part constitutes the variant of the FlashProgram() function
    // that is located in ROM. The source code of this variant is not visible in
    // internal or external driverlib. The source code is only compiled during a ROM
    // build.
    // The two above code parts (seperated by compile switches) constitute wrapper
    // functions which both call this ROM variant of the function.
    // The ROM variant is called by referrencing it directly through the ROM API table.
    uint32_t ui32StartIndex;
    uint32_t ui32StopIndex;
    uint8_t ui8BankWidth;
    uint8_t ui8NoOfBytes;
    uint32_t ui32ErrorReturn;
    uint32_t ui32SectorNum;
    uint32_t ui32BankNum;
    uint32_t ui32Region;
    uint32_t bank0Size;
    uint32_t ui32NoOfSectorsBank0;
    tFlashStateCommandsType StateMachineCmd;
    uint32_t sectorSize;

    sectorSize = FlashSectorSizeGet();

    // Check the arguments.
    // onlt main region and non-main CCFG
    ui32BankNum = 0;
    if  ( (ui32Address + ui32Count) <= (FLASHMEM_BASE + FlashSizeGet()) )
    {   // get bank-0 size
        bank0Size = ((HWREG(NVMNW_BASE + NVMNW_O_BANK0INFO0) &
                       NVMNW_BANK0INFO0_MAINSIZE_M) >>
                       NVMNW_BANK0INFO0_MAINSIZE_S) * sectorSize;

        if (ui32Address >= bank0Size)
            ui32BankNum = 1;

        // address is in the main region
        ui32Region = NVMNW_CMDCTL_REGIONSEL_MAIN ;

        ui32NoOfSectorsBank0 = (HWREG(NVMNW_BASE + NVMNW_O_BANK0INFO0) &
                                NVMNW_BANK0INFO0_MAINSIZE_M) >>
                                NVMNW_BANK0INFO0_MAINSIZE_S;
    }
    else if ( ( ui32Address >= (CCFG_BASE_DEFAULT) ) &&
             ( (ui32Address + ui32Count) <= (CCFG_BASE_DEFAULT + sectorSize ) ) )
    {
        // the address is CCFG in non-main region
        ui32Region = NVMNW_CMDCTL_REGIONSEL_NONMAIN ;
        ui32BankNum = 0;

    }
    else if ( ( ui32Address >= (FCFG1_BASE) ) &&
         ( (ui32Address + ui32Count) <= (FCFG1_BASE + sectorSize) ) )
    {
        // the address is FCFG1 in non-main region, ( bank 1 )
        ui32Region = NVMNW_CMDCTL_REGIONSEL_NONMAIN ;
        ui32BankNum = 1;

    }
    else
    {   // address is wrong
        return FAPI_STATUS_ADDRESS_ERROR;
    }

    // Set the status to indicate success.
    ui32ErrorReturn = FAPI_STATUS_SUCCESS;

    // Find flash bank width in number of bytes.
    ui8BankWidth = (((HWREG(NVMNW_BASE + NVMNW_O_GBLINFO1) &
                      NVMNW_GBLINFO1_DATAWIDTH_M ) >>
                      NVMNW_GBLINFO1_DATAWIDTH_S) >> 3);

    // dataIndex =0 for all modes (1X,2X,4X)
    HWREG(NVMNW_BASE + NVMNW_O_CMDDATAINDEX) = 0x0000;

    while ( ui32Count)
    {
        // Clear the Status register.
        IssueFsmCommand(FAPI_CLEAR_STATUS);

        // set up WEPROT register
        // based on the flash address to figure out WEPROT register for each state machine command
        if ( ui32Region == NVMNW_CMDCTL_REGIONSEL_MAIN)
        {   // for main region
            // based on the flash address, get the sector number on fly
            ui32SectorNum = (ui32Address - FLASHMEM_BASE) / sectorSize;

            // for main flash region
            // Unprotect sector to be erased.
            // sectorNum = sectorAddr / sectorSize
            // if sectorNum < 256 (number of sector in bank0)
            //  set bankNum =0
            // else set bankNum =1
            //
            // if sectorNum<32, it is the first 32 sector, it is 2K protect, use the rgister A
            //      registerA = 1<<sectorNum
            // if sector>=32 and sector<256, select bank0, registerB
            //      registerB = 1<< ( (sectorNum-32)/8 + 4)
            //  if (sector>256)
            //      select Bank=1, registerB = 1<< (sectorNum-256)/8
            //

            // set up Dynamic Write/Erase Protect to unprotect mode (clear the bit)
            if ( ui32SectorNum < 32)
            {
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTA) &= ~(1 << ui32SectorNum);
            }
            else if ( ui32SectorNum < ui32NoOfSectorsBank0)
            {
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTB) &=  ~( 1 << ((ui32SectorNum-32)/8 + 4));
            }
            else
            {
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTB) &= ~( 1 << ((ui32SectorNum - ui32NoOfSectorsBank0)/8));
            }

            // set up the command address, translate to Flash word adress
            // address is relative to each bank, translate to Flash word address
            HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = (ui32Address & ( bank0Size -1) )>> 4;
        }
        else
        {   // for NON-main region (CCFG)
            // the address is CCFG in non-main region
            if ( ui32BankNum ==0 )
            {
                ui32SectorNum = (ui32Address - CCFG_BASE_DEFAULT) / sectorSize;
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTNM) &=  ~( 1 << (ui32SectorNum));

                // set up the command address, translate to Flash word adress
                // address is relative to each bank, translate to Flash word address
                HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = (ui32Address - CCFG_BASE_DEFAULT )>> 4;
            }
            else
            {
                // the address is FCFG1 in non-main region
                ui32SectorNum = (ui32Address - FCFG1_BASE) / sectorSize;
                HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTNM) &=  ~( 1 << (ui32SectorNum ));

                // set up the command address, translate to Flash word adress
                // address is relative to each bank, translate to Flash word address
                HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = (ui32Address - FCFG1_BASE )>> 4;

            }
        }

        // set up NW control register
        /*
            21   enable the data verification for 1T only
            19   Stair Step Erase =0
            18   erase mask disable 0
            17   Program mask disable (0)
            16   ECC override (no ECC) 0
            15   address translate overrid =1
            14   post verify enable (1)
            13   preverify enable (1)
            12:9 regionsel = 1 (main region)/Non-Main
            8:4  bank selection = 0 or 1
            3:0  N/A (only for mode change)
        */

        HWREG(NVMNW_BASE + NVMNW_O_CMDCTL) = (NVMNW_CMDCTL_BANKSEL_BANK0 <<(ui32BankNum)) |
                                              NVMNW_CMDCTL_DATAVEREN |
                                              (ui32Region) |
                                              NVMNW_CMDCTL_ADDRXLATEOVR_OVERRIDE |
                                              NVMNW_CMDCTL_POSTVEREN_ENABLE |
                                              NVMNW_CMDCTL_PREVEREN_ENABLE ;

        // based on the ui32Address alignment and ui32Count to figure oue
        // 1. if ui32Address is 4X Flashword aligned and ui32Count>=4X flashword
        //      goto 4X program mode
        // 2. if ui32Address is 2X Flashword aligned and ui32Count>=2X flashword
        //      goto 2X program mode
        // 3. otherwise
        //      goto 1X program mode (default mode)

        if ( (( ui32Address & ( FLASHWORDSIZE_FOUR -1 ) ) == 0x00 ) &&
             ( ui32Count >= FLASHWORDSIZE_FOUR ) )
        {   // 4X program mode
            ui8NoOfBytes = FlashCopyMultiFlashWordToHW (pui8DataBuffer,ui32Address,FLASHWORDSIZE_FOUR);

            StateMachineCmd = FAPI_PROGRAM_FOURWORD;
        }
        else if ( (( ui32Address & ( FLASHWORDSIZE_TWO -1 ) ) == 0x00 ) &&
                  ( ui32Count >= FLASHWORDSIZE_TWO ) )
        {   // 2X program mode
            ui8NoOfBytes = FlashCopyMultiFlashWordToHW (pui8DataBuffer,ui32Address,FLASHWORDSIZE_TWO);

            StateMachineCmd = FAPI_PROGRAM_TWOWORD;
        }
        else
        {   // 1X program mode

            // Setup the start position within the write data registers.
            ui32StartIndex = ui32Address & (uint32_t)(ui8BankWidth - 1);

            // setup number of bytes to program
            ui8NoOfBytes = ui8BankWidth - ui32StartIndex;
            if(ui8NoOfBytes > ui32Count)
            {
                ui8NoOfBytes = ui32Count;
            }

            // Setup the stop position within the write data registers.
            ui32StopIndex = ui32StartIndex + (uint32_t)(ui8NoOfBytes - 1);

            // Write each byte to the Flash Data registers
            FlashCopyOneFlashWordToHW(pui8DataBuffer,ui32Address,
                                       ui32StartIndex,ui32StopIndex);
            StateMachineCmd = FAPI_PROGRAM_ONEWORD;
        }

        // Issue the Program command to the FSM.
        IssueFsmCommand(StateMachineCmd);

        // Wait until the word has been programmed.
        while(FlashCheckFsmForReady() == FAPI_STATUS_FSM_BUSY)
        {
        }

        // Exit if an access violation occurred.
        ui32ErrorReturn = FlashCheckFsmForError();
        if(ui32ErrorReturn != FAPI_STATUS_SUCCESS)
        {
            break;
        }

        // Prepare for next data burst.
        ui32Count       -= ui8NoOfBytes;
        ui32Address     += ui8NoOfBytes;
        pui8DataBuffer  += ui8NoOfBytes;

        // Check if next data burst require change of target bank
        if( (ui32Region == NVMNW_CMDCTL_REGIONSEL_MAIN) &&
            (ui32BankNum == 0) && (ui32Address >= bank0Size))
        {
            // Change target bank.
            ui32BankNum = 1;
        }

    }

    // Return status of operation.
    return(ui32ErrorReturn);
}

Here is the call graph for this function:

FlashProgramNowait()

uint32_t FlashProgramNowait	(	uint32_t	ui32StartAddress,
		uint8_t *	pui8DataBuffer,
		uint8_t	ui8NoOfBytes
	)

Starts programming within unprotected main bank flash sector and returns.

This function is depreciated

The pui8DataBuffer pointer can not point to flash.

Parameters

ui32StartAddress	is the start address in flash to program.
pui8DataBuffer	is a pointer to the data to be programmed.
ui8NoOfBytes	is the number of bytes to program.

Returns

Returns the status of the flash programming start:

• FAPI_STATUS_SUCCESS : Success.
• FAPI_STATUS_INCORRECT_DATABUFFER_LENGTH : Too many bytes were requested.

Referenced by FlashIntClear().

{
    // Return the function status.
    return (FAPI_STATUS_NOSUPPORT_ERROR);
}

FlashProtectionGet()

uint32_t FlashProtectionGet

(

uint32_t

ui32SectorAddress

)

Get sector protection.

This return the protection mode for the specified flash bank sector.

Parameters

ui32SectorAddress

is the start address of the desired sector.

Returns

Returns the sector protection:

• FLASH_NO_PROTECT
• FLASH_WRITE_PROTECT

Referenced by FlashProtectionSave(), and FlashSizeGet().

{
    uint32_t ui32SectorProtect;
    uint32_t ui32SectorNumber;
    uint32_t ui32Mask,ui32result;
    uint32_t region;

    // Check the arguments.
    // only Bank 0 first 32 sectors are protected
    // for CCFG which is in non-main region
    // sector address should be aligned on sector size
    // inverted logic: in CCFG

    if ((ui32SectorAddress & (FlashSectorSizeGet() - 1)) != 00)
    {
        return FAPI_STATUS_ADDRESS_ALIGN_ERROR;
    }

    if (ui32SectorAddress < (FLASHMEM_BASE + FlashSectorSizeGet() * 32))
    {
        // address is in the main region
        // FLASH_O_WEPROT_B0_31_0_BY1 only first 32 sectors are static protected
        region = NVMNW_CMDCTL_REGIONSEL_MAIN ;

        ui32SectorNumber = (ui32SectorAddress - FLASHMEM_BASE) / FlashSectorSizeGet();
        ui32Mask = 1 << (ui32SectorNumber);
    }
    else if ( ( ui32SectorAddress >= (CCFG_BASE_DEFAULT) ) &&
            ( ui32SectorAddress < (CCFG_BASE_DEFAULT + FlashSectorSizeGet() ) ) )
    {
        // the address is CCFG in non-main region
        // non main region only one sector for each region
        region = NVMNW_CMDCTL_REGIONSEL_NONMAIN ;
        ui32Mask = FLASH_WEPROT_AUX_BY1_WEPROT_B0_CCFG_BY1_M;
    }
    else
    {   // address is wrong
        return FAPI_STATUS_ADDRESS_ERROR;
    }

    if (region == NVMNW_CMDCTL_REGIONSEL_MAIN )
    {
        ui32result = HWREG(FLASH_BASE + FLASH_O_WEPROT_B0_31_0_BY1) & ui32Mask;
    }
    else
    {
        ui32result = HWREG(FLASH_BASE + FLASH_O_WEPROT_AUX_BY1) & ui32Mask;
    }

    if (ui32result)
    {
        ui32SectorProtect = FLASH_WRITE_PROTECT;
    }
    else
    {
        ui32SectorProtect = FLASH_NO_PROTECT;
    }

    return ui32SectorProtect;
}

Here is the call graph for this function:

FlashProtectionSave()

uint32_t FlashProtectionSave

(

uint32_t

ui32SectorAddress

)

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!

Parameters

ui32SectorAddress

is the start address of the sector to be protected.

Returns

Returns the status of the sector protection:

• FAPI_STATUS_SUCCESS : Success.
• FAPI_STATUS_FSM_ERROR : An erase error is encountered.

Referenced by FlashSizeGet().

{
    uint32_t ui32SectorProtect;
    uint32_t ui32SectorNumber;
    uint32_t ui32Mask;
    uint32_t ui32ErrorReturn;
    uint32_t ui32CcfgSectorAddr;
    uint32_t ccfgVal;

    // Check the arguments.
    // only Bank 0 first 32 sectors are protected
    // for CCFG which is in non-main region
    // sector address should be aligned on sector size

    if ((ui32SectorAddress & (FlashSectorSizeGet() - 1)) != 00)
    {
        return FAPI_STATUS_ADDRESS_ALIGN_ERROR;
    }

    if (ui32SectorAddress < (FLASHMEM_BASE + FlashSectorSizeGet() * 32))
    {
        // address is in the main region
        // FLASH_O_WEPROT_B0_31_0_BY1 only first 32 sectors are static protected

        ui32SectorNumber = (ui32SectorAddress - FLASHMEM_BASE) / FlashSectorSizeGet();
        ui32Mask = 1 << (ui32SectorNumber);

        ui32CcfgSectorAddr = CCFG_BASE_DEFAULT + CCFG_O_CCFG_WEPROT_31_0_BY2K;
    }
    else if ( ( ui32SectorAddress >= (CCFG_BASE_DEFAULT) ) &&
            ( ui32SectorAddress < (CCFG_BASE_DEFAULT + FlashSectorSizeGet() ) ) )
    {
        // the address is CCFG in non-main region
        // non main region only one sector for each region
        ui32Mask = CCFG_ERASE_CONF_1_WEPROT_CCFG_N_M;

        ui32CcfgSectorAddr = CCFG_BASE_DEFAULT + CCFG_O_ERASE_CONF_1;
    }
    else
    {   // address is wrong
        return FAPI_STATUS_ADDRESS_ERROR;
    }

    // read from Flash static protection register
    ui32SectorProtect = FlashProtectionGet(ui32SectorAddress) ;
    ui32ErrorReturn = FAPI_STATUS_UNPROTECT_ERROR ;
    // CCFG change
    //  unprotected (1) ==> protect (0) (allow)
    //  protected (0)   ==> protect (0) (no chnage with FlashProgram call)
    //  unprotected (1) ==> unprotect (1) (no action, no FlashProgram call)
    //  protected (0)   ==> unprotect (1) (no possible without erase, no Flashprogram Call)

    if(ui32SectorProtect == FLASH_WRITE_PROTECT)
    {
        // Find sector number for specified sector. (conversion)
        //  write 1: unprotected
        //  write 0: protected
        //  from unprotected mode ==> protected mode
        //  from protected mode ==> unprotected mode (need reset ??)
        //
        //  only change one bit from unprotec (CCFG value=1 ) to protect (CCFG value =0)

        // read from the CCFG
        ccfgVal = HWREG(ui32CcfgSectorAddr);
        // clear the bit to protetc the sector
        ccfgVal &= (~ui32Mask);
        ui32SectorProtect = ~ui32Mask;

        // write the cleared bit back to CCFG
        // need to reset to take effect
        ui32ErrorReturn = FlashProgram((uint8_t*)&ccfgVal, ui32CcfgSectorAddr,
                                       CCFG_SIZE_SECT_PROT);
    }

    // Return status.
    return(ui32ErrorReturn);
}

Here is the call graph for this function:

FlashProtectionSet()

void FlashProtectionSet	(	uint32_t	ui32SectorAddress,
		uint32_t	ui32ProtectMode
	)

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 FLASH_NO_PROTECT to FLASH_WRITE_PROTECT! After write protecting a sector this sector can only be set back to unprotected by a device reset.

Parameters

ui32SectorAddress	is the start address of the sector to protect.
ui32ProtectMode	is the enumerated sector protection mode. FLASH_NO_PROTECT FLASH_WRITE_PROTECT

Returns

None

Referenced by FlashSizeGet().

{
    uint32_t ui32SectorNumber;
    uint32_t ui32Mask;
    uint32_t ui32SetMask;
    uint32_t region;

    // Check the arguments.
    // only Bank 0 first 32 sectors are protected
    // for CCFG which is in non-main region
    // sector address should be aligned on sector size

    if ((ui32SectorAddress & (FlashSectorSizeGet() - 1)) != 00)
    {
        //return FAPI_STATUS_ADDRESS_ALIGN_ERROR;
        return;
    }

    if (ui32SectorAddress < (FLASHMEM_BASE + FlashSectorSizeGet() * 32))
    {
        // address is in the main region
        // FLASH_O_WEPROT_B0_31_0_BY1 only first 32 sectors are static protected
        region = NVMNW_CMDCTL_REGIONSEL_MAIN ;

        ui32SectorNumber = (ui32SectorAddress - FLASHMEM_BASE) / FlashSectorSizeGet();
        ui32Mask = 1 << (ui32SectorNumber);
    }
    else if ( ( ui32SectorAddress >= (CCFG_BASE_DEFAULT) ) &&
             ( ui32SectorAddress < (CCFG_BASE_DEFAULT + FlashSectorSizeGet() ) ) )
    {
        // the address is CCFG in non-main region
        // non main region only one sector for each region
        region = NVMNW_CMDCTL_REGIONSEL_NONMAIN ;
        ui32Mask = FLASH_WEPROT_AUX_BY1_WEPROT_B0_CCFG_BY1_M;
    }
    else
    {   // address is wrong
        //return FAPI_STATUS_ADDRESS_ERROR;
        return;
    }

    if(ui32ProtectMode == FLASH_WRITE_PROTECT)
    {   // set the corresponding bit
        ui32SetMask = ui32Mask;
    }
    else
    {   // clear the corresponding bit
        ui32SetMask = 0;
    }

    if (region == NVMNW_CMDCTL_REGIONSEL_MAIN )
    {   // clear the bit based on mask and set the bit
        HWREG(FLASH_BASE + FLASH_O_WEPROT_B0_31_0_BY1) &= ~ui32Mask;
        HWREG(FLASH_BASE + FLASH_O_WEPROT_B0_31_0_BY1) |= ui32SetMask;
    }
    else
    {   // clear the bit based on mask and set the bit
        HWREG(FLASH_BASE + FLASH_O_WEPROT_AUX_BY1) &= ~ui32Mask;
        HWREG(FLASH_BASE + FLASH_O_WEPROT_AUX_BY1) |= ui32SetMask;
    }

    return;
}

Here is the call graph for this function:

FlashSectorErase()

uint32_t FlashSectorErase

(

uint32_t

ui32SectorAddress

)

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.

Parameters

ui32SectorAddress

is the starting address in flash of the sector to be erased.

Returns

Returns the status of the sector erase:

• FAPI_STATUS_SUCCESS : Success.
• FAPI_STATUS_INCORRECT_DATABUFFER_LENGTH : Invalid argument.
• FAPI_STATUS_FSM_ERROR : A programming error is encountered.

Referenced by FlashIntClear().

{
    // The below code part constitutes the variant of the FlashSectorErase()
    // function that is located in ROM. The source code of this variant is not
    // visible in internal or external driverlib. The source code is
    // only compiled during a ROM build.
    // The two above code parts (seperated by compile switches) constitute wrapper
    // functions which both call this ROM variant of the function.
    // The ROM variant is called by referrencing it directly through the ROM API table.
    uint32_t ui32ErrorReturn;
    uint32_t ui32SectorNumber;
    uint32_t ui32NoOfSectorsBank0;
    uint32_t ui32BankNum;
    uint32_t ui32Region;
    uint32_t bank0Size;

    if ((ui32SectorAddress & (FlashSectorSizeGet() - 1)) != 00)
    {
        return FAPI_STATUS_ADDRESS_ALIGN_ERROR;
    }

    if  ( ui32SectorAddress < (FLASHMEM_BASE + FlashSizeGet()) )
    {
        bank0Size = ((HWREG(NVMNW_BASE + NVMNW_O_BANK0INFO0) &
                       NVMNW_BANK0INFO0_MAINSIZE_M) >>
                       NVMNW_BANK0INFO0_MAINSIZE_S) * FlashSectorSizeGet();
        // address is in the main region
        ui32Region = NVMNW_CMDCTL_REGIONSEL_MAIN ;

        ui32SectorNumber = (ui32SectorAddress - FLASHMEM_BASE) / FlashSectorSizeGet();
    }
    else if ( ( ui32SectorAddress >= (CCFG_BASE_DEFAULT) ) &&
            ( ui32SectorAddress < (CCFG_BASE_DEFAULT + FlashSectorSizeGet() ) ) )
    {
        // the address is CCFG in non-main region, bank 0
        ui32Region = NVMNW_CMDCTL_REGIONSEL_NONMAIN ;
        ui32SectorNumber = (ui32SectorAddress - CCFG_BASE_DEFAULT) / FlashSectorSizeGet();
        ui32BankNum = 0;
    }
    else if ( ( ui32SectorAddress >= (FCFG1_BASE) ) &&
            ( ui32SectorAddress < (FCFG1_BASE + FlashSectorSizeGet() ) ) )
    {
        // the address is FCFG1 in non-main region, bank 1
        ui32Region = NVMNW_CMDCTL_REGIONSEL_NONMAIN ;
        ui32SectorNumber = (ui32SectorAddress - FCFG1_BASE) / FlashSectorSizeGet();
        ui32BankNum = 1;
    }
    else
    {   // address is wrong
        return FAPI_STATUS_ADDRESS_ERROR;
    }

    // Clear the Status register.
    IssueFsmCommand(FAPI_CLEAR_STATUS);

    if ( ui32Region == NVMNW_CMDCTL_REGIONSEL_MAIN )
    {
        // for main flash region
        // Unprotect sector to be erased.
        // sectorNum = sectorAddr / sectorSize
        // if sectorNum < 256 (number of sector in bank0)
        //  set bankNum =0
        // else set bankNum =1
        //
        // if sectorNum<32, it is the first 32 sector, it is 2K protect, use the rgister A
        //      registerA = 1<<sectorNum
        // if sector>=32 and sector<256, select bank0, registerB
        //      registerB = 1<< ( (sectorNum-32)/8 + 4)
        //  if (sector>256)
        //      select Bank=1, registerB = 1<< (sectorNum-256)/8
        //
        ui32NoOfSectorsBank0 = (HWREG(NVMNW_BASE + NVMNW_O_BANK0INFO0) &
                                NVMNW_BANK0INFO0_MAINSIZE_M) >>
                                NVMNW_BANK0INFO0_MAINSIZE_S;

        if (ui32SectorNumber < ui32NoOfSectorsBank0)
        {
            ui32BankNum = 0;
        }
        else
        {
            ui32BankNum = 1;
        }

        // set up Dynamic Write/Erase Protect to unprotect mode (clear the bit)
        if ( ui32SectorNumber < 32)
        {
            HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTA) &= ~(1 << ui32SectorNumber);
        }
        else if ( ui32SectorNumber < ui32NoOfSectorsBank0)
        {
            HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTB) &=  ~( 1 << ((ui32SectorNumber-32)/8 + 4));
        }
        else
        {
            HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTB) &= ~( 1 << ((ui32SectorNumber - ui32NoOfSectorsBank0)/8));
        }

        // set up the command address, translate to Flash word adress
        // address is relative to each bank, translate to Flash word address
        HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = ( ( ui32SectorAddress - FLASHMEM_BASE ) & (bank0Size -1) ) >> 4 ;
    }
    else
    {
        // for NON-MAIN CCFG /FCFG1 region
        // set up Dynamic Write/Erase Protect to unprotect mode (clear the bit)
        HWREG(NVMNW_BASE + NVMNW_O_CMDWEPROTNM) &=  ~( 1 << (ui32SectorNumber) );

        // set up the command address, translate to Flash word adress
        // address is relative to each bank, translate to Flash word address
        if ( ui32BankNum == 0 )
        {   // CCFG bank 0
            HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = (ui32SectorAddress - CCFG_BASE_DEFAULT )>> 4;
        }
        else
        {   // FCFG1 bank 1
            HWREG(NVMNW_BASE + NVMNW_O_CMDADDR ) = (ui32SectorAddress - FCFG1_BASE )>> 4;
        }
    }

    // set up control register
    /*
        19   Stair Step Erase =0
        18   erase mask disable 0
        17   Program mask disable (0)
        16   ECC override (no ECC) 0
        15   address translate overrid = 1
        14   post verify enable (1)
        13   preverify enable (1)
        12:9 regionsel = (main region) /Non-main
        8:4  bank selection = 0 /1
        3:0  N/A (only for mode change)

    */
    HWREG(NVMNW_BASE + NVMNW_O_CMDCTL) = NVMNW_CMDCTL_BANKSEL_BANK0 <<(ui32BankNum) |
                                         ui32Region |
                                         NVMNW_CMDCTL_ADDRXLATEOVR_OVERRIDE |
                                         NVMNW_CMDCTL_POSTVEREN_ENABLE |
                                         NVMNW_CMDCTL_PREVEREN_ENABLE ;

    // Issue the sector erase command to the FSM.
    IssueFsmCommand(FAPI_ERASE_SECTOR);

    // Wait for erase to finish.
    while(FlashCheckFsmForReady() == FAPI_STATUS_FSM_BUSY)
    {
    }

    // Update status.
    ui32ErrorReturn = FlashCheckFsmForError();

    // check if the it is CCFG region
    if ( ( ui32Region == NVMNW_CMDCTL_REGIONSEL_NONMAIN ) &&
         ( ui32BankNum == 0 ) &&
         ( ui32ErrorReturn == FAPI_STATUS_SUCCESS ) )
    {
        // program security data to default vaues in the customer configuration
        // are within the flash CCFG sector

        // Program security data to default values in the customer configuration
        // area within the flash CCFG.
        ui32ErrorReturn = FlashProgram((uint8_t *)g_pui8CcfgDefaultSec,
                                 (ui32SectorAddress + CCFG_OFFSET_SECURITY),
                                 CCFG_SIZE_SECURITY);

    }
    // Return status of operation.
    return(ui32ErrorReturn);
}

Here is the call graph for this function:

FlashSectorSizeGet()

static uint32_t FlashSectorSizeGet ( void  )

inlinestatic

Get size of a flash sector in number of bytes.

This function will return the size of a flash sector in number of bytes.

Returns

Returns size of a flash sector in number of bytes.

Referenced by FlashProgram(), FlashProgram4X(), FlashProtectionGet(), FlashProtectionSave(), FlashProtectionSet(), FlashSectorErase(), and FlashSizeGet().

{

    uint32_t ui32SectorSizeInKbyte;

    ui32SectorSizeInKbyte = (HWREG(NVMNW_BASE + NVMNW_O_GBLINFO0) &
                             NVMNW_GBLINFO0_SECTORSIZE_M) >>
                             NVMNW_GBLINFO0_SECTORSIZE_S;

    // Return flash sector size in number of bytes.
    return (ui32SectorSizeInKbyte);
}

FlashSizeGet()

static uint32_t FlashSizeGet ( void  )

inlinestatic

Get the size of the flash.

This function returns the size of the flash main bank in number of bytes.

Returns

Returns the flash size in number of bytes.

Referenced by FlashProgram(), FlashProgram4X(), and FlashSectorErase().

{
    uint32_t ui32NoOfSectors;

    // get the number of sectors from the FLASH:FLASH_SIZE register
    ui32NoOfSectors = (( HWREG(FLASH_BASE + FLASH_O_FLASH_SIZE) &
                        FLASH_FLASH_SIZE_SECTORS_M ) >>
                        FLASH_FLASH_SIZE_SECTORS_S ) << FLASH_FLASH_SIZE_SECTORS_S;

    // Return flash size in number of bytes
    return (ui32NoOfSectors * FlashSectorSizeGet());
}

Here is the call graph for this function:

Macro Definition Documentation

DUMPWORD_INSTR

#define DUMPWORD_INSTR   0x04

Referenced by FlashEfuseReadRow().

FAPI_STATUS_ADDRESS_ALIGN_ERROR

#define FAPI_STATUS_ADDRESS_ALIGN_ERROR   0x00000006

Referenced by FlashProtectionGet(), FlashProtectionSave(), and FlashSectorErase().

FAPI_STATUS_ADDRESS_ERROR

#define FAPI_STATUS_ADDRESS_ERROR   0x00000005

Referenced by FlashProgram(), FlashProgram4X(), FlashProtectionGet(), FlashProtectionSave(), and FlashSectorErase().

FAPI_STATUS_BANK_NUM_ERROR

#define FAPI_STATUS_BANK_NUM_ERROR   0x00000007

FAPI_STATUS_FSM_BUSY

#define FAPI_STATUS_FSM_BUSY   0x00000001

Referenced by FlashCheckFsmForReady(), FlashProgram(), FlashProgram4X(), and FlashSectorErase().

FAPI_STATUS_FSM_ERROR

#define FAPI_STATUS_FSM_ERROR   0x00000004

Referenced by FlashCheckFsmForError().

FAPI_STATUS_FSM_READY

#define FAPI_STATUS_FSM_READY   0x00000002

Referenced by FlashCheckFsmForReady().

FAPI_STATUS_INCORRECT_DATABUFFER_LENGTH

#define FAPI_STATUS_INCORRECT_DATABUFFER_LENGTH   0x00000003

FAPI_STATUS_NOSUPPORT_ERROR

#define FAPI_STATUS_NOSUPPORT_ERROR   0x00000008

Referenced by FlashPowerModeGet(), and FlashProgramNowait().

FAPI_STATUS_SUCCESS

#define FAPI_STATUS_SUCCESS   0x00000000

Referenced by FlashCheckFsmForError(), FlashProgram(), FlashProgram4X(), and FlashSectorErase().

FAPI_STATUS_UNPROTECT_ERROR

#define FAPI_STATUS_UNPROTECT_ERROR   0x00000009

Referenced by FlashProtectionSave().

FBFALLBACK_ACTIVE

#define FBFALLBACK_ACTIVE   3

FBFALLBACK_DEEP_STDBY

#define FBFALLBACK_DEEP_STDBY   1

FBFALLBACK_SLEEP

#define FBFALLBACK_SLEEP   0

FCFG1_OFFSET

#define FCFG1_OFFSET   0x0800

FLASH_INT_FSM_DONE

#define FLASH_INT_FSM_DONE   0x00400000

FLASH_INT_RV

#define FLASH_INT_RV   0x00010000

FLASH_NO_PROTECT

#define FLASH_NO_PROTECT   0x00000000

Referenced by FlashProtectionGet().

FLASH_PWR_ACTIVE_MODE

#define FLASH_PWR_ACTIVE_MODE   0x00000000

FLASH_PWR_DEEP_STDBY_MODE

#define FLASH_PWR_DEEP_STDBY_MODE   0x00000002

FLASH_PWR_OFF_MODE

#define FLASH_PWR_OFF_MODE   0x00000001

FLASH_WRITE_PROTECT

#define FLASH_WRITE_PROTECT   0x00000001

Referenced by FlashProtectionGet(), FlashProtectionSave(), and FlashProtectionSet().

FLASHWORD_MASKBIT

#define FLASHWORD_MASKBIT   (0x03)

Referenced by FlashCopyOneFlashWordToHW().

FLASHWORD_SHIFTBIT

#define FLASHWORD_SHIFTBIT   (2)

Referenced by FlashCopyOneFlashWordToHW().

FLASHWORDSIZE_FOUR

#define FLASHWORDSIZE_FOUR   (0x40)

Referenced by FlashProgram(), and FlashProgram4X().

FLASHWORDSIZE_ONE

#define FLASHWORDSIZE_ONE   (0x10)

Referenced by FlashCopyOneFlashWordToHW().

FLASHWORDSIZE_TWO

#define FLASHWORDSIZE_TWO   (0x20)

Referenced by FlashProgram(), and FlashProgram4X().

FSM_REG_WRT_DISABLE

#define FSM_REG_WRT_DISABLE   2

FSM_REG_WRT_ENABLE

#define FSM_REG_WRT_ENABLE   5

FW_PWRMODE_DEPRECATED

#define FW_PWRMODE_DEPRECATED   0x00000002

FW_WRT_TRIMMED

#define FW_WRT_TRIMMED   0x00000001

Enumeration Type Documentation

tFlashStateCommandsType

enum tFlashStateCommandsType

Defined values for Flash State Machine commands.

Enumerator
FAPI_PROGRAM_FOURWORD	Program 4 Flash Word Mode.
FAPI_PROGRAM_TWOWORD	Program 4 Flash Word Mode.
FAPI_PROGRAM_ONEWORD	Program 1 Flash word mode.
FAPI_ERASE_SECTOR	Erase sector.
FAPI_ERASE_BANK	Erase bank.
FAPI_CLEAR_STATUS	Clear status.
FAPI_READVERIFY	Read and Verify.

{
    FAPI_PROGRAM_FOURWORD   = 0x0021, 
    FAPI_PROGRAM_TWOWORD    = 0x0011, 
    FAPI_PROGRAM_ONEWORD    = 0x0001, 
    FAPI_ERASE_SECTOR       = 0x0042, 
    FAPI_ERASE_BANK         = 0x0052, 
    FAPI_CLEAR_STATUS       = 0x0005, 
    FAPI_READVERIFY         = 0x0003   

} tFlashStateCommandsType;