Overview

The Secure Request Framework (SRF) offers a standardized way to implement secure operations that are accessible to the non-secure world. It integrates arm’s Cortex-M Security Extensions (CMSE) and Infineon's Peripheral Protection Controller (PPC) and Memory Protection Controller (MPC) regions into a single streamlined process.

The secure world exposes operations to the non-secure world. An operation is a function with strict argument requirements and permission arrays which define which peripherals it can be invoked on. These are grouped into submodules which are grouped into modules. A module is the unit of integration between different entities in the system that wish to expose secure operations. For example, a middleware library would be one module and submodules would be categories of functionality in that library. Modules are registered to a secure context structure.

The non-secure world invokes operations by submitting requests. Requests consist of input and output vectors, or ioVecs. The first inVec and first outVec must point to dedicated input and output structures. The SRF uses these to identify the operation and peripheral, perform validation, as well as store the result of the operation.

In a multi-core environment, the SRF will redirect requests from the non-TrustZone core to the TrustZone core using Infineon's Interprocessor Communication Library (MTB-IPC). The process of submitting a request from the non-secure TrustZone core and a non-TrustZone core is identical.

This framework requires the user manage a mtb_srf_config.h file that contains macros for the various modules that use the SRF. The file comes with the default macros for module IDs. Should a library be added to the project that uses SRF, that library will generate a relevant error message requesting that its module ID is added to the mtb_srf_config.h file.

These are fully documented in the SRF API Reference Manual.

Features

Provides registeration framework mtb_srf_module_register() for a module in the secure world
Provides an implementation of secure request pools (e.g. mtb_srf_pool_s, mtb_srf_ipc_pool_s), which are empty buffers of shared memory that can be allocated and freed through the SRF. The purpose of these pools is to declare one section of shared memory for SRF requests to use instead of individual requests declaring their own shared memory.
Provides SRF comminucation via non-secure-callable (NSC) within TrustZone core. Calling mtb_srf_request_submit() from the non-secure world, secure world provides memory access checking, permission validation, operation dispatch and execution of exposed operation.
Provides SRF IPC communication between one core (sender) and one TrustZone core (receiver)
- Sender: Transmit an SRF request over IPC mtb_srf_ipc_request_submit()
- Receiver: Receives an SRF request over IPC mtb_srf_ipc_receive_request() and process the SRF request from IPC mtb_srf_ipc_process_request().

More information

For more information, refer to the following documents: