SPRUJ96 User guide

Sets up data and issues program command to valid Flash or OTP memory addresses.

Synopsis

Fapi_StatusType Fapi_issueProgrammingCommand(          
                          uint32 *pu32StartAddress,          
                          uint16 *pu16DataBuffer,          
                          uint16  u16DataBufferSizeInWords,
                          uint16 *pu16EccBuffer,
                          uint16  u16EccBufferSizeInBytes,
                          Fapi_FlashProgrammingCommandType oMode
                                            )

Parameters

pu32StartAddress [in]	Start address in Flash for the data and ECC to be programmed. Also, the start address should always be even.
pu16DataBuffer [in]	Pointer to the Data buffer address. Data buffer should be 128-bit aligned.
u16DataBufferSizeInWords [in]	Number of 16-bit words in the Data buffer
pu16EccBuffer [in]	Pointer to the ECC buffer address
u16EccBufferSizeInBytes [in]	Number of 8-bit bytes in the ECC buffer
oMode [in]	Indicates the programming mode to use: Fapi_DataOnly Programs only the data buffer Fapi_AutoEccGeneration Programs the data buffer and auto generates and programs the ECC. Fapi_DataAndEcc Programs both the data and ECC buffers Fapi_EccOnly Programs only the ECC buffer

Note: The pu16EccBuffer should contain ECC corresponding to the data at the 128-bit aligned main array/OTP address. The LSB of the pu16EccBuffer corresponds to the lower 64 bits of the main array and the MSB of the pu16EccBuffer corresponds to the upper 64 bits of the main array.

Description

This function sets up the programming registers of the Flash State Machine based on the supplied parameters. It offers four different programming modes to the user for use in different scenarios as mentioned in Uses of Different Programming Modes.

For allowed programming range for the function, see Table 3-1.

Table 3-1 Uses of Different Programming Modes

Programming Mode (oMode)	Arguments Used	Usage Purpose
Fapi_DataOnly	pu32StartAddress, pu16DataBuffer, u16DataBufferSizeInWords	Used when any custom programming utility or an user application (that embed/use Flash API) has to program data and corresponding ECC separately. Data is programmed using Fapi_DataOnly mode and then the ECC is programmed using Fapi_EccOnly mode. Generally most of the programming utilities do not calculate ECC separately and instead use Fapi_AutoEccGeneration mode. However, some Safety applications may require to insert intentional ECC errors in their Flash image (which is not possible when Fapi_AutoEccGeneration mode is used) to check the health of the SECDED (Single Error Correction and Double Error Detection) module at run time. In such case, ECC is calculated separately (using the Fapi_calculateEcc() function as applicable). Application may want to insert errors in either main array data or in the ECC as needed. In such scenarios, after the error insertion, Fapi_DataOnly mode and Fapi_EccOnly modes can be used to program the data and ECC respectively.
Fapi_AutoEccGeneration	pu32StartAddress, pu16DataBuffer, u16DataBufferSizeInWords	Used when any custom programming utility or user application (that embed/use Flash API to program Flash at run time to store data or to do a firmware update) has to program data and ECC together without inserting any intentional errors. This is the most prominently used mode.
Fapi_DataAndEcc	pu32StartAddress, pu16DataBuffer, u16DataBufferSizeInWords, pu16EccBuffer, u16EccBufferSizeInBytes	Purpose of this mode is not different than that of using Fapi_DataOnly and Fapi_EccOnly modes together. However, this mode is beneficial when both the data and the calculated ECC can be programmed at the same time.
Fapi_EccOnly	pu16EccBuffer u16EccBufferSizeInBytes	See the usage purpose given for Fapi_DataOnly mode.

Table 3-2 Permitted Programming Range for Fapi_issueProgrammingCommand()

