Functions
fsp_err_t	R_FSP_VersionGet (fsp_pack_version_t *const p_version)

void	Default_Handler (void)

BSP_TARGET_ARM BSP_ATTRIBUTE_STACKLESS void	system_init (void)

BSP_TARGET_ARM BSP_ATTRIBUTE_STACKLESS void	bsp_register_initialization (void)

void	SystemInit (void)

void	R_BSP_WarmStart (bsp_warm_start_event_t event)

BSP_ATTRIBUTE_STACKLESS void	R_BSP_WarmStart_StackLess (void)

void	R_BSP_CacheEnableInst (void)

void	R_BSP_CacheEnableData (void)

void	R_BSP_CacheEnableMemoryProtect (void)

void	R_BSP_CacheDisableInst (void)

void	R_BSP_CacheDisableData (void)

void	R_BSP_CacheDisableMemoryProtect (void)

void	R_BSP_CacheCleanAll (void)

void	R_BSP_CacheInvalidateAll (void)

void	R_BSP_CacheCleanInvalidateAll (void)

void	R_BSP_CacheCleanRange (uintptr_t base_address, uintptr_t length)

void	R_BSP_CacheInvalidateRange (uintptr_t base_address, uintptr_t length)

void	R_BSP_CacheCleanInvalidateRange (uintptr_t base_address, uintptr_t length)

void	R_BSP_CacheL3PowerCtrl (void)

__WEAK void	R_BSP_FspAssert (void)

__STATIC_INLINE IRQn_Type	R_FSP_CurrentIrqGet (void)

__STATIC_INLINE uint32_t	R_FSP_SystemClockHzGet (fsp_priv_clock_t clock)

void	R_BSP_SoftwareDelay (uint32_t delay, bsp_delay_units_t units)

__STATIC_INLINE void	R_FSP_IsrContextSet (IRQn_Type const irq, void *p_context)
	Sets the ISR context associated with the requested IRQ. More...

__STATIC_INLINE void	R_BSP_IrqClearPending (IRQn_Type irq)

__STATIC_INLINE uint32_t	R_BSP_IrqPendingGet (IRQn_Type irq)

__STATIC_INLINE void	R_BSP_IrqCfg (IRQn_Type const irq, uint32_t priority, void *p_context)

__STATIC_INLINE void	R_BSP_IrqEnableNoClear (IRQn_Type const irq)

__STATIC_INLINE void	R_BSP_IrqEnable (IRQn_Type const irq)

__STATIC_INLINE void	R_BSP_IrqDisable (IRQn_Type const irq)

__STATIC_INLINE void	R_BSP_IrqCfgEnable (IRQn_Type const irq, uint32_t priority, void *p_context)

__STATIC_INLINE void *	R_FSP_IsrContextGet (IRQn_Type const irq)
	Finds the ISR context associated with the requested IRQ. More...

__STATIC_INLINE void	R_BSP_IrqDetectTypeSet (IRQn_Type const irq, uint32_t detect_type)

__STATIC_INLINE void	R_BSP_IrqGroupSet (IRQn_Type const irq, uint32_t interrupt_group)

__STATIC_INLINE void	R_BSP_IrqMaskLevelSet (uint32_t mask_level)

__STATIC_INLINE uint32_t	R_BSP_IrqMaskLevelGet (void)

void	R_BSP_RegisterProtectEnable (bsp_reg_protect_t regs_to_protect)

void	R_BSP_RegisterProtectDisable (bsp_reg_protect_t regs_to_unprotect)

void	R_BSP_SystemReset (void)

void	R_BSP_CpuReset (bsp_reset_t cpu)

void	R_BSP_CpuResetAutoRelease (bsp_reset_t cpu)

void	R_BSP_CpuResetRelease (bsp_reset_t cpu)

void	R_BSP_ModuleResetEnable (bsp_module_reset_t module_to_enable)

void	R_BSP_ModuleResetDisable (bsp_module_reset_t module_to_disable)

BSP_TFU_INLINE float	__sinf (float angle)

BSP_TFU_INLINE float	__cosf (float angle)

BSP_TFU_INLINE void	__sincosf (float angle, float sin, float cos)

BSP_TFU_INLINE float	__atan2f (float y_cord, float x_cord)

BSP_TFU_INLINE float	__hypotf (float x_cord, float y_cord)

BSP_TFU_INLINE void	__atan2hypotf (float y_cord, float x_cord, float atan2, float hypot)

BSP_TFU_INLINE uint32_t	__sinfx (uint32_t angle)

BSP_TFU_INLINE uint32_t	__cosfx (uint32_t angle)

BSP_TFU_INLINE void	__sincosfx (uint32_t angle, uint32_t sin, uint32_t cos)

BSP_TFU_INLINE uint32_t	__atan2fx (uint32_t y_cord, uint32_t x_cord)

BSP_TFU_INLINE int32_t	__hypotfx (uint32_t x_cord, uint32_t y_cord)

BSP_TFU_INLINE void	__atan2hypotfx (uint32_t y_cord, uint32_t x_cord, uint32_t atan2, int32_t hypot)

BSP_ATTRIBUTE_STACKLESS void	r_bsp_software_delay_loop (__attribute__((unused)) uint32_t loop_cnt)

fsp_err_t	R_BSP_GroupIrqWrite (bsp_grp_irq_t irq, void(*p_callback)(bsp_grp_irq_t irq))

void	R_BSP_GICD_SetCtlr (bsp_gicd_ctlr_bit_t bit)

uint32_t	R_BSP_GICD_GetCtlr (void)

void	R_BSP_GICD_Enable (bsp_gicd_ctlr_bit_t bit)

void	R_BSP_GICD_Disable (bsp_gicd_ctlr_bit_t bit)

void	R_BSP_GICD_AffinityRouteEnable (bsp_gicd_ctlr_bit_t bit)

void	R_BSP_GICD_SpiEnable (IRQn_Type irq)

void	R_BSP_GICD_SpiDisable (IRQn_Type irq)

void	R_BSP_GICD_SetSpiPriority (IRQn_Type irq, uint32_t priority)

uint32_t	R_BSP_GICD_GetSpiPriority (IRQn_Type irq)

void	R_BSP_GICD_SetSpiRoute (IRQn_Type id, uint64_t route, bsp_gicd_irouter_route_t mode)

uint64_t	R_BSP_GICD_GetSpiRoute (IRQn_Type id)

void	R_BSP_GICD_SetSpiSense (IRQn_Type irq, bsp_gicd_icfgr_sense_t sense)

uint32_t	R_BSP_GICD_GetSpiSense (IRQn_Type irq)

void	R_BSP_GICD_SetSpiPending (IRQn_Type irq)

uint32_t	R_BSP_GICD_GetSpiPending (IRQn_Type irq)

void	R_BSP_GICD_SetSpiClearPending (IRQn_Type irq)

uint32_t	R_BSP_GICD_GetSpiClearPending (IRQn_Type irq)

void	R_BSP_GICD_SetSpiSecurity (IRQn_Type irq, bsp_gic_igroupr_secure_t group)

void	R_BSP_GICD_SetSpiSecurityLine (uint32_t line, bsp_gic_igroupr_secure_t group)

void	R_BSP_GICD_SetSpiSecurityAll (bsp_gic_igroupr_secure_t group)

void	R_BSP_GICD_SetSpiClass (IRQn_Type id, bsp_gicd_iclar_class_t class_group)

void	R_BSP_GICR_Enable (void)

void	R_BSP_GICR_SgiPpiEnable (IRQn_Type irq)

void	R_BSP_GICR_SgiPpiDisable (IRQn_Type irq)

void	R_BSP_GICR_SetSgiPpiPriority (IRQn_Type irq, uint32_t priority)

uint32_t	R_BSP_GICR_GetSgiPpiPriority (IRQn_Type irq)

void	R_BSP_GICR_SetSgiPpiSense (IRQn_Type irq, bsp_gicd_icfgr_sense_t sense)

uint32_t	R_BSP_GICR_GetSgiPpiSense (IRQn_Type irq)

void	R_BSP_GICR_SetSgiPpiPending (IRQn_Type irq)

uint32_t	R_BSP_GICR_GetSgiPpiPending (IRQn_Type irq)

void	R_BSP_GICR_SetSgiPpiClearPending (IRQn_Type irq)

uint32_t	R_BSP_GICR_GetSgiPpiClearPending (IRQn_Type irq)

void	R_BSP_GICR_SetSgiPpiSecurity (IRQn_Type irq, bsp_gic_igroupr_secure_t group)

void	R_BSP_GICR_SetSgiPpiSecurityLine (bsp_gic_igroupr_secure_t group)

void	R_BSP_GICR_SetClass (bsp_gicd_iclar_class_t class_group)

uint32_t	R_BSP_GICR_GetRoute (void)

void	R_BSP_GICC_SetMaskLevel (uint64_t mask_level)

uint64_t	R_BSP_GICC_GetMaskLevel (void)

void	R_BSP_GICC_SetEoiGrp0 (IRQn_Type irq)

void	R_BSP_GICC_SetEoiGrp1 (IRQn_Type irq)

uint32_t	R_BSP_GICC_Get_IntIdGrp0 (void)

uint32_t	R_BSP_GICC_Get_IntIdGrp1 (void)

fsp_err_t	R_BSP_MmuVatoPa (uint64_t vaddress, uint64_t *p_paddress)

fsp_err_t	R_BSP_MmuPatoVa (uint64_t paddress, uint64_t *p_vaddress, bsp_mmu_conversion_flag_t cache_flag)

fsp_err_t	R_BSP_MemoryMap (r_mmu_pgtbl_cfg_t *p_memory_map_cfg)

fsp_err_t	R_BSP_MemoryUnMap (void)

fsp_err_t	R_BSP_MpuRegionDynamicConfig (bsp_mpu_dynamic_cfg_t *p_dynamic_region_cfg)

fsp_err_t	R_BSP_MpuRegionRestoreConfig (void)

Detailed Description

The BSP is responsible for getting the MCU from reset to the user's application. Before reaching the user's application, the BSP sets up the stacks, heap, clocks, interrupts, C runtime environment, and stack monitor.

Default initialization function.

BSP Features
BSP Clock Configuration
System Interrupts
Multiplex Interrupts
External and Peripheral Interrupts
BSP Weak Symbols
Warm Start Callbacks
FSP Assert
C Runtime Initialization
Register Protection
Software Delay
Trigonometric Function
Critical Section Macros
Noncache Section
Memory Attributes
Memory Access
Dynamic Memory Protection Unit Setting
Memory Management Unit
Dynamic Memory Management Unit Setting(Dynamic Memory Mapping)
TrustZone Address Space Controller (TZC-400)
Module Stop
Module Reset
Software Reset
System Error Interrupt (SEI,NMI)
LPDDR4 SDRAM Subsystem
Linker Script
Change Program Location
Pin Setting
eSD Boot
eMMC Boot
Exclusive access
Configuration
Core Comparison

Overview

BSP Features

BSP Clock Configuration

All system clocks are set up during BSP initialization based on the settings in bsp_clock_cfg.h. These settings are derived from clock configuration information provided from the Configuration editor Clocks tab.

Clock configuration is performed prior to initializing the C runtime environment to speed up the startup process.
The BSP implements the required delays to allow the selected clock to stabilize.
The BSP will configure the CMSIS SystemCoreClock variable after clock initialization with the current system clock frequency.

System Interrupts

As Cortex-R ARM architecture, the Generic Interrupt Controller (GIC) handles exceptions and interrupt configuration, prioritization and interrupt masking. In the ARM architecture, the GIC handles IRQ and FIQ exceptions and receives the following interrupt types.

Private Peripheral Interrupt (PPI)
Shared Peripheral Interrupt (SPI)
Software Generated Interrupt (SGI)

SGI and PPI are core-related specific interrupts, and SPI is connected to interrupts from each peripheral. GIC has interrupt number (INTID) internally. SGI uses INTID 0 to 15, PPI uses INTID 16 to 31, and SPI uses INTID 32 or later.

Multiplex Interrupts

When multiplex interrupts are enabled, another interrupt can operated while one interrupt is operating.

If an interrupt occurs, it branches to BSP common handler and then to HAL interrupt handler. The user can choose whether to allow multiple interrupts in BSP common handler or in HAL interrupt handler.

There are two ways to enable it:

Enable in BSP properties
- Multiplex interrupts are enabled system-wide

The behavior when multiplex interrupts are enabled in the BSP properties is as follows. Pink areas represent critical sections.

Behavior when multiplex interrupts are enabled in BSP

Enable in HAL module properties
- Multiplex interrupts are enabled only on set HAL modules

The behavior when multiplex interrupts are enabled for only HAL1 of the two HAL modules in the HAL module properties is as follows. Pink areas represent critical sections.

Behavior when multiplex interrupts are enabled in HAL module

Note: If you enable Multiplex interrupts in BSP properties, it will be enabled even if you disable it in HAL module

External and Peripheral Interrupts

User configurable interrupts begin with slot 32 (SPI). These may be external, or peripheral generated interrupts.

The SPI is mapped along the Event Table, and the BSP allows the user to select only the events of interest as interrupt sources.

BSP Weak Symbols

The weak attribute causes the declaration to be emitted as a weak symbol rather than a global. A weak symbol is one that can be overridden by an accompanying strong reference with the same name. When the BSP declares a function as weak, user code can define the same function and it will be used in place of the BSP function.

Weak symbols are supported for ELF targets and also for a.out targets when using the GNU assembler and linker.

Note that in CMSIS system.c, there is also a weak definition (and a function body) for the Warm Start callback function R_BSP_WarmStart(). Because this function is defined in the same file as the weak declaration, it will be called as the 'default' implementation. The function may be overridden by the user by copying the body into their user application and modifying it as necessary. The linker identifies this as the 'strong' reference and uses it.

Warm Start Callbacks

As the BSP is in the process of bringing up the board out of reset, there are three points where the user can request a callback. These are defined as the 'Pre Clock Init', 'Post Clock Init' and 'Post C' warm start callbacks.

As described above, this function is already weakly defined as R_BSP_WarmStart(), so it is a simple matter of redefining the function or copying the existing body from CMSIS system.c into the application code to get a callback. R_BSP_WarmStart() takes an event parameter of type bsp_warm_start_event_t which describes the type of warm start callback being made.

This function is not enabled/disabled and is always called for both events as part of the BSP startup. Therefore it needs a function body, which will not be called if the user is overriding it. The function body is located in system.c. To use this function just copy this function into your own code and modify it to meet your needs. need to check

FSP Assert

When an assertion or error occurs, the user assert function will be called.

This function is weakly defined as R_BSP_FspAssert(), so it is a simple matter of redefining the function or copying the existing body from bsp_common.c into the application code to manage assertions or errors.

Note: This function is not called even in cases that would return FSP_ERR_ASSERTION when BSP_CFG_ASSERT is defined as 3 (When "Disable checks that would return FSP_ERR_ASSERTION" is set to "Assert Failures" option in the RZT Common configurations on the BSP tab).

C Runtime Initialization

If C Runtime is disabled, users must perform C runtime initialization themselves.

Register Protection

The BSP register protection functions utilize reference counters to ensure that an application which has specified a certain register and subsequently calls another function doesn't have its register protection settings inadvertently modified.

Each time R_BSP_RegisterProtectDisable() is called, the respective reference counter is incremented.

Each time R_BSP_RegisterProtectEnable() is called, the respective reference counter is decremented.

Both functions will only modify the protection state if their reference counter is zero.

    /* Enable writing to protected CGC registers */
    R_BSP_RegisterProtectDisable(BSP_REG_PROTECT_CGC);
    /* Insert code to modify protected CGC registers. */
    /* Disable writing to protected CGC registers */
    R_BSP_RegisterProtectEnable(BSP_REG_PROTECT_CGC);

Software Delay

Do not recommend using R_BSP_SoftwareDelay () for strict wait time processing. The reason we do not recommend using this API is that the Delay Time may change depending on the memory area where the execution program is placed.

Implements a blocking software delay. A delay can be specified in microseconds, milliseconds or seconds. The delay is implemented based on the system clock rate.

    /* Delay at least 1 second. Depending on the number of wait states required for the region of memory
     * that the software_delay_loop has been linked in this could take longer. The default is 4 cycles per loop.
     * This can be modified by redefining DELAY_LOOP_CYCLES. BSP_DELAY_UNITS_SECONDS, BSP_DELAY_UNITS_MILLISECONDS,
     * and BSP_DELAY_UNITS_MICROSECONDS can all be used with R_BSP_SoftwareDelay. */
    R_BSP_SoftwareDelay(1, BSP_DELAY_UNITS_SECONDS);

Trigonometric Function

Implements Trigonometric math inline functions utilizing TFU hardware. These functions can calculate sine, cosine, arctangent and hypotenuse. The trigonometric library functions sinf(), cosf(), atan2f(), and hypotf() can be mapped to respective TFU functions by enabling TFU Mathlib property in FSP Configuration tool. Extended functions sincosf() and atan2hypotf() are also available when the TFU Mathlib property is enabled in the FSP Configuration editor.

TFU functions are not reentrant. Disable the TFU Mathlib property in Configuration editor if reentrant access to trigonometric library functions is required.

Note: Refer to the MCU hardware user's manual or datasheet to determine if it has TFU support.

Critical Section Macros

Implements a critical section. Interrupts with priority less than or equal to BSP_CFG_IRQ_MASK_LEVEL_FOR_CRITICAL_SECTION are not serviced in critical sections. Interrupts with higher priority than BSP_CFG_IRQ_MASK_LEVEL_FOR_CRITICAL_SECTION still execute in critical sections.

    FSP_CRITICAL_SECTION_DEFINE;
    /* Store the current interrupt state. */
    FSP_CRITICAL_SECTION_ENTER;
    /* Interrupts cannot run in this section if their priority is less than or equal to BSP_CFG_IRQ_MASK_LEVEL_FOR_CRITICAL_SECTION. */
    /* Restore saved interrupt state. */
    FSP_CRITICAL_SECTION_EXIT;

Noncache Section

Variables placed in the following sections will be invalidated for caching.

To place the variables in these noncache sections, use the BSP_PLACE_IN_SECTION macro to define them. (e.g. uint32_t value BSP_PLACE_IN_SECTION(".data_noncache") = 1)

Data with and without initial values can be placed.

.data_noncache
- Places noncache data for user applications
.dmac_link_mode
- Place DMAC link mode descriptor
- See Link Mode Example for how to place descriptors
.noncache_buffer
- Places noncache data exclusively for each core without sharing between cores
- This is only for the FSP driver, and it is not possible to place noncache data used by user applications
.shared_noncache_buffer
- Place noncache data that can be shared between cores when multi-core processing
- To prevent unexpected initialization of variables, define variables placed here only in the primary project
- This is only for the FSP driver, and it is not possible to place noncache data used by user applications

Note: In EWARM, do not mix variables with and without initial values. A warning will occur. To avoid the warning, perform the following operations.

Explicitly define "0" even for variables without initial values. (e.g. uint32_t value BSP_PLACE_IN_SECTION(".data_noncache") = 0)
If you cannot explicitly define the value, you can prevent the warning from occurring by adding "--diag_suppress Be006" to Project Option -> C/C++ Compiler -> Extra Options.

FSPv3.0 or later, the memory layout will be changed as follows:

The address obtained by subtracting 0x80000 from the end address of the Mirror area of System SRAM is the start address of the noncache section.
- e.g.)
  - For RZ/T2M, the end address of the Mirror area of System SRAM is 0x3020_0000, so the start address is 0x3018_0000.
  - For RZ/T2H CR52, the end address of the System SRAM is 0x1020_0000, so the start address is 0x1018_0000. (No mirror area)
  - For RZ/T2H CA55, the end address of the Mirror area of System SRAM is 0x1040_0000, so the start address is 0x1038_0000. (Virtual address by MMU)
The address obtained by subtracting 0x20000 from the end address of the Mirror area of System SRAM is the start address of the .shared_noncache_buffer.
- e.g.)
  - For RZ/T2M, the end address of the Mirror area of System SRAM is 0x3020_0000, so the start address is 0x301E_0000.
  - For RZ/T2H CR52, the end address of the System SRAM is 0x1020_0000, so the start address is 0x101E_0000. (No mirror area)
  - For RZ/T2H CA55, the end address of the Mirror area of System SRAM is 0x1040_0000, so the start address is 0x103E_0000. (Virtual address by MMU)
In a multi-core project, the start address is the address aligned with 0x20 from the end address of the noncache section used in the primary.
- e.g.)
  - For RZ/T2H CR52, if the primary uses up to 0x1018_0050, the secondary start address will be 0x1018_0060.

Memory attributes

Attributes and Regions can be set in the CPU-MPU/MMU of the BSP property.

Attribute: Select cacheability settings.
Region: Define the address and other information that specifies the attribute.

