Macros
#define	BLOCKS_FROM_EESIZE(x)

#define	SIZE_FROM_EESIZE(x)

#define	OFFSET_FROM_ADDR(x) (((x) >> 2) & 0x0F)

#define	EEPROM_MASS_ERASE_KEY ((uint32_t)0xE37B << EEPROM_EEDBGME_KEY_S)

#define	EEPROM_INIT_OK 0

#define	EEPROM_INIT_ERROR 2

#define	EEPROM_RC_WRBUSY 0x00000020

#define	EEPROM_RC_NOPERM 0x00000010

#define	EEPROM_RC_WKCOPY 0x00000008

#define	EEPROM_RC_WKERASE 0x00000004

#define	EEPROM_RC_WORKING 0x00000001

#define	EEPROM_PROT_SUPERVISOR_ONLY 0x00000008

#define	EEPROM_PROT_RW_LRO_URW 0x00000000

#define	EEPROM_PROT_NA_LNA_URW 0x00000001

#define	EEPROM_PROT_RO_LNA_URO 0x00000002

#define	EEPROM_INT_PROGRAM 0x00000004

#define	EEPROMBlockFromAddr(ui32Addr) ((ui32Addr) >> 6)

#define	EEPROMAddrFromBlock(ui32Block) ((ui32Block) << 6)

Functions
static void	_EEPROMSectorMaskSet (uint32_t ui32Address)

static void	_EEPROMSectorMaskClear (void)

static void	_EEPROMWaitForDone (void)

uint32_t	EEPROMInit (void)

uint32_t	EEPROMSizeGet (void)

uint32_t	EEPROMBlockCountGet (void)

void	EEPROMRead (uint32_t *pui32Data, uint32_t ui32Address, uint32_t ui32Count)

uint32_t	EEPROMProgram (uint32_t *pui32Data, uint32_t ui32Address, uint32_t ui32Count)

uint32_t	EEPROMProgramNonBlocking (uint32_t ui32Data, uint32_t ui32Address)

uint32_t	EEPROMMassErase (void)

uint32_t	EEPROMBlockProtectGet (uint32_t ui32Block)

uint32_t	EEPROMBlockProtectSet (uint32_t ui32Block, uint32_t ui32Protect)

uint32_t	EEPROMBlockPasswordSet (uint32_t ui32Block, uint32_t *pui32Password, uint32_t ui32Count)

uint32_t	EEPROMBlockLock (uint32_t ui32Block)

uint32_t	EEPROMBlockUnlock (uint32_t ui32Block, uint32_t *pui32Password, uint32_t ui32Count)

void	EEPROMBlockHide (uint32_t ui32Block)

void	EEPROMIntEnable (uint32_t ui32IntFlags)

void	EEPROMIntDisable (uint32_t ui32IntFlags)

uint32_t	EEPROMIntStatus (bool bMasked)

void	EEPROMIntClear (uint32_t ui32IntFlags)

uint32_t	EEPROMStatusGet (void)

Detailed Description

Macro Definition Documentation

#define BLOCKS_FROM_EESIZE ( x )

Value:

(((x) & EEPROM_EESIZE_BLKCNT_M) >> \

EEPROM_EESIZE_BLKCNT_S)

EEPROM_EESIZE_BLKCNT_M

#define EEPROM_EESIZE_BLKCNT_M

Definition: hw_eeprom.h:75

EEPROM_EESIZE_BLKCNT_S

#define EEPROM_EESIZE_BLKCNT_S

Definition: hw_eeprom.h:77

Definition at line 66 of file eeprom.c.

Referenced by EEPROMBlockCountGet(), EEPROMBlockHide(), EEPROMBlockLock(), EEPROMBlockPasswordSet(), EEPROMBlockProtectGet(), EEPROMBlockProtectSet(), and EEPROMBlockUnlock().

#define EEPROM_INIT_ERROR 2

This value may be returned from a call to EEPROMInit(). It indicates that a previous data or protection write operation was interrupted by a reset event and that the EEPROM peripheral was unable to clean up after the problem. This situation may be resolved with another reset or may be fatal depending upon the cause of the problem. For example, if the voltage to the part is unstable, retrying once the voltage has stabilized may clear the error.

Definition at line 83 of file eeprom.h.

Referenced by EEPROMInit().

#define EEPROM_INIT_OK 0

This value may be returned from a call to EEPROMInit(). It indicates that no previous write operations were interrupted by a reset event and that the EEPROM peripheral is ready for use.

Definition at line 72 of file eeprom.h.

Referenced by EEPROMInit().

#define EEPROM_INT_PROGRAM 0x00000004

This value may be passed to EEPROMIntEnable() and EEPROMIntDisable() and is returned by EEPROMIntStatus() if an EEPROM interrupt is currently being signaled.

Definition at line 176 of file eeprom.h.

Referenced by EEPROMIntDisable(), EEPROMIntEnable(), and EEPROMIntStatus().

#define EEPROM_MASS_ERASE_KEY ((uint32_t)0xE37B << EEPROM_EEDBGME_KEY_S)

Definition at line 83 of file eeprom.c.

Referenced by EEPROMMassErase().

#define EEPROM_PROT_NA_LNA_URW 0x00000001

This value may be passed to EEPROMBlockProtectSet() or returned from EEPROMBlockProtectGet(). It indicates that the block should offer neither read nor write access unless it is protected by a password and unlocked.

Definition at line 158 of file eeprom.h.

#define EEPROM_PROT_RO_LNA_URO 0x00000002

This value may be passed to EEPROMBlockProtectSet() or returned from EEPROMBlockProtectGet(). It indicates that the block should offer read-only access when no password is set or when a password is set and the block is unlocked. When a password is set and the block is locked, neither read nor write access is permitted.

Definition at line 167 of file eeprom.h.