Flash API	Main Array	DCSM OTP	ECC	Link Pointer
Fapi_issueProgrammingCommand() 128-bit, Fapi_AutoEccGeneration mode	Allowed	Allowed	Allowed	Allowed (Flash API will program it as Fapi_DataOnly)
Fapi_issueProgrammingCommand() 128-bit, Fapi_DataOnly mode	Allowed	Allowed (Flash API will program it as Fapi_AutoEccGeneration)	Not allowed	Allowed
Fapi_issueProgrammingCommand() 128-bit, Fapi_DataAndEcc mode	Allowed	Allowed	Allowed	Allowed (Flash API will program it as Fapi_DataOnly)
Fapi_issueProgrammingCommand() 128-bit, Fapi_EccOnly mode	Not allowed	Not allowed	Allowed	Not allowed

Note: Users must always program ECC for their flash image since ECC check is enabled at power up.

Programming modes:

Fapi_DataOnly – This mode will only program the data portion in Flash at the address specified. It can program from 1-bit up to 8 16-bit words. However, review the restrictions provided for this function to know the limitations of flash programming data size. The supplied starting address to program at plus the data buffer length cannot cross the 128-bit aligned address boundary. Arguments 4 and 5 are ignored when using this mode.

Fapi_AutoEccGeneration – This mode will program the supplied data in Flash along with automatically generated ECC. The ECC is calculated for every 64-bit data aligned on a 64-bit memory boundary. Hence, when using this mode, all the 64 bits of the data should be programmed at the same time for a given 64-bit aligned memory address. Data not supplied is treated as all 1s (0xFFFF). Once ECC is calculated and programmed for a 64-bit data, those 64 bits can not be reprogrammed (unless the sector is erased) even if it is programming a bit from 1 to 0 in that 64-bit data, since the new ECC value will collide with the previously programmed ECC value. When using this mode, if the start address is 128-bit aligned, then either 8 or 4 16-bit words can be programmed at the same time as needed. If the start address is 64-bit aligned but not 128-bit aligned, then only 4 16-bit words can be programmed at the same time. The data restrictions for Fapi_DataOnly also exist for this option. Arguments 4 and 5 are ignored.

Note: Fapi_AutoEccGeneration mode will program the supplied data portion in Flash along with automatically generated ECC. The ECC is calculated for 64-bit aligned address and the corresponding 64-bit data. Any data not supplied is treated as 0xFFFF. Note that there are practical implications of this when writing a custom programming utility that streams in the output file of a code project and programs the individual sections one at a time into flash. If a 64-bit word spans more than one section (that is, contains the end of one section, and the start of another), values of 0xFFFF cannot be assumed for the missing data in the 64-bit word when programming the first section. When you go to program the second section, you will not be able to program the ECC for the first 64-bit word since it was already (incorrectly) computed and programmed using assumed 0xFFFF for the missing values. One way to avoid this problem is to align all sections linked to flash on a 64-bit boundary in the linker command file for your code project.

Here is an example:

SECTIONS
   {  
     .text        : > FLASH, ALIGN(4)
     .cinit       : > FLASH, ALIGN(4)
     .const       : > FLASH, ALIGN(4)
     .init_array  : > FLASH, ALIGN(4)
     .switch      : > FLASH, ALIGN(4)
   }

If you do not align the sections in flash, you would need to track incomplete 64-bit words in a section and combine them with the words in other sections that complete the 64-bit word. This will be difficult to do. So it is recommended to align your sections on 64-bit boundaries.

Some 3rd party Flash programming tools or TI Flash programming kernel examples (C2000Ware) or any custom Flash programming solution may assume that the incoming data stream is all 128-bit aligned and may not expect that a section might start on an unaligned address. Thus it may try to program the maximum possible (128-bits) words at a time assuming that the address provided is 128-bit aligned. This can result in a failure when the address is not aligned. So, it is suggested to align all the sections (mapped to Flash) on a 128-bit boundary.

Fapi_DataAndEcc – This mode will program both the supplied data and ECC in Flash at the address specified. The data supplied must be aligned on a 64-bit memory boundary and the length of data must correlate to the supplied ECC. That means, if the data buffer length is 4 16-bit words, the ECC buffer must be 1 byte. If the data buffer length is 8 16-bit words, the ECC buffer must be 2 bytes in length. If the start address is 128-bit aligned, then either 8 or 4 16-bit words should be programmed at the same time as needed. If the start address is 64-bit aligned but not 128-bit aligned, then only 4 16-bit words should be programmed at the same time.