For example, in the SystemRAM area, the cacheability settings shown below are used:

Attribute: Set Attribute 1 to Normal memory, Inner/Outer Write-Through non-transient, R/W Allocate.
Region:
- Set the starting address (Base) and the ending address (Limit) of the memory area.
- Set the Shareability field to Non-shareable and the Attribute Index to Attribute1 to enable cache.

The configuration values are generated as macro values in bsp_mcu_cpu_memory_cfg.h and are reflected in the ARM core registers in the startup code.

Note: In the case of the write-back policy, the write operation basically updates data in the cache, and data updates to main memory are performed according to the state of the cache. If it is necessary to explicitly update data to main memory, a separate clean operation must be performed. Please use the following BSP API functions for the clean operation:; - R_BSP_CacheCleanAll; - R_BSP_CacheCleanInvalidateAll; If you need to invalidate the cache (clean data from the cache) in addition to the clean operation, use the following BSP API functions:; - R_BSP_CacheCleanRange; - R_BSP_CacheCleanInvalidateRange; When using Cortex-R52 as the secondary core on the RZ/T2H for multi-core operation, set Cortex-R52 CPU0 ATCM via AXIS (0x20000000 - 0x2007FFFF) and Cortex-R52 CPU1 ATCM via AXIS (0x21000000 - 0x2107FFFF) to Device Memory.

Memory Access

In the CPU-MPU configuration, it is feasible to configure memory attributes tailored to specific applications. For instance, the Normal memory attribute facilitates high-speed access, rendering it suitable for RAM access and instruction execution. Conversely, the Device memory attribute enforces strict execution order, making it apt for peripheral register access and flash memory write operations.

Moreover, the system is capable of detecting and reporting faults in the event of unforeseen access to each memory attribute.

A comprehensive understanding of these specifications is crucial in preventing improper memory access and unintended aborts. Below are some examples of how each memory attribute can be utilized. For detailed information, please consult the Technical Reference Manual and Architecture Reference Manual published by ARM.

In cases where data is written to flash memory with Write Enable command, it is imperative that the sequence of execution adheres strictly to the programmed order. Consequently, configuring the attribute of the target region to Device-nGnRnE (non-Gathering, non-Reordering, with no Early Write Acknowledgement) is deemed appropriate.
Performing unaligned access on Device memory can cause a Data Abort due to an Alignment fault. Please ensure that accesses are aligned.
Speculative instruction access to memory with Device memory via the AXI bus may cause a Prefetch Abort due to a Permission fault, leading to UNPREDICTABLE behavior. This may occur, for example, when executing instructions directly from external flash. In such cases, it is recommended to set memory attribute to Normal memory for instruction fetching.

Dynamic Memory Protection Unit Setting

Glossary of key terms used in this document:

Static region: The memory range is programmed during startup process.
Dynamic region: The memory range is programmed dynamically during run-time.

In addition to configuring MPU regions via BSP properties in the BSP tab, run-time configuration is also supported, offering greater flexibility. Please use the following BSP API function for configuring a dynamic region and reset the setting to initial value:

Note: - R_BSP_MpuRegionDynamicConfig (); - R_BSP_MpuRegionRestoreConfig (); Only one dynamic region can be configured at setup; consequently, once R_BSP_MpuRegionDynamicConfig () has been executed, it cannot run again until R_BSP_MpuRegionRestoreConfig () is performed.

Configure dynamic region in the bsp_mpu_dynamic_cfg_t in the following file.
{rz device}/fsp/src/bsp/mcu/all/cr/bsp_mpu_core.h

The configuration structure is show as below.

 #define DYNAMIC_REGION_BASE_ADRRESS    (0x10008024)
 #define DYNAMIC_REGION_SIZE            (0x1E)
void bsp_mpu_example_cr52 (void)
{
    bsp_mpu_dynamic_cfg_t dynamic_region_cfg =
    {
        .base      = DYNAMIC_REGION_BASE_ADRRESS, /* Base address */
        .size      = DYNAMIC_REGION_SIZE,         /* Size */
        .attribute =                              /* Attribute */
        {
            BSP_ATTRINDEX3,
            BSP_OUTER_SHAREABLE,
            BSP_EL1RW_EL0RW,
            BSP_EXECUTE_ENABLE,
        }
    };
    /* Set a dynamic region */
    R_BSP_MpuRegionDynamicConfig(&dynamic_region_cfg);
    /* Reset the configuration to the initial setting. */
    R_BSP_MpuRegionRestoreConfig();
}

base address
Set the base address of the dynamic region. The address must be aligned with 64 bytes.
size
Set the size of the dynamic region. The input size is not less than 64 bytes and must increase in increments of 64 bytes.

Note: If an unaligned base and size are set, these values will be dynamically configured to the nearest 64-byte boundary.; After the dynamic configuration, accessing addresses outside dynamic region triggers an exception.

attribute
Configures the attribute properties of the dynamic region. All required properties must be specified by the user.
These setting value by using a macro of Access Permission, Shareability, Attribute Index and Other.

Access Permision macro

Name	Description
BSP_EL1RW_EL0NO	Privileged mode: read/write possible, user mode: not accessible
BSP_EL1RW_EL0RW	Privileged mode: read/write possible, user mode: read/write possible
BSP_EL1RO_EL0NO	Privileged mode: read only , user mode: not accessible
BSP_EL1RO_EL0RO	Privileged mode: read only , user mode: read only

Shareability macro

Name	Description
BSP_NON_SHAREABLE	A domain limited to the local agent and do not require synchronization with other cores, processors, or devices.
BSP_INNER_SHAREABLE	A domain that is shared by other agents, but not necessarily all agent in the system.
BSP_OUTER_SHAREABLE	A domain that is shared by multiple agents that can consist of one or more Inner Shareable domains.

Attribute Index maco

Name	Description
BSP_ATTRINDEX0	Attribute Index 0.
BSP_ATTRINDEX1	Attribute Index 1.
BSP_ATTRINDEX2	Attribute Index 2.
BSP_ATTRINDEX3	Attribute Index 3.
BSP_ATTRINDEX4	Attribute Index 4.
BSP_ATTRINDEX5	Attribute Index 5.
BSP_ATTRINDEX6	Attribute Index 6.
BSP_ATTRINDEX7	Attribute Index 7.

Regarding the memory attribute properties such as Memory type and Inner/Outer Attribute settings, these will be set up in CPU MPU|Attribute property in FSP Configuration tool.

Other macro

Name	Description
BSP_EXECUTE_ENABLE	Programs will be allowed to run in the region.
BSP_EXECUTE_NEVER	programs will be prohibited from running in the region.

Example of dynamically region allocated
The following pattern illustrates how a 128-byte region is dynamaically allocated.

A 128-byte aligned memory block

Memory Management Unit

In the CPU-MMU (CA55), a virtual address is assigned to a physical address, so the CPU accesses the virtual address. The use of virtual addresses enables access with different attributes from the CPU. For example, in RZ/T2H CA55, a virtual address noncache is placed in the area offset 0x0020_0000 (Reserved) from the physical address (System SRAM) in order to realize cache access to System SRAM and access noncache.

Region01 (System SRAM : Cache)
- Virtual address: 0x1000_0000
- Physical address: 0x1000_0000
- Size: 0x0020_0000
Region02 (System SRAM mirror : Non-cache)
- Virtual address: 0x1020_0000
- Physical address: 0x1000_0000
- Size: 0x0020_0000

Note that if a bus master other than the CPU accesses the same resource, direct access to the physical address is required. For example, when setting the source/destination address for a DMA transfer, the virtual address must be converted to a physical address. If address translation is required within a driver, such as FSP's DMAC driver, the BSP APIs (R_BSP_MmuVatoPa, R_BSP_MmuPatoVa) are used to perform address translation. If address translation is required within a user application, these BSP APIs should be used. Refer to FSP Module (DMAC, USB, Ethernet) for specific implementation examples of BSP API.

Note: When using Cortex-R52 as the secondary core on the RZ/T2H for multi-core operation, set Cortex-R52 CPU0 ATCM via AXIS (0x20000000 - 0x2007FFFF) and Cortex-R52 CPU1 ATCM via AXIS (0x21000000 - 0x2107FFFF) to Device Memory.

The CPU-MMU assigns two virtual addresses with different cache attributes to a single physical region to enable both cached memory access and non-cached DMA access to a shared memory region.

Target memory regions:
- System SRAM: normal and mirror regions
- xSPIn CSm: normal and mirror regions (n=0,1 m=0,1)
- CSn: normal and mirror regions (n=0,2,3,5)
Initial settings:
- Normal regions: Inner/Outer Write-Back non-transient, Read/Write allocate
- Mirror regions: Inner/Outer Non-Cacheable, Read/Write do not allocate

When using this CPU-MMU configuration, it is essential to maintain data consistency, processing order, and coherency. When accessing the target memory regions from a user application, ensure that cache cleaning and invalidation, as well as DMB barrier instructions, are executed to guarantee shared access. For more information, refer to the Arm Architecture Reference Manual.

Dynamic Memory Management Unit Setting(Dynamic Memory Mapping)

Glossary of key terms used in this document:

Static region: The memory range is programmed during startup process.
Dynamic region: The area has its properties changed during run-time to meet the desired requirements.

In addition to configuring MMU regions via BSP properties in the BSP tab, run-time configuration is also supported, offering greater flexibility. Please use the following BSP API function for configuring a dynamic region and reset the setting to initial value:

Note: - R_BSP_MemoryMap (); - R_BSP_MemoryUnMap (); Only one dynamic region can be configured at setup; consequently, once R_BSP_MemoryMap () has been executed, it cannot run again until R_BSP_MemoryUnMap () is performed.

Configure dynamic region in the r_mmu_pgtbl_cfg_t in the following file.
{rz device}/fsp/src/bsp/mcu/all/ca/bsp_mmu_core.h

The configuration structure is show as below.

 #define MEMORY_MAP_VIRTUAL_ADDRESS     (0x40700000)
 #define MEMORY_MAP_PHYSICAL_ADDRESS    (0x40700000)
 #define MEMORY_MAP_SIZE                (0x00180000)
void bsp_mmu_example_ca55 (void)
{
    r_mmu_pgtbl_cfg_t dynamic_memory_map_cfg =
    {
        .vaddress  = MEMORY_MAP_VIRTUAL_ADDRESS,  /* Virtual address */
        .paddress  = MEMORY_MAP_PHYSICAL_ADDRESS, /* Phisical address */
        .size      = MEMORY_MAP_SIZE,             /* Size */
        .attribute = BSP_UXN_EXECUTE_ENABLE |     /* Attribute */
                     BSP_PXN_EXECUTE_ENABLE |
                     BSP_INNER_SHAREABLE | BSP_EL321RW_EL0RW |
                     BSP_NS_SECURE | BSP_ATTRINDEX2 |
                     BSP_REGION_ENABLE
    };
    /* Set a dynamic memory map */
    R_BSP_MemoryMap(&dynamic_memory_map_cfg);
    /* Reset the configuration to the initial setting. */
    R_BSP_MemoryUnMap();
}

Virtual address
Set the virtual address of the dynamic area. If the address is less than 4GB area, it must be aligned with 2M-bytes, and if it is more than 4GB area, it must be aligned with 1G-bytes.

Physical address
Set the physical address of the dynamic area. If the virtual address is less than 4GB, it must be aligned to 2MB. Also, the virtual address and bit21-bit0 must match.If the virtual address exceeds 4GB, it must be aligned to 1GB. Also, the virtual address and bit30-bit0 must match.

Size
Set the size of the dynamic region. If the virtual address is less than 4GB area, it must be aligned with 2M-bytes, and if it is more than 4GB area, it must be aligned with 1G-bytes.

Note: If an unaligned virtual address, physical and size are set, these values will be dynamically configured to the nearest 2M-byte or 1G-byte boundary.

Attribute
Configures the attribute properties of the dynamic memory mapping. All required properties must be specified by the user.
These setting value by using a macro of Access Permission, Shareability, Attribute Index and Other.

Unprivileged Execute Never (UXN) macro

Name	Description
BSP_UXN_EXECUTE_ENABLE	Can be executed in unprivileged mode
BSP_UXN_EXECUTE_DISABLE	Cannot run in unprivileged mode

Privileged Execute Never (PXN) macro

Name	Description
BSP_PXN_EXECUTE_ENABLE	Can be executed in privileged mode
BSP_PXN_EXECUTE_DISABLE	Cannot run in privileged mode

Shareability macro

Name	Description
BSP_NON_SHAREABLE	A domain limited to the local agent and do not require synchronization with other cores, processors, or devices
BSP_INNER_SHAREABLE	A domain that is shared by other agents, but not necessarily all agent in the system
BSP_OUTER_SHAREABLE	A domain that is shared by multiple agents that can consist of one or more Inner Shareable domains

Access Permision macro

Name	Description
BSP_EL321RW_EL0NO	Unprivileged mode(EL1,EL2,EL3): read/write possible, Privileged mode(EL0): not accessible
BSP_EL321RW_EL0RW	Unprivileged mode(EL1,EL2,EL3): read/write possible, Privileged mode(EL0): read/write possible
BSP_EL321RO_EL0NO	Unprivileged mode(EL1,EL2,EL3): read only, Privileged mode(EL0): not accessible
BSP_EL321RO_EL0RO	Unprivileged mode(EL1,EL2,EL3): read only, Privileged mode(EL0): read only

Attribute Index macro

Name	Description
BSP_ATTRINDEX0	Attribute Index 0
BSP_ATTRINDEX1	Attribute Index 1
BSP_ATTRINDEX2	Attribute Index 2
BSP_ATTRINDEX3	Attribute Index 3
BSP_ATTRINDEX4	Attribute Index 4
BSP_ATTRINDEX5	Attribute Index 5
BSP_ATTRINDEX6	Attribute Index 6
BSP_ATTRINDEX7	Attribute Index 7

Regarding the memory attribute properties such as Memory type and Inner/Outer Attribute settings, these will be set up in CPU MMU|Attribute property in FSP Configuration tool.

Security bit(only EL3 and EL1)

Name	Description
BSP_NS_SECURE	Secure
BSP_NS_NON_SECURE	Non Secure

Other macro

Name	Description
BSP_REGION_ENABLE	Enable the region of the specified virtual address
BSP_REGION_DISABLE	Disable the region of the specified virtual address

Example of dynamically region allocated
The following pattern illustrates how a 2M-byte region is dynamaically allocated.

A 2M-byte aligned memory block

TrustZone Address Space Controller (TZC-400)

The TZC-400 module can be configured from the BSP properties of the RZ microprocessor containing the TZC-400.

TZC-400-0: DDR SDRAM A0/A1 I/F.
TZC-400-1: DDR SDRAM A4 I/F.
TZC-400-2: PCIE Unit 0/1.
TZC-400-3: DDR SDRAM R2 I/F.
TZC-400-4: DDR SDRAM R3 I/F.
TZC-400-5: SYSRAM unit 0/1/2/3.
TZC-400-6: BSC
TZC-400-7: xSPI unit 0/1.
TZC-400-8: Cortex-R52 CPU0/1 AXIS (TCM).

The configuration values are generated as macro values in bsp_mcu_tzc400_memory_cfg.h and reflected in the ARM core registers in the startup code.

The default settings of the TZC-400 modules allow access in unprivileged and privileged in non-secure and secure in region 0.

For example, in RZT2H device, when creating the access rule in TZC-400-0: DDR SDRAM A0/A1 I/F, the settings shown below are used:

Enter the filter unit in the Gatekeeper field.
Region 0: Enter the filter unit in the attribute field.
Region 0: Enable write control in attribute.
Region 0: Enable read control in attribute.
Region 0: Set ID (e.g. allow unprivileged and privileged access in non-secure, allow unprivileged and privileged access in secure) in NSAID read/write enable.

Note: When using Cortex-R52 as the secondary core on the RZ/T2H for multi-core operation, set filters 0 and 1 on the TZC-400-8 to enable access to the TCM of Cortex-R52 CPU0 and CPU1.

Module Stop

The BSP shall provide a method to enable or cancel module stop for a given peripheral channel.

Note: The module start function and module stop function for ENCIF are exclusive to RZT2M and RZT2ME.; - R_BSP_MODULE_START(FSP_IP_ENCIF, n); - R_BSP_MODULE_STOP(FSP_IP_ENCIF, n)

Module Reset

The reset state and the release can be set for each peripheral module. To secure processing after release from a module reset, dummy read the same register at sevral times after writing to initiate release from the module reset.

Note: Dummy reads are performed several times in the R_BSP_ModuleResetDisable function according to the RZ microprocessor manual. However, depending on the device used, the number of dummy reads for RTC and LCDC may not be met. In that case, please perform additional dummy read processing after API execution. For example, in the case of the RZT2H, the RTC requires 300 dummy reads and the LCDC requires 100 dummy reads.

Software Reset

Note: If the core that called the software reset function is different from the core you want to reset, you must execute the WFI instruction manually.; In Cortex-A55, the bit in Reset Status Register 0 (RSTSR0) is not set when a software reset occurs. If you want to determine if a software reset has occurred, use g_bsp_software_reset_occurred, which is defined in rzt/fsp/src/bsp/cmsis/Device/RENESAS/Source/ca/startup_core.c.

System Error Interrupt (SEI,NMI)

When a request signal is input to the SEI pin (or NMI pin), a System Error Interrupt occurs. The sequence to detect a System Error Interrupt is different for each core.

Note: Note that the initial devices of the RZ/T2 series refer to SEI as NMI. Since the subsequent documentation uniformly describe it as SEI, if you are using an initial device, please replace SEI with NMI.

Cortex-R52

The SEI pin is connected to SEI and VSEI in Cortex-R52 CPU0 and CPU1, and an asynchronous external abort occurs when a request signal is input.

The implementation method is described below.

Implement the SEI pin detection setting.
- Enable the noise filter.
- Set the noise filter sampling frequency divider ratio.
- Set the detection mode.
Implement the Abort_Handler function.
- Determine if the value of DFSR.status [5:0] is 0b10001 (Asynchronous external abort).
Register the SEI pin from the Pins tab in the FSP Configuration editor.
- Pins tab > Pin Selection > Peripherals > Interrupt:IRQ > SEI
- Change the Operation mode from "Disabled" to "Custom".
- Assign any pin

Here is how the implementation example works.

Build and run this program.
Press the SEI pin on the board.
The program branches to the Abort_Handler function, and since the judgment of asynchronous external abort is true, it enters an infinite loop.

Note: It is not possible to distinguish whether an asynchronous external abort occurred due to an error during a data write access to memory.

 #define SEI_NOISE_FILTER_ENABLE             (0x1UL)  /* Noise filter enable */
 #define SEI_NOISE_FILTER_SAMPLING_FREQ      (0x3UL)  /* Noise filter sampling frequency: Divided by 64 */
 #define SEI_EDGE_DETECTION_MODE             (0x1UL)  /* Detection mode: Falling edge */
 #define DSFR_STATUS_MASK                    (0x3FUL) /* Mask DSFR.STATUS bits[5:0] */
 #define DSFR_ASYNCHRONOUS_EXTERNAL_ABORT    (0x11UL) /* Fault status is Asynchronous external abort */
void bsp_sei_example_cr52 (void)
{
    /* Set SEI pin detection. */
 #if (1 == BSP_FEATURE_ICU_SAFETY_REGISTER_TYPE)
    R_ICU->S_PORTNF_FLTSEL_b.FLTNMI   = SEI_NOISE_FILTER_ENABLE;
    R_ICU->S_PORTNF_CLKSEL_b.CKSELNMI = SEI_NOISE_FILTER_SAMPLING_FREQ;
    R_ICU->S_PORTNF_MD_b.MDNMI        = SEI_EDGE_DETECTION_MODE;
 #else
    R_ICU_S->S_PORTNF_FLTSEL_b.FLTSEI    = SEI_NOISE_FILTER_ENABLE;
    R_ICU_S->S_PORTNF_CLKSEL_b.CLKSELSEI = SEI_NOISE_FILTER_SAMPLING_FREQ;
    R_ICU_S->S_PORTNF_MD_b.MDSEI         = SEI_EDGE_DETECTION_MODE;
 #endif
    while (1)
    {
        /* Do Nothing */
    }
}
void Abort_Handler (void)
{
    /* SEI causes a transition to Asynchronous external abort. */
    uint32_t dsfr_status = __get_DFSR() & DSFR_STATUS_MASK;
    if (DSFR_ASYNCHRONOUS_EXTERNAL_ABORT == dsfr_status)
    {
        while (1)
        {
            /* SEI(SEI) interrupt occurred. */
        }
    }
}

Cortex-A55

The SEI pin is connected to Shared Peripheral Interrupt(SPI), and a SPI occurs when a request signal is input. It is possible to detect SEI by interrupt generation due to the event number of SPI.

The implementation method is described below.

