RA Flexible Software Package Documentation  Release v5.2.0

 
Flash (r_flash_lp)

Functions

fsp_err_t R_FLASH_LP_Open (flash_ctrl_t *const p_api_ctrl, flash_cfg_t const *const p_cfg)
 
fsp_err_t R_FLASH_LP_Write (flash_ctrl_t *const p_api_ctrl, uint32_t const src_address, uint32_t flash_address, uint32_t const num_bytes)
 
fsp_err_t R_FLASH_LP_Erase (flash_ctrl_t *const p_api_ctrl, uint32_t const address, uint32_t const num_blocks)
 
fsp_err_t R_FLASH_LP_BlankCheck (flash_ctrl_t *const p_api_ctrl, uint32_t const address, uint32_t num_bytes, flash_result_t *p_blank_check_result)
 
fsp_err_t R_FLASH_LP_StatusGet (flash_ctrl_t *const p_api_ctrl, flash_status_t *const p_status)
 
fsp_err_t R_FLASH_LP_AccessWindowSet (flash_ctrl_t *const p_api_ctrl, uint32_t const start_addr, uint32_t const end_addr)
 
fsp_err_t R_FLASH_LP_AccessWindowClear (flash_ctrl_t *const p_api_ctrl)
 
fsp_err_t R_FLASH_LP_IdCodeSet (flash_ctrl_t *const p_api_ctrl, uint8_t const *const p_id_code, flash_id_code_mode_t mode)
 
fsp_err_t R_FLASH_LP_Reset (flash_ctrl_t *const p_api_ctrl)
 
fsp_err_t R_FLASH_LP_StartUpAreaSelect (flash_ctrl_t *const p_api_ctrl, flash_startup_area_swap_t swap_type, bool is_temporary)
 
fsp_err_t R_FLASH_LP_BankSwap (flash_ctrl_t *const p_api_ctrl)
 
fsp_err_t R_FLASH_LP_UpdateFlashClockFreq (flash_ctrl_t *const p_api_ctrl)
 
fsp_err_t R_FLASH_LP_InfoGet (flash_ctrl_t *const p_api_ctrl, flash_info_t *const p_info)
 
fsp_err_t R_FLASH_LP_Close (flash_ctrl_t *const p_api_ctrl)
 
fsp_err_t R_FLASH_LP_CallbackSet (flash_ctrl_t *const p_api_ctrl, void(*p_callback)(flash_callback_args_t *), void const *const p_context, flash_callback_args_t *const p_callback_memory)
 

Detailed Description

Driver for the flash memory on RA low-power MCUs. This module implements the Flash Interface.

Overview

The Flash HAL module APIs allow an application to write, erase and blank check both the data and code flash areas that reside within the MCU. The amount of flash memory available varies across MCU parts.

Features

The Low-Power Flash HAL module has the following key features:

Configuration

Build Time Configurations for r_flash_lp

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

ConfigurationOptionsDefaultDescription
Parameter Checking
  • Default (BSP)
  • Enabled
  • Disabled
Default (BSP) If selected code for parameter checking is included in the build.
Code Flash Programming
  • Enabled
  • Disabled
Disabled Controls whether or not code-flash programming is enabled. Disabling reduces the amount of ROM and RAM used by the API.
Data Flash Programming
  • Enabled
  • Disabled
Enabled Controls whether or not data-flash programming is enabled. Disabling reduces the amount of ROM used by the API.
Data Flash Background Operation Support
  • Enabled
  • Disabled
Enabled Controls whether or not Data Flash Background Operation support is included in the build. Disabling reduces the amount of ROM used by the API.

Configurations for Storage > Flash (r_flash_lp)

This module can be added to the Stacks tab via New Stack > Storage > Flash (r_flash_lp).

ConfigurationOptionsDefaultDescription
NameName must be a valid C symbolg_flash0 Module name.
Data Flash Background Operation
  • Enabled
  • Disabled