The LSB of pu16EccBuffer corresponds to the lower 64-bits of the main array and the MSB of pu16EccBuffer corresponds to the upper 64-bits of the main array.

The Fapi_calculateEcc() function can be used to calculate ECC for a given 64-bit aligned address and the corresponding data.

Fapi_EccOnly – This mode will only program the ECC portion in Flash ECC memory space at the address (Flash main array address should be provided for this function and not the corresponding ECC address) specified. It can program either 2 bytes (both LSB and MSB at a location in ECC memory) or 1 byte (LSB at a location in ECC memory).

The LSB of pu16EccBuffer corresponds to the lower 64-bits of the main array and the MSB of pu16EccBuffer corresponds to the upper 64-bits of the main array.

Arguments two and three are ignored when using this mode.

Note: The length of pu16DataBuffer and pu16EccBuffer cannot exceed 8 and 2, respectively.

Note: This function does not check STATCMD after issuing the program command. The user application must check the STATCMD value when FSM has completed the program operation. STATCMD indicates if there is any failure occurrence during the program operation. The user application can use the Fapi_getFsmStatus function to obtain the STATCMD value.

Also, the user application should use the Fapi_doVerify() function to verify that the Flash is programmed correctly.

This function does not wait until the program operation is over; it just issues the command and returns back. Hence, the user application must wait for the Flash Wrapper to complete the program operation before returning to any kind of Flash accesses. The Fapi_checkFsmForReady() function should be used to monitor the status of an issued command.

Restrictions

As described above, this function can program only a max of 128-bits (given the address provided is 128-bit aligned) at a time. If the user wants to program more than that, this function should be called in a loop to program 128-bits (or 64-bits as needed by application) at a time.
The Main Array flash programming must be aligned to 64-bit address boundaries and each 64-bit word may only be programmed once per write or erase cycle.
It is alright to program the data and ECC separately. However, each 64-bit dataword and the corresponding ECC word may only be programmed once per write or erase cycle.
ECC should not be programmed for linkpointer locations. The API will issue the Fapi_DataOnly command for these locations even if the user chooses Fapi_AutoEccGeneration mode or Fapi_DataAndEcc mode. Fapi_EccOnly mode is not supported for linkpointer locations.
Fapi_EccOnly mode should not be used for Bank0 DCSM OTP space. If used, an error will be returned. For the DCSM OTP space, either Fapi_AutoEccGeneration or Fapi_DataAndEcc programming modes should be used.

Return Value

Fapi_Status_Success (success)
Fapi_Status_FsmBusy (FSM busy)
Fapi_Error_AsyncIncorrectDataBufferLength (failure: Data buffer size specified is incorrect. Also, this error will be returned if Fapi_EccOnly mode is selected when programming the Bank0 DCSM OTP space)
Fapi_Error_AsyncIncorrectEccBufferLength (failure: ECC buffer size specified is incorrect)
Fapi_Error_AsyncDataEccBufferLengthMismatch (failure: Data buffer size either is not 64-bit aligned or data length crosses the 128-bit aligned memory boundary)
Fapi_Error_FlashRegsNotWritable (failure: Flash register writes failed. The user should make sure that the API is executing from the same zone as that of the target address for flash operation OR the user should unlock before the flash operation.
Fapi_Error_FeatureNotAvailable (failure: User passed a mode that is not supported)
Fapi_Error_InvalidAddress (failure: User provided an invalid address. For the valid address range, see the TMS320F280013x Real-Time Microcontrollers Data Manual
for TMS320F280013x. For TMS320F180015x, see the TMS320F280015x Real-Time Microcontrollers Data Manual.

Sample Implementation

See the flash programming example provided in C2000Ware at “C2000Ware_.....\driverlib\f280013x\examples\flash\flashapi_ex1_programming.c” for TMS320F280013x.