Implement the SEI pin detection setting.
- The settings are the same as for Cortex-R52.
Implement SEI interrupt enable setting.
Implement the SEI interrupt handler (sei_isr).
Register the SEI interrupt handler from Interrupts tab in the FSP Configuration editor.
- Interrupts tab > New User Event > ICU > SEI (System Error Interrupt)
- Enter the SEI interrupt handler name "sei_isr".
Register the SEI pin from the Pins tab in the FSP Configuration editor.
- The settings are the same as for Cortex-R52.

Here is how the implementation example works.

Build and run this program.
Press the SEI pin on the board.
The program branches to the SEI interrupt handler and enters an infinite loop.

 #define VECTOR_NUMBER_SEI                 ((IRQn_Type) 406) /* SEI (System error interrupt) */
 #define SEI_NOISE_FILTER_ENABLE           (0x1UL)           /* Noise filter enable */
 #define SEI_NOISE_FILTER_SAMPLING_FREQ    (0x3UL)           /* Noise filter sampling frequency: Divided by 64 */
 #define SEI_EDGE_DETECTION_MODE           (0x1UL)           /* Detection mode: Falling edge */
 #define SENSE_EDGE                        (1UL)             /* Detection type: Edge */
 #define SEI_IPL                           (0UL)             /* Interrupt priority level: 0 */
void bsp_sei_example_ca55 (void)
{
    /* Set SEI pin detection. */
    R_ICU_S->S_PORTNF_FLTSEL_b.FLTSEI    = SEI_NOISE_FILTER_ENABLE;
    R_ICU_S->S_PORTNF_CLKSEL_b.CLKSELSEI = SEI_NOISE_FILTER_SAMPLING_FREQ;
    R_ICU_S->S_PORTNF_MD_b.MDSEI         = SEI_EDGE_DETECTION_MODE;
    /* For the CA55, SEI(SEI) interrupts are treated as normal interrupt events. */
    R_BSP_IrqDetectTypeSet(VECTOR_NUMBER_SEI, SENSE_EDGE);
    R_BSP_IrqCfg(VECTOR_NUMBER_SEI, SEI_IPL, NULL);
    /* Clear the interrupt status and pending bits, before the interrupt is enabled. */
    R_BSP_IrqEnable(VECTOR_NUMBER_SEI);
    while (1)
    {
        /* Do Nothing */
    }
}
void sei_isr (void)
{
    while (1)
    {
        /* SEI(SEI) interrupt occurred. */
    }
}

LPDDR4 SDRAM Subsystem

The FSP applies the DDR parameter file generated by the DDR parameter generation tool (hereinafter referred to as "gen_tool"). The procedure for modifying the DDR parameter file is as follows.

Let's assume the file name of the file generated by gen_tool is "param_ddrinit_ref_lpddr4_r02p03.h".

Rename "param_ddrinit_ref_lpddr4_r02p03.h" to "board_ddr_param.h".
Replace the existing "board_ddr_param.h" file located in the "rzt/board/rzt2h_evb" folder with the new one.

Note: The folder path may vary depending on the board or device being used. For example, for a custom board, the path would be "rzt/board/custom".

Linker Script

To prevent build warnings, the GCC linker script separates the placement regions for .text and .data. (The same goes for .loader_text and .loader_data)

Below is a simplified version of fsp_ram_execution.ld.

.text is placed in RAM_TEXT, and .data is placed in RAM_DATA. The start address and size of both regions are the same.

Also, the start address of .data is set to the end address of .ARM.exidx. Without this, .data would be placed at the beginning of RAM_DATA and would overlap with .text.

SECTIONS
{
    .text TEXT_ADDRESS:
    {
        _text_start = .;
        *(.text*)
        _text_end = .;
    } > RAM_TEXT
    .ARM.extab :
    {
        __extab_start = .;
        *(.ARM.extab* .gnu.linkonce.armextab.*)
        __extab_end = .;
    } > RAM_TEXT
    .ARM.exidx :
    {
        __exidx_start = .;
        *(.ARM.exidx* .gnu.linkonce.armexidx.*)
        __exidx_end = .;
    } > RAM_TEXT
    .data __exidx_end :
    {
        _data_start = .;
        *(.data*)
        _data_end = .;
    } > RAM_DATA
}

For example, if you want to move .ARM.exidx to the BTCM region, modify the end address of .ARM.extab to match the start address of .data.

SECTIONS
{
    .text TEXT_ADDRESS:
    {
        _text_start = .;
        *(.text*)
        _text_end = .;
    } > RAM_TEXT
    .ARM.extab :
    {
        __extab_start = .;
        *(.ARM.extab* .gnu.linkonce.armextab.*)
        __extab_end = .;
    } > RAM_TEXT
    .ARM.exidx :
    {
        __exidx_start = .;
        *(.ARM.exidx* .gnu.linkonce.armexidx.*)
        __exidx_end = .;
    } > BTCM                                        /* Changed from "RAM_TEXT" to "BTCM". */
    .data __extab_end :                             /* Changed from  "__exidx_end" to "__extab_end".  */
    {
        _data_start = .;
        *(.data*)
        _data_end = .;
    } > RAM_DATA
}

Change Program Location

You can change the program placement region by configuring the settings described below.
This only applies to Cortex-R52, which has a TCM implemented.
Therefore, it does not apply to the Cortex-R52 CPU1 of RZ/T2M and RZ/T2ME.

Note: If you change the program location on a device that does not have a TCM, a build error will be output.

Change the location region for the following two types of programs:

Loader program: program used by the Second Stage Boot Loader (SSBL) (The default placement is BTCM)
User program: program implemented by the user (The default placement is ATCM)

The placement region that can be changed are as follows:

ATCM
BTCM
System SRAM

Note: Due to the specifications of the First Stage Boot Loader (FSBL), the Loader program of primary project will not function properly unless it is placed on the BTCM. If it is set to be placed anywhere other than the BTCM, a build error will be output.

The symbols "LOADER_PROGRAM_LOCATION_PRV" and "USER_PROGRAM_LOCATION_PRV" are defined in the linker script, and the location is changed depending on these values.
The values correspond to the following locations:

0: ATCM
1: BTCM
2: SYSTEM_RAM

The setting method varies depending on the IDE.

e² studio The following additional properties must be set.

In the Properties window of the project, click C/C++ Build > Settings > Tool Settings > Cross ARM C Linker > Other.
Add symbols at Other linker flags. (x=0,1,2)
- -Wl,–defsym=LOADER_PROGRAM_LOCATION=x
- -Wl,–defsym=USER_PROGRAM_LOCATION=x

EWARM The following additional properties must be set.

In the Options... window of the project, click Linker > Config.
Add symbols at Configuration file symbol definitions. (x=0,1,2)
- LOADER_PROGRAM_LOCATION=x
- USER_PROGRAM_LOCATION=x
Click C/C++ Compiler > Preprocessor.
Add symbols at Defined symbols. (x: The same value as set in No. 2)
- LOADER_PROGRAM_LOCATION=x
- USER_PROGRAM_LOCATION=x

Note: After adding the symbol in step 2, if you do not add the symbol in step 4, a build error will occur for "duplicate definitions".; If you place both the Loader program and the User program in the BTCM, you must reduce the size of the stack or HEAP.

Pin Setting

When operating in multi-core, the primary and secondary core copy code and data from ROM to RAM.

Changing the pins accessed by the ROM boot during this copy process can cause it to fail. Specifically, changing the ROM boot pins in the primary's Pins tab may lead to this issue.

To work around this, the Pins tab preserves the ROM boot pin settings. Instead, configure the pins using the IOPORT driver's API on the user application side after each core's startup is complete.

eSD boot

In eSD boot mode (if the device supports), device boots a program from an external eSD device (including SD card) with 4-bit data bus. In FSP, you can create a write image file for the SD card by building a project for eSD boot mode. The created image file can be written to the SD card using a tool on your PC.

Note: The FSP eSD boot mode project virtually use memory space 0x88000000 - 0x93FFFFFF for the eSD boot process. This area cannot be used by user's application, for example, when using the CA55 MMU.; The values of loader parameters in eSD boot mode can be configured in the FSP Configurator. As the default value for the loader parameter, the loader program size LDR_SIZE_NML is set to 0x8000. Similarly, in the linker file, the loader program size is defined as LOADER_PROGRAM_SIZE = 0x8000; .Therefore, if LDR_SIZE_NML is changed from its default value in the FSP Configurator, the value of LOADER_PROGRAM_SIZE in the linker file must also be modified to match.

Preparation procedure for the SD card image file

How to prepare an image file for an SD card in e² studio

When using e² studio, after building the project, the <project_name>.bin file is created in the Debug folder as a write image file for the SD card. Use the SD card writing tool on your PC to write the created image file to the SD card.

Created .bin file (e² studio)

How to prepare an image file with multiplexed loader programs in e² studio

To perform multiplexing of the loader program, follow the procedure below. Skip the procedure if multiplexing is not required. Note that loader parameters are multiplexed by default. Refer to "Allocation of the Loader Parameter and Loader Program" in the RZ microprocessor User's Manual for details.

When the project is built, loader1.o - loader6.o are also generated in the Debug folder. To include loader1.o - loader6.o at subsequent builds, set loader1.o - loader6.o in the Other objects section of e² studio's Linker settings. This allows to place the loader program in spare areas #1-#6. To prevent build errors, this configuration must be set after loader1.o - loader6.o are generated in a prior build.

Following additional properties must be set.

In the properties window of project, click C/C++ Build > Settings > Tool Settings > Cross ARM C Linker > Miscellaneous.
Set file path of loader1.o - loader6.o files in the project to Other objects

${workspace_loc:/${ProjName}/Debug/loader1.o}

${workspace_loc:/${ProjName}/Debug/loader2.o}

${workspace_loc:/${ProjName}/Debug/loader3.o}

${workspace_loc:/${ProjName}/Debug/loader4.o}

${workspace_loc:/${ProjName}/Debug/loader5.o}

${workspace_loc:/${ProjName}/Debug/loader6.o}

Linker setting for placing loader program on spare area

When the project is built again, loader1.o -loader6.o are linked, and an image file with a multiplexed loader program is generated in the Debug folder. It can be written to the SD card.

How to prepare an image file for an SD card in EWARM

When using EWARM, set the Output format of the Output Converter to "Raw binary".

Following additional properties must be set.

Click Project > Options...
Click Output Converter > Output and set "Raw binary" to Output format

Output format setting

Created .bin file (EWARM)

This allows to create a <project_name>.bin file in the Debug/Exe folder as a write image file for the SD card. Use the SD card writing tool on your PC to write the created image file to the SD card.

How to prepare an image file with multiplexed loader programs in EWARM

To perform multiplexing of the loader program, follow the procedure below. Skip the procedure if multiplexing is not required. Note that loader parameters are multiplexed by default. Refer to "Allocation of the Loader Parameter and Loader Program" in the RZ microprocessor User's Manual for details.

To place the loader program in spare areas #1 to #6, extract the loader program.

Following additional properties must be set.

Click Project > Options...
Click Build Actions > Build Actions Configuration > New and set it as follows:
- a. Command line
  
  ielftool --bin-multi=0x88001000-0x88008FFF; $TARGET_BPATH$.out $TARGET_BPATH$loader.bin
  
  Note
  If the loader program size LDR_SIZE_NML is changed from the default in FSP Configurator, the address range specified with –bin-multi for extraction must be changed accordingly. This example shows the command for the default value, LDR_SIZE_NML = 0x8000.
- b. Build order
  
  Set "Run after Linking" for the Build order.
  
  Build action setting to extract loader program
  
  When the project is built, <project_name>loader-0x88001000.bin is generated in the Debug/Exe folder as a binary for placing in spare areas #1 to #6.

To import .bin file at subsequent builds and place it in the spare areas #1 to #6, add the image_input definition LOADER1 - LOADER6 to Linker > Extra Options and keep LOADER1 - LOADER6 symbols at Linker > Input > Keep symbols

Following additional properties must be set.

Click Linker > Extra Options and add as follows:

--image_input=$PROJ_DIR$\Debug\Exe\<project_name>loader-0x88001000.bin,LOADER1,LOADER1,8

--image_input=$PROJ_DIR$\Debug\Exe\<project_name>loader-0x88001000.bin,LOADER2,LOADER2,8

--image_input=$PROJ_DIR$\Debug\Exe\<project_name>loader-0x88001000.bin,LOADER3,LOADER3,8

--image_input=$PROJ_DIR$\Debug\Exe\<project_name>loader-0x88001000.bin,LOADER4,LOADER4,8

--image_input=$PROJ_DIR$\Debug\Exe\<project_name>loader-0x88001000.bin,LOADER5,LOADER5,8

--image_input=$PROJ_DIR$\Debug\Exe\<project_name>loader-0x88001000.bin,LOADER6,LOADER6,8

Linker Extra Options setting for placing loader program on spare area
Click Linker > Input and set it as follows:

Keep symbols (one per line).

LOADER1

LOADER2

LOADER3

LOADER4

LOADER5

LOADER6

Linker Keep symbols setting for placing loader program on spare area

When the project is built again, <project_name>loader-0x88001000.bin is linked, and an image file with a multiplexed loader program is generated in the Debug/Exe folder. It can be written to the SD card.

Writing to the SD card and executing eSD boot

Using an SD card writing tool on your PC, write the created image file to the SD card. Use a tool similar to the following:

Win32 Disk Imager (Win32 Disk Imager download | SourceForge.net)

This section shows how to write to an SD card using PC tool Win32 Disk Imager for example. The binary data of the image file is written starting from the first sector of the SD card.

Select the generated SD card image file <project_name>.bin as the write image file. When selecting the file, set "*.*" to enable selection of .bin files.

Select image file (Win32 Disk Imager)

Click Write to write the image file to the SD card.

Write image file (Win32 Disk Imager)

Set the eSD boot mode using the MD pins of the device. Insert the SD card into the SD card slot connected to the device, then turn the power ON. Device boots a program from the SD card.

How to debug an eSD boot project

Insert the loop part in startup_core.c according to "Appendix. How to Debug FSP Project with Flash Boot Mode" in RZ/T2, RZ/N2 Getting Started with Flexible Software Package.

Warning: Due to code size differences, the loop count value differs from that described for flash boots in the document.

For CR52
BSP_ATTRIBUTE_STACKLESS void R_BSP_WarmStart_StackLess (void)
{
/* The very beginning of the startup process. */
#if 1 // Software loops are only needed when debugging.
__asm volatile (
" mov r0, #0 \n"
" movw r1, #0xb3ff \n"
" movt r1, #0x4c4 \n"
"software_loop: \n"
" adds r0, #1 \n"
" cmp r0, r1 \n"
" bne software_loop \n"
::: "memory");
#endif
/* Do not delete. Required to return to system_init. */
#if (0 == BSP_LP64_SUPPORT)
__asm volatile ("BX lr");
#else
__asm volatile ("BR lr");
#endif
}
For CA55
BSP_ATTRIBUTE_STACKLESS void R_BSP_WarmStart_StackLess (void)
{
/* The very beginning of the startup process. */
#if 1 // Software loops are only needed when debugging.
__asm volatile (
" mov x1, #0 \n"
" movz x2, #0xb3ff \n"
" movk x2, #0x4c4, LSL #16 \n"
"software_loop: \n"
" adds x1, x1, #1 \n"
" cmp x1, x2 \n"
" b.ne software_loop \n"
::: "memory");
#endif
/* Do not delete. Required to return to system_init. */
#if (0 == BSP_LP64_SUPPORT)
__asm volatile ("BX lr");
#else
__asm volatile ("BR lr");
#endif
}

How to debug an eSD boot project in e² studio

The eSD boot project can be debugged as the flash boot project described in RZ/T2, RZ/N2 Getting Started with Flexible Software Package. However, the following settings are different for eSD boot project debugging:

For primary project, change the Load type in the e² studio debugger connection settings from "Image and Symbols" to "Symbols only".

Load Symbols only
For secondary (or later) project, leave the Load type as "Image and Symbols" in the e² studio debugger connection settings. No change is necessary.

Load image and symbols
Build the project and write the image file to the SD card, then run the program by eSD boot. After that, debug the primary and secondary(or later) project.

How to debug an eSD boot project in EWARM

The eSD boot project can be debugged as the flash boot project described in RZ/T2, RZ/N2 Getting Started with Flexible Software Package. However, establish a debug connection while the program is running.

Build the project and write the image file to the SD card, then run the program by eSD boot. After that, debug the primary and secondary (or later) project.

How to make the FSP program and FAT file system on an SD card coexist

The SD card written with image file created by the FSP Project contain a valid MBR (Master Boot Record) area in the first sector. However, no partition table has been created. By creating a FAT partition using a disk management tool, the FSP program and the FAT file system can coexist on the SD card.

For example, using the DISKPART tool provided as standard on Windows PCs, a FAT partition is created as follows.

Insert the SD card written with image file created by the FSP Project into your PC. Launch the DISKPART tool on your Windows PC and execute the following command. This create a FAT partition on the SD card. When creating a FAT partition, it is recommended to add an offset of certain bytes from the beginning of the SD card to avoid overlapping with the pre-written FSP program.

list disk
select disk n                            // Select SD card disk. "n" depends on the development environment.
create partition primary offset = yyy    // Create a partition at yyy KB offset from the beginning so that it does not overlap with existing FSP programs.
format fs=fat32 quick                    // Quick format the partition as FAT32
assign
exit

The following is an example of creating a FAT partition by adding an offset of 128MB (=131072KB) from the beginning of the SD card.

Create FAT partition on DISKPART tool

You can check the partitions on the SD card.

list partition

The following is an example of confirming that a FAT partition has been created with an offset of 128MB (=131072KB) from the beginning of the SD card.

List partition on DISKPART tool

Warning: Be sure to select the target SD card when select disk n. "n" depends on the development environment. If selected a different disk and issue the partition management command, the disk may become unusable.

eMMC boot

In eMMC boot mode (if the device supports), device boots a program from an external eMMC device with 8-bit data bus. In FSP, you can create a write image file for the eMMC by building a project for eMMC boot mode. The created image file can be written to the eMMC using a tool on your PC.

Note: The FSP eMMC boot mode project virtually use memory space 0x88000000 - 0x93FFFFFF for the eMMC boot process. This area cannot be used by user's application, for example, when using the CA55 MMU.; The values of loader parameters in eMMC boot mode can be configured in the FSP Configurator. As the default value for the loader parameter, the loader program size LDR_SIZE_NML is set to 0x8000. Similarly, in the linker file, the loader program size is defined as LOADER_PROGRAM_SIZE = 0x8000; .Therefore, if LDR_SIZE_NML is changed from its default value in the FSP Configurator, the value of LOADER_PROGRAM_SIZE in the linker file must also be modified to match.

Preparation procedure for the eMMC image file

How to prepare an image file for an eMMC in e² studio

When using e² studio, after building the project, the loader.srec and user.srec file is created in the Debug folder as a write image file for the eMMC. Use the eMMC writing tool on your PC to write the created image file to the eMMC.

Created .srec file (e² studio)

How to prepare an image file for an eMMC in EWARM

Use a Motorola S-record conversion tool to split the image file into .srec files for the loader parameters/loader program and the user application. Use a tool similar to the following;

SRecord (SRecord download | SourceForge.net)

This section demonstrates how to split the file using, for example, the PC tool SRecord.

The following instructions assume that the SRecord executable directory has been added to the Windows PC PATH environment variable. Example: C:\Program Files\srecord\bin

Following additional properties must be set in EWARM.

1.Click Project > Options... 2.Click Build Actions > Build Actions Configuration > New and set it as follows:

No.	Command line:	Output files	Input files	Working directory	Build order
1	`srec_cat $TARGET_BPATH$.srec -crop 0x88000000 0x88008FFF -offset -0x88000000 -o $PROJ_DIR$\Debug\Exe\loader.srec -motorola -address-length=4 -Output_Block_Size 16 -execution-start-address=0`	loader.srec	$TARGET_BPATH$.srec	$PROJ_DIR$	Run after linking
2	`srec_cat $TARGET_BPATH$.srec -crop 0x88009000 0x93FFFFFF -offset -0x88009000 -o $PROJ_DIR$\Debug\Exe\user.srec -motorola -address-length=4 -Output_Block_Size 16 -execution-start-address=0`	user.srec	$TARGET_BPATH$.srec	$PROJ_DIR$	Run after linking

3.When the project is built, loader.srec and user.srec are generated in the Debug/Exe folder.

Created .srec file (EWARM)

Writing to the eMMC and executing eMMC boot

Using an eMMC writing tool on your PC, write the created image file to the eMMC. Use a tool similar to the following;

Linux Flash Programmer (RZ/T2H and RZ/N2H Linux Software Package [V5.10-CIP] | Renesas)

