Functions
uint32_t	CPUcpsid (void)
	Disable all external interrupts. More...

uint32_t	CPUprimask (void)
	Get the current interrupt state. More...

uint32_t	CPUcpsie (void)
	Enable all external interrupts. More...

static void	CPUwfi (void)
	Wait for interrupt. More...

static void	CPUwfe (void)
	Wait for event. More...

static void	CPUsev (void)
	Send event. More...

static void	CPUbasepriSet (uint32_t ui32NewBasepri)
	Update the interrupt priority disable level. More...

uint32_t	CPUbasepriGet (void)
	Get the interrupt priority disable level. More...

void	CPUdelay (uint32_t ui32Count)
	Provide a small delay. More...

static void	CPU_WriteBufferDisable (void)
	Disable CPU write buffering (recommended for debug purpose only). More...

static void	CPU_WriteBufferEnable (void)
	Enable CPU write buffering (default setting). More...

Detailed Description

Introduction

The CPU API provides a set of functions performing very low-level control of the system CPU. All functions in this API are written in assembler in order to either access special registers or avoid any compiler optimizations. Each function exists in several compiler specific versions: One version for each supported compiler.

Function Documentation

static void CPU_WriteBufferDisable ( void )

inlinestatic

Disable CPU write buffering (recommended for debug purpose only).

This function helps debugging "bus fault crashes". Disables write buffer use during default memory map accesses.

This causes all bus faults to be precise bus faults but decreases the performance of the processor because the stores to memory have to complete before the next instruction can be executed.

Returns: None

See also: CPU_WriteBufferEnable()

 {
     HWREGBITW( CPU_SCS_BASE + CPU_SCS_O_ACTLR, CPU_SCS_ACTLR_DISDEFWBUF_BITN ) = 1;
 }

static void CPU_WriteBufferEnable ( void )

inlinestatic

Enable CPU write buffering (default setting).

Re-enables write buffer during default memory map accesses if CPU_WriteBufferDisable() has been used for bus fault debugging.

Returns: None

See also: CPU_WriteBufferDisable()

 {
     HWREGBITW( CPU_SCS_BASE + CPU_SCS_O_ACTLR, CPU_SCS_ACTLR_DISDEFWBUF_BITN ) = 0;
 }

uint32_t CPUbasepriGet ( void )

Get the interrupt priority disable level.

Use this function to get the the level of priority that will disable interrupts with a lower priority level.

Returns: Returns the value of the BASEPRI register.

Referenced by IntPriorityMaskGet().

 {
     // Read BASEPRI.
     __asm("    mrs     r0, BASEPRI\n"
           "    bx      lr\n");
 
     // The following keeps the compiler happy, because it wants to see a
     // return value from this function.  It will generate code to return
     // a zero.  However, the real return is the "bx lr" above, so the
     // return(0) is never executed and the function returns with the value
     // you expect in R0.
     return(0);
 }

Here is the call graph for this function:

static void CPUbasepriSet ( uint32_t ui32NewBasepri )

inlinestatic

Update the interrupt priority disable level.

Use this function to change the level of priority that will disable interrupts with a lower priority level.

Parameters

ui32NewBasepri is the new basis priority level to set.

Returns: None

Referenced by IntPriorityMaskSet().

 {
     // Set the BASEPRI register.
     __asm("    msr     BASEPRI, r0\n");
 }

Here is the call graph for this function:

uint32_t CPUcpsid ( void )

Disable all external interrupts.

Use this function to disable all system interrupts. This function is implemented as a wrapper function for the CPSID instruction.

Returns: Returns the state of PRIMASK on entry

Referenced by AuxAdiDdiSafeRead(), AuxAdiDdiSafeWrite(), IntMasterDisable(), SafeHapiAuxAdiSelect(), SafeHapiVoid(), and SysCtrlSystemReset().

 {
     // Read PRIMASK and disable interrupts.
     __asm("    mrs     r0, PRIMASK\n"
           "    cpsid   i\n"
           "    bx      lr\n");
 
     // The following keeps the compiler happy, because it wants to see a
     // return value from this function.  It will generate code to return
     // a zero.  However, the real return is the "bx lr" above, so the
     // return(0) is never executed and the function returns with the value
     // you expect in R0.
     return(0);
 }

Here is the call graph for this function:

uint32_t CPUcpsie ( void )

Enable all external interrupts.

Use this function to enable all system interrupts. This function is implemented as a wrapper function for the CPSIE instruction.

Returns: Returns the state of PRIMASK on entry.

Referenced by AuxAdiDdiSafeRead(), AuxAdiDdiSafeWrite(), IntMasterEnable(), SafeHapiAuxAdiSelect(), and SafeHapiVoid().

 {
     // Read PRIMASK and enable interrupts.
     __asm("    mrs     r0, PRIMASK\n"
           "    cpsie   i\n"
           "    bx      lr\n");
 
     // The following keeps the compiler happy, because it wants to see a
     // return value from this function.  It will generate code to return
     // a zero.  However, the real return is the "bx lr" above, so the
     // return(0) is never executed and the function returns with the value
     // you expect in R0.
     return(0);
 }

Here is the call graph for this function:

void CPUdelay ( uint32_t ui32Count )

Provide a small delay.

This function provides means for generating a constant length delay. It is written in assembly to keep the delay consistent across tool chains, avoiding the need to tune the delay based on the tool chain in use.

The loop takes 3 cycles/loop.

Parameters

ui32Count is the number of delay loop iterations to perform.

Returns: None

Referenced by CRYPTOAesCbc(), CRYPTOAesEcb(), CRYPTOAesLoadKey(), CRYPTOCcmAuthEncrypt(), CRYPTOCcmAuthEncryptResultGet(), CRYPTOCcmInvAuthDecrypt(), CRYPTOCcmInvAuthDecryptResultGet(), and I2CMasterControl().

uint32_t CPUprimask ( void )

Get the current interrupt state.

Use this function to retrieve the current state of the interrupts. This function is implemented as a wrapper function returning the state of PRIMASK.

Returns: Returns the state of the PRIMASK (indicating whether interrupts are enabled or disabled).

 {
     // Read PRIMASK.
     __asm("    mrs     r0, PRIMASK\n"
           "    bx      lr\n");
 
     // The following keeps the compiler happy, because it wants to see a
     // return value from this function.  It will generate code to return
     // a zero.  However, the real return is the "bx lr" above, so the
     // return(0) is never executed and the function returns with the value
     // you expect in R0.
     return(0);
 }

Here is the call graph for this function:

static void CPUsev ( void )

inlinestatic

Send event.

Use this function to let the System CPU send an event. This function is implemented as a wrapper function for the SEV instruction.

Returns: None

 {
     // Send event.
     __asm("    sev\n");
 }

Here is the call graph for this function:

static void CPUwfe ( void )

inlinestatic

Wait for event.

Use this function to let the System CPU wait for the next event. This function is implemented as a wrapper function for the WFE instruction.

Returns: None

 {
     // Wait for the next event.
     __asm("    wfe\n");
 }

Here is the call graph for this function:

static void CPUwfi ( void )

inlinestatic

Wait for interrupt.

Use this function to let the System CPU wait for the next interrupt. This function is implemented as a wrapper function for the WFI instruction.

Returns: None

Referenced by PRCMDeepSleep(), and PRCMSleep().

 {
     // Wait for the next interrupt.
     __asm("    wfi\n");
 }

Here is the call graph for this function:

Functions

Detailed Description

Introduction

Function Documentation