Enabled Enabling allows Flash API calls that reference data-flash to return immediately, with the operation continuing in the background.
CallbackName must be a valid C symbolNULL A user callback function can be specified. Callback function called when a Data Flash Background Operation completes or errors.
Flash Ready Interrupt PriorityMCU Specific OptionsSelect the flash ready interrupt priority.

Clock Configuration

Flash either uses FCLK or ICLK as the clock source depending on the MCU. When writing and erasing the clock source must be at least 4 MHz.

Pin Configuration

This module does not use I/O pins.

Usage Notes

Warning
It is highly recommended that the developer reviews sections 5 and 6 of the Flash Memory section of the target MCUs Hardware User’s Manual prior to using the r_flash_lp module. In particular, understanding ID Code and Access Window functionality can help avoid unrecoverable flash scenarios.

Data Flash Background Operation (BGO) Precautions

When using the data flash BGO, the code flash, RAM and external memory can still be accessed. You must ensure that the data flash is not accessed during a data flash operation. This includes interrupts that may access the data flash.

Code Flash Precautions

Code flash cannot be accessed while writing, erasing or blank checking code flash. Code flash cannot be accessed while modifying the access window, selecting the startup area or setting the ID code. In order to support modifying code flash all supporting code must reside in RAM. This is only done when code flash programming is enabled. BGO mode is not supported for code flash, so a code flash operation will not return before the operation has completed. By default, the vector table resides in the code flash. If an interrupt occurs during the code flash operation, then code flash will be accessed to fetch the interrupt's starting address and an error will occur. The simplest work-around is to disable interrupts during code flash operations. Another option is to copy the vector table to RAM, update the VTOR (Vector Table Offset Register) accordingly and ensure that any interrupt service routines execute out of RAM. Similarly, you must insure that if in a multi-threaded environment, threads running from code flash cannot become active while a code flash operation is in progress.

Flash Clock Source

The flash clock source is the clock used by the Flash peripheral in performing all Flash operations. As part of the flash_api_t::open function the Flash clock source is checked will return FSP_ERR_FCLK if it is invalid. Once the Flash API has been opened, if the flash clock source frequency is changed, the flash_api_t::updateFlashClockFreq API function must be called to inform the API of the change. Failure to do so could result in flash operation failures and possibly damage the part.

Interrupts

Enable the flash ready interrupt only if you plan to use the data flash BGO. In this mode, the application can initiate a data flash operation and then be asynchronously notified of its completion, or an error, using a user supplied-callback function. The callback function is passed a structure containing event information that indicates the source of the callback event (for example, flash_api_t::FLASH_EVENT_ERASE_COMPLETE) When the FLASH FRDYI interrupt is enabled, the corresponding ISR will be defined in the flash driver. The ISR will call a user-callback function if one was registered with the flash_api_t::open API.

Note
The Flash HP supports an additional flash-error interrupt and if the BGO mode is enabled for the FLASH HP then both the Flash Ready Interrupt and Flash Error Interrupts must be enabled (assigned a priority).

Viewing flash contents in e2 studio

By default, the contents of data flash and code flash are cached by e2 studio. This means that during a debug session, modifications to these memory regions will not be observed by e2 studio. When debugging applications using e2 studio, disable the "Allow caching of flash contents" option in the debug configuration in order to view modified flash contents (Debug Configuration > Debugger > Debug Tool Settings > Allow caching of flash contents).

r_flash_hp_disable_caching.png
Debug Configuration

Limitations

Examples

Low-Power Flash Basic Example

This is a basic example of erasing and writing to data flash and code flash.