Note: The above links are for the Linux Software Package for RZ/T2H and RZ/N2H. If you are using a different RZ/T2 device, please obtain the Linux Flash Programmer from the page for that specific device.

This section shows how to write to an eMMC using PC tool Linux Flash Programmer for example. The binary data of the image file is written starting from the first sector of the eMMC.

Execute SCI boot and download the Linux Flash Programmer to the RAM of the RZ microprocessor.

1.Connect between the board and a control PC by USB serial cable.

2.Launch the terminal software and specify the serial port of board.

3.Select the Setup > Serial port to set the settings about serial communication protocol on the software. Set the settings about serial communication protocol on a terminal software as below:

Speed: 115200 bps
Data: 8bit
Parity: none
Stop bit: 1 bit
Flow control: none
Transmit delay: 0 msec/line

4.Configure the SCI boot mode using the MD pins of the device.

5.After finishing all settings, turn on power, the messages below are displayed on the terminal.

SCI Download mode (Normal SCI boot)

6.Below is a sample procedure with Tera Term. Drag HDR NM file and drop the file to the Tera Term window, then click OK.

Drag and Drop to Tera Term Window

7.The image will be sent to the board via serial connection. After completing that, send Flash_Programmer_SCIF_CR52_RZT2H_EVK.mot as same as HDR NM. Send it as soon as possible.

Send file of Tera Term

8.After successfully downloading the binary, Flash Programmer starts automatically and shows a message like below on the terminal.

SCI Download mode (Normal SCI boot)
-- Load Program to RAM ---------------
-- Start Boot Program on RAM ---------
Flash Programmer Vx.xx (RZT2x)(CR52_0)

Next, write two image files to the eMMC.

Write the loader.srec to the eMMC boot partition.
Write the user.srec to the eMMC user area.

Follow the steps below to operate Tera Term.

9.Execute the EMMCWECSD command with the arguments 0xb3 0x9 to enable access to the eMMC boot partition 1.

> EMMCWECSD 0xb3 0x9

EXT_CSD[b3] = 0x9

10.Execute the EMMCW command with arguments 0x0 0x0. When "send file" is displayed, drag loader.srec file and drop the file to the Tera Term window, then click “OK”. When the transfer is complete, "EMMCW Complete!" will be displayed.

> EMMCW 0x0 0x0
send file        <--- Drag loader.srec
EMMCW Complete!

11.Execute the EMMCWECSD command with the arguments 0xb3 0x8 to enable access to the user area.

> EMMCWECSD 0xb3 0x8

EXT_CSD[b3] = 0x8

12.Execute the EMMCW command with arguments 0x0 0x0. When "send file" is displayed, drag user.srec file and drop the file to the Tera Term window, then click “OK”. When the transfer is complete, "EMMCW Complete!" will be displayed.

> EMMCW 0x0 0x0
send file        <--- Drag user.srec
EMMCW Complete!

13.Execute the EMMCWECSD command with the arguments 0xb1 0x2 to change the eMMC boot access bus width to 8-bit.

> EMMCWECSD 0xb1 0x2

EXT_CSD[b1] = 0x2

14.After writing loader.srec and user.srec files normally, turn off the power switch of the board.

15.Configure the eMMC boot mode using the MD pins of the device. Then turn the power ON. Device boots a program from the eMMC.

How to debug an eMMC boot project

The debugging procedure is the same as eSD boot. Refer to the How to debug an eSD boot project section in this document.

Exclusive access

Exclusive access instructions for synchronization and semaphores in Cortex-R52 and Cortex-A55 are prohibited to System SRAM. For exclusive control, perform either of the below methods,

Use mailbox and semaphore instead of exclusive access instruction.
Use exclusive access to LPDDR4 SDRAM.
Use exclusive access to TCM (not via AXIS).
Use exclusive access to System SRAM where is set as Cacheable and Non-shareable. In this case, transaction of exclusive access is not transferred to System SRAM.

For details of the target instructions, see the below sections in Arm Architecture Reference Manual for A-profile architecture (DDI 0487).

For AArch64
- B2.17 Synchronization and semaphores
For AArch32
- E2.10 Synchronization and semaphores

Note: Please refer to the RZ microprocessor's user manual to confirm whether LPDDR4 SDRAM is installed.

Configuration

The BSP is heavily data driven with most features and functionality being configured based on the content from configuration files. Configuration files represent the settings specified by the user and are generated when the project is built and/or when the Generate Project Content button is clicked in the FSP Configuration editor.

Build Time Configurations for fsp_common

The following build time configurations are defined in fsp_cfg/bsp/bsp_cfg.h:

Configuration	Options	Default	Description
MCU Vcc (mV)	Value must between 0 and 3800 (3.8V)	3300	Some peripherals require different settings based on the supplied voltage. Entering Vcc here (in mV) allows the relevant driver modules to configure the associated peripherals accordingly.
Parameter checking	Enabled Disabled	Disabled	When enabled, parameter checking for the BSP is turned on. In addition, any modules whose parameter checking configuration is set to 'Default (BSP)' will perform parameter checking as well.
Assert Failures	Return FSP_ERR_ASSERTION Call fsp_error_log then Return FSP_ERR_ASSERTION Use assert() to Halt Execution Disable checks that would return FSP_ERR_ASSERTION	Return FSP_ERR_ASSERTION	Define the behavior of the FSP_ASSERT() macro.
Error Log	No Error Log Errors Logged via fsp_error_log	No Error Log	Specify error logging behavior.
Soft Reset	Disabled Enabled	Disabled	Support for soft reset. If disabled, registers are assumed to be set to their default value during startup.
Port Protect	Disabled Enabled	Enabled	Keep the write protection function related GPIO settings locked when they are not being modified. If disabled they will be unlocked during startup.
Early BSP Initialization	Enabled Disabled	Disabled	Enable this option to use BSP functions before C runtime initialization (BSP_WARM_START_RESET or BSP_WARM_START_POST_CLOCK).
Multiplex Interrupt	Enabled Disabled	Disabled	Enable multiplex interrupt system-wide.
Register Protect Polling Count	Value must between 0x1 and 0xFFFFFFFF	0xFFFFFFFF	When the semaphore is enabled, the semaphore is acquired in order to configure the protect register. While waiting for the semaphore to become available, the protect register is polled the number of times indicated by this counter.

Duplication of resources

In the case of the secondary project (Non-primary cores), duplicate resource are indicated as the followings in Configuration tab when using resources that are used in the linked the primary (CR52_0 (CPU0) or CA55_0) project.

BSP
- Settings marked as "Valid only for primary core" are executed only for the primary project.
  - Master MPU
  - TrustZone Address Space Controller (TZC-400)
  - Address Expander
Clocks
- In secondary projects, this will be greyed out and cannot be set.
Pins
- The secondary project does not see the pin settings that you set in the primary project.
Interrupts
- There is no mutual exclusion control. If the user specifies an interrupt, be careful of resource overlaps.
Event Links
- The secondary project does not see the event factor that you set in the primary project.
Stacks
- Duplicate resource are indicated as red character that you set in the primary project.

Core Comparison

RZ/T2 uses Cortex-R52(CR52) and Cortex-A55(CA55) cores. The following is a cautionary execution when porting programs to different cores.

Specifications	CR52	CA55	Porting from CR52 to CA55	Porting from CA55 to CR52
Instruction set	AArch32 (32bit)	AArch64 (64bit)	Stack consumption doubles as CPU registers go from 32-bit to 64-bit.	-
Address space	4GB	32GB	Pointer type size changes from 32-bit to 64-bit.	Data placed in areas larger than 4 GB will need to be rearranged.
Cache	Instruction/data cache	L1 instruction/data cache L2 cache L3 cache	-	CA55-specific BSP API cannot be used. - R_BSP_CacheL3PowerCtrl()
Memory management	CPU-MPU	CPU-MMU	The non-cache section placed in System SRAM is allocated to a different area (Reserved) from the physical address as a virtual address. When handling physical addresses in user applications, address conversion is performed using the BSP API (R_BSP_MmuVatoPa, R_BSP_MmuPatoVa) that converts addresses.	CA55-specific BSP API cannot be used. - R_BSP_MmuVatoPa() - R_BSP_MmuPatoVa()
Interrupt	GIC	GIC-600	-	CA55-specific BSP API cannot be used. - R_BSP_GICD_xxxx() - R_BSP_GICR_xxxx() - R_BSP_GICC_xxxx()
Trigonometric Function Unit (TFU)	FSP supported	FSP not supported	Unable to use TFU-related BSP API.	-
System Error Interrupt (SEI,NMI)	Asynchronous external abort	SPI	Please refer to the implementation guide in the System Error Interrupt (SEI,NMI) section.	Refer to the left

Modules
	RZT2H

	RZT2L

	RZT2M

	RZT2ME

Macros
#define	BSP_IRQ_DISABLED

#define	FSP_RETURN(err)

#define	FSP_ERROR_LOG(err)

#define	FSP_ASSERT(a)

#define	FSP_ASSERT_NOT_RETURN_VALUE(a)

#define	FSP_ERROR_RETURN(a, err)

#define	FSP_ERROR_NOT_RETURN_VALUE(a, err)

#define	FSP_CRITICAL_SECTION_ENTER

#define	FSP_CRITICAL_SECTION_EXIT

#define	FSP_INVALID_VECTOR

#define	BSP_CFG_HANDLE_UNRECOVERABLE_ERROR(x)

#define	BSP_SECTION_AARCH64_STACK

#define	BSP_STACK_ALIGNMENT

#define	R_BSP_MODULE_START(ip, channel)

#define	R_BSP_MODULE_STOP(ip, channel)

Enumerations
enum	fsp_ip_t

enum	fsp_signal_t

enum	bsp_warm_start_event_t

enum	bsp_delay_units_t

enum	bsp_reg_protect_t

enum	bsp_reset_t

enum	bsp_cluster_reset_auto_release_t

enum	bsp_module_reset_t

enum	bsp_resource_state_t

enum	bsp_resource_num_t

enum	bsp_grp_irq_t

Variables
uint32_t	SystemCoreClock

Macro Definition Documentation

◆ BSP_IRQ_DISABLED

#define BSP_IRQ_DISABLED

Used to signify that an ELC event is not able to be used as an interrupt.

◆ FSP_RETURN

#define FSP_RETURN ( err )

Macro to log and return error without an assertion.

◆ FSP_ERROR_LOG

#define FSP_ERROR_LOG ( err )

This function is called before returning an error code. To stop on a runtime error, define fsp_error_log in user code and do required debugging (breakpoints, stack dump, etc) in this function.

◆ FSP_ASSERT

#define FSP_ASSERT ( a )

Default assertion calls FSP_ERROR_RETURN if condition "a" is false. Used to identify incorrect use of API's in FSP functions.

◆ FSP_ASSERT_NOT_RETURN_VALUE

#define FSP_ASSERT_NOT_RETURN_VALUE ( a )

Default assertion calls FSP_ERROR_NOT_RETURN_VALUE if condition "a" is false. Used to identify incorrect use of API's in FSP functions.

◆ FSP_ERROR_RETURN

#define FSP_ERROR_RETURN	(	a,
		err
	)

All FSP error codes are returned using this macro. Calls FSP_ERROR_LOG function if condition "a" is false. Used to identify runtime errors in FSP functions.

◆ FSP_ERROR_NOT_RETURN_VALUE

#define FSP_ERROR_NOT_RETURN_VALUE	(	a,
		err
	)

This function performs the same operation as FSP_ERROR_RETURN, but can be applied to functions that do not return an error code.

◆ FSP_CRITICAL_SECTION_ENTER

#define FSP_CRITICAL_SECTION_ENTER

This macro temporarily saves the current interrupt state and disables interrupts.

◆ FSP_CRITICAL_SECTION_EXIT

#define FSP_CRITICAL_SECTION_EXIT

This macro restores the previously saved interrupt state, reenabling interrupts.

◆ FSP_INVALID_VECTOR

#define FSP_INVALID_VECTOR

Used to signify that the requested IRQ vector is not defined in this system.

◆ BSP_CFG_HANDLE_UNRECOVERABLE_ERROR

#define BSP_CFG_HANDLE_UNRECOVERABLE_ERROR ( x )

In the event of an unrecoverable error, the BSP will by default take no action. The user can override this default behavior by defining their own BSP_CFG_HANDLE_UNRECOVERABLE_ERROR macro.

When BSP_CFG_HANDLE_UNRECOVERABLE_ERROR is called from error handlers, the user will need to investigate the cause. Common problems are stack corruption or the use of an invalid pointer.

Use the Fault Status window in e2 studio or manually check the fault status registers for more information. After an error handler, other interrupts may occur. Therefore, override BSP_CFG_HANDLE_UNRECOVERABLE_ERROR macro with a user-defined function and place a breakpoint inside it. This will help you catch the first interrupt and identify the root cause of the error.

◆ BSP_SECTION_AARCH64_STACK

#define BSP_SECTION_AARCH64_STACK

Common macro for FSP header files. There is also a corresponding FSP_FOOTER macro at the end of this file.

◆ BSP_STACK_ALIGNMENT

#define BSP_STACK_ALIGNMENT

Stacks (and heap) must be sized and aligned to an integer multiple of this number.

◆ R_BSP_MODULE_START

#define R_BSP_MODULE_START	(	ip,
		channel
	)

Cancels the module stop state.

Parameters

ip	fsp_ip_t enum value for the module to be stopped
channel	The channel. Use channel 0 for modules without channels.

◆ R_BSP_MODULE_STOP

#define R_BSP_MODULE_STOP	(	ip,
		channel
	)

Enables the module stop state.

Parameters

ip	fsp_ip_t enum value for the module to be stopped
channel	The channel. Use channel 0 for modules without channels.

Enumeration Type Documentation

◆ fsp_ip_t

enum fsp_ip_t

Available modules.

Enumerator
FSP_IP_CGC	Clock Generation Circuit.
FSP_IP_CLMA	Clock Monitor Circuit.
FSP_IP_MSTP	Module Stop.
FSP_IP_ICU	Interrupt Control Unit.
FSP_IP_BSC	Bus State Contoller.
FSP_IP_CKIO	CKIO.
FSP_IP_DMAC	DMA Controller.
FSP_IP_ELC	Event Link Controller.
FSP_IP_IOPORT	I/O Ports.
FSP_IP_MTU3	Multi-Function Timer Pulse Unit.
FSP_IP_POE3	Port Output Enable for MTU3.
FSP_IP_GPT	General PWM Timer.
FSP_IP_POEG	Port Output Enable for GPT.
FSP_IP_TFU	Arithmetic Unit for Trigonometric Functions.
FSP_IP_CMT	Compare Match Timer.
FSP_IP_CMTW	Compare Match Timer W.
FSP_IP_WDT	Watch Dog Timer.
FSP_IP_RTC	Real Time Clock.
FSP_IP_ETHSS	Ethernet Subsystem.
FSP_IP_GMAC	Ethernet MAC.
FSP_IP_ETHSW	Ethernet Switch.
FSP_IP_ESC	EtherCAT Slave Controller.
FSP_IP_USBHS	USB High Speed.
FSP_IP_SCI	Serial Communications Interface.
FSP_IP_IIC	I2C Bus Interface.
FSP_IP_CANFD	Controller Area Network with Flexible Data Rate.
FSP_IP_SPI	Serial Peripheral Interface.
FSP_IP_XSPI	expanded Serial Peripheral Interface
FSP_IP_CRC	Cyclic Redundancy Check Calculator.
FSP_IP_BSCAN	Boundary Scan.
FSP_IP_DSMIF	Delta Sigma Interface.
FSP_IP_ADC12	12-Bit A/D Converter
FSP_IP_TSU	Temperature Sensor.
FSP_IP_DOC	Data Operation Circuit.
FSP_IP_SYSRAM	System SRAM.
FSP_IP_ENCIF	Encoder Interface.
FSP_IP_SHOSTIF	Serial Host Interface.
FSP_IP_AFMT	A-Format.
FSP_IP_HDSL	HIPERFACE DSL.
FSP_IP_BISS	BiSS-C.
FSP_IP_ENDAT	EnDat 2.2.
FSP_IP_SCIE	Serial Communications Interface for encoder interface.
FSP_IP_TRACECLOCK	Trace Clock.
FSP_IP_ENCOUT	Encoder Divided-Output.
FSP_IP_DDRSS	LPDDR4 SDRAM Subsystem.
FSP_IP_LCDC	LCD Controller.
FSP_IP_PCIE	PCI Express 3.0 Interface.
FSP_IP_SDHI	SDMMC Host Interface.
FSP_IP_CPU1	CPU1 Module Stop.
FSP_IP_CR52	Cortex-R52 CPUn Module Stop.
FSP_IP_CA55	Cortex-A55 CPUn Module Stop.

◆ fsp_signal_t

enum fsp_signal_t

Signals that can be mapped to an interrupt.

