Hint: Use the tree menu to navigate groups of related pages

Using FreeRTOS on ARM Cortex-A9 Embedded Processors
That use a proprietary interrupt controller

Introduction

On this page:

• Features of the FreeRTOS ARM Cortex-A kernel port
• Using the floating point unit (FPU)
• ARM Cortex-A specific FreeRTOSConfig.h settings
• Configuring and installing the RTOS tick interrupt
• Interrupt handling
• Installing the FreeRTOS IRQ and SWI (SVC) interrupt handlers
• Cortex-A processor modes and stacks

Features of the FreeRTOS ARM Cortex-A RTOS port

• Extends the use of the familiar, small, simple, deterministic, de facto standard FreeRTOS kernel beyond the microcontroller market

• Supports interrupt nesting (note that, unlike the RTOS version for ARM Cortex-A parts that incorporate a GIC, the version for processors with a proprietary interrupt controller does not keep a subset of interrupt priorities permanently enabled - this is because no assumptions are made as to the interrupt controller in use).

• Includes hardware floating point support

• Uses a flat/linear memory model (the MMU is not supported).

Using the floating point unit (FPU)

void vATaskFunction( void *pvParameters )
{
double x, y;

    /* This task is going to use floating point operations.  Therefore it calls
    portTASK_USES_FLOATING_POINT() once on task entry, before entering the loop
    that implements its functionality.  From this point on the task has a floating
    point context. */
    portTASK_USES_FLOATING_POINT();

    /* Enter the loop that implements the task's function. */
    for( ;; )
    {
        /* portTASK_USES_FLOATING_POINT() has already been called, so it is safe
        to use the floating point x and y variables here... */
        x = [whatever];
        y = [whatever];
    }
}
						

It should be noted that, by default, the Cortex-A9 port does not support the use of the floating point unit in interrupts. If it is necessary to use the floating point unit in interrupts then it will also be necessary to save the entire floating point context to the stack on entry to each (potentially nested) interrupt.

ARM Cortex-A specific FreeRTOSConfig.h settings

• configFPU_D32

  If the FPU has 16 'd' registers then set configFPU_D32 to 0. If the FPU has 32 'd' registers then set configFPU_D32 to 1.

• configINTERRUPT_VECTOR_ADDRESS

  Most interrupt controllers contain a register from which the address of the currently asserted (executing) interrupt handler can be read. If such a register exists then set configINTERRUPT_VECTOR_ADDRESS to its address. If such a register does not exist then set configINTERRUPT_VECTOR_ADDRESS to the address of a variable that points to a central interrupt handler.

• configEOI_ADDRESS

  Most interrupt controllers contain an End of Interrupt (EOI) register that must be written to at the end of an interrupt handing routine. If such a register exists then set configEIO_ADDRESS to its address. If a register does not exist then set configEIO_ADDRESS to the address of a variable to which writes will be harmless.

• configCLEAR_TICK_INTERRUPT()

  As described in the "Configuring and installing the RTOS tick interrupt" section below, the RTOS tick interrupt can be generated from any convenient timer source. If the interrupt generated by the selected timer must be cleared within its handling function then defined configCLEAR_TICK_INTERRUPT() to clear the interrupt. If the interrupt generated by the selected timer does not require explicit clearing then configCLEAR_TICK_INTERRUPT() can be defined to nothing (so it does not generate any code).

Note: If there is an official demo for the Cortex-A9 processor you are using then the FreeRTOSConfig.h file provided with the demo will already contain the correct settings.

Configuring and installing the RTOS tick interrupt

The macro configSETUP_TICK_INTERRUPT() is called by the RTOS kernel port layer. configSETUP_TICK_INTERRUPT() must be #defined in FreeRTOSConfig.h to configure a peripheral to generate a periodic interrupt at the frequency set by the configTICK_RATE_HZ FreeRTOSConfig.h setting. FreeRTOS_Tick_Handler() must then be installed as the interrupt's handling function. For example:

/* Implement a function in a C file to generate a periodic interrupt at the
required frequency. */
void vSetupTickInterrupt( void )
{
/* FreeRTOS_Tick_Handler() is itself defined in the RTOS port layer.  An extern
declaration is required to allow the following code to compile. */
extern void FreeRTOS_Tick_Handler( void );

    /* Assume TIMER1_configure() configures a hypothetical timer peripheral called
    TIMER1 to generate a periodic interrupt with a frequency set by its parameter. */
    TIMER1_configure( configTICK_RATE_HZ );

    /* Next assume Install_Interrupt() installs the function passed as its second
    parameter as the handler for the peripheral passed as its first parameter. */
    Install_Interrupt( TIMER1, FreeRTOS_Tick_Handler );
}
						

/* Given the function definition above, add the following line to FreeRTOSConfig.h. */
#define configSETUP_TICK_INTERRUPT() vSetupTickInterrupt()
						

Interrupt handling

Interrupt entry, nesting, and exit is managed by the RTOS kernel port layer so interrupt handlers provided by the application writer can be standard C functions. Specific interrupt related pragmas, assembly code wrappers or attribute qualifiers are not required.

Interrupt handling routes provided by the application writer are called by the RTOS with interrupts enabled.

Also see the description of the configINTERRUPT_VECTOR_ADDRESS FreeRTOSConfig.h setting above.

Installing the FreeRTOS IRQ and SWI (SVC) interrupt handlers

FreeRTOS_SWI_Handler() must be installed as the Cortex-A's SWI (SVC) handler.

If it is not possible to edit the interrupt vector code then map the FreeRTOS handlers to the required handler names using #defines in FreeRTOSConfig.h. For example, if the installed handlers are called IRQ_Handler() and SWI_Handler() respectively, then the FreeRTOS handlers can be mapped to these names by adding the following two lines to FreeRTOSConfig.h.

#define FreeRTOS_IRQ_Handler IRQ_Handler
#define FreeRTOS_SWI_Handler SWI_Handler
						

Cortex-A processor modes and stacks

It is not necessary to allocate a stack to User/System mode unless main() is called from System mode (main() must not be called from User mode). If a stack is allocated to User/System mode it will not be used after the RTOS kernel has been started.

The RTOS stack overflow detection functionality only detects overflows in task stacks, not IRQ or Supervisor stacks.