#define FLASH_DF_BLOCK_0 0x40100000U /* 1 KB: 0x40100000 - 0x401003FF */
#define FLASH_CF_BLOCK_10 0x00005000 /* 2 KB: 0x00005000 - 0x000057FF */
#define FLASH_DATA_BLOCK_SIZE (1024)
#define FLASH_LP_EXAMPLE_WRITE_SIZE 32
uint8_t g_dest[TRANSFER_LENGTH];
uint8_t g_src[TRANSFER_LENGTH];
flash_result_t blank_check_result;
void R_FLASH_LP_basic_example (void)
{
/* Initialize p_src to known data */
for (uint32_t i = 0; i < TRANSFER_LENGTH; i++)
{
g_src[i] = (uint8_t) ('A' + (i % 26));
}
/* Open the flash lp instance. */
fsp_err_t err = R_FLASH_LP_Open(&g_flash_ctrl, &g_flash_cfg);
assert(FSP_SUCCESS == err);
/* Erase 1 block of data flash starting at block 0. */
err = R_FLASH_LP_Erase(&g_flash_ctrl, FLASH_DF_BLOCK_0, 1);
assert(FSP_SUCCESS == err);
/* Check if block 0 is erased. */
err = R_FLASH_LP_BlankCheck(&g_flash_ctrl, FLASH_DF_BLOCK_0, FLASH_DATA_BLOCK_SIZE, &blank_check_result);
assert(FSP_SUCCESS == err);
/* Verify the previously erased area is blank */
assert(FLASH_RESULT_BLANK == blank_check_result);
/* Write 32 bytes to the first block of data flash. */
err = R_FLASH_LP_Write(&g_flash_ctrl, (uint32_t) g_src, FLASH_DF_BLOCK_0, FLASH_LP_EXAMPLE_WRITE_SIZE);
assert(FSP_SUCCESS == err);
assert(0 == memcmp(g_src, (uint8_t *) FLASH_DF_BLOCK_0, FLASH_LP_EXAMPLE_WRITE_SIZE));
/* Disable interrupts to prevent vector table access while code flash is in P/E mode. */
__disable_irq();
/* Erase 1 block of code flash starting at block 10. */
err = R_FLASH_LP_Erase(&g_flash_ctrl, FLASH_CF_BLOCK_10, 1);
assert(FSP_SUCCESS == err);
/* Write 32 bytes to the first block of data flash. */
err = R_FLASH_LP_Write(&g_flash_ctrl, (uint32_t) g_src, FLASH_CF_BLOCK_10, FLASH_LP_EXAMPLE_WRITE_SIZE);
assert(FSP_SUCCESS == err);
/* Enable interrupts after code flash operations are complete. */
__enable_irq();
assert(0 == memcmp(g_src, (uint8_t *) FLASH_CF_BLOCK_10, FLASH_LP_EXAMPLE_WRITE_SIZE));
}

Low-Power Flash Advanced Example

This example demonstrates using BGO to do non-blocking operations on the data flash.

bool interrupt_called;
flash_event_t flash_event;
static flash_cfg_t g_flash_bgo_example_cfg =
{
.p_callback = flash_callback,
.p_context = 0,
.p_extend = NULL,
.data_flash_bgo = true,
.ipl = 5,
.irq = BSP_VECTOR_FLASH_LP_FRDYI_ISR,
};
void R_FLASH_LP_bgo_example (void)
{
/* Initialize p_src to known data */
for (uint32_t i = 0; i < TRANSFER_LENGTH; i++)
{
g_src[i] = (uint8_t) ('A' + (i % 26));
}
/* Open the flash lp instance. */
fsp_err_t err = R_FLASH_LP_Open(&g_flash_ctrl, &g_flash_bgo_example_cfg);
/* Handle any errors. This function should be defined by the user. */
assert(FSP_SUCCESS == err);
interrupt_called = false;
/* Erase 1 block of data flash starting at block 0. */
err = R_FLASH_LP_Erase(&g_flash_ctrl, FLASH_DF_BLOCK_0, 1);
assert(FSP_SUCCESS == err);
while (!interrupt_called)
{
;
}
assert(FLASH_EVENT_ERASE_COMPLETE == flash_event);
interrupt_called = false;
/* Write 32 bytes to the first block of data flash. */
err = R_FLASH_LP_Write(&g_flash_ctrl, (uint32_t) g_src, FLASH_DF_BLOCK_0, FLASH_LP_EXAMPLE_WRITE_SIZE);
assert(FSP_SUCCESS == err);
/* Wait until the current flash operation completes. */
do
{
err = R_FLASH_LP_StatusGet(&g_flash_ctrl, &status);
} while ((FSP_SUCCESS == err) && (FLASH_STATUS_BUSY == status));
/* If the interrupt wasn't called process the error. */
assert(interrupt_called);
/* If the event wasn't a write complete process the error. */
assert(FLASH_EVENT_WRITE_COMPLETE == flash_event);
/* Verify the data was written correctly. */
assert(0 == memcmp(g_src, (uint8_t *) FLASH_DF_BLOCK_0, FLASH_LP_EXAMPLE_WRITE_SIZE));
}
void flash_callback (flash_callback_args_t * p_args)
{
interrupt_called = true;
flash_event = p_args->event;
}