Enumerator
FSP_SIGNAL_INTCPU0	Software interrupt 0.
FSP_SIGNAL_INTCPU1	Software interrupt 1.
FSP_SIGNAL_INTCPU2	Software interrupt 2.
FSP_SIGNAL_INTCPU3	Software interrupt 3.
FSP_SIGNAL_INTCPU4	Software interrupt 4.
FSP_SIGNAL_INTCPU5	Software interrupt 5.
FSP_SIGNAL_IRQ0	External pin interrupt 0.
FSP_SIGNAL_IRQ1	External pin interrupt 1.
FSP_SIGNAL_IRQ2	External pin interrupt 2.
FSP_SIGNAL_IRQ3	External pin interrupt 3.
FSP_SIGNAL_IRQ4	External pin interrupt 4.
FSP_SIGNAL_IRQ5	External pin interrupt 5.
FSP_SIGNAL_IRQ6	External pin interrupt 6.
FSP_SIGNAL_IRQ7	External pin interrupt 7.
FSP_SIGNAL_IRQ8	External pin interrupt 8.
FSP_SIGNAL_IRQ9	External pin interrupt 9.
FSP_SIGNAL_IRQ10	External pin interrupt 10.
FSP_SIGNAL_IRQ11	External pin interrupt 11.
FSP_SIGNAL_IRQ12	External pin interrupt 12.
FSP_SIGNAL_IRQ13	External pin interrupt 13.
FSP_SIGNAL_BSC_CMI	Refresh compare match interrupt.
FSP_SIGNAL_DMAC0_INT0	DMAC0 transfer completion 0.
FSP_SIGNAL_DMAC0_INT1	DMAC0 transfer completion 1.
FSP_SIGNAL_DMAC0_INT2	DMAC0 transfer completion 2.
FSP_SIGNAL_DMAC0_INT3	DMAC0 transfer completion 3.
FSP_SIGNAL_DMAC0_INT4	DMAC0 transfer completion 4.
FSP_SIGNAL_DMAC0_INT5	DMAC0 transfer completion 5.
FSP_SIGNAL_DMAC0_INT6	DMAC0 transfer completion 6.
FSP_SIGNAL_DMAC0_INT7	DMAC0 transfer completion 7.
FSP_SIGNAL_DMAC0_INT8	DMAC0 transfer completion 8.
FSP_SIGNAL_DMAC0_INT9	DMAC0 transfer completion 9.
FSP_SIGNAL_DMAC0_INT10	DMAC0 transfer completion 10.
FSP_SIGNAL_DMAC0_INT11	DMAC0 transfer completion 11.
FSP_SIGNAL_DMAC0_INT12	DMAC0 transfer completion 12.
FSP_SIGNAL_DMAC0_INT13	DMAC0 transfer completion 13.
FSP_SIGNAL_DMAC0_INT14	DMAC0 transfer completion 14.
FSP_SIGNAL_DMAC0_INT15	DMAC0 transfer completion 15.
FSP_SIGNAL_DMAC1_INT0	DMAC1 transfer completion 0.
FSP_SIGNAL_DMAC1_INT1	DMAC1 transfer completion 1.
FSP_SIGNAL_DMAC1_INT2	DMAC1 transfer completion 2.
FSP_SIGNAL_DMAC1_INT3	DMAC1 transfer completion 3.
FSP_SIGNAL_DMAC1_INT4	DMAC1 transfer completion 4.
FSP_SIGNAL_DMAC1_INT5	DMAC1 transfer completion 5.
FSP_SIGNAL_DMAC1_INT6	DMAC1 transfer completion 6.
FSP_SIGNAL_DMAC1_INT7	DMAC1 transfer completion 7.
FSP_SIGNAL_DMAC1_INT8	DMAC1 transfer completion 8.
FSP_SIGNAL_DMAC1_INT9	DMAC1 transfer completion 9.
FSP_SIGNAL_DMAC1_INT10	DMAC1 transfer completion 10.
FSP_SIGNAL_DMAC1_INT11	DMAC1 transfer completion 11.
FSP_SIGNAL_DMAC1_INT12	DMAC1 transfer completion 12.
FSP_SIGNAL_DMAC1_INT13	DMAC1 transfer completion 13.
FSP_SIGNAL_DMAC1_INT14	DMAC1 transfer completion 14.
FSP_SIGNAL_DMAC1_INT15	DMAC1 transfer completion 15.
FSP_SIGNAL_CMT0_CMI	CMT0 Compare match.
FSP_SIGNAL_CMT1_CMI	CMT1 Compare match.
FSP_SIGNAL_CMT2_CMI	CMT2 Compare match.
FSP_SIGNAL_CMT3_CMI	CMT3 Compare match.
FSP_SIGNAL_CMT4_CMI	CMT4 Compare match.
FSP_SIGNAL_CMT5_CMI	CMT5 Compare match.
FSP_SIGNAL_CMTW0_CMWI	CMTW0 Compare match.
FSP_SIGNAL_CMTW0_IC0I	CMTW0 Input capture of register 0.
FSP_SIGNAL_CMTW0_IC1I	CMTW0 Input capture of register 1.
FSP_SIGNAL_CMTW0_OC0I	CMTW0 Output compare of register 0.
FSP_SIGNAL_CMTW0_OC1I	CMTW0 Output compare of register 1.
FSP_SIGNAL_CMTW1_CMWI	CMTW1 Compare match.
FSP_SIGNAL_CMTW1_IC0I	CMTW1 Input capture of register 0.
FSP_SIGNAL_CMTW1_IC1I	CMTW1 Input capture of register 1.
FSP_SIGNAL_CMTW1_OC0I	CMTW1 Output compare of register 0.
FSP_SIGNAL_CMTW1_OC1I	CMTW1 Output compare of register 1.
FSP_SIGNAL_TGIA0	MTU0.TGRA input capture/compare match.
FSP_SIGNAL_TGIB0	MTU0.TGRB input capture/compare match.
FSP_SIGNAL_TGIC0	MTU0.TGRC input capture/compare match.
FSP_SIGNAL_TGID0	MTU0.TGRD input capture/compare match.
FSP_SIGNAL_TCIV0	MTU0.TCNT overflow.
FSP_SIGNAL_TGIE0	MTU0.TGRE compare match.
FSP_SIGNAL_TGIF0	MTU0.TGRF compare match.
FSP_SIGNAL_TGIA1	MTU1.TGRA input capture/compare match.
FSP_SIGNAL_TGIB1	MTU1.TGRB input capture/compare match.
FSP_SIGNAL_TCIV1	MTU1.TCNT overflow.
FSP_SIGNAL_TCIU1	MTU1.TCNT underflow.
FSP_SIGNAL_TGIA2	MTU2.TGRA input capture/compare match.
FSP_SIGNAL_TGIB2	MTU2.TGRB input capture/compare match.
FSP_SIGNAL_TCIV2	MTU2.TCNT overflow.
FSP_SIGNAL_TCIU2	MTU2.TCNT underflow.
FSP_SIGNAL_TGIA3	MTU3.TGRA input capture/compare match.
FSP_SIGNAL_TGIB3	MTU3.TGRB input capture/compare match.
FSP_SIGNAL_TGIC3	MTU3.TGRC input capture/compare match.
FSP_SIGNAL_TGID3	MTU3.TGRD input capture/compare match.
FSP_SIGNAL_TCIV3	MTU3.TCNT overflow.
FSP_SIGNAL_TGIA4	MTU4.TGRA input capture/compare match.
FSP_SIGNAL_TGIB4	MTU4.TGRB input capture/compare match.
FSP_SIGNAL_TGIC4	MTU4.TGRC input capture/compare match.
FSP_SIGNAL_TGID4	MTU4.TGRD input capture/compare match.
FSP_SIGNAL_TCIV4	MTU4.TCNT overflow/underflow.
FSP_SIGNAL_TGIU5	MTU5.TGRU input capture/compare match.
FSP_SIGNAL_TGIV5	MTU5.TGRV input capture/compare match.
FSP_SIGNAL_TGIW5	MTU5.TGRW input capture/compare match.
FSP_SIGNAL_TGIA6	MTU6.TGRA input capture/compare match.
FSP_SIGNAL_TGIB6	MTU6.TGRB input capture/compare match.
FSP_SIGNAL_TGIC6	MTU6.TGRC input capture/compare match.
FSP_SIGNAL_TGID6	MTU6.TGRD input capture/compare match.
FSP_SIGNAL_TCIV6	MTU6.TCNT overflow.
FSP_SIGNAL_TGIA7	MTU7.TGRA input capture/compare match.
FSP_SIGNAL_TGIB7	MTU7.TGRB input capture/compare match.
FSP_SIGNAL_TGIC7	MTU7.TGRC input capture/compare match.
FSP_SIGNAL_TGID7	MTU7.TGRD input capture/compare match.
FSP_SIGNAL_TCIV7	MTU7.TCNT overflow/underflow.
FSP_SIGNAL_TGIA8	MTU8.TGRA input capture/compare match.
FSP_SIGNAL_TGIB8	MTU8.TGRB input capture/compare match.
FSP_SIGNAL_TGIC8	MTU8.TGRC input capture/compare match.
FSP_SIGNAL_TGID8	MTU8.TGRD input capture/compare match.
FSP_SIGNAL_TCIV8	MTU8.TCNT overflow.
FSP_SIGNAL_OEI1	Output enable interrupt 1.
FSP_SIGNAL_OEI2	Output enable interrupt 2.
FSP_SIGNAL_OEI3	Output enable interrupt 3.
FSP_SIGNAL_OEI4	Output enable interrupt 4.
FSP_SIGNAL_GPT0_CCMPA	GPT0 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT0_CCMPB	GPT0 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT0_CMPC	GPT0 GTCCRC compare match.
FSP_SIGNAL_GPT0_CMPD	GPT0 GTCCRD compare match.
FSP_SIGNAL_GPT0_CMPE	GPT0 GTCCRE compare match.
FSP_SIGNAL_GPT0_CMPF	GPT0 GTCCRF compare match.
FSP_SIGNAL_GPT0_OVF	GPT0 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT0_UDF	GPT0 GTCNT underflow.
FSP_SIGNAL_GPT0_DTE	GPT0 Dead time error.
FSP_SIGNAL_GPT1_CCMPA	GPT1 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT1_CCMPB	GPT1 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT1_CMPC	GPT1 GTCCRC compare match.
FSP_SIGNAL_GPT1_CMPD	GPT1 GTCCRD compare match.
FSP_SIGNAL_GPT1_CMPE	GPT1 GTCCRE compare match.
FSP_SIGNAL_GPT1_CMPF	GPT1 GTCCRF compare match.
FSP_SIGNAL_GPT1_OVF	GPT1 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT1_UDF	GPT1 GTCNT underflow.
FSP_SIGNAL_GPT1_DTE	GPT1 Dead time error.
FSP_SIGNAL_GPT2_CCMPA	GPT2 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT2_CCMPB	GPT2 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT2_CMPC	GPT2 GTCCRC compare match.
FSP_SIGNAL_GPT2_CMPD	GPT2 GTCCRD compare match.
FSP_SIGNAL_GPT2_CMPE	GPT2 GTCCRE compare match.
FSP_SIGNAL_GPT2_CMPF	GPT2 GTCCRF compare match.
FSP_SIGNAL_GPT2_OVF	GPT2 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT2_UDF	GPT2 GTCNT underflow.
FSP_SIGNAL_GPT2_DTE	GPT2 Dead time error.
FSP_SIGNAL_GPT3_CCMPA	GPT3 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT3_CCMPB	GPT3 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT3_CMPC	GPT3 GTCCRC compare match.
FSP_SIGNAL_GPT3_CMPD	GPT3 GTCCRD compare match.
FSP_SIGNAL_GPT3_CMPE	GPT3 GTCCRE compare match.
FSP_SIGNAL_GPT3_CMPF	GPT3 GTCCRF compare match.
FSP_SIGNAL_GPT3_OVF	GPT3 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT3_UDF	GPT3 GTCNT underflow.
FSP_SIGNAL_GPT3_DTE	GPT3 Dead time error.
FSP_SIGNAL_GPT4_CCMPA	GPT4 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT4_CCMPB	GPT4 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT4_CMPC	GPT4 GTCCRC compare match.
FSP_SIGNAL_GPT4_CMPD	GPT4 GTCCRD compare match.
FSP_SIGNAL_GPT4_CMPE	GPT4 GTCCRE compare match.
FSP_SIGNAL_GPT4_CMPF	GPT4 GTCCRF compare match.
FSP_SIGNAL_GPT4_OVF	GPT4 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT4_UDF	GPT4 GTCNT underflow.
FSP_SIGNAL_GPT4_DTE	GPT4 Dead time error.
FSP_SIGNAL_GPT5_CCMPA	GPT5 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT5_CCMPB	GPT5 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT5_CMPC	GPT5 GTCCRC compare match.
FSP_SIGNAL_GPT5_CMPD	GPT5 GTCCRD compare match.
FSP_SIGNAL_GPT5_CMPE	GPT5 GTCCRE compare match.
FSP_SIGNAL_GPT5_CMPF	GPT5 GTCCRF compare match.
FSP_SIGNAL_GPT5_OVF	GPT5 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT5_UDF	GPT5 GTCNT underflow.
FSP_SIGNAL_GPT5_DTE	GPT5 Dead time error.
FSP_SIGNAL_GPT6_CCMPA	GPT6 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT6_CCMPB	GPT6 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT6_CMPC	GPT6 GTCCRC compare match.
FSP_SIGNAL_GPT6_CMPD	GPT6 GTCCRD compare match.
FSP_SIGNAL_GPT6_CMPE	GPT6 GTCCRE compare match.
FSP_SIGNAL_GPT6_CMPF	GPT6 GTCCRF compare match.
FSP_SIGNAL_GPT6_OVF	GPT6 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT6_UDF	GPT6 GTCNT underflow.
FSP_SIGNAL_GPT6_DTE	GPT6 Dead time error.
FSP_SIGNAL_GPT7_CCMPA	GPT7 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT7_CCMPB	GPT7 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT7_CMPC	GPT7 GTCCRC compare match.
FSP_SIGNAL_GPT7_CMPD	GPT7 GTCCRD compare match.
FSP_SIGNAL_GPT7_CMPE	GPT7 GTCCRE compare match.
FSP_SIGNAL_GPT7_CMPF	GPT7 GTCCRF compare match.
FSP_SIGNAL_GPT7_OVF	GPT7 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT7_UDF	GPT7 GTCNT underflow.
FSP_SIGNAL_GPT7_DTE	GPT7 Dead time error.
FSP_SIGNAL_GPT8_CCMPA	GPT8 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT8_CCMPB	GPT8 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT8_CMPC	GPT8 GTCCRC compare match.
FSP_SIGNAL_GPT8_CMPD	GPT8 GTCCRD compare match.
FSP_SIGNAL_GPT8_CMPE	GPT8 GTCCRE compare match.
FSP_SIGNAL_GPT8_CMPF	GPT8 GTCCRF compare match.
FSP_SIGNAL_GPT8_OVF	GPT8 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT8_UDF	GPT8 GTCNT underflow.
FSP_SIGNAL_GPT8_DTE	GPT8 Dead time error.
FSP_SIGNAL_GPT9_CCMPA	GPT9 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT9_CCMPB	GPT9 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT9_CMPC	GPT9 GTCCRC compare match.
FSP_SIGNAL_GPT9_CMPD	GPT9 GTCCRD compare match.
FSP_SIGNAL_GPT9_CMPE	GPT9 GTCCRE compare match.
FSP_SIGNAL_GPT9_CMPF	GPT9 GTCCRF compare match.
FSP_SIGNAL_GPT9_OVF	GPT9 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT9_UDF	GPT9 GTCNT underflow.
FSP_SIGNAL_GPT9_DTE	GPT9 Dead time error.
FSP_SIGNAL_GPT10_CCMPA	GPT10 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT10_CCMPB	GPT10 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT10_CMPC	GPT10 GTCCRC compare match.
FSP_SIGNAL_GPT10_CMPD	GPT10 GTCCRD compare match.
FSP_SIGNAL_GPT10_CMPE	GPT10 GTCCRE compare match.
FSP_SIGNAL_GPT10_CMPF	GPT10 GTCCRF compare match.
FSP_SIGNAL_GPT10_OVF	GPT10 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT10_UDF	GPT10 GTCNT underflow.
FSP_SIGNAL_GPT10_DTE	GPT10 Dead time error.
FSP_SIGNAL_GPT11_CCMPA	GPT11 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT11_CCMPB	GPT11 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT11_CMPC	GPT11 GTCCRC compare match.
FSP_SIGNAL_GPT11_CMPD	GPT11 GTCCRD compare match.
FSP_SIGNAL_GPT11_CMPE	GPT11 GTCCRE compare match.
FSP_SIGNAL_GPT11_CMPF	GPT11 GTCCRF compare match.
FSP_SIGNAL_GPT11_OVF	GPT11 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT11_UDF	GPT11 GTCNT underflow.
FSP_SIGNAL_GPT11_DTE	GPT11 Dead time error.
FSP_SIGNAL_GPT12_CCMPA	GPT12 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT12_CCMPB	GPT12 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT12_CMPC	GPT12 GTCCRC compare match.
FSP_SIGNAL_GPT12_CMPD	GPT12 GTCCRD compare match.
FSP_SIGNAL_GPT12_CMPE	GPT12 GTCCRE compare match.
FSP_SIGNAL_GPT12_CMPF	GPT12 GTCCRF compare match.
FSP_SIGNAL_GPT12_OVF	GPT12 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT12_UDF	GPT12 GTCNT underflow.
FSP_SIGNAL_GPT12_DTE	GPT12 Dead time error.
FSP_SIGNAL_GPT13_CCMPA	GPT13 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT13_CCMPB	GPT13 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT13_CMPC	GPT13 GTCCRC compare match.
FSP_SIGNAL_GPT13_CMPD	GPT13 GTCCRD compare match.
FSP_SIGNAL_GPT13_CMPE	GPT13 GTCCRE compare match.
FSP_SIGNAL_GPT13_CMPF	GPT13 GTCCRF compare match.
FSP_SIGNAL_GPT13_OVF	GPT13 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT13_UDF	GPT13 GTCNT underflow.
FSP_SIGNAL_GPT13_DTE	GPT13 Dead time error.
FSP_SIGNAL_POEG0_GROUP0	POEG group A interrupt for channels in LLPP.
FSP_SIGNAL_POEG0_GROUP1	POEG group B interrupt for channels in LLPP.
FSP_SIGNAL_POEG0_GROUP2	POEG group C interrupt for channels in LLPP.
FSP_SIGNAL_POEG0_GROUP3	POEG group D interrupt for channels in LLPP.
FSP_SIGNAL_POEG1_GROUP0	POEG group A interrupt for channels in NONSAFETY.
FSP_SIGNAL_POEG1_GROUP1	POEG group B interrupt for channels in NONSAFETY.
FSP_SIGNAL_POEG1_GROUP2	POEG group C interrupt for channels in NONSAFETY.
FSP_SIGNAL_POEG1_GROUP3	POEG group D interrupt for channels in NONSAFETY.
FSP_SIGNAL_GMAC_LPI	GMAC1 energy efficient.
FSP_SIGNAL_GMAC_PMT	GMAC1 power management.
FSP_SIGNAL_GMAC_SBD	GMAC1 general interrupt.
FSP_SIGNAL_ETHSW_INTR	Ethernet Switch interrupt.
FSP_SIGNAL_ETHSW_DLR	Ethernet Switch DLR interrupt.
FSP_SIGNAL_ETHSW_PRP	Ethernet Switch PRP interrupt.
FSP_SIGNAL_ETHSW_IHUB	Ethernet Switch Integrated Hub interrupt.
FSP_SIGNAL_ETHSW_PTRN0	Ethernet Switch RX Pattern Matcher interrupt 0.
FSP_SIGNAL_ETHSW_PTRN1	Ethernet Switch RX Pattern Matcher interrupt 1.
FSP_SIGNAL_ETHSW_PTRN2	Ethernet Switch RX Pattern Matcher interrupt 2.
FSP_SIGNAL_ETHSW_PTRN3	Ethernet Switch RX Pattern Matcher interrupt 3.
FSP_SIGNAL_ETHSW_PTRN4	Ethernet Switch RX Pattern Matcher interrupt 4.
FSP_SIGNAL_ETHSW_PTRN5	Ethernet Switch RX Pattern Matcher interrupt 5.
FSP_SIGNAL_ETHSW_PTRN6	Ethernet Switch RX Pattern Matcher interrupt 6.
FSP_SIGNAL_ETHSW_PTRN7	Ethernet Switch RX Pattern Matcher interrupt 7.
FSP_SIGNAL_ETHSW_PTRN8	Ethernet Switch RX Pattern Matcher interrupt 8.
FSP_SIGNAL_ETHSW_PTRN9	Ethernet Switch RX Pattern Matcher interrupt 9.
FSP_SIGNAL_ETHSW_PTRN10	Ethernet Switch RX Pattern Matcher interrupt 10.
FSP_SIGNAL_ETHSW_PTRN11	Ethernet Switch RX Pattern Matcher interrupt 11.
FSP_SIGNAL_ETHSW_PTPOUT0	Ethernet switch timer pulse output 0.
FSP_SIGNAL_ETHSW_PTPOUT1	Ethernet switch timer pulse output 1.
FSP_SIGNAL_ETHSW_PTPOUT2	Ethernet switch timer pulse output 2.
FSP_SIGNAL_ETHSW_PTPOUT3	Ethernet switch timer pulse output 3.
FSP_SIGNAL_ETHSW_TDMAOUT0	Ethernet Switch TDMA timer output 0.
FSP_SIGNAL_ETHSW_TDMAOUT1	Ethernet Switch TDMA timer output 1.
FSP_SIGNAL_ETHSW_TDMAOUT2	Ethernet Switch TDMA timer output 2.
FSP_SIGNAL_ETHSW_TDMAOUT3	Ethernet Switch TDMA timer output 3.
FSP_SIGNAL_ESC_SYNC0	EtherCAT Sync0 interrupt.
FSP_SIGNAL_ESC_SYNC1	EtherCAT Sync1 interrupt.
FSP_SIGNAL_ESC_CAT	EtherCAT interrupt.
FSP_SIGNAL_ESC_SOF	EtherCAT SOF interrupt.
FSP_SIGNAL_ESC_EOF	EtherCAT EOF interrupt.
FSP_SIGNAL_ESC_WDT	EtherCAT WDT interrupt.
FSP_SIGNAL_ESC_RST	EtherCAT RESET interrupt.
FSP_SIGNAL_USB_HI	USB (Host) interrupt.
FSP_SIGNAL_USB_FI	USB (Function) interrupt.
FSP_SIGNAL_USB_FDMA0	USB (Function) DMA 0 transmit completion.
FSP_SIGNAL_USB_FDMA1	USB (Function) DMA 1 transmit completion.
FSP_SIGNAL_SCI0_ERI	SCI0 Receive error.
FSP_SIGNAL_SCI0_RXI	SCI0 Receive data full.
FSP_SIGNAL_SCI0_TXI	SCI0 Transmit data empty.
FSP_SIGNAL_SCI0_TEI	SCI0 Transmit end.
FSP_SIGNAL_SCI1_ERI	SCI1 Receive error.
FSP_SIGNAL_SCI1_RXI	SCI1 Receive data full.
FSP_SIGNAL_SCI1_TXI	SCI1 Transmit data empty.
FSP_SIGNAL_SCI1_TEI	SCI1 Transmit end.
FSP_SIGNAL_SCI2_ERI	SCI2 Receive error.
FSP_SIGNAL_SCI2_RXI	SCI2 Receive data full.
FSP_SIGNAL_SCI2_TXI	SCI2 Transmit data empty.
FSP_SIGNAL_SCI2_TEI	SCI2 Transmit end.
FSP_SIGNAL_SCI3_ERI	SCI3 Receive error.
FSP_SIGNAL_SCI3_RXI	SCI3 Receive data full.
FSP_SIGNAL_SCI3_TXI	SCI3 Transmit data empty.
FSP_SIGNAL_SCI3_TEI	SCI3 Transmit end.
FSP_SIGNAL_SCI4_ERI	SCI4 Receive error.
FSP_SIGNAL_SCI4_RXI	SCI4 Receive data full.
FSP_SIGNAL_SCI4_TXI	SCI4 Transmit data empty.
FSP_SIGNAL_SCI4_TEI	SCI4 Transmit end.
FSP_SIGNAL_IIC0_EEI	IIC0 Transfer error or event generation.
FSP_SIGNAL_IIC0_RXI	IIC0 Receive data full.
FSP_SIGNAL_IIC0_TXI	IIC0 Transmit data empty.
FSP_SIGNAL_IIC0_TEI	IIC0 Transmit end.
FSP_SIGNAL_IIC1_EEI	IIC1 Transfer error or event generation.
FSP_SIGNAL_IIC1_RXI	IIC1 Receive data full.
FSP_SIGNAL_IIC1_TXI	IIC1 Transmit data empty.
FSP_SIGNAL_IIC1_TEI	IIC1 Transmit end.
FSP_SIGNAL_CAN_RXF	CANFD RX FIFO interrupt.
FSP_SIGNAL_CAN_GLERR	CANFD Global error interrupt.
FSP_SIGNAL_CAN0_TX	CAFND0 Channel TX interrupt.
FSP_SIGNAL_CAN0_CHERR	CAFND0 Channel CAN error interrupt.
FSP_SIGNAL_CAN0_COMFRX	CAFND0 Common RX FIFO or TXQ interrupt.
FSP_SIGNAL_CAN1_TX	CAFND1 Channel TX interrupt.
FSP_SIGNAL_CAN1_CHERR	CAFND1 Channel CAN error interrupt.
FSP_SIGNAL_CAN1_COMFRX	CAFND1 Common RX FIFO or TXQ interrupt.
FSP_SIGNAL_SPI0_SPRI	SPI0 Reception buffer full.
FSP_SIGNAL_SPI0_SPTI	SPI0 Transmit buffer empty.
FSP_SIGNAL_SPI0_SPII	SPI0 SPI idle.
FSP_SIGNAL_SPI0_SPEI	SPI0 errors.
FSP_SIGNAL_SPI0_SPCEND	SPI0 Communication complete.
FSP_SIGNAL_SPI1_SPRI	SPI1 Reception buffer full.
FSP_SIGNAL_SPI1_SPTI	SPI1 Transmit buffer empty.
FSP_SIGNAL_SPI1_SPII	SPI1 SPI idle.
FSP_SIGNAL_SPI1_SPEI	SPI1 errors.
FSP_SIGNAL_SPI1_SPCEND	SPI1 Communication complete.
FSP_SIGNAL_SPI2_SPRI	SPI2 Reception buffer full.
FSP_SIGNAL_SPI2_SPTI	SPI2 Transmit buffer empty.
FSP_SIGNAL_SPI2_SPII	SPI2 SPI idle.
FSP_SIGNAL_SPI2_SPEI	SPI2 errors.
FSP_SIGNAL_SPI2_SPCEND	SPI2 Communication complete.
FSP_SIGNAL_XSPI0_INT	xSPI0 Interrupt
FSP_SIGNAL_XSPI0_INTERR	xSPI0 Error interrupt
FSP_SIGNAL_XSPI1_INT	xSPI1 Interrupt
FSP_SIGNAL_XSPI1_INTERR	xSPI1 Error interrupt
FSP_SIGNAL_DSMIF0_CDRUI	DSMIF0 current data register update (ORed ch0 to ch2)
FSP_SIGNAL_DSMIF1_CDRUI	DSMIF1 current data register update (ORed ch3 to ch5)
FSP_SIGNAL_ADC0_ADI	ADC0 A/D scan end interrupt.
FSP_SIGNAL_ADC0_GBADI	ADC0 A/D scan end interrupt for Group B.
FSP_SIGNAL_ADC0_GCADI	ADC0 A/D scan end interrupt for Group C.
FSP_SIGNAL_ADC0_CMPAI	ADC0 Window A compare match.
FSP_SIGNAL_ADC0_CMPBI	ADC0 Window B compare match.
FSP_SIGNAL_ADC1_ADI	ADC1 A/D scan end interrupt.
FSP_SIGNAL_ADC1_GBADI	ADC1 A/D scan end interrupt for Group B.
FSP_SIGNAL_ADC1_GCADI	ADC1 A/D scan end interrupt for Group C.
FSP_SIGNAL_ADC1_CMPAI	ADC1 Window A compare match.
FSP_SIGNAL_ADC1_CMPBI	ADC1 Window B compare match.
FSP_SIGNAL_ENCIF_INT0	ENCIF CH0 Interrupt A.
FSP_SIGNAL_ENCIF_INT1	ENCIF CH0 Interrupt B.
FSP_SIGNAL_ENCIF_INT2	ENCIF CH0 OUTPUT FIFO Interrupt.
FSP_SIGNAL_ENCIF_INT3	ENCIF CH0 INPUT FIFO Interrupt.
FSP_SIGNAL_ENCIF_INT4	ENCIF CH1 Interrupt A.
FSP_SIGNAL_ENCIF_INT5	ENCIF CH1 Interrupt B.
FSP_SIGNAL_ENCIF_INT6	ENCIF CH1 OUTPUT FIFO Interrupt.
FSP_SIGNAL_ENCIF_INT7	ENCIF CH1 INPUT FIFO Interrupt.
FSP_SIGNAL_CPU0_ERR0	Cortex-R52 CPU0 error event 0.
FSP_SIGNAL_CPU0_ERR1	Cortex-R52 CPU0 error event 1.
FSP_SIGNAL_CPU1_ERR0	Cortex-R52 CPU1 error event 0.
FSP_SIGNAL_CPU1_ERR1	Cortex-R52 CPU1 error event 1.
FSP_SIGNAL_PERI_ERR0	Peripherals error event 0.
FSP_SIGNAL_PERI_ERR1	Peripherals error event 1.
FSP_SIGNAL_INTCPU6	Software interrupt 6.
FSP_SIGNAL_INTCPU7	Software interrupt 7.
FSP_SIGNAL_IRQ14	External pin interrupt 14.
FSP_SIGNAL_IRQ15	External pin interrupt 15.
FSP_SIGNAL_GPT14_CCMPA	GPT14 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT14_CCMPB	GPT14 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT14_CMPC	GPT14 GTCCRC compare match.
FSP_SIGNAL_GPT14_CMPD	GPT14 GTCCRD compare match.
FSP_SIGNAL_GPT14_CMPE	GPT14 GTCCRE compare match.
FSP_SIGNAL_GPT14_CMPF	GPT14 GTCCRF compare match.
FSP_SIGNAL_GPT14_OVF	GPT14 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT14_UDF	GPT14 GTCNT underflow.
FSP_SIGNAL_GPT15_CCMPA	GPT15 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT15_CCMPB	GPT15 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT15_CMPC	GPT15 GTCCRC compare match.
FSP_SIGNAL_GPT15_CMPD	GPT15 GTCCRD compare match.
FSP_SIGNAL_GPT15_CMPE	GPT15 GTCCRE compare match.
FSP_SIGNAL_GPT15_CMPF	GPT15 GTCCRF compare match.
FSP_SIGNAL_GPT15_OVF	GPT15 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT15_UDF	GPT15 GTCNT underflow.
FSP_SIGNAL_GPT16_CCMPA	GPT16 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT16_CCMPB	GPT16 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT16_CMPC	GPT16 GTCCRC compare match.
FSP_SIGNAL_GPT16_CMPD	GPT16 GTCCRD compare match.
FSP_SIGNAL_GPT16_CMPE	GPT16 GTCCRE compare match.
FSP_SIGNAL_GPT16_CMPF	GPT16 GTCCRF compare match.
FSP_SIGNAL_GPT16_OVF	GPT16 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT16_UDF	GPT16 GTCNT underflow.
FSP_SIGNAL_GPT17_CCMPA	GPT17 GTCCRA input capture/compare match.
FSP_SIGNAL_GPT17_CCMPB	GPT17 GTCCRB input capture/compare match.
FSP_SIGNAL_GPT17_CMPC	GPT17 GTCCRC compare match.
FSP_SIGNAL_GPT17_CMPD	GPT17 GTCCRD compare match.
FSP_SIGNAL_GPT17_CMPE	GPT17 GTCCRE compare match.
FSP_SIGNAL_GPT17_CMPF	GPT17 GTCCRF compare match.
FSP_SIGNAL_GPT17_OVF	GPT17 GTCNT overflow (GTPR compare match)
FSP_SIGNAL_GPT17_UDF	GPT17 GTCNT underflow.
FSP_SIGNAL_POEG2_GROUP0	POEG group A interrupt for channels in SAFETY.
FSP_SIGNAL_POEG2_GROUP1	POEG group B interrupt for channels in SAFETY.
FSP_SIGNAL_POEG2_GROUP2	POEG group C interrupt for channels in SAFETY.
FSP_SIGNAL_POEG2_GROUP3	POEG group D interrupt for channels in SAFETY.
FSP_SIGNAL_RTC_ALM	Alarm interrupt.
FSP_SIGNAL_RTC_1S	1 second interrupt
FSP_SIGNAL_RTC_PRD	Fixed interval interrupt.
FSP_SIGNAL_SCI5_ERI	SCI5 Receive error.
FSP_SIGNAL_SCI5_RXI	SCI5 Receive data full.
FSP_SIGNAL_SCI5_TXI	SCI5 Transmit data empty.
FSP_SIGNAL_SCI5_TEI	SCI5 Transmit end.
FSP_SIGNAL_IIC2_EEI	IIC2 Transfer error or event generation.
FSP_SIGNAL_IIC2_RXI	IIC2 Receive data full.
FSP_SIGNAL_IIC2_TXI	IIC2 Transmit data empty.
FSP_SIGNAL_IIC2_TEI	IIC2 Transmit end.
FSP_SIGNAL_SPI3_SPRI	SPI3 Reception buffer full.
FSP_SIGNAL_SPI3_SPTI	SPI3 Transmit buffer empty.
FSP_SIGNAL_SPI3_SPII	SPI3 SPI idle.
FSP_SIGNAL_SPI3_SPEI	SPI3 errors.
FSP_SIGNAL_SPI3_SPCEND	SPI3 Communication complete.
FSP_SIGNAL_DREQ	External DMA request.
FSP_SIGNAL_CAN_RF_DMAREQ0	CAFND RX FIFO 0 DMA request.
FSP_SIGNAL_CAN_RF_DMAREQ1	CAFND RX FIFO 1 DMA request.
FSP_SIGNAL_CAN_RF_DMAREQ2	CAFND RX FIFO 2 DMA request.
FSP_SIGNAL_CAN_RF_DMAREQ3	CAFND RX FIFO 3 DMA request.
FSP_SIGNAL_CAN_RF_DMAREQ4	CAFND RX FIFO 4 DMA request.
FSP_SIGNAL_CAN_RF_DMAREQ5	CAFND RX FIFO 5 DMA request.
FSP_SIGNAL_CAN_RF_DMAREQ6	CAFND RX FIFO 6 DMA request.
FSP_SIGNAL_CAN_RF_DMAREQ7	CAFND RX FIFO 7 DMA request.
FSP_SIGNAL_CAN0_CF_DMAREQ	CAFND0 First common FIFO DMA request.
FSP_SIGNAL_CAN1_CF_DMAREQ	CAFND1 First common FIFO DMA request.
FSP_SIGNAL_ADC0_WCMPM	ADC0 compare match.
FSP_SIGNAL_ADC0_WCMPUM	ADC0 compare mismatch.
FSP_SIGNAL_ADC1_WCMPM	ADC1 compare match.
FSP_SIGNAL_ADC1_WCMPUM	ADC1 compare mismatch.
FSP_SIGNAL_TCIV4_OF	MTU4.TCNT overflow.
FSP_SIGNAL_TCIV4_UF	MTU4.TCNT underflow.
FSP_SIGNAL_TCIV7_OF	MTU7.TCNT overflow.
FSP_SIGNAL_TCIV7_UF	MTU7.TCNT underflow.
FSP_SIGNAL_IOPORT_GROUP1	Input edge detection of input port group 1.
FSP_SIGNAL_IOPORT_GROUP2	Input edge detection of input port group 2.
FSP_SIGNAL_IOPORT_SINGLE0	Input edge detection of single input port 0.
FSP_SIGNAL_IOPORT_SINGLE1	Input edge detection of single input port 1.
FSP_SIGNAL_IOPORT_SINGLE2	Input edge detection of single input port 2.
FSP_SIGNAL_IOPORT_SINGLE3	Input edge detection of single input port 3.
FSP_SIGNAL_GPT0_ADTRGA	GPT0 GTADTRA compare match.
FSP_SIGNAL_GPT0_ADTRGB	GPT0 GTADTRB compare match.
FSP_SIGNAL_GPT1_ADTRGA	GPT1 GTADTRA compare match.
FSP_SIGNAL_GPT1_ADTRGB	GPT1 GTADTRB compare match.
FSP_SIGNAL_GPT2_ADTRGA	GPT2 GTADTRA compare match.
FSP_SIGNAL_GPT2_ADTRGB	GPT2 GTADTRB compare match.
FSP_SIGNAL_GPT3_ADTRGA	GPT3 GTADTRA compare match.
FSP_SIGNAL_GPT3_ADTRGB	GPT3 GTADTRB compare match.
FSP_SIGNAL_GPT4_ADTRGA	GPT4 GTADTRA compare match.
FSP_SIGNAL_GPT4_ADTRGB	GPT4 GTADTRB compare match.
FSP_SIGNAL_GPT5_ADTRGA	GPT5 GTADTRA compare match.
FSP_SIGNAL_GPT5_ADTRGB	GPT5 GTADTRB compare match.
FSP_SIGNAL_GPT6_ADTRGA	GPT6 GTADTRA compare match.
FSP_SIGNAL_GPT6_ADTRGB	GPT6 GTADTRB compare match.
FSP_SIGNAL_GPT7_ADTRGA	GPT7 GTADTRA compare match.
FSP_SIGNAL_GPT7_ADTRGB	GPT7 GTADTRB compare match.
FSP_SIGNAL_GPT8_ADTRGA	GPT8 GTADTRA compare match.
FSP_SIGNAL_GPT8_ADTRGB	GPT8 GTADTRB compare match.
FSP_SIGNAL_GPT9_ADTRGA	GPT9 GTADTRA compare match.
FSP_SIGNAL_GPT9_ADTRGB	GPT9 GTADTRB compare match.
FSP_SIGNAL_GPT10_ADTRGA	GPT10 GTADTRA compare match.
FSP_SIGNAL_GPT10_ADTRGB	GPT10 GTADTRB compare match.
FSP_SIGNAL_GPT11_ADTRGA	GPT11 GTADTRA compare match.
FSP_SIGNAL_GPT11_ADTRGB	GPT11 GTADTRB compare match.
FSP_SIGNAL_GPT12_ADTRGA	GPT12 GTADTRA compare match.
FSP_SIGNAL_GPT12_ADTRGB	GPT12 GTADTRB compare match.
FSP_SIGNAL_GPT13_ADTRGA	GPT13 GTADTRA compare match.
FSP_SIGNAL_GPT13_ADTRGB	GPT13 GTADTRB compare match.