#define EEPROM_PROT_RW_LRO_URW 0x00000000

This value may be passed to EEPROMBlockProtectSet() or returned from EEPROMBlockProtectGet(). It indicates that the block should offer read/write access when no password is set or when a password is set and the block is unlocked, and read-only access when a password is set but the block is locked.

Definition at line 151 of file eeprom.h.

#define EEPROM_PROT_SUPERVISOR_ONLY 0x00000008

This bit may be ORed with the protection option passed to EEPROMBlockProtectSet() or returned from EEPROMBlockProtectGet(). It restricts EEPROM access to threads running in supervisor mode and prevents access to an EEPROM block when the CPU is in user mode.

Definition at line 142 of file eeprom.h.

#define EEPROM_RC_NOPERM 0x00000010

This return code bit indicates that an attempt was made to write a value but the destination permissions disallow write operations. This may be due to the destination block being locked, access protection set to prohibit writes or an attempt to write a password when one is already written.

Definition at line 105 of file eeprom.h.

#define EEPROM_RC_WKCOPY 0x00000008

This return code bit indicates that the EEPROM programming state machine is currently copying to or from the internal copy buffer to make room for a newly written value. It is provided as a status indicator and does not indicate an error.

Definition at line 113 of file eeprom.h.

#define EEPROM_RC_WKERASE 0x00000004

This return code bit indicates that the EEPROM programming state machine is currently erasing the internal copy buffer. It is provided as a status indicator and does not indicate an error.

Definition at line 120 of file eeprom.h.

#define EEPROM_RC_WORKING 0x00000001

This return code bit indicates that the EEPROM programming state machine is currently working. No new write operations should be attempted until this bit is clear.

Definition at line 127 of file eeprom.h.

#define EEPROM_RC_WRBUSY 0x00000020

This return code bit indicates that an attempt was made to read from the EEPROM while a write operation was in progress.

Definition at line 96 of file eeprom.h.

#define EEPROMAddrFromBlock ( ui32Block ) ((ui32Block) << 6)

Returns the offset address of the first word in an EEPROM block.

Parameters

ui32Block is the index of the EEPROM block whose first word address is to be returned.

This macro may be used to determine the address of the first word in a given EEPROM block. The address returned is expressed as a byte offset from the base of EEPROM storage.

Returns: Returns the address of the first word in the given EEPROM block.

Definition at line 211 of file eeprom.h.

#define EEPROMBlockFromAddr ( ui32Addr ) ((ui32Addr) >> 6)

Returns the EEPROM block number containing a given offset address.

Parameters

ui32Addr is the linear, byte address of the EEPROM location whose block number is to be returned. This is a zero-based offset from the start of the EEPROM storage.

This macro may be used to translate an EEPROM address offset into a block number suitable for use in any of the driver's block protection functions. The address provided is expressed as a byte offset from the base of the EEPROM.

Returns: Returns the zero-based block number which contains the passed address.

Definition at line 195 of file eeprom.h.

Referenced by EEPROMProgram(), EEPROMProgramNonBlocking(), and EEPROMRead().

#define OFFSET_FROM_ADDR ( x ) (((x) >> 2) & 0x0F)

Definition at line 76 of file eeprom.c.

Referenced by EEPROMProgram(), EEPROMProgramNonBlocking(), and EEPROMRead().

#define SIZE_FROM_EESIZE ( x )

Value:

((((x) & EEPROM_EESIZE_WORDCNT_M) >> \

EEPROM_EESIZE_WORDCNT_S) * 4)

EEPROM_EESIZE_WORDCNT_M

#define EEPROM_EESIZE_WORDCNT_M

Definition: hw_eeprom.h:74

EEPROM_EESIZE_WORDCNT_S

#define EEPROM_EESIZE_WORDCNT_S

Definition: hw_eeprom.h:76

Definition at line 68 of file eeprom.c.

Referenced by EEPROMProgram(), EEPROMProgramNonBlocking(), EEPROMRead(), and EEPROMSizeGet().

Function Documentation

static void _EEPROMSectorMaskClear ( void )

static

Definition at line 121 of file eeprom.c.

References HWREG, and SysCtlDelay().