Data Structures

struct  flash_lp_instance_ctrl_t
 

Data Structure Documentation

◆ flash_lp_instance_ctrl_t

struct flash_lp_instance_ctrl_t

Flash instance control block. DO NOT INITIALIZE. Initialization occurs when R_FLASH_LP_Open() is called.

Function Documentation

◆ R_FLASH_LP_Open()

fsp_err_t R_FLASH_LP_Open ( flash_ctrl_t *const  p_api_ctrl,
flash_cfg_t const *const  p_cfg 
)

Initialize the Low Power flash peripheral. Implements flash_api_t::open.

The Open function initializes the Flash.

This function must be called once prior to calling any other FLASH API functions. If a user supplied callback function is supplied, then the Flash Ready interrupt will be configured to call the users callback routine with an Event type describing the source of the interrupt for Data Flash operations.

Example:

/* Open the flash lp instance. */
fsp_err_t err = R_FLASH_LP_Open(&g_flash_ctrl, &g_flash_cfg);
Note
Providing a callback function in the supplied p_cfg->callback field automatically configures the Flash for Data Flash to operate in non-blocking background operation (BGO) mode.
Return values
FSP_SUCCESSInitialization was successful and timer has started.
FSP_ERR_ASSERTIONNULL provided for p_ctrl, p_cfg or p_callback if BGO is enabled.
FSP_ERR_IRQ_BSP_DISABLEDCaller is requesting BGO but the Flash interrupts are not enabled.
FSP_ERR_FCLKFCLK must be a minimum of 4 MHz for Flash operations.
FSP_ERR_ALREADY_OPENFlash Open() has already been called.
FSP_ERR_TIMEOUTFailed to exit P/E mode after configuring flash.
FSP_ERR_INVALID_STATEThe system is not running from the required clock.

◆ R_FLASH_LP_Write()

fsp_err_t R_FLASH_LP_Write ( flash_ctrl_t *const  p_api_ctrl,
uint32_t const  src_address,
uint32_t  flash_address,
uint32_t const  num_bytes 
)

Write to the specified Code or Data Flash memory area. Implements flash_api_t::write.

Example:

/* Write 32 bytes to the first block of data flash. */
err = R_FLASH_LP_Write(&g_flash_ctrl, (uint32_t) g_src, FLASH_DF_BLOCK_0, FLASH_LP_EXAMPLE_WRITE_SIZE);
Return values
FSP_SUCCESSOperation successful. If BGO is enabled this means the operation was started successfully.
FSP_ERR_IN_USEThe Flash peripheral is busy with a prior on-going transaction.
FSP_ERR_NOT_OPENThe Flash API is not Open.
FSP_ERR_WRITE_FAILEDStatus is indicating a Programming error for the requested operation. This may be returned if the requested Flash area is not blank.
FSP_ERR_TIMEOUTTimed out waiting for FCU operation to complete.
FSP_ERR_INVALID_SIZENumber of bytes provided was not a multiple of the programming size or exceeded the maximum range.
FSP_ERR_INVALID_ADDRESSInvalid address was input or address not on programming boundary.
FSP_ERR_ASSERTIONNULL provided for p_ctrl.