◆ bsp_warm_start_event_t

enum bsp_warm_start_event_t

Different warm start entry locations in the BSP.

Enumerator
BSP_WARM_START_RESET	Called almost immediately after reset. No C runtime environment, clocks, or IRQs.
BSP_WARM_START_POST_CLOCK	Called after clock initialization. No C runtime environment or IRQs.
BSP_WARM_START_POST_C	Called after clocks and C runtime environment have been set up.

◆ bsp_delay_units_t

enum bsp_delay_units_t

Available delay units for R_BSP_SoftwareDelay(). These are ultimately used to calculate a total # of microseconds

Enumerator
BSP_DELAY_UNITS_SECONDS	Requested delay amount is in seconds.
BSP_DELAY_UNITS_MILLISECONDS	Requested delay amount is in milliseconds.
BSP_DELAY_UNITS_MICROSECONDS	Requested delay amount is in microseconds.

◆ bsp_reg_protect_t

enum bsp_reg_protect_t

The different types of registers that can be protected.

Enumerator
BSP_REG_PROTECT_CGC	Enables writing to the registers related to the clock generation circuit.
BSP_REG_PROTECT_LPC_RESET	Enables writing to the registers related to low power consumption and reset.
BSP_REG_PROTECT_GPIO	Enables writing to the registers related to GPIO.
BSP_REG_PROTECT_SYSTEM	Enables writing to the registers related to Non-Safety reg.

◆ bsp_reset_t

enum bsp_reset_t

CPU to be reset target.

Enumerator
BSP_RESET_CR52_0	Software reset for CR52_0.
BSP_RESET_CR52_1	Software reset for CR52_1.
BSP_RESET_CA55_CLUSTER	Software reset for CA55_CLUSTER.
BSP_RESET_CA55_0	Software reset for CA55_0.
BSP_RESET_CA55_1	Software reset for CA55_1.
BSP_RESET_CA55_2	Software reset for CA55_2.
BSP_RESET_CA55_3	Software reset for CA55_3.

◆ bsp_cluster_reset_auto_release_t

enum bsp_cluster_reset_auto_release_t

CA55 cluster reset auto reset release status.

◆ bsp_module_reset_t

enum bsp_module_reset_t

The different types of registers that can control the reset of peripheral modules related to Ethernet.

Enumerator
BSP_MODULE_RESET_XSPI0	Enables writing to the registers related to xSPI Unit 0 reset control.
BSP_MODULE_RESET_XSPI1	Enables writing to the registers related to xSPI Unit 1 reset control.
BSP_MODULE_RESET_GMAC0_PCLKH	Enables writing to the registers related to GMAC (PCLKH clock domain) reset control.
BSP_MODULE_RESET_GMAC0_PCLKM	Enables writing to the registers related to GMAC (PCLKM clock domain) reset control.
BSP_MODULE_RESET_ETHSW	Enables writing to the registers related to ETHSW reset control.
BSP_MODULE_RESET_ESC_BUS	Enables writing to the registers related to ESC (Bus clock domain) reset control.
BSP_MODULE_RESET_ESC_IP	Enables writing to the registers related to ESC (IP clock domain) reset control.
BSP_MODULE_RESET_ESC_ETH_SUBSYSTEM	Enables writing to the registers related to Ethernet subsystem register reset control.
BSP_MODULE_RESET_MII	Enables writing to the registers related to MII converter reset control.
BSP_MODULE_RESET_GMAC1_ACLK	Enables writing to the registers related to GMAC Unit 1 (PCLKAH clock domain) reset control.
BSP_MODULE_RESET_GMAC1_HCLK	Enables writing to the registers related to GMAC Unit 1 (PCLKAM clock domain) reset control.
BSP_MODULE_RESET_GMAC2_ACLK	Enables writing to the registers related to GMAC Unit 2 (PCLKAH clock domain) reset control.
BSP_MODULE_RESET_GMAC2_HCLK	Enables writing to the registers related to GMAC Unit 2 (PCLKAM clock domain) reset control.
BSP_MODULE_RESET_SHOSTIF_MASTER_BUS_CLOCK	Enables writing to the registers related to SHOSTIF (Master bus clock domain) reset control.
BSP_MODULE_RESET_SHOSTIF_SLAVE_BUS_CLOCK	Enables writing to the registers related to SHOSTIF (Slave bus clock domain) reset control.
BSP_MODULE_RESET_SHOSTIF_IP_CLOCK	Enables writing to the registers related to SHOSTIF (IP clock domain) reset control.
BSP_MODULE_RESET_AFMT0	Enables writing to the registers related to AFMT0 reset control.
BSP_MODULE_RESET_HDSL0	Enables writing to the registers related to HDSL0 reset control.
BSP_MODULE_RESET_BISS0	Enables writing to the registers related to BISS0 reset control.
BSP_MODULE_RESET_ENDAT0	Enables writing to the registers related to ENDAT0 reset control.
BSP_MODULE_RESET_AFMT1	Enables writing to the registers related to AFMT1 reset control.
BSP_MODULE_RESET_HDSL1	Enables writing to the registers related to HDSL1 reset control.
BSP_MODULE_RESET_BISS1	Enables writing to the registers related to BISS1 reset control.
BSP_MODULE_RESET_ENDAT1	Enables writing to the registers related to ENDAT1 reset control.
BSP_MODULE_RESET_PCIE	Enables writing to the registers related to PCIE reset control.
BSP_MODULE_RESET_DDRSS_RST_N	Enables writing to the registers related to DDRSS rst_n reset control.
BSP_MODULE_RESET_DDRSS_RST_PWROKLN	Enables writing to the registers related to DDRSS PwrOkln reset control.
BSP_MODULE_RESET_DDRSS_RESET	Enables writing to the registers related to DDRSS Reset reset control.
BSP_MODULE_RESET_DDRSS_AXI0_ARESETN	Enables writing to the registers related to DDRSS axi0_ARESETn reset control.
BSP_MODULE_RESET_DDRSS_AXI1_ARESETN	Enables writing to the registers related to DDRSS axi1_ARESETn reset control.
BSP_MODULE_RESET_DDRSS_AXI2_ARESETN	Enables writing to the registers related to DDRSS axi2_ARESETn reset control.
BSP_MODULE_RESET_DDRSS_AXI3_ARESETN	Enables writing to the registers related to DDRSS axi3_ARESETn reset control.
BSP_MODULE_RESET_DDRSS_AXI4_ARESETN	Enables writing to the registers related to DDRSS axi4_ARESETn reset control.
BSP_MODULE_RESET_DDRSS_MC_PRESETN	Enables writing to the registers related to DDRSS MC_PRESETn reset control.
BSP_MODULE_RESET_DDRSS_PHY_PRESETN	Enables writing to the registers related to DDRSS PHY_PRESETn reset control.