Referenced by EEPROMIntClear(), EEPROMMassErase(), and EEPROMProgram().

 {
     SysCtlDelay(10);
     HWREG(0x400FD0FC) = 3;
     SysCtlDelay(10);
     HWREG(0x400AE2C0) = 0;
     SysCtlDelay(10);
     HWREG(0x400FD0FC) = 0;
     SysCtlDelay(10);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void _EEPROMSectorMaskSet ( uint32_t ui32Address )

static

Definition at line 94 of file eeprom.c.

References HWREG, and SysCtlDelay().

Referenced by EEPROMProgram(), and EEPROMProgramNonBlocking().

 {
     uint32_t ui32Mask;
 
     //
     // Determine which page contains the passed EEPROM address.  The 2KB EEPROM
     // is implemented in 16KB of flash with each 1KB sector of flash holding
     // values for 32 consecutive EEPROM words (or 128 bytes).
     //
     ui32Mask = ~(1 << (ui32Address >> 7));
 
     SysCtlDelay(10);
     HWREG(0x400FD0FC) = 3;
     SysCtlDelay(10);
     HWREG(0x400AE2C0) = ui32Mask;
     SysCtlDelay(10);
     HWREG(0x400FD0FC) = 0;
     SysCtlDelay(10);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void _EEPROMWaitForDone ( void )

static

Definition at line 138 of file eeprom.c.

References EEPROM_EEDONE, EEPROM_EEDONE_WORKING, and HWREG.

Referenced by EEPROMInit(), and EEPROMMassErase().

 {
     //
     // Is the EEPROM still busy?
     //
     while(HWREG(EEPROM_EEDONE) & EEPROM_EEDONE_WORKING)
     {
         //
         // Spin while EEPROM is busy.
         //
     }
 }

Here is the caller graph for this function:

uint32_t EEPROMBlockCountGet ( void )

Determines the number of blocks in the EEPROM.

This function may be called to determine the number of blocks in the EEPROM. Each block is the same size and the number of bytes of storage contained in a block may be determined by dividing the size of the device, obtained via a call to the EEPROMSizeGet() function, by the number of blocks returned by this function.

Returns: Returns the total number of blocks in the device EEPROM.

Definition at line 270 of file eeprom.c.

References BLOCKS_FROM_EESIZE, EEPROM_EESIZE, and HWREG.

 {
     //
     // Extract the number of blocks and return it to the caller.
     //
 #ifdef EEPROM_SIZE_LIMIT
     //
     // If a size limit has been specified, fake the number of blocks to match.
     //
     return(EEPROM_SIZE_LIMIT / 48);
 #else
     //
     // Return the actual number of blocks supported by the hardware.
     //
     return(BLOCKS_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
 #endif
 }

void EEPROMBlockHide ( uint32_t ui32Block )

Hides an EEPROM block until the next reset.

Parameters

ui32Block is the EEPROM block number which is to be hidden.

This function hides an EEPROM block other than block 0. Once hidden, a block is completely inaccessible until the next reset. This mechanism allows initialization code to have access to data which is to be hidden from the rest of the application. Unlike applications using passwords, an application making using of block hiding need not contain any embedded passwords which could be found through disassembly.

Returns: None.

Definition at line 960 of file eeprom.c.

References ASSERT, BLOCKS_FROM_EESIZE, EEPROM_EEHIDE, EEPROM_EESIZE, and HWREG.

 {
     //
     // Check parameters in a debug build.
     //
     ASSERT(!ui32Block);
     ASSERT(ui32Block < BLOCKS_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
 
     //
     // Hide the requested block.
     //
     HWREG(EEPROM_EEHIDE) = (1 << ui32Block);
 }

uint32_t EEPROMBlockLock ( uint32_t ui32Block )

Locks a password-protected EEPROM block.

Parameters

ui32Block is the EEPROM block number which is to be locked.

This function locks an EEPROM block that has previously been protected by writing a password. Access to the block once it is locked is determined by the protection settings applied via a previous call to the EEPROMBlockProtectSet() function. If no password has previously been set for the block, this function has no effect.

Locking block 0 has the effect of making all other blocks in the EEPROM inaccessible.

Returns: Returns the lock state for the block on exit, 1 if unlocked (as would be the case if no password was set) or 0 if locked.

Definition at line 847 of file eeprom.c.

References ASSERT, BLOCKS_FROM_EESIZE, EEPROM_EEBLOCK, EEPROM_EESIZE, EEPROM_EEUNLOCK, and HWREG.

 {
     //
     // Check parameters in a debug build.
     //
     ASSERT(ui32Block < BLOCKS_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
 
     //
     // Select the block we are going to lock.
     //
     HWREG(EEPROM_EEBLOCK) = ui32Block;
 
     //
     // Lock the block.
     //
     HWREG(EEPROM_EEUNLOCK) = 0xFFFFFFFF;
 
     //
     // Return the current lock state.
     //
     return(HWREG(EEPROM_EEUNLOCK));
 }

uint32_t EEPROMBlockPasswordSet	(	uint32_t	ui32Block,
		uint32_t *	pui32Password,
		uint32_t	ui32Count
	)

Sets the password used to protect an EEPROM block.

Parameters

ui32Block	is the EEPROM block number for which the password is to be set.
pui32Password	points to an array of uint32_t values comprising the password to set. Each element may be any 32-bit value other than 0xFFFFFFFF. This array must contain the number of elements given by the ui32Count parameter.
ui32Count	provides the number of uint32_ts in the ui32Password. Valid values are 1, 2 and 3.

This function allows the password used to unlock an EEPROM block to be set. Valid passwords may be either 32, 64 or 96 bits comprising words with any value other than 0xFFFFFFFF. The password may only be set once. Any further attempts to set the password result in an error. Once the password is set, the block remains unlocked until EEPROMBlockLock() is called for that block or block 0, or a reset occurs.

If a password is set on block 0, this affects locking of the peripheral as a whole. When block 0 is locked, all other EEPROM blocks are inaccessible until block 0 is unlocked. Once block 0 is unlocked, other blocks become accessible according to any passwords set on those blocks and the protection set for that block via a call to EEPROMBlockProtectSet().

Returns: Returns a logical OR combination of EEPROM_RC_WRBUSY, EEPROM_RC_NOPERM, EEPROM_RC_WKCOPY, EEPROM_RC_WKERASE, and EEPROM_RC_WORKING to indicate status and error conditions.

Definition at line 771 of file eeprom.c.

References ASSERT, BLOCKS_FROM_EESIZE, EEPROM_EEBLOCK, EEPROM_EEDONE, EEPROM_EEDONE_WORKING, EEPROM_EEPASS0, EEPROM_EESIZE, and HWREG.

 {
     uint32_t ui32Reg;
 
     //
     // Check parameters in a debug build.
     //
     ASSERT(pui32Password);
     ASSERT(ui32Block < BLOCKS_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
     ASSERT(ui32Count <= 3);
 
     //
     // Set the block number whose password we are about to write.
     //
     HWREG(EEPROM_EEBLOCK) = ui32Block;
 
     //
     // Start with the first password word.
     //
     ui32Reg = EEPROM_EEPASS0;
 
     //
     // Write the password.
     //
     while(ui32Count)
     {
         //
         // Start the process of writing the password.
         //
         HWREG(ui32Reg) = *pui32Password;
 
         //
         // Update values in preparation for writing the next word.
         //
         pui32Password++;
         ui32Reg += 4;
         ui32Count--;
 
         //
         // Wait for the last word write to complete or an error to be reported.
         //
         while(HWREG(EEPROM_EEDONE) & EEPROM_EEDONE_WORKING)
         {
             //
             // Still working.
             //
         }
     }
 
     //
     // Return the final write status.
     //
     return(HWREG(EEPROM_EEDONE));
 }

uint32_t EEPROMBlockProtectGet ( uint32_t ui32Block )

Returns the current protection level for an EEPROM block.

Parameters

ui32Block is the block number for which the protection level is to be queried.

This function returns the current protection settings for a given EEPROM block. If block 0 is currently locked, it must be unlocked prior to calling this function to query the protection setting for other blocks.

Returns: Returns one of EEPROM_PROT_RW_LRO_URW, EEPROM_PROT_NA_LNA_URW or EEPROM_PROT_RO_LNA_URO optionally OR-ed with EEPROM_PROT_SUPERVISOR_ONLY.

Definition at line 643 of file eeprom.c.

References ASSERT, BLOCKS_FROM_EESIZE, EEPROM_EEBLOCK, EEPROM_EEPROT, EEPROM_EESIZE, and HWREG.

 {
     //
     // Parameter validity check.
     //
     ASSERT(ui32Block < BLOCKS_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
 
     //
     // Set the current block.
     //
     HWREG(EEPROM_EEBLOCK) = ui32Block;
 
     //
     // Return the protection flags for this block.
     //
     return(HWREG(EEPROM_EEPROT));
 }

uint32_t EEPROMBlockProtectSet	(	uint32_t	ui32Block,
		uint32_t	ui32Protect
	)

Set the current protection options for an EEPROM block.

Parameters

ui32Block	is the block number for which the protection options are to be set.
ui32Protect	consists of one of the values EEPROM_PROT_RW_LRO_URW, EEPROM_PROT_NA_LNA_URW or EEPROM_PROT_RO_LNA_URO optionally ORed with EEPROM_PROT_SUPERVISOR_ONLY.

This function sets the protection settings for a given EEPROM block assuming no protection settings have previously been written. Note that protection settings applied to block 0 have special meaning and control access to the EEPROM peripheral as a whole. Protection settings applied to blocks numbered 1 and above are layered above any protection set on block 0 such that the effective protection on each block is the logical OR of the protection flags set for block 0 and for the target block. This protocol allows global protection options to be set for the whole device via block 0 and more restrictive protection settings to be set on a block-by-block basis.

The protection flags indicate access permissions as follow:

EEPROM_PROT_SUPERVISOR_ONLY restricts access to the block to threads running in supervisor mode. If clear, both user and supervisor threads can access the block.

EEPROM_PROT_RW_LRO_URW provides read/write access to the block if no password is set or if a password is set and the block is unlocked. If the block is locked, only read access is permitted.

EEPROM_PROT_NA_LNA_URW provides neither read nor write access unless a password is set and the block is unlocked. If the block is unlocked, both read and write access are permitted.

EEPROM_PROT_RO_LNA_URO provides read access to the block if no password is set or if a password is set and the block is unlocked. If the block is password protected and locked, neither read nor write access is permitted.

Returns: Returns a logical OR combination of EEPROM_RC_WRBUSY, EEPROM_RC_NOPERM, EEPROM_RC_WKCOPY, EEPROM_RC_WKERASE, and EEPROM_RC_WORKING to indicate status and error conditions.

Definition at line 706 of file eeprom.c.

References ASSERT, BLOCKS_FROM_EESIZE, EEPROM_EEBLOCK, EEPROM_EEDONE, EEPROM_EEDONE_WORKING, EEPROM_EEPROT, EEPROM_EESIZE, and HWREG.

 {
     //
     // Parameter validity check.
     //
     ASSERT(ui32Block < BLOCKS_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
 
     //
     // Set the current block.
     //
     HWREG(EEPROM_EEBLOCK) = ui32Block;
 
     //
     // Set the protection options for this block.
     //
     HWREG(EEPROM_EEPROT) = ui32Protect;
 
     //
     // Wait for the write to complete.
     //
     while(HWREG(EEPROM_EEDONE) & EEPROM_EEDONE_WORKING)
     {
         //
         // Still working.
         //
     }
 
     //
     // Pass any error codes back to the caller.
     //
     return(HWREG(EEPROM_EEDONE));
 }

uint32_t EEPROMBlockUnlock	(	uint32_t	ui32Block,
		uint32_t *	pui32Password,
		uint32_t	ui32Count
	)

Unlocks a password-protected EEPROM block.

Parameters

ui32Block	is the EEPROM block number which is to be unlocked.
pui32Password	points to an array of uint32_t values containing the password for the block. Each element must match the password originally set via a call to EEPROMBlockPasswordSet().
ui32Count	provides the number of elements in the pui32Password array and must match the value originally passed to EEPROMBlockPasswordSet(). Valid values are 1, 2 and 3.

This function unlocks an EEPROM block that has previously been protected by writing a password. Access to the block once it is unlocked is determined by the protection settings applied via a previous call to the EEPROMBlockProtectSet() function.

To successfully unlock an EEPROM block, the password provided must match the password provided on the original call to EEPROMBlockPasswordSet(). If an incorrect password is provided, the block remains locked.

Unlocking block 0 has the effect of making all other blocks in the device accessible according to their own access protection settings. When block 0 is locked, all other EEPROM blocks are inaccessible.

Returns: Returns the lock state for the block on exit, 1 if unlocked or 0 if locked.

Definition at line 900 of file eeprom.c.

References ASSERT, BLOCKS_FROM_EESIZE, EEPROM_EEBLOCK, EEPROM_EESIZE, EEPROM_EEUNLOCK, and HWREG.

 {
     //
     // Check parameters in a debug build.
     //
     ASSERT(pui32Password);
     ASSERT(ui32Block < BLOCKS_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
     ASSERT(ui32Count <= 3);
 
     //
     // Set the block that we are trying to unlock.
     //
     HWREG(EEPROM_EEBLOCK) = ui32Block;
 
     //
     // Write the unlock register with 0xFFFFFFFF to reset the unlock
     // sequence just in case a short password was previously used to try to
     // unlock the block.
     //
     HWREG(EEPROM_EEUNLOCK) = 0xFFFFFFFF;
 
     //
     // We need to write the password words in the opposite order when unlocking
     // compared to locking so start at the end of the array.
     //
     pui32Password += (ui32Count - 1);
 
     //
     // Write the supplied password to unlock the block.
     //
     while(ui32Count)
     {
         HWREG(EEPROM_EEUNLOCK) = *pui32Password--;
         ui32Count--;
     }
 
     //
     // Let the caller know if their password worked.
     //
     return(HWREG(EEPROM_EEUNLOCK));
 }

uint32_t EEPROMInit ( void )

Performs any necessary recovery in case of power failures during write.

This function must be called after SysCtlPeripheralEnable() and before the EEPROM is accessed. It is used to check for errors in the EEPROM state such as from power failure during a previous write operation. The function detects these errors and performs as much recovery as possible.

If EEPROM_INIT_ERROR is returned, the EEPROM was unable to recover its state. If power is stable when this occurs, this indicates a fatal error and is likely an indication that the EEPROM memory has exceeded its specified lifetime write/erase specification. If the supply voltage is unstable when this return code is observed, retrying the operation once the voltage is stabilized may clear the error.

Failure to call this function after a reset may lead to incorrect operation or permanent data loss if the EEPROM is later written.

Returns: Returns EEPROM_INIT_OK if no errors were detected or EEPROM_INIT_ERROR if the EEPROM peripheral cannot currently recover from an interrupted write or erase operation.

Definition at line 176 of file eeprom.c.

References _EEPROMWaitForDone(), EEPROM_EESUPP, EEPROM_EESUPP_ERETRY, EEPROM_EESUPP_PRETRY, EEPROM_INIT_ERROR, EEPROM_INIT_OK, HWREG, SYSCTL_PERIPH_EEPROM0, SysCtlDelay(), and SysCtlPeripheralReset().

 {
     uint32_t ui32Status;
 
     //
     // Insert a small delay (6 cycles + call overhead) to guard against the
     // possibility that this function is called immediately after the EEPROM
     // peripheral is enabled.  Without this delay, there is a slight chance
     // that the first EEPROM register read will fault if you are using a
     // compiler with a ridiculously good optimizer!
     //
     SysCtlDelay(2);
 
     //
     // Make sure the EEPROM has finished any ongoing processing.
     //
     _EEPROMWaitForDone();
 
     //
     // Read the EESUPP register to see if any errors have been reported.
     //
     ui32Status = HWREG(EEPROM_EESUPP);
 
     //
     // Did an error of some sort occur during initialization?
     //
     if(ui32Status & (EEPROM_EESUPP_PRETRY | EEPROM_EESUPP_ERETRY))
     {
         return(EEPROM_INIT_ERROR);
     }
 
     //
     // Perform a second EEPROM reset.
     //
     SysCtlPeripheralReset(SYSCTL_PERIPH_EEPROM0);
 
     //
     // Wait for the EEPROM to complete its reset processing once again.
     //
     SysCtlDelay(2);
     _EEPROMWaitForDone();
 
     //
     // Read EESUPP once again to determine if any error occurred.
     //
     ui32Status = HWREG(EEPROM_EESUPP);
 
     //
     // Was an error reported following the second reset?
     //
     if(ui32Status & (EEPROM_EESUPP_PRETRY | EEPROM_EESUPP_ERETRY))
     {
         return(EEPROM_INIT_ERROR);
     }
 
     //
     // The EEPROM does not indicate that any error occurred.
     //
     return(EEPROM_INIT_OK);
 }

Here is the call graph for this function:

void EEPROMIntClear ( uint32_t ui32IntFlags )

Clears the EEPROM interrupt.

Parameters

ui32IntFlags indicates which interrupt sources to clear. Currently, the only valid value is EEPROM_INT_PROGRAM.

This function allows an application to clear the EEPROM interrupt.

Note: Because there is a write buffer in the Cortex-M processor, it may take several clock cycles before the interrupt source is actually cleared. Therefore, it is recommended that the interrupt source be cleared early in the interrupt handler (as opposed to the very last action) to avoid returning from the interrupt handler before the interrupt source is actually cleared. Failure to do so may result in the interrupt handler being immediately reentered (because the interrupt controller still sees the interrupt source asserted).

Returns: None.

Definition at line 1112 of file eeprom.c.

References _EEPROMSectorMaskClear(), CLASS_IS_TM4C123, FLASH_FCMISC, FLASH_FCMISC_EMISC, HWREG, and REVISION_IS_A0.

 {
     //
     // Clear the flash interrupt.
     //
     HWREG(FLASH_FCMISC) = FLASH_FCMISC_EMISC;
 
     //
     // Clear the sector protection bits to prevent possible problems when
     // programming the main flash array later.
     //
     if(CLASS_IS_TM4C123 && REVISION_IS_A0)
     {
         _EEPROMSectorMaskClear();
     }
 }

Here is the call graph for this function:

void EEPROMIntDisable ( uint32_t ui32IntFlags )

Disables the EEPROM interrupt.

Parameters

ui32IntFlags indicates which EEPROM interrupt source to disable. This must be EEPROM_INT_PROGRAM currently.

This function disables the EEPROM interrupt and prevents calls to the interrupt vector when any EEPROM write or erase operation completes. The EEPROM peripheral shares a single interrupt vector with the flash memory subsystem, INT_FLASH. This function is provided as a convenience but the EEPROM interrupt can also be disabled using a call to FlashIntDisable() passing FLASH_INT_EEPROM in the ui32IntFlags parameter.

Returns: None.

Definition at line 1028 of file eeprom.c.

References ASSERT, EEPROM_EEINT, EEPROM_EEINT_INT, EEPROM_INT_PROGRAM, FLASH_FCIM, FLASH_FCIM_EMASK, and HWREG.

 {
     //
     // Look for valid interrupt sources.
     //
     ASSERT(ui32IntFlags == EEPROM_INT_PROGRAM);
 
     //
     // Disable the EEPROM interrupt in the flash controller module.
     //
     HWREG(FLASH_FCIM) &= ~FLASH_FCIM_EMASK;
 
     //
     // Disable interrupts from the EEPROM module.
     //
     HWREG(EEPROM_EEINT) &= ~EEPROM_EEINT_INT;
 }

void EEPROMIntEnable ( uint32_t ui32IntFlags )

Enables the EEPROM interrupt.

Parameters

ui32IntFlags indicates which EEPROM interrupt source to enable. This must be EEPROM_INT_PROGRAM currently.

This function enables the EEPROM interrupt. When enabled, an interrupt is generated when any EEPROM write or erase operation completes. The EEPROM peripheral shares a single interrupt vector with the flash memory subsystem, INT_FLASH. This function is provided as a convenience but the EEPROM interrupt can also be enabled using a call to FlashIntEnable() passing FLASH_INT_EEPROM in the ui32IntFlags parameter.

Returns: None.

Definition at line 992 of file eeprom.c.

References ASSERT, EEPROM_EEINT, EEPROM_EEINT_INT, EEPROM_INT_PROGRAM, FLASH_FCIM, FLASH_FCRIS_ERIS, and HWREG.

 {
     //
     // Look for valid interrupt sources.
     //
     ASSERT(ui32IntFlags == EEPROM_INT_PROGRAM);
 
     //
     // Enable interrupts from the EEPROM module.
     //
     HWREG(EEPROM_EEINT) |= EEPROM_EEINT_INT;
 
     //
     // Enable the EEPROM interrupt in the flash controller module.
     //
     HWREG(FLASH_FCIM) |= FLASH_FCRIS_ERIS;
 }

uint32_t EEPROMIntStatus ( bool bMasked )

Reports the state of the EEPROM interrupt.

Parameters

bMasked determines whether the masked or unmasked state of the interrupt is to be returned. If bMasked is true, the masked state is returned, otherwise the unmasked state is returned.

This function allows an application to query the state of the EEPROM interrupt. If active, the interrupt may be cleared by calling EEPROMIntClear().

Returns: Returns EEPROM_INT_PROGRAM if an interrupt is being signaled or 0 otherwise.

Definition at line 1063 of file eeprom.c.

References EEPROM_EEDONE, EEPROM_EEDONE_WORKING, EEPROM_INT_PROGRAM, FLASH_FCMISC, FLASH_FCMISC_EMISC, and HWREG.

 {
     if(bMasked)
     {
         //
         // If asked for the masked interrupt status, we check to see if the
         // relevant interrupt is pending in the flash controller then return
         // the appropriate EEPROM flag if it is.
         //
         return((HWREG(FLASH_FCMISC) & FLASH_FCMISC_EMISC) ?
                EEPROM_INT_PROGRAM : 0);
     }
     else
     {
         //
         // If asked for the unmasked interrupt status, infer that an interrupt
         // is pending if the WORKING bit of the EEDONE register is clear.  The
         // actual interrupt fires on the high to low transition of this bit
         // but we don't have access to an unmasked interrupt status for the
         // EEPROM because it's handled via the flash controller so we have to
         // make do with this instead.
         //
         return((HWREG(EEPROM_EEDONE) & EEPROM_EEDONE_WORKING) ?
                0 : EEPROM_INT_PROGRAM);
     }
 }

uint32_t EEPROMMassErase ( void )

Erases the EEPROM and returns it to the factory default condition.

This function completely erases the EEPROM and removes any and all access protection on its blocks, leaving the device in the factory default condition. After this operation, all EEPROM words contain the value 0xFFFFFFFF and all blocks are accessible for both read and write operations in all CPU modes. No passwords are active.

The function is synchronous and does not return until the erase operation has completed.

Returns: Returns 0 on success or non-zero values on failure. Failure codes are logical OR combinations of EEPROM_RC_WRBUSY, EEPROM_RC_NOPERM, EEPROM_RC_WKCOPY, EEPROM_RC_WKERASE, and EEPROM_RC_WORKING.

Definition at line 587 of file eeprom.c.

References _EEPROMSectorMaskClear(), _EEPROMWaitForDone(), CLASS_IS_TM4C123, EEPROM_EEDBGME, EEPROM_EEDBGME_ME, EEPROM_EEDONE, EEPROM_MASS_ERASE_KEY, HWREG, REVISION_IS_A0, SYSCTL_PERIPH_EEPROM0, SysCtlDelay(), and SysCtlPeripheralReset().

 {
     //
     // This is a workaround for a silicon problem on Blizzard rev A.
     //
     if(CLASS_IS_TM4C123 && REVISION_IS_A0)
     {
         _EEPROMSectorMaskClear();
     }
 
     //
     // Start the mass erase processing
     //
     HWREG(EEPROM_EEDBGME) = EEPROM_MASS_ERASE_KEY | EEPROM_EEDBGME_ME;
 
     //
     // Wait for completion.
     //
     _EEPROMWaitForDone();
 
     //
     // Reset the peripheral.  This is required so that all protection
     // mechanisms and passwords are reset now that the EEPROM data has been
     // scrubbed.
     //
     SysCtlPeripheralReset(SYSCTL_PERIPH_EEPROM0);
 
     //
     // Wait for completion again.
     //
     SysCtlDelay(2);
     _EEPROMWaitForDone();
 
     //
     // Pass any error codes back to the caller.
     //
     return(HWREG(EEPROM_EEDONE));
 }

Here is the call graph for this function:

uint32_t EEPROMProgram	(	uint32_t *	pui32Data,
		uint32_t	ui32Address,
		uint32_t	ui32Count
	)

Writes data to the EEPROM.

Parameters

pui32Data	points to the first word of data to write to the EEPROM.
ui32Address	defines the byte address within the EEPROM that the data is to be written to. This value must be a multiple of 4.
ui32Count	defines the number of bytes of data that is to be written. This value must be a multiple of 4.

This function may be called to write data into the EEPROM at a given word-aligned address. The call is synchronous and returns only after all data has been written or an error occurs.

Returns: Returns 0 on success or non-zero values on failure. Failure codes are logical OR combinations of EEPROM_RC_WRBUSY, EEPROM_RC_NOPERM, EEPROM_RC_WKCOPY, EEPROM_RC_WKERASE, and EEPROM_RC_WORKING.

Definition at line 381 of file eeprom.c.

References _EEPROMSectorMaskClear(), _EEPROMSectorMaskSet(), ASSERT, CLASS_IS_TM4C123, EEPROM_EEBLOCK, EEPROM_EEDONE, EEPROM_EEDONE_NOPERM, EEPROM_EEDONE_WORKING, EEPROM_EEOFFSET, EEPROM_EERDWRINC, EEPROM_EESIZE, EEPROMBlockFromAddr, HWREG, OFFSET_FROM_ADDR, REVISION_IS_A0, SIZE_FROM_EESIZE, and SysCtlDelay().

 {
     uint32_t ui32Status;
 
     //
     // Check parameters in a debug build.
     //
     ASSERT(pui32Data);
     ASSERT(ui32Address < SIZE_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
     ASSERT((ui32Address + ui32Count) <=
            SIZE_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
     ASSERT((ui32Address & 3) == 0);
     ASSERT((ui32Count & 3) == 0);
 
     //
     // Make sure the EEPROM is idle before we start.
     //
     do
     {
         //
         // Read the status.
         //
         ui32Status = HWREG(EEPROM_EEDONE);
     }
     while(ui32Status & EEPROM_EEDONE_WORKING);
 
     //
     // Set the block and offset appropriately to program the first word.
     //
     HWREG(EEPROM_EEBLOCK) = EEPROMBlockFromAddr(ui32Address);
     HWREG(EEPROM_EEOFFSET) = OFFSET_FROM_ADDR(ui32Address);
 
     //
     // Convert the byte count to a word count.
     //
     ui32Count /= 4;
 
     //
     // Write each word in turn.
     //
     while(ui32Count)
     {
         //
         // This is a workaround for a silicon problem on Blizzard rev A.  We
         // need to do this before every word write to ensure that we don't
         // have problems in multi-word writes that span multiple flash sectors.
         //
         if(CLASS_IS_TM4C123 && REVISION_IS_A0)
         {
             _EEPROMSectorMaskSet(ui32Address);
         }
 
         //
         // Write the next word through the autoincrementing register.
         //
         HWREG(EEPROM_EERDWRINC) = *pui32Data;
 
         //
         // Wait a few cycles.  In some cases, the WRBUSY bit is not set
         // immediately and this prevents us from dropping through the polling
         // loop before the bit is set.
         //
         SysCtlDelay(10);
 
         //
         // Wait for the write to complete.
         //
         do
         {
             //
             // Read the status.
             //
             ui32Status = HWREG(EEPROM_EEDONE);
         }
         while(ui32Status & EEPROM_EEDONE_WORKING);
 
         //
         // Make sure we completed the write without errors.  Note that we
         // must check this per-word because write permission can be set per
         // block resulting in only a section of the write not being performed.
         //
         if(ui32Status & EEPROM_EEDONE_NOPERM)
         {
             //
             // An error was reported that would prevent the values from
             // being written correctly.
             //
             if(CLASS_IS_TM4C123 && REVISION_IS_A0)
             {
                 _EEPROMSectorMaskClear();
             }
             return(ui32Status);
         }
 
         //
         // Move on to the next word.
         //
         pui32Data++;
         ui32Count--;
 
         //
         // Do we need to move to the next block?  This is the case if the
         // offset register has just wrapped back to 0.  Note that we only
         // write the block register if we have more data to read.  If this
         // register is written, the hardware expects a read or write operation
         // next.  If a mass erase is requested instead, the mass erase will
         // fail.
         //
         if(ui32Count && (HWREG(EEPROM_EEOFFSET) == 0))
         {
             HWREG(EEPROM_EEBLOCK) += 1;
         }
     }
 
     //
     // Clear the sector protection bits to prevent possible problems when
     // programming the main flash array later.
     //
     if(CLASS_IS_TM4C123 && REVISION_IS_A0)
     {
         _EEPROMSectorMaskClear();
     }
 
     //
     // Return the current status to the caller.
     //
     return(HWREG(EEPROM_EEDONE));
 }

Here is the call graph for this function:

uint32_t EEPROMProgramNonBlocking	(	uint32_t	ui32Data,
		uint32_t	ui32Address
	)

Writes a word to the EEPROM.

Parameters

ui32Data	is the word to write to the EEPROM.
ui32Address	defines the byte address within the EEPROM to which the data is to be written. This value must be a multiple of 4.

This function is intended to allow EEPROM programming under interrupt control. It may be called to start the process of writing a single word of data into the EEPROM at a given word-aligned address. The call is asynchronous and returns immediately without waiting for the write to complete. Completion of the operation is signaled by means of an interrupt from the EEPROM module. The EEPROM peripheral shares a single interrupt vector with the flash memory subsystem, INT_FLASH.

Returns: Returns status and error information in the form of a logical OR combinations of EEPROM_RC_WRBUSY, EEPROM_RC_NOPERM, EEPROM_RC_WKCOPY, EEPROM_RC_WKERASE and EEPROM_RC_WORKING. Flags EEPROM_RC_WKCOPY, EEPROM_RC_WKERASE, and EEPROM_RC_WORKING are expected in normal operation and do not indicate an error.

Definition at line 534 of file eeprom.c.

References _EEPROMSectorMaskSet(), ASSERT, CLASS_IS_TM4C123, EEPROM_EEBLOCK, EEPROM_EEDONE, EEPROM_EEOFFSET, EEPROM_EERDWRINC, EEPROM_EESIZE, EEPROMBlockFromAddr, HWREG, OFFSET_FROM_ADDR, REVISION_IS_A0, and SIZE_FROM_EESIZE.

 {
     //
     // Check parameters in a debug build.
     //
     ASSERT(ui32Address < SIZE_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
     ASSERT((ui32Address & 3) == 0);
 
     //
     // This is a workaround for a silicon problem on Blizzard rev A.
     //
     if(CLASS_IS_TM4C123 && REVISION_IS_A0)
     {
         _EEPROMSectorMaskSet(ui32Address);
     }
 
     //
     // Set the block and offset appropriately to program the desired word.
     //
     HWREG(EEPROM_EEBLOCK) = EEPROMBlockFromAddr(ui32Address);
     HWREG(EEPROM_EEOFFSET) = OFFSET_FROM_ADDR(ui32Address);
 
     //
     // Write the new word using the auto-incrementing register just in case
     // the caller wants to write follow-on words using direct register access
     //
     HWREG(EEPROM_EERDWRINC) = ui32Data;
 
     //
     // Return the current status to the caller.
     //
     return(HWREG(EEPROM_EEDONE));
 }

Here is the call graph for this function:

void EEPROMRead	(	uint32_t *	pui32Data,
		uint32_t	ui32Address,
		uint32_t	ui32Count
	)

Reads data from the EEPROM.

Parameters

pui32Data	is a pointer to storage for the data read from the EEPROM. This pointer must point to at least ui32Count bytes of available memory.
ui32Address	is the byte address within the EEPROM from which data is to be read. This value must be a multiple of 4.
ui32Count	is the number of bytes of data to read from the EEPROM. This value must be a multiple of 4.

This function may be called to read a number of words of data from a word-aligned address within the EEPROM. Data read is copied into the buffer pointed to by the pui32Data parameter.

Returns: None.

Definition at line 307 of file eeprom.c.

References ASSERT, EEPROM_EEBLOCK, EEPROM_EEOFFSET, EEPROM_EERDWRINC, EEPROM_EESIZE, EEPROMBlockFromAddr, HWREG, OFFSET_FROM_ADDR, and SIZE_FROM_EESIZE.

 {
     //
     // Check parameters in a debug build.
     //
     ASSERT(pui32Data);
     ASSERT(ui32Address < SIZE_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
     ASSERT((ui32Address + ui32Count) <=
            SIZE_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
     ASSERT((ui32Address & 3) == 0);
     ASSERT((ui32Count & 3) == 0);
 
     //
     // Set the block and offset appropriately to read the first word.
     //
     HWREG(EEPROM_EEBLOCK) = EEPROMBlockFromAddr(ui32Address);
     HWREG(EEPROM_EEOFFSET) = OFFSET_FROM_ADDR(ui32Address);
 
     //
     // Convert the byte count to a word count.
     //
     ui32Count /= 4;
 
     //
     // Read each word in turn.
     //
     while(ui32Count)
     {
         //
         // Read the next word through the autoincrementing register.
         //
         *pui32Data = HWREG(EEPROM_EERDWRINC);
 
         //
         // Move on to the next word.
         //
         pui32Data++;
         ui32Count--;
 
         //
         // Do we need to move to the next block?  This is the case if the
         // offset register has just wrapped back to 0.  Note that we only
         // write the block register if we have more data to read.  If this
         // register is written, the hardware expects a read or write operation
         // next.  If a mass erase is requested instead, the mass erase will
         // fail.
         //
         if(ui32Count && (HWREG(EEPROM_EEOFFSET) == 0))
         {
             HWREG(EEPROM_EEBLOCK) += 1;
         }
     }
 }

uint32_t EEPROMSizeGet ( void )

Determines the size of the EEPROM.

This function returns the size of the EEPROM in bytes.

Returns: Returns the total number of bytes in the EEPROM.

Definition at line 248 of file eeprom.c.

References EEPROM_EESIZE, HWREG, and SIZE_FROM_EESIZE.

 {
     //
     // Return the size of the EEPROM in bytes.
     //
     return(SIZE_FROM_EESIZE(HWREG(EEPROM_EESIZE)));
 }

uint32_t EEPROMStatusGet ( void )

Returns status on the last EEPROM program or erase operation.

This function returns the current status of the last program or erase operation performed by the EEPROM. It is intended to provide error information to applications programming or setting EEPROM protection options under interrupt control.

Returns: Returns 0 if the last program or erase operation completed without any errors. If an operation is ongoing or an error occurred, the return value is a logical OR combination of EEPROM_RC_WRBUSY, EEPROM_RC_NOPERM, EEPROM_RC_WKCOPY, EEPROM_RC_WKERASE, and EEPROM_RC_WORKING.

Definition at line 1146 of file eeprom.c.

References EEPROM_EEDONE, and HWREG.

 {
     return(HWREG(EEPROM_EEDONE));
 }

Macros

Functions

Detailed Description

Macro Definition Documentation

Function Documentation