shared_params.c File Reference

Typedefs
typedef struct t_shared_params_buffer	tSharedParamsBuffer
	Layout of the shared parameters RAM buffer.

Functions
static tSharedParamsBuffer sharedParamsBuffer	__attribute__ ((section(".shared")))
static bool	SharedParamsValidateBuffer (void)
	Validates the shared parameter buffer contents by looking at the table identifier and verifying its checksum.
static void	SharedParamsWriteChecksum (void)
	Calculates and writes the checksum into the buffer.
static bool	SharedParamsVerifyChecksum (void)
	Calculates and verifies the checksum that is currently present in the buffer.
static uint16_t	SharedParamsCalculateChecksum (void)
	Calculates and returns the checksum value for the current contents in the buffer. The checksum is calculated by taking the sum of all bytes in the parameter buffer (excluding the checksum at the end) and them taking the two's complement value of it.
void	SharedParamsInit (void)
	Initializes the shared RAM parameters module.
bool	SharedParamsReadByIndex (uint32_t idx, uint8_t *value)
	Reads a data byte from the shared parameter buffer at the specified index.
bool	SharedParamsWriteByIndex (uint32_t idx, uint8_t value)
	Writes a data byte to the shared parameter buffer at the specified index.

Typedef Documentation

tSharedParamsBuffer

typedef struct t_shared_params_buffer tSharedParamsBuffer

Layout of the shared parameters RAM buffer.

Function Documentation

__attribute__()

static tSharedParamsBuffer sharedParamsBuffer __attribute__ ( (section(".shared"))  )

static

SharedParamsCalculateChecksum()

static uint16_t SharedParamsCalculateChecksum ( void  )

static

Calculates and returns the checksum value for the current contents in the buffer. The checksum is calculated by taking the sum of all bytes in the parameter buffer (excluding the checksum at the end) and them taking the two's complement value of it.

Returns

The calculated checksum value.

Definition at line 237 of file shared_params.c.

{
  uint16_t result = 0;
  uint32_t byteIdx;
 
  /* Add the identifier bytes to the checksum. */
  result += (uint8_t)sharedParamsBuffer.identifier;
  result += (uint8_t)(sharedParamsBuffer.identifier >> 8u);
  result += (uint8_t)(sharedParamsBuffer.identifier >> 16u);
  result += (uint8_t)(sharedParamsBuffer.identifier >> 24u);
  /* Loop through the parameter data array. */
  for (byteIdx=0; byteIdx<SHARED_PARAMS_CFG_BUFFER_DATA_LEN; byteIdx++)
  {
    /* Add parameter data byte to the checksum. */
    result += (uint8_t)sharedParamsBuffer.data[byteIdx];
  }
  /* Determine one's complement. */
  result = ~result;
  /* Determine two's complement. */
  result += 1;
  /* Give the result back to the caller. */
  return result;
} /*** end of SharedParamsCalculateChecksum ***/

Referenced by SharedParamsVerifyChecksum(), and SharedParamsWriteChecksum().

Here is the caller graph for this function:

SharedParamsInit()

void SharedParamsInit

(

void

)

Initializes the shared RAM parameters module.

Returns

none.

Definition at line 83 of file shared_params.c.

{
  uint32_t byteIdx;
 
  /* The shared parameter buffer does not get initialized by the C-startup code. Another
   * previously running program could have initialized it, in which case it is ready
   * for use and nothing more needs to be done.
   */
  if (!SharedParamsValidateBuffer())
  {
    /* The shared parameter buffer was not yet initialized by a running program. This
     * typically happens after a cold reset where the RAM contents were lost. In this
     * case we need to explicitly configure and initialize it, since the C-startup code
     * was configured to not do this.
     *
     * The initialization consists of setting the buffer identifier, zeroing the
     * actual parameter data and updating the checksum at the end.
     */
    sharedParamsBuffer.identifier = SHARED_PARAMS_BUFFER_ID;
    for (byteIdx=0; byteIdx < SHARED_PARAMS_CFG_BUFFER_DATA_LEN; byteIdx++)
    {
      sharedParamsBuffer.data[byteIdx] = 0;
    }
    SharedParamsWriteChecksum();
  }
} /*** end of SharedParamsInit ***/