◆ bsp_resource_state_t

enum bsp_resource_state_t

The semaphore resource state shared by CPU0 and CPU1

Enumerator
BSP_RESOURCE_STATE_BEING_USED	Semaphore resource being used.
BSP_RESOURCE_STATE_NOT_BEING_USED	Semaphore resource not being used.

◆ bsp_resource_num_t

enum bsp_resource_num_t

The semaphore resource number shared by CPU0 and CPU1

Enumerator
BSP_RESOURCE_NUM_0	Semaphore resource number 0.
BSP_RESOURCE_NUM_1	Semaphore resource number 1.
BSP_RESOURCE_NUM_2	Semaphore resource number 2.
BSP_RESOURCE_NUM_3	Semaphore resource number 3.
BSP_RESOURCE_NUM_4	Semaphore resource number 4.
BSP_RESOURCE_NUM_5	Semaphore resource number 5.
BSP_RESOURCE_NUM_6	Semaphore resource number 6.
BSP_RESOURCE_NUM_7	Semaphore resource number 7.

◆ bsp_grp_irq_t

enum bsp_grp_irq_t

Which interrupts can have callbacks registered.

Enumerator
BSP_GRP_IRQ_UNSUPPORTED	NMI Group IRQ are not supported.

Function Documentation

◆ R_FSP_VersionGet()

fsp_err_t R_FSP_VersionGet ( fsp_pack_version_t *const p_version )

Get the FSP version based on compile time macros.

Parameters

[out] p_version Memory address to return version information to.

Return values

FSP_SUCCESS	Version information stored.
FSP_ERR_ASSERTION	The parameter p_version is NULL.

◆ Default_Handler()

void Default_Handler ( void )

Default exception handler.

◆ system_init()

BSP_TARGET_ARM BSP_ATTRIBUTE_STACKLESS void system_init ( void )

After boot processing, LSI starts executing here.

◆ bsp_register_initialization()

BSP_TARGET_ARM BSP_ATTRIBUTE_STACKLESS void bsp_register_initialization ( void )

Initialize each register.

◆ SystemInit()

void SystemInit ( void )

Initialize the MCU and the runtime environment.

◆ R_BSP_WarmStart()

void R_BSP_WarmStart ( bsp_warm_start_event_t event )

This function is called at various points during the startup process. This function is declared as a weak symbol higher up in this file because it is meant to be overridden by a user implemented version. One of the main uses for this function is to call functional safety code during the startup process. To use this function just copy this function into your own code and modify it to meet your needs.

Parameters

[in] event Where the code currently is in the start up process

Note: All programs that are executed when a BSP_WARM_START_RESET, or BSP_WARM_START_POST_CLOCK event occurs must be placed in the LOADER section(BTCM for CR52 core, SystemRAM for CA55 core). These events occur before the copy of the application program in the startup code is executed, so the application program is on ROM and cannot be executed at that time. The FSP linker script specifies that the .warm_start section be placed in the LOADER section. Adding a section specification to the definition of a function or variable makes it easier to place it in the LOADER section.

◆ R_BSP_WarmStart_StackLess()

BSP_ATTRIBUTE_STACKLESS void R_BSP_WarmStart_StackLess ( void )

This function is called without a stack at the very beginning of the startup process. This function is declared as a weak symbol higher up in this file because it is meant to be overridden by a user implemented version. To use this function just copy this function into your own code and modify it to meet your needs.

Note: At the point this function is called, the stack has not been initialized, so all instructions must be written in inline assembly.

◆ R_BSP_CacheEnableInst()

void R_BSP_CacheEnableInst ( void )

Enable instruction caching.

◆ R_BSP_CacheEnableData()

void R_BSP_CacheEnableData ( void )

Enable data caching.

◆ R_BSP_CacheEnableMemoryProtect()

void R_BSP_CacheEnableMemoryProtect ( void )

Enable memory protect.

◆ R_BSP_CacheDisableInst()

void R_BSP_CacheDisableInst ( void )

Disable instruction caching.

◆ R_BSP_CacheDisableData()

void R_BSP_CacheDisableData ( void )

Disable data caching.

◆ R_BSP_CacheDisableMemoryProtect()

void R_BSP_CacheDisableMemoryProtect ( void )

Disable memory protect.

◆ R_BSP_CacheCleanAll()

void R_BSP_CacheCleanAll ( void )

Clean data cache by set/way. Clean means writing the cache data to memory and clear the dirty bits if there is a discrepancy between the cache and memory data.

◆ R_BSP_CacheInvalidateAll()

void R_BSP_CacheInvalidateAll ( void )

Invalidate data cache by set/way. Also Invalidate instruction cache.

Invalidate means to delete cache data.

◆ R_BSP_CacheCleanInvalidateAll()

void R_BSP_CacheCleanInvalidateAll ( void )

Clean and Invalidate data cache by set/way. Also Invalidate instruction cache.

Clean means writing the cache data to memory and clear the dirty bits if there is a discrepancy between the cache and memory data.

Invalidate means to delete cache data.

◆ R_BSP_CacheCleanRange()

void R_BSP_CacheCleanRange	(	uintptr_t	base_address,
		uintptr_t	length
	)

Clean data cache and Invalidate instruction cache by address.

Clean means writing the cache data to memory and clear the dirty bits if there is a discrepancy between the cache and memory data.

Invalidate means to delete cache data.

Parameters

[in]	base_address	Start address of area you want to Clean.
[in]	length	Size of area you want to Clean.

◆ R_BSP_CacheInvalidateRange()

void R_BSP_CacheInvalidateRange	(	uintptr_t	base_address,
		uintptr_t	length
	)

Invalidate instruction and data cache by address.

Invalidate means to delete cache data.

Parameters

[in]	base_address	Start address of area you want to Invalidate.
[in]	length	Size of area you want to Invalidate.

◆ R_BSP_CacheCleanInvalidateRange()

void R_BSP_CacheCleanInvalidateRange	(	uintptr_t	base_address,
		uintptr_t	length
	)

Clean and Invalidate data cache and Invalidate instruction cache by address.

Clean means writing the cache data to memory and clear the dirty bits if there is a discrepancy between the cache and memory data.

Invalidate means to delete cache data.

Parameters

[in]	base_address	Start address of area you want to Clean and Invalidate.
[in]	length	Size of area you want to Clean and Invalidate.

◆ R_BSP_CacheL3PowerCtrl()

void R_BSP_CacheL3PowerCtrl ( void )

Powers on and off the L3 cache way. CA55 only.

◆ R_BSP_FspAssert()

__WEAK void R_BSP_FspAssert ( void )

This function is called within the following macros when assertion or error conditions occur: FSP_ASSERT, FSP_ASSERT_NOT_RETURN_VALUE, FSP_ERROR_RETURN, FSP_ERROR_NOT_RETURN_VALUE

This function is declared as a weak symbol because it is meant to be overridden by the user. To use this function just copy this function into your own code and modify it to meet your needs.

◆ R_FSP_CurrentIrqGet()

__STATIC_INLINE IRQn_Type R_FSP_CurrentIrqGet ( void )

Return active interrupt vector number value

Returns: Active interrupt vector number value

◆ R_FSP_SystemClockHzGet()

__STATIC_INLINE uint32_t R_FSP_SystemClockHzGet ( fsp_priv_clock_t clock )

Gets the frequency of a system clock.

Returns: Frequency of requested clock in Hertz.

◆ R_BSP_SoftwareDelay()

void R_BSP_SoftwareDelay	(	uint32_t	delay,
		bsp_delay_units_t	units
	)

Delay for at least the specified duration in units and return.

Parameters

[in]	delay	The number of 'units' to delay.
[in]	units	The 'base' (bsp_delay_units_t) for the units specified. Valid values are: BSP_DELAY_UNITS_SECONDS, BSP_DELAY_UNITS_MILLISECONDS, BSP_DELAY_UNITS_MICROSECONDS. For example: At 200 MHz one cycle takes 1/200 microsecond or 5 nanoseconds. At 800 MHz one cycle takes 1/800 microsecond or 1.25 nanoseconds. Therefore one run through bsp_prv_software_delay_loop() takes: ~ (1.25 * BSP_DELAY_LOOP_CYCLES) or 5 ns. A delay of 2 us therefore requires 2000ns/5ns or 400 loops.

The 'theoretical' maximum delay that may be obtained is determined by a full 32 bit loop count and the system clock rate. @200MHz: ((0xFFFFFFFF loops * 4 cycles /loop) / 200000000) = 85 seconds. @800MHz: ((0xFFFFFFFF loops * 4 cycles /loop) / 800000000) = 21 seconds.

Note that requests for very large delays will be affected by rounding in the calculations and the actual delay achieved may be slightly longer. @200 MHz, for example, a request for 85 seconds will be closer to 86 seconds.

Note also that if the calculations result in a loop_cnt of zero, the bsp_prv_software_delay_loop() function is not called at all. In this case the requested delay is too small (nanoseconds) to be carried out by the loop itself, and the overhead associated with executing the code to just get to this point has certainly satisfied the requested delay.

Note

R_BSP_SoftwareDelay() obtains the system clock value by reading the SystemCoreClock variable. Therefore, R_BSP_SoftwareDelay() cannot be used until after the SystemCoreClock has been updated. The SystemCoreClock is updated by executing SystemCoreClockUpdate() in startup; users cannot call R_BSP_SoftwareDelay() inside R_BSP_WarmStart(BSP_WARM_START_RESET) and R_BSP_WarmStart(BSP_WARM_START_POST_CLOCK) since they are invoked before SystemCoreClockUpdate() in startup.

This function will delay for at least the specified duration. Due to overhead in calculating the correct number of loops to delay, very small delay values (generally 1-5 microseconds) may be significantly longer than specified. Approximate overhead for this function is as follows:

CR52: 94-117 cycles

If more accurate microsecond timing must be performed in software it is recommended to use bsp_prv_software_delay_loop() directly. In this case, use BSP_DELAY_LOOP_CYCLES or BSP_DELAY_LOOPS_CALCULATE() to convert a calculated delay cycle count to a number of software delay loops.

Delays may be longer than expected when compiler optimization is turned off.

◆ R_FSP_IsrContextSet()

__STATIC_INLINE void R_FSP_IsrContextSet	(	IRQn_Type const	irq,
		void *	p_context
	)

Sets the ISR context associated with the requested IRQ.

Parameters