◆ R_FLASH_LP_Erase()

fsp_err_t R_FLASH_LP_Erase ( flash_ctrl_t *const  p_api_ctrl,
uint32_t const  address,
uint32_t const  num_blocks 
)

Erase the specified Code or Data Flash blocks. Implements flash_api_t::erase.

Example:

/* Erase 1 block of data flash starting at block 0. */
err = R_FLASH_LP_Erase(&g_flash_ctrl, FLASH_DF_BLOCK_0, 1);
Return values
FSP_SUCCESSSuccessful open.
FSP_ERR_INVALID_BLOCKSInvalid number of blocks specified
FSP_ERR_INVALID_ADDRESSInvalid address specified
FSP_ERR_IN_USEOther flash operation in progress, or API not initialized
FSP_ERR_ASSERTIONNULL provided for p_ctrl
FSP_ERR_NOT_OPENThe Flash API is not Open.
FSP_ERR_TIMEOUTTimed out waiting for FCU to be ready.
FSP_ERR_ERASE_FAILEDStatus is indicating a Erase error.

◆ R_FLASH_LP_BlankCheck()

fsp_err_t R_FLASH_LP_BlankCheck ( flash_ctrl_t *const  p_api_ctrl,
uint32_t const  address,
uint32_t  num_bytes,
flash_result_t p_blank_check_result 
)

Perform a blank check on the specified address area. Implements flash_api_t::blankCheck.

Example:

/* Check if block 0 is erased. */
err = R_FLASH_LP_BlankCheck(&g_flash_ctrl, FLASH_DF_BLOCK_0, FLASH_DATA_BLOCK_SIZE, &blank_check_result);
assert(FSP_SUCCESS == err);
Return values
FSP_SUCCESSBlankcheck operation completed with result in p_blank_check_result, or blankcheck started and in-progess (BGO mode).
FSP_ERR_INVALID_ADDRESSInvalid data flash address was input
FSP_ERR_INVALID_SIZE'num_bytes' was either too large or not aligned for the CF/DF boundary size.
FSP_ERR_IN_USEFlash is busy with an on-going operation.
FSP_ERR_ASSERTIONNULL provided for p_ctrl
FSP_ERR_NOT_OPENFlash API has not yet been opened.
FSP_ERR_TIMEOUTTimed out waiting for the FCU to become ready.
FSP_ERR_BLANK_CHECK_FAILEDAn error occurred during blank checking.

◆ R_FLASH_LP_StatusGet()

fsp_err_t R_FLASH_LP_StatusGet ( flash_ctrl_t *const  p_api_ctrl,
flash_status_t *const  p_status 
)

Query the FLASH for its status. Implements flash_api_t::statusGet.

Example:

/* Wait until the current flash operation completes. */
do
{
err = R_FLASH_LP_StatusGet(&g_flash_ctrl, &status);
} while ((FSP_SUCCESS == err) && (FLASH_STATUS_BUSY == status));
Return values
FSP_SUCCESSFlash is ready and available to accept commands.
FSP_ERR_ASSERTIONNULL provided for p_ctrl
FSP_ERR_NOT_OPENFlash API has not yet been opened.

◆ R_FLASH_LP_AccessWindowSet()

fsp_err_t R_FLASH_LP_AccessWindowSet ( flash_ctrl_t *const  p_api_ctrl,
uint32_t const  start_addr,
uint32_t const  end_addr 
)

Configure an access window for the Code Flash memory. Implements flash_api_t::accessWindowSet.

An access window defines a contiguous area in Code Flash for which programming/erase is enabled. This area is on block boundaries. The block containing start_addr is the first block. The block containing end_addr is the last block. The access window then becomes first block (inclusive) –> last block (exclusive). Anything outside this range of Code Flash is then write protected. As an example, if you wanted to place an accesswindow on Code Flash Blocks 0 and 1, such that only those two blocks were writable, you would need to specify (address in block 0, address in block 2) as the respective start and end address.