Referenced by jump_to_openblt(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

SharedParamsReadByIndex()

bool SharedParamsReadByIndex	(	uint32_t	idx,
		uint8_t *	value
	)

Reads a data byte from the shared parameter buffer at the specified index.

Parameters

idx	Index into the parameter data array. A valid value is between 0 and (SHARED_PARAMS_CFG_BUFFER_DATA_LEN - 1).
value	Pointer to where the read data value is stored.

Returns

True if successful, false otherwise.

Definition at line 119 of file shared_params.c.

{
  bool result = false;
 
  /* Only continue if the buffer and the specified parameters are valid. */
  if ( (SharedParamsValidateBuffer()) &&
       (idx < SHARED_PARAMS_CFG_BUFFER_DATA_LEN)  &&
       (value != NULL) )
  {
    /* Read the value and update the result. */
    *value = sharedParamsBuffer.data[idx];
    result = true;
  }
  /* Give the result back to the caller. */
  return result;
} /*** end of SharedParamsReadByIndex ***/

Referenced by checkIfRebootIntoOpenBltRequested(), and checkIfResetLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

SharedParamsValidateBuffer()

static bool SharedParamsValidateBuffer ( void  )

static

Validates the shared parameter buffer contents by looking at the table identifier and verifying its checksum.

Returns

True if successful, false otherwise.

Definition at line 180 of file shared_params.c.

{
  bool result = false;
 
  /* Perform validation. */
  if ( (sharedParamsBuffer.identifier == SHARED_PARAMS_BUFFER_ID) &&
       (SharedParamsVerifyChecksum()) )
  {
    /* The shared parameter buffer is valid, so update the result value. */
    result = true;
  }
  /* Give the result back to the caller. */
  return result;
} /*** end of SharedParamsValitabeTable ***/

Referenced by SharedParamsInit(), SharedParamsReadByIndex(), and SharedParamsWriteByIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

SharedParamsVerifyChecksum()

static bool SharedParamsVerifyChecksum ( void  )

static

Calculates and verifies the checksum that is currently present in the buffer.

Returns

True is the checksum is correct, false otherwise.

Definition at line 214 of file shared_params.c.

{
  bool result = false;
 
  /* Calculate and verify the checksum. */
  if (SharedParamsCalculateChecksum() == sharedParamsBuffer.checksum)
  {
    /* Checksum is correct, so update the result value. */
    result = true;
  }
  /* Give the result back to the caller. */
  return result;
} /*** end of SharedParamsVerifyChecksum ***/

Referenced by SharedParamsValidateBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

SharedParamsWriteByIndex()

bool SharedParamsWriteByIndex	(	uint32_t	idx,
		uint8_t	value
	)

Writes a data byte to the shared parameter buffer at the specified index.

Parameters

idx	Index into the parameter data array. A valid value is between 0 and (SHARED_PARAMS_CFG_BUFFER_DATA_LEN - 1).
value	Value to write.

Returns

True if successful, false otherwise.

Definition at line 145 of file shared_params.c.

{
  bool result = false;
 
  /* Only continue if the buffer and the specified parameters are valid. */
  if ( (SharedParamsValidateBuffer()) &&
       (idx < SHARED_PARAMS_CFG_BUFFER_DATA_LEN) )
  {
    /* Write the value. */
    sharedParamsBuffer.data[idx] = value;
    /* Update the checksum since the contents were just changed. */
    SharedParamsWriteChecksum();
    /* Update the result. */
    result = true;
 
    // Flush pipelines
    __ISB();
    __DSB();
 
    #if CORTEX_MODEL == 7
      // If we have a cache, drop the relevant cache lines.
      SCB_CleanDCache_by_Addr((uint32_t*)&sharedParamsBuffer, sizeof(sharedParamsBuffer));
    #endif
  }
  /* Give the result back to the caller. */
  return result;
} /*** end of SharedParamsWriteByIndex ***/

Referenced by checkIfRebootIntoOpenBltRequested(), checkIfResetLoop(), jump_to_openblt(), and tryResetWatchdog().

Here is the call graph for this function:

Here is the caller graph for this function:

SharedParamsWriteChecksum()

static void SharedParamsWriteChecksum ( void  )

static

Calculates and writes the checksum into the buffer.

Returns

none.

Definition at line 201 of file shared_params.c.

{
  /* Calculate and write the checksum. */
  sharedParamsBuffer.checksum = SharedParamsCalculateChecksum();
} /*** end of SharedParamsWriteChecksum ***/

Referenced by SharedParamsInit(), and SharedParamsWriteByIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

Go to the source code of this file.