[in]	irq	IRQ number (parameter checking must ensure the IRQ number is valid before calling this function.
[in]	p_context	ISR context for IRQ.

◆ R_BSP_IrqClearPending()

__STATIC_INLINE void R_BSP_IrqClearPending ( IRQn_Type irq )

Clear the GIC pending interrupt.

Parameters

[in] irq Interrupt for which to clear the Pending bit. Note that the enums listed for IRQn_Type are only those for the Cortex Processor Exceptions Numbers.

◆ R_BSP_IrqPendingGet()

__STATIC_INLINE uint32_t R_BSP_IrqPendingGet ( IRQn_Type irq )

Get the GIC pending interrupt.

Parameters

[in] irq Interrupt that gets a pending bit.. Note that the enums listed for IRQn_Type are only those for the Cortex Processor Exceptions Numbers.

Returns: Value indicating the status of the level interrupt.

◆ R_BSP_IrqCfg()

__STATIC_INLINE void R_BSP_IrqCfg	(	IRQn_Type const	irq,
		uint32_t	priority,
		void *	p_context
	)

Sets the interrupt priority and context.

Parameters

[in]	irq	The IRQ number to configure.
[in]	priority	GIC priority of the interrupt
[in]	p_context	The interrupt context is a pointer to data required in the ISR.

◆ R_BSP_IrqEnableNoClear()

__STATIC_INLINE void R_BSP_IrqEnableNoClear ( IRQn_Type const irq )

Enable the IRQ in the GIC (Without clearing the pending bit).

Parameters

[in] irq The IRQ number to enable. Note that the enums listed for IRQn_Type are only those for the Cortex Processor Exceptions Numbers.

◆ R_BSP_IrqEnable()

__STATIC_INLINE void R_BSP_IrqEnable ( IRQn_Type const irq )

Enable the IRQ in the GIC (With clearing the pending bit).

Parameters

[in] irq The IRQ number to enable. Note that the enums listed for IRQn_Type are only those for the Cortex Processor Exceptions Numbers.

◆ R_BSP_IrqDisable()

__STATIC_INLINE void R_BSP_IrqDisable ( IRQn_Type const irq )

Disables interrupts in the GIC.

Parameters

[in] irq The IRQ number to disable in the GIC. Note that the enums listed for IRQn_Type are only those for the Cortex Processor Exceptions Numbers.

◆ R_BSP_IrqCfgEnable()

__STATIC_INLINE void R_BSP_IrqCfgEnable	(	IRQn_Type const	irq,
		uint32_t	priority,
		void *	p_context
	)

Sets the interrupt priority and context, clears pending interrupts, then enables the interrupt.

Parameters

[in]	irq	Interrupt number.
[in]	priority	GIC priority of the interrupt
[in]	p_context	The interrupt context is a pointer to data required in the ISR.

◆ R_FSP_IsrContextGet()

__STATIC_INLINE void* R_FSP_IsrContextGet ( IRQn_Type const irq )

Finds the ISR context associated with the requested IRQ.

Parameters

[in] irq IRQ number (parameter checking must ensure the IRQ number is valid before calling this function.

Returns: ISR context for IRQ.

◆ R_BSP_IrqDetectTypeSet()

__STATIC_INLINE void R_BSP_IrqDetectTypeSet	(	IRQn_Type const	irq,
		uint32_t	detect_type
	)

Sets the interrupt detect type.

Parameters

[in]	irq	The IRQ number to configure.
[in]	detect_type	GIC detect type of the interrupt (0 : active-HIGH level, 1 : rising edge-triggerd).

◆ R_BSP_IrqGroupSet()

__STATIC_INLINE void R_BSP_IrqGroupSet	(	IRQn_Type const	irq,
		uint32_t	interrupt_group
	)

Sets the interrupt Group.

Parameters

[in]	irq	The IRQ number to configure.
[in]	interrupt_group	GIC interrupt group number ( 0 : FIQ, 1 : IRQ ).

◆ R_BSP_IrqMaskLevelSet()

__STATIC_INLINE void R_BSP_IrqMaskLevelSet ( uint32_t mask_level )

Sets the interrupt mask level.

Parameters

[in] mask_level The interrupt mask level

◆ R_BSP_IrqMaskLevelGet()

__STATIC_INLINE uint32_t R_BSP_IrqMaskLevelGet ( void )

Gets the interrupt mask level.

Returns: Value indicating the interrupt mask level.

◆ R_BSP_RegisterProtectEnable()

void R_BSP_RegisterProtectEnable ( bsp_reg_protect_t regs_to_protect )

Enable register protection. Registers that are protected cannot be written to. Register protection is enabled by using the Protect Register (PRCR) and the MPC's Write-Protect Register (PWPR).

Parameters

[in] regs_to_protect Registers which have write protection enabled.

◆ R_BSP_RegisterProtectDisable()

void R_BSP_RegisterProtectDisable ( bsp_reg_protect_t regs_to_unprotect )

Disable register protection. Registers that are protected cannot be written to. Register protection is disabled by using the Protect Register (PRCR) and the MPC's Write-Protect Register (PWPR).

Parameters

[in] regs_to_unprotect Registers which have write protection disabled.

◆ R_BSP_SystemReset()

void R_BSP_SystemReset ( void )

Occur the system software reset.

◆ R_BSP_CpuReset()

void R_BSP_CpuReset ( bsp_reset_t cpu )

Occur the CPU software reset.

Parameters

[in] cpu to be reset state.

Note: With Cortex-A55, you cannot use resets that are not automatically released when a software reset is executed.

◆ R_BSP_CpuResetAutoRelease()

void R_BSP_CpuResetAutoRelease ( bsp_reset_t cpu )

Occur the CPU software reset. When using this function, the CPU reset state is automatically released after an elapsed time corresponding to the setting value in SCKCR2.DIVSELSUB bit.

Parameters

[in] cpu to be reset state.

◆ R_BSP_CpuResetRelease()

void R_BSP_CpuResetRelease ( bsp_reset_t cpu )

Release the CPU reset state.

Parameters

[in] cpu to be release reset state.

◆ R_BSP_ModuleResetEnable()

void R_BSP_ModuleResetEnable ( bsp_module_reset_t module_to_enable )

Enable module reset state.

Parameters

[in] module_to_enable Modules to enable module reset state.

◆ R_BSP_ModuleResetDisable()

void R_BSP_ModuleResetDisable ( bsp_module_reset_t module_to_disable )

Disable module reset state.

Parameters

[in] module_to_disable Modules to disable module reset state.

Note: After reset release is performed by the module control register, a dummy read is performed to allow access to other than the RTC and LCDC. This is done several times according to the RZ microprocessor manual. However, the dummy read count for the RTC and LCDC may not be met depending on the device used. In that case, please perform additional dummy read processing after API execution. For example, in the case of RZT2H, 300 dummy reads are required for RTC and 100 dummy reads are required for LCDC.

◆ __sinf()

BSP_TFU_INLINE float __sinf ( float angle )

Calculates sine of the given angle.

Parameters

[in] angle The value of an angle in radian.

Return values

Sine	value of an angle.

◆ __cosf()

BSP_TFU_INLINE float __cosf ( float angle )

Calculates cosine of the given angle.

Parameters

[in] angle The value of an angle in radian.

Return values

Cosine value of an angle.

◆ __sincosf()

BSP_TFU_INLINE void __sincosf	(	float	angle,
		float *	sin,
		float *	cos
	)

Calculates sine and cosine of the given angle.

Parameters

[in]	angle	The value of an angle in radian.
[out]	sin	Sine value of an angle.
[out]	cos	Cosine value of an angle.

◆ __atan2f()

BSP_TFU_INLINE float __atan2f	(	float	y_cord,
		float	x_cord
	)

Calculates the arc tangent based on given X-cordinate and Y-cordinate values.

Parameters

[in]	y_cord	Y-Axis cordinate value.
[in]	x_cord	X-Axis cordinate value.

Return values

Arc	tangent for given values.

◆ __hypotf()

BSP_TFU_INLINE float __hypotf	(	float	x_cord,
		float	y_cord
	)

Calculates the hypotenuse based on given X-cordinate and Y-cordinate values.

Parameters

[in]	y_cord	Y-cordinate value.
[in]	x_cord	X-cordinate value.

Return values

Hypotenuse for given values.

◆ __atan2hypotf()

BSP_TFU_INLINE void __atan2hypotf	(	float	y_cord,
		float	x_cord,
		float *	atan2,
		float *	hypot
	)

Calculates the arc tangent and hypotenuse based on given X-cordinate and Y-cordinate values.

Parameters

[in]	y_cord	Y-cordinate value.
[in]	x_cord	X-cordinate value.
[out]	atan2	Arc tangent for given values.
[out]	hypot	Hypotenuse for given values.

◆ __sinfx()

BSP_TFU_INLINE uint32_t __sinfx ( uint32_t angle )

Calculates sine of the given angle.

Parameters

[in] angle The value of an angle.

Return values

Sine	value of an angle.

◆ __cosfx()

BSP_TFU_INLINE uint32_t __cosfx ( uint32_t angle )

Calculates cosine of the given angle.

Parameters

[in] angle The value of an angle in radian.

Return values

Cosine value of an angle.

◆ __sincosfx()

BSP_TFU_INLINE void __sincosfx	(	uint32_t	angle,
		uint32_t *	sin,
		uint32_t *	cos
	)

Calculates sine and cosine of the given angle.

Parameters

[in]	angle	The value of an angle.
[out]	sin	Sine value of an angle.
[out]	cos	Cosine value of an angle.

◆ __atan2fx()

BSP_TFU_INLINE uint32_t __atan2fx	(	uint32_t	y_cord,
		uint32_t	x_cord
	)

Calculates the arc tangent based on given X-cordinate and Y-cordinate values.

Parameters

[in]	y_cord	Y-Axis cordinate value.
[in]	x_cord	X-Axis cordinate value.

Return values

Arc	tangent for given values.

◆ __hypotfx()

BSP_TFU_INLINE int32_t __hypotfx	(	uint32_t	x_cord,
		uint32_t	y_cord
	)

Calculates the hypotenuse based on given X-cordinate and Y-cordinate values.

Parameters

[in]	y_cord	Y-cordinate value.
[in]	x_cord	X-cordinate value.

Return values

Hypotenuse for given values.

◆ __atan2hypotfx()

BSP_TFU_INLINE void __atan2hypotfx	(	uint32_t	y_cord,
		uint32_t	x_cord,
		uint32_t *	atan2,
		int32_t *	hypot
	)

Calculates the arc tangent and hypotenuse based on given X-cordinate and Y-cordinate values.

Parameters

[in]	y_cord	Y-cordinate value.
[in]	x_cord	X-cordinate value.
[out]	atan2	Arc tangent for given values.
[out]	hypot	Hypotenuse for given values.

◆ r_bsp_software_delay_loop()

BSP_ATTRIBUTE_STACKLESS void r_bsp_software_delay_loop ( __attribute__((unused)) uint32_t loop_cnt )

This assembly language routine takes roughly 4 cycles per loop. 2 additional cycles occur when the loop exits. The 'naked' attribute indicates that the specified function does not need prologue/epilogue sequences generated by the compiler.

Parameters

[in] loop_cnt The number of loops to iterate.

◆ R_BSP_GroupIrqWrite()

fsp_err_t R_BSP_GroupIrqWrite	(	bsp_grp_irq_t	irq,
		void(*)(bsp_grp_irq_t irq)	p_callback
	)

Register a callback function for supported interrupts. If NULL is passed for the callback argument then any previously registered callbacks are unregistered.

Parameters

[in]	irq	Interrupt for which to register a callback.
[in]	p_callback	Pointer to function to call when interrupt occurs.

Return values

FSP_ERR_UNSUPPORTED NMI Group IRQ are not supported in RZ/A3UL.

◆ R_BSP_GICD_SetCtlr()

void R_BSP_GICD_SetCtlr ( bsp_gicd_ctlr_bit_t bit )

Set GICD_CTLR Register.

Parameters

[in] bit Set value of GICD_CTRL register bit.

◆ R_BSP_GICD_GetCtlr()

uint32_t R_BSP_GICD_GetCtlr ( void )

Get value of GICD_CTLR Register.

Return values

GICD_CTLR register value.

◆ R_BSP_GICD_Enable()

void R_BSP_GICD_Enable ( bsp_gicd_ctlr_bit_t bit )

Set the values specified in the argument to EnableGrp0 bit, EnableGrp1NS bit, and EnableGrp1S bit of GICD_CTLR, to enable interrupts for any interrupt group.

Parameters

[in] bit Set value of GICD_CTRL register bit.

◆ R_BSP_GICD_Disable()

void R_BSP_GICD_Disable ( bsp_gicd_ctlr_bit_t bit )

Set the values specified in the argument to EnableGrp0 bit, EnableGrp1NS bit, and EnableGrp1S bit of GICD_CTLR, to disable interrupts for any interrupt group.

Parameters

[in] bit Clear value of GICD_CTRL register bit.

◆ R_BSP_GICD_AffinityRouteEnable()

void R_BSP_GICD_AffinityRouteEnable ( bsp_gicd_ctlr_bit_t bit )

Set the values specified in the argument to ARE_S bit and ARE_NS bit of GICD_CTLR, to enable Affinity Routing for Secure state and/or Non-secure state.

Parameters

[in] bit Set value of GICD_CTRL register bit.

◆ R_BSP_GICD_SpiEnable()

void R_BSP_GICD_SpiEnable ( IRQn_Type irq )

Enable interrupt forwarding to the CPU interface by set the bit of GICD_ISENABLERn to 1 corresponding to the ID specified in the argument.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICD_SpiDisable()

void R_BSP_GICD_SpiDisable ( IRQn_Type irq )

Disable interrupt forwarding to the CPU interface by set the bit of GICD_ICENABLERn to 1 corresponding to the ID specified in the argument.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICD_SetSpiPriority()

void R_BSP_GICD_SetSpiPriority	(	IRQn_Type	irq,
		uint32_t	priority
	)

Sets the value specified for GICD_IPRIORITYRn to set the interrupt priority for the specified ID.

Parameters

[in]	irq	Interrupt number ID.
[in]	priority	Interrupt Priority.

◆ R_BSP_GICD_GetSpiPriority()

uint32_t R_BSP_GICD_GetSpiPriority ( IRQn_Type irq )

Gets the interrupt priority for the specified ID by reads the value of GICD_IPRIORITYRn.

Parameters

[in] irq Interrupt number ID.

Return values

interrupt priority.

◆ R_BSP_GICD_SetSpiRoute()

void R_BSP_GICD_SetSpiRoute	(	IRQn_Type	irq,
		uint64_t	route,
		bsp_gicd_irouter_route_t	mode
	)

Set affinity routing information that is SPI Affinity level and routing mode to GICD_IROUTERn.

Parameters

[in]	irq	Interrupt number ID.
[in]	route	Affinity route settings. Since it will be used as it is as the setting value of the Affinity level, write the value of Aff0 from bit 7 to bit 0, the value of Aff1 from bit 15 to bit 8, the value of Aff2 from bit 23 to bit 16, and the value of Aff3 from bit 39 to bit 32.
[in]	mode	Mode of routing

◆ R_BSP_GICD_GetSpiRoute()

uint64_t R_BSP_GICD_GetSpiRoute ( IRQn_Type irq )

Get affinity routing information that is SPI Affinity level and routing mode by reads GICD_IROUTERn.

Parameters

[in] irq Interrupt number ID.

Return values

interrupt routing information. Aff0 is stored in bit 7 to bit 0, Aff1 in bit 15 to bit 8, Aff2 in bit 23 to bit 16, Routing mode in bit 31, and Aff3 in bit 39 to bit 32.

◆ R_BSP_GICD_SetSpiSense()

void R_BSP_GICD_SetSpiSense	(	IRQn_Type	irq,
		bsp_gicd_icfgr_sense_t	sense
	)

Set interrupt as edge-triggered or level-sensitive.

Parameters

[in]	irq	Interrupt number ID.
[in]	sense	Interrupt trigger sense.

◆ R_BSP_GICD_GetSpiSense()

uint32_t R_BSP_GICD_GetSpiSense ( IRQn_Type irq )

Get interrupt trigger information.

Parameters

[in] irq Interrupt number ID.

Return values

Value that means interrupt trigger sense, which is edge-triggered or level-sensitive.

◆ R_BSP_GICD_SetSpiPending()

void R_BSP_GICD_SetSpiPending ( IRQn_Type irq )

Sets the specified interrupt to the pending state by write to GICD_ISPENDRn.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICD_GetSpiPending()

uint32_t R_BSP_GICD_GetSpiPending ( IRQn_Type irq )

Sets the specified interrupt to the pending state by write to GICD_ISPENDRn.

Parameters

[in] irq Interrupt number ID.

Return values

Information of SPI pending.

◆ R_BSP_GICD_SetSpiClearPending()

void R_BSP_GICD_SetSpiClearPending ( IRQn_Type irq )

Clear the specified interrupt to the pending state by write to GICD_ICPENDRn.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICD_GetSpiClearPending()

uint32_t R_BSP_GICD_GetSpiClearPending ( IRQn_Type irq )

Gets information about whether the specified interrupt is pending state by reading the value of GICD_ICPENDRn.

Parameters

[in] irq Interrupt number ID.

Return values

Information of SPI pending.

◆ R_BSP_GICD_SetSpiSecurity()

void R_BSP_GICD_SetSpiSecurity	(	IRQn_Type	irq,
		bsp_gic_igroupr_secure_t	group
	)

Set SPI security group. The combination of the modifier bit of GICD_IGRPMODR and the status bit of GICD_IGROUPR determines whether the security group is Secure Group 0, Non-Secure Group 1, or Secure Group 1.

Parameters

[in]	irq	Interrupt number ID.
[in]	group	Security group.

◆ R_BSP_GICD_SetSpiSecurityLine()

void R_BSP_GICD_SetSpiSecurityLine	(	uint32_t	line,
		bsp_gic_igroupr_secure_t	group
	)

Sets SPI security group with each 32 interrupts (each line). The combination of the modifier bit of GICD_IGRPMODR and the status bit of GICD_IGROUPR determines whether the security group is Secure Group 0, Non-Secure Group 1, or Secure Group 1.

Parameters

[in]	line	Line of GICD_IGRPMODRn register. Line is the quotient of the interrupt ID divided by 32. For example, an interrupt with IDs 32 to 63 corresponds to line 1.
[in]	group	Security group.

◆ R_BSP_GICD_SetSpiSecurityAll()

void R_BSP_GICD_SetSpiSecurityAll ( bsp_gic_igroupr_secure_t group )

Set SPI security group for all GICD_IGRPMODRn register. The combination of the modifier bit of GICD_IGRPMODR and the status bit of GICD_IGROUPR determines whether the security group is Secure Group 0, Non-Secure Group 1, or Secure Group 1.

Parameters

[in] group Security group.

◆ R_BSP_GICD_SetSpiClass()

void R_BSP_GICD_SetSpiClass	(	IRQn_Type	irq,
		bsp_gicd_iclar_class_t	class_group
	)

Sets whether the Class0 or Class1 class is the target of the SPI.

Parameters

[in]	irq	Interrupt number ID.
[in]	class_group	Interrupt class.

Note: R_BSP_GICR_SetClass can be set whether each interrupt is Class0 or Class1.

◆ R_BSP_GICR_Enable()

void R_BSP_GICR_Enable ( void )

Enables Redistributor and configue power management by access GICR_PWRR and GICR_WAKER. This BSP sets GICR_WAKER.ProcessorSleep to 0, so wake_request signal wake-up the core when the core is powered off is disabled.

◆ R_BSP_GICR_SgiPpiEnable()

void R_BSP_GICR_SgiPpiEnable ( IRQn_Type irq )

Enable SGI or PPI forwarding to the CPU interface by set the bit of GICR_ISENABLER0 to 1 corresponding to the ID specified in the argument.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICR_SgiPpiDisable()

void R_BSP_GICR_SgiPpiDisable ( IRQn_Type irq )

Disable SGI of PPI forwarding to the CPU interface by set the bit of GICR_ICENABLER0 to 1 corresponding to the ID specified in the argument.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICR_SetSgiPpiPriority()

void R_BSP_GICR_SetSgiPpiPriority	(	IRQn_Type	irq,
		uint32_t	priority
	)

Sets the value specified for GICR_IPRIORITYRn to set the interrupt priority for the specified ID.

Parameters

[in]	irq	Interrupt number ID.
[in]	priority	Interrupt Priority.

◆ R_BSP_GICR_GetSgiPpiPriority()

uint32_t R_BSP_GICR_GetSgiPpiPriority ( IRQn_Type irq )

Gets the interrupt priority for the specified ID by reads the value of GICR_IPRIORITYRn.

Parameters

[in] irq Interrupt number ID.

Return values

interrupt priority.

◆ R_BSP_GICR_SetSgiPpiSense()

void R_BSP_GICR_SetSgiPpiSense	(	IRQn_Type	irq,
		bsp_gicd_icfgr_sense_t	sense
	)

Set interrupt as edge-triggered or level-sensitive.

Parameters

[in]	irq	Interrupt number ID.
[in]	sense	Interrupt trigger sense.

◆ R_BSP_GICR_GetSgiPpiSense()

uint32_t R_BSP_GICR_GetSgiPpiSense ( IRQn_Type irq )

Get interrupt trigger information.

Parameters

[in] irq Interrupt number ID.

Return values

Value that means interrupt trigger sense, which is edge-triggered or level-sensitive.

◆ R_BSP_GICR_SetSgiPpiPending()

void R_BSP_GICR_SetSgiPpiPending ( IRQn_Type irq )

Sets the specified interrupt to the pending state by write to GICR_ISPENDR0.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICR_GetSgiPpiPending()

uint32_t R_BSP_GICR_GetSgiPpiPending ( IRQn_Type irq )

Gets information about whether the specified interrupt is pending state by reading the value of GICR_ISPENDR0.

Parameters

[in] irq Interrupt number ID.

Return values

Information of SGI or PPI pending.

◆ R_BSP_GICR_SetSgiPpiClearPending()

void R_BSP_GICR_SetSgiPpiClearPending ( IRQn_Type irq )

Clear the specified interrupt to the pending state by write to GICR_ICPENDR0.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICR_GetSgiPpiClearPending()

uint32_t R_BSP_GICR_GetSgiPpiClearPending ( IRQn_Type irq )

Gets information about whether the specified interrupt is pending state by reading the value of GICR_ICPENDR0.

Parameters

[in] irq Interrupt number ID.

Return values

Information of SGI or PPI pending.

◆ R_BSP_GICR_SetSgiPpiSecurity()

void R_BSP_GICR_SetSgiPpiSecurity	(	IRQn_Type	irq,
		bsp_gic_igroupr_secure_t	group
	)

Set SGI and PPI security group. The combination of the modifier bit of GICR_IGRPMODR0 and the status bit of GICR_IGROUPR determines whether the security group is Secure Group 0, Non-Secure Group 1, or Secure Group 1.

Parameters

[in]	irq	Interrupt number ID.
[in]	group	Security group.

◆ R_BSP_GICR_SetSgiPpiSecurityLine()

void R_BSP_GICR_SetSgiPpiSecurityLine ( bsp_gic_igroupr_secure_t group )

Sets security group for all SGI and PPI. The combination of the modifier bit of GICR_IGRPMODR0 and the status bit of GICR_IGROUPR0 determines whether the security group is Secure Group 0, Non-Secure Group 1, or Secure Group 1.

Parameters

[in] group Security group.

◆ R_BSP_GICR_SetClass()

void R_BSP_GICR_SetClass ( bsp_gicd_iclar_class_t class_group )

Sets the interrupt class to either Class0 or Class1.

Parameters

[in] class_group Interrupt class group.

◆ R_BSP_GICR_GetRoute()

uint32_t R_BSP_GICR_GetRoute ( void )

Get routing information (Affinity level value) by reading bit[63:32] of GICR_TYPER.

Return values

value interrupt routing information. Aff3 is stored from bit 31 to bit 24, Aff2 from bit 23 to bit 16, Aff1 from bit15 to 8, and Aff0 from bit 7 to 0.

◆ R_BSP_GICC_SetMaskLevel()

void R_BSP_GICC_SetMaskLevel ( uint64_t mask_level )

Set interrupt mask level to Interrupt Priority Mask Register.

Parameters

[in] mask_level Mask level.

◆ R_BSP_GICC_GetMaskLevel()

uint64_t R_BSP_GICC_GetMaskLevel ( void )

Get interrupt mask level information from Interrupt Priority Mask Register.

Return values

Information of mask level.

◆ R_BSP_GICC_SetEoiGrp0()

void R_BSP_GICC_SetEoiGrp0 ( IRQn_Type irq )

Set end of interrupt to End Of Interrupt Register 0 for Group 0.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICC_SetEoiGrp1()

void R_BSP_GICC_SetEoiGrp1 ( IRQn_Type irq )

Set end of interrupt to End Of Interrupt Register 1 for Group 1.

Parameters

[in] irq Interrupt number ID.

◆ R_BSP_GICC_Get_IntIdGrp0()

uint32_t R_BSP_GICC_Get_IntIdGrp0 ( void )

Get interrupt ID being asserted from Group 0 by reading Interrupt Acknowledge Register 0.

Return values

Interrupt ID number.

◆ R_BSP_GICC_Get_IntIdGrp1()

uint32_t R_BSP_GICC_Get_IntIdGrp1 ( void )

Get interrupt ID being asserted from Group 1 by reading Interrupt Acknowledge Register 1.

Return values

Interrupt ID number.

◆ R_BSP_MmuVatoPa()

fsp_err_t R_BSP_MmuVatoPa	(	uint64_t	vaddress,
		uint64_t *	p_paddress
	)

Convert virtual address into physical address.

Parameters

[in]	vaddress	Virtual address to convert.
[out]	p_paddress	Pointer to store physical address.

Return values

FSP_SUCCESS	Successful
FSP_ERR_INVALID_ADDRESS	Virtual address is invalid address.

◆ R_BSP_MmuPatoVa()

fsp_err_t R_BSP_MmuPatoVa	(	uint64_t	paddress,
		uint64_t *	p_vaddress,
		bsp_mmu_conversion_flag_t	cache_flag
	)

Convert physical address into virtual address.

Parameters

[in]	paddress	Physical address to convert.
[out]	p_vaddress	Pointer to store virtual address.
[in]	cache_flag	Cache flag to select VA.

Return values

FSP_SUCCESS	Successful
FSP_ERR_INVALID_ADDRESS	Physical address is invalid address.

◆ R_BSP_MemoryMap()

fsp_err_t R_BSP_MemoryMap ( r_mmu_pgtbl_cfg_t * p_memory_map_cfg )

Change the setting of Memory Map in run-time

Parameters

[in] p_memory_map_cfg Pointer to configuration memory map

Return values

FSP_SUCCESS	No configuration errors detected
FSP_ERR_IN_USE	Dynamic configuration is in use.
FSP_ERR_INVALID_ARGUMENT	Invalid input configuration

◆ R_BSP_MemoryUnMap()

fsp_err_t R_BSP_MemoryUnMap ( void )

Canceling memory mapping settings

Return values

FSP_SUCCESS	No configuration errors detected.
FSP_ERR_NOT_INITIALIZED	Memory map configuration has not beeen initialized yet.

◆ R_BSP_MpuRegionDynamicConfig()

fsp_err_t R_BSP_MpuRegionDynamicConfig ( bsp_mpu_dynamic_cfg_t * p_dynamic_region_cfg )

Change the setting of the MPU region at runtime. There is only one dynamic region setting at a time.

Parameters

[in] p_dynamic_region_cfg Pointer to dynamically region configuration.

Return values

FSP_SUCCESS	No configuration errors detected.
FSP_ERR_CLAMPED	There are no available regions for dynamic settings.
FSP_ERR_IN_USE	Dynamic region configuration has already been used.

◆ R_BSP_MpuRegionRestoreConfig()

fsp_err_t R_BSP_MpuRegionRestoreConfig ( void )

Restore static and dynamic MPU regions.

Return values

FSP_SUCCESS	No configuration errors detected
FSP_ERR_NOT_INITIALIZED	Dynamic region configuration has not been initialized yet.

Variable Documentation

◆ SystemCoreClock

uint32_t SystemCoreClock

System Clock Frequency (Core Clock)

Functions

Detailed Description

Overview

BSP Features

BSP Clock Configuration

System Interrupts

Multiplex Interrupts

External and Peripheral Interrupts

BSP Weak Symbols

Warm Start Callbacks

FSP Assert

C Runtime Initialization

Register Protection

Software Delay

Trigonometric Function

Critical Section Macros

Noncache Section

Memory attributes

Memory Access

Dynamic Memory Protection Unit Setting

Memory Management Unit

Dynamic Memory Management Unit Setting(Dynamic Memory Mapping)

TrustZone Address Space Controller (TZC-400)

Module Stop

Module Reset

Software Reset

System Error Interrupt (SEI,NMI)

LPDDR4 SDRAM Subsystem

Linker Script

Change Program Location

Pin Setting

eSD boot

Preparation procedure for the SD card image file

How to prepare an image file for an SD card in e² studio

How to prepare an image file with multiplexed loader programs in e² studio

How to prepare an image file for an SD card in EWARM

How to prepare an image file with multiplexed loader programs in EWARM

Writing to the SD card and executing eSD boot

How to debug an eSD boot project

How to debug an eSD boot project in e² studio

How to debug an eSD boot project in EWARM

How to make the FSP program and FAT file system on an SD card coexist

eMMC boot

Preparation procedure for the eMMC image file

How to prepare an image file for an eMMC in e² studio

How to prepare an image file for an eMMC in EWARM

Writing to the eMMC and executing eMMC boot

How to debug an eMMC boot project

Exclusive access

Configuration

Build Time Configurations for fsp_common

Duplication of resources

Core Comparison

Modules

Macros

Enumerations

Variables

Macro Definition Documentation

◆ BSP_IRQ_DISABLED

◆ FSP_RETURN

◆ FSP_ERROR_LOG

◆ FSP_ASSERT

◆ FSP_ASSERT_NOT_RETURN_VALUE

◆ FSP_ERROR_RETURN

◆ FSP_ERROR_NOT_RETURN_VALUE

◆ FSP_CRITICAL_SECTION_ENTER

◆ FSP_CRITICAL_SECTION_EXIT

◆ FSP_INVALID_VECTOR

◆ BSP_CFG_HANDLE_UNRECOVERABLE_ERROR

◆ BSP_SECTION_AARCH64_STACK

◆ BSP_STACK_ALIGNMENT

◆ R_BSP_MODULE_START

◆ R_BSP_MODULE_STOP

Enumeration Type Documentation

◆ fsp_ip_t

◆ fsp_signal_t

◆ bsp_warm_start_event_t

◆ bsp_delay_units_t

◆ bsp_reg_protect_t

◆ bsp_reset_t