Note
If the start address and end address are set to the same value, then the access window is effectively removed. This accomplishes the same functionality as R_FLASH_LP_AccessWindowClear().

The invalid address and programming boundaries supported and enforced by this function are dependent on the MCU in use as well as the part package size. Please see the User manual and/or requirements document for additional information.

Parameters
p_api_ctrlThe p api control
[in]start_addrThe start address
[in]end_addrThe end address
Return values
FSP_SUCCESSAccess window successfully configured.
FSP_ERR_INVALID_ADDRESSInvalid settings for start_addr and/or end_addr.
FSP_ERR_IN_USEFLASH peripheral is busy with a prior operation.
FSP_ERR_ASSERTIONNULL provided for p_ctrl.
FSP_ERR_UNSUPPORTEDCode Flash Programming is not enabled.
FSP_ERR_NOT_OPENFlash API has not yet been opened.
FSP_ERR_TIMEOUTTimed out waiting for the FCU to become ready.
FSP_ERR_WRITE_FAILEDStatus is indicating a Programming error for the requested operation.

◆ R_FLASH_LP_AccessWindowClear()

fsp_err_t R_FLASH_LP_AccessWindowClear ( flash_ctrl_t *const  p_api_ctrl)

Remove any access window that is configured in the Code Flash. Implements flash_api_t::accessWindowClear. On successful return from this call all Code Flash is writable.

Return values
FSP_SUCCESSAccess window successfully removed.
FSP_ERR_IN_USEFLASH peripheral is busy with a prior operation.
FSP_ERR_ASSERTIONNULL provided for p_ctrl.
FSP_ERR_UNSUPPORTEDCode Flash Programming is not enabled.
FSP_ERR_NOT_OPENFlash API has not yet been opened.
FSP_ERR_TIMEOUTTimed out waiting for the FCU to become ready.
FSP_ERR_WRITE_FAILEDStatus is indicating a Programming error for the requested operation.

◆ R_FLASH_LP_IdCodeSet()

fsp_err_t R_FLASH_LP_IdCodeSet ( flash_ctrl_t *const  p_api_ctrl,
uint8_t const *const  p_id_code,
flash_id_code_mode_t  mode 
)

Write the ID code provided to the id code registers. Implements flash_api_t::idCodeSet.

Return values
FSP_SUCCESSID code successfully configured.
FSP_ERR_IN_USEFLASH peripheral is busy with a prior operation.
FSP_ERR_ASSERTIONNULL provided for p_ctrl.
FSP_ERR_UNSUPPORTEDCode Flash Programming is not enabled.
FSP_ERR_NOT_OPENFlash API has not yet been opened.
FSP_ERR_TIMEOUTTimed out waiting for completion of extra command.
FSP_ERR_WRITE_FAILEDStatus is indicating a Programming error for the requested operation.

◆ R_FLASH_LP_Reset()

fsp_err_t R_FLASH_LP_Reset ( flash_ctrl_t *const  p_api_ctrl)

Reset the FLASH peripheral. Implements flash_api_t::reset.

No attempt is made to check if the flash is busy before executing the reset since the assumption is that a reset will terminate any existing operation.

Return values
FSP_SUCCESSFlash circuit successfully reset.
FSP_ERR_ASSERTIONNULL provided for p_ctrl
FSP_ERR_NOT_OPENFlash API has not yet been opened.

◆ R_FLASH_LP_StartUpAreaSelect()

fsp_err_t R_FLASH_LP_StartUpAreaSelect ( flash_ctrl_t *const  p_api_ctrl,
flash_startup_area_swap_t  swap_type,
bool  is_temporary 
)

Select which block is used as the startup area block. Implements flash_api_t::startupAreaSelect.

Selects which block - Default (Block 0) or Alternate (Block 1) is used as the startup area block. The provided parameters determine which block will become the active startup block and whether that action will be immediate (but temporary), or permanent subsequent to the next reset. Doing a temporary switch might appear to have limited usefulness. If there is an access window in place such that Block 0 is write protected, then one could do a temporary switch, update the block and switch them back without having to touch the access window.

Return values
FSP_SUCCESSStart-up area successfully toggled.
FSP_ERR_IN_USEFlash is busy with an on-going operation.
FSP_ERR_ASSERTIONNULL provided for p_ctrl
FSP_ERR_NOT_OPENFlash API has not yet been opened.
FSP_ERR_WRITE_FAILEDStatus is indicating a Programming error for the requested operation.
FSP_ERR_TIMEOUTTimed out waiting for the FCU to become ready.
FSP_ERR_UNSUPPORTEDCode Flash Programming is not enabled. Cannot set FLASH_STARTUP_AREA_BTFLG when the temporary flag is false.

◆ R_FLASH_LP_BankSwap()

fsp_err_t R_FLASH_LP_BankSwap ( flash_ctrl_t *const  p_api_ctrl)

Swap the Code Flash bank to update new program. Implement flash_api_t::bankSwap.

Swap the flash bank located at address 0x00000000 and address 0x00040000. After a bank swap is done the MCU will need to be reset for the changes to take place.

To use this API, Code Flash Programming in the FSP Configuration Tool under Stack Properties must be enabled.

Note
This function only available on MCUs which support bank swap feature.
When active bank is bank 1, startup program protection function is invalid.
Parameters
[in]p_api_ctrlThe api control instance.
Return values
FSP_SUCCESSBanks were swapped.
FSP_ERR_UNSUPPORTEDModule does not support Bank Swap.
FSP_ERR_ASSERTIONNULL provided for p_ctrl.
FSP_ERR_NOT_OPENThe control block is not open.
FSP_ERR_IN_USEExtra area is being used by other command.

◆ R_FLASH_LP_UpdateFlashClockFreq()

fsp_err_t R_FLASH_LP_UpdateFlashClockFreq ( flash_ctrl_t *const  p_api_ctrl)

Indicate to the already open Flash API that the FCLK has changed. Implements flash_api_t::updateFlashClockFreq.

This could be the case if the application has changed the system clock, and therefore the FCLK. Failure to call this function subsequent to changing the FCLK could result in damage to the flash macro.

Return values
FSP_SUCCESSStart-up area successfully toggled.
FSP_ERR_IN_USEFlash is busy with an on-going operation.
FSP_ERR_FCLKInvalid flash clock source frequency.
FSP_ERR_ASSERTIONNULL provided for p_ctrl
FSP_ERR_NOT_OPENFlash API has not yet been opened.
FSP_ERR_TIMEOUTTimed out waiting for the FCU to become ready.

◆ R_FLASH_LP_InfoGet()

fsp_err_t R_FLASH_LP_InfoGet ( flash_ctrl_t *const  p_api_ctrl,
flash_info_t *const  p_info 
)

Returns the information about the flash regions. Implements flash_api_t::infoGet.

Return values
FSP_SUCCESSSuccessful retrieved the request information.
FSP_ERR_ASSERTIONNULL provided for p_ctrl or p_info.
FSP_ERR_NOT_OPENThe flash is not open.

◆ R_FLASH_LP_Close()

fsp_err_t R_FLASH_LP_Close ( flash_ctrl_t *const  p_api_ctrl)

Release any resources that were allocated by the Flash API. Implements flash_api_t::close.

Return values
FSP_SUCCESSSuccessful close.
FSP_ERR_ASSERTIONNULL provided for p_ctrl or p_cfg.
FSP_ERR_NOT_OPENFlash API has not yet been opened.
FSP_ERR_IN_USEThe flash is currently in P/E mode.

◆ R_FLASH_LP_CallbackSet()

fsp_err_t R_FLASH_LP_CallbackSet ( flash_ctrl_t *const  p_api_ctrl,
void(*)(flash_callback_args_t *)  p_callback,
void const *const  p_context,
flash_callback_args_t *const  p_callback_memory 
)

Stub function Implements flash_api_t::callbackSet.

Return values
FSP_ERR_UNSUPPORTEDFunction has not been implemented.