Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-10-02 03:00:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

feat(hal): Add support for flash/PSRAM protection through MSPI PMS

Browse Source
This commit is contained in:
Laukik Hase
2026-07-10 13:13:09 +05:30
parent d0b65797c3
commit 11fe9fdad6
15 changed files with 1114 additions and 524 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/esp_hal_mspi/esp32c5/include/hal/mspi_pms_ll.h
+195
View File
@@ -0,0 +1,195 @@
/*
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/*******************************************************************************
* NOTICE
* The ll is not public api, don't use in application code.
* See readme.md in hal/include/hal/readme.md
******************************************************************************/
#pragma once
#include <stdint.h>
#include <stdbool.h>
#include "hal/assert.h"
#include "hal/config.h"
#include "hal/mspi_ll.h"
#include "hal/mspi_pms_types.h"
#include "soc/spi_mem_struct.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MSPI_LL_PMS_REGION_NUM 4
#define MSPI_LL_PMS_REGION_ADDR_ALIGN 0x1000
/**
* @brief Enable/Disable MSPI PMS permission management
*
* @param mem Memory type (shared register - value ignored on this target)
* @param enable true to enable, false to disable
*/
__attribute__((always_inline))
static inline void mspi_ll_pms_enable(mspi_pms_mem_t mem, bool enable)
{
(void)mem;
SPIMEM0.mem_pms_reject.mem_pm_en = enable;
}
/**
* @brief Set MSPI PMS region start address
*
* @param mem Memory type (flash or PSRAM)
* @param regn Region number (0-3)
* @param addr Start address of the PMS region
*/
__attribute__((always_inline))
static inline void mspi_ll_pms_set_region_addr(mspi_pms_mem_t mem, uint32_t regn, uint32_t addr)
{
HAL_ASSERT(mem == MSPI_PMS_MEM_FLASH || mem == MSPI_PMS_MEM_PSRAM);
HAL_ASSERT(regn < MSPI_LL_PMS_REGION_NUM);
if (mem == MSPI_PMS_MEM_FLASH) {
SPIMEM0.fmem_pmsn_addr[regn].fmem_pmsn_addr_s = addr;
} else {
SPIMEM0.smem_pmsn_addr[regn].smem_pmsn_addr_s = addr;
}
}
/**
* @brief Set MSPI PMS region size (in bytes)
*
* @param mem Memory type (flash or PSRAM)
* @param regn Region number (0-3)
* @param size Size in bytes (must be a multiple of MSPI_LL_PMS_REGION_ADDR_ALIGN)
*/
__attribute__((always_inline))
static inline void mspi_ll_pms_set_region_size(mspi_pms_mem_t mem, uint32_t regn, uint32_t size)
{
HAL_ASSERT(mem == MSPI_PMS_MEM_FLASH || mem == MSPI_PMS_MEM_PSRAM);
HAL_ASSERT(regn < MSPI_LL_PMS_REGION_NUM);
HAL_ASSERT((size % MSPI_LL_PMS_REGION_ADDR_ALIGN) == 0);
if (mem == MSPI_PMS_MEM_FLASH) {
SPIMEM0.fmem_pmsn_size[regn].fmem_pmsn_size = size / MSPI_LL_PMS_REGION_ADDR_ALIGN;
} else {
SPIMEM0.smem_pmsn_size[regn].smem_pmsn_size = size / MSPI_LL_PMS_REGION_ADDR_ALIGN;
}
}
/**
* @brief Get MSPI PMS region start address
*
* @param mem Memory type (flash or PSRAM)
* @param regn Region number (0-3)
* @return Start address of the PMS region
*/
__attribute__((always_inline))
static inline uint32_t mspi_ll_pms_get_region_addr(mspi_pms_mem_t mem, uint32_t regn)
{
HAL_ASSERT(mem == MSPI_PMS_MEM_FLASH || mem == MSPI_PMS_MEM_PSRAM);
HAL_ASSERT(regn < MSPI_LL_PMS_REGION_NUM);
uint32_t addr = 0;
if (mem == MSPI_PMS_MEM_FLASH) {
addr = SPIMEM0.fmem_pmsn_addr[regn].fmem_pmsn_addr_s;
} else {
addr = SPIMEM0.smem_pmsn_addr[regn].smem_pmsn_addr_s;
}
return addr;
}
/**
* @brief Get MSPI PMS region size (in bytes)
*
* @param mem Memory type (flash or PSRAM)
* @param regn Region number (0-3)
* @return Size of the PMS region in bytes
*/
__attribute__((always_inline))
static inline uint32_t mspi_ll_pms_get_region_size(mspi_pms_mem_t mem, uint32_t regn)
{
HAL_ASSERT(mem == MSPI_PMS_MEM_FLASH || mem == MSPI_PMS_MEM_PSRAM);
HAL_ASSERT(regn < MSPI_LL_PMS_REGION_NUM);
uint32_t size = 0;
if (mem == MSPI_PMS_MEM_FLASH) {
size = SPIMEM0.fmem_pmsn_size[regn].fmem_pmsn_size;
} else {
size = SPIMEM0.smem_pmsn_size[regn].smem_pmsn_size;
}
return size * MSPI_LL_PMS_REGION_ADDR_ALIGN;
}
/**
* @brief Set MSPI PMS region attributes for a specific security mode
*
* @param mem Memory type (flash or PSRAM)
* @param regn Region number (0-3)
* @param mode Security mode
* @param attr Region attribute flags - RD/WR/ECC (mspi_pms_attr_t)
*/
__attribute__((always_inline))
static inline void mspi_ll_pms_set_region_attr(mspi_pms_mem_t mem, uint32_t regn, mspi_pms_mode_t mode, mspi_pms_attr_t attr)
{
HAL_ASSERT(mem == MSPI_PMS_MEM_FLASH || mem == MSPI_PMS_MEM_PSRAM);
HAL_ASSERT(regn < MSPI_LL_PMS_REGION_NUM);
if (mode != MSPI_PMS_MODE_TEE) {
return;
}
uint32_t bits = attr & (MSPI_PMS_ATTR_RD | MSPI_PMS_ATTR_WR | MSPI_PMS_ATTR_ECC);
if (mem == MSPI_PMS_MEM_FLASH) {
SPIMEM0.fmem_pmsn_attr[regn].val = bits;
} else {
SPIMEM0.smem_pmsn_attr[regn].val = bits;
}
}
/**
* @brief Get MSPI PMS reject address
*
* @param mem Memory type (shared register - value ignored on this target)
* @return Address that caused PMS violation
*/
__attribute__((always_inline))
static inline uint32_t mspi_ll_pms_get_reject_addr(mspi_pms_mem_t mem)
{
(void)mem;
return SPIMEM0.mem_pms_reject_addr.mem_reject_addr;
}
/**
* @brief Get MSPI PMS error mask
*
* @param mem Memory type (shared register - value ignored on this target)
* @return Bitmask of error types (mspi_pms_err_t), or MSPI_PMS_ERR_NONE if no error
*/
__attribute__((always_inline))
static inline uint32_t mspi_ll_pms_get_err_mask(mspi_pms_mem_t mem)
{
(void)mem;
uint32_t err = MSPI_PMS_ERR_NONE;
if (SPIMEM0.mem_pms_reject.mem_pms_multi_hit) {
err |= MSPI_PMS_ERR_ADDR_MULTI;
}
if (SPIMEM0.mem_pms_reject.mem_pms_ivd) {
err |= MSPI_PMS_ERR_ADDR_MISS;
}
if (SPIMEM0.mem_pms_reject.mem_pms_st) {
err |= MSPI_PMS_ERR_WRITE;
}
if (SPIMEM0.mem_pms_reject.mem_pms_ld) {
err |= MSPI_PMS_ERR_READ;
}
return err;
}
#ifdef __cplusplus
}
#endif
components/esp_hal_mspi/esp32c5/include/hal/psram_ctrlr_ll.h
+1 -102
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -33,9 +33,6 @@ extern "C" {
#define PSRAM_CTRLR_LL_MSPI_ID_PERI PSRAM_CTRLR_LL_MSPI_ID_1
#define PSRAM_LL_CS_SEL SPI_MEM_CS1_DIS_M
#define PSRAM_CTRLR_LL_PMS_REGION_NUMS 4
#define PSRAM_CTRLR_LL_PMS_ATTR_WRITABLE (1<<0)
#define PSRAM_CTRLR_LL_PMS_ATTR_READABLE (1<<1)
#define PSRAM_CTRLR_LL_PMS_INT_SUPPORTED 1
#define PSRAM_CTRLR_LL_ADDR_INT_SUPPORTED 1
@@ -429,104 +426,6 @@ static inline void psram_ctrlr_ll_enable_ecc_addr_conversion(uint32_t mspi_id, b
SPIMEM0.smem_ecc_ctrl.smem_ecc_addr_en = en;
}
/*---------------------------------------------------------------
PMS
---------------------------------------------------------------*/
/**
* @brief Enable PMS ECC
*
* @param mspi_id mspi_id
* @param region_id region_id
* @param en enable / disable
*/
__attribute__((always_inline))
static inline void psram_ctrlr_ll_enable_pms_region_ecc(uint32_t mspi_id, uint32_t region_id, bool en)
{
(void)mspi_id;
HAL_ASSERT(region_id < PSRAM_CTRLR_LL_PMS_REGION_NUMS);
SPIMEM0.smem_pmsn_attr[region_id].smem_pmsn_ecc = en;
}
/**
* @brief Set PMS attr
*
* @param mspi_id mspi_id
* @param region_id region_id
* @param attr_mask attribute mask
*/
__attribute__((always_inline))
static inline void psram_ctrlr_ll_set_pms_region_attr(uint32_t mspi_id, uint32_t region_id, uint32_t attr_mask)
{
(void)mspi_id;
HAL_ASSERT(region_id < PSRAM_CTRLR_LL_PMS_REGION_NUMS);
SPIMEM0.smem_pmsn_attr[region_id].smem_pmsn_wr_attr = 0;
SPIMEM0.smem_pmsn_attr[region_id].smem_pmsn_rd_attr = 0;
if (attr_mask & PSRAM_CTRLR_LL_PMS_ATTR_WRITABLE) {
SPIMEM0.smem_pmsn_attr[region_id].smem_pmsn_wr_attr = 1;
}
if (attr_mask & PSRAM_CTRLR_LL_PMS_ATTR_READABLE) {
SPIMEM0.smem_pmsn_attr[region_id].smem_pmsn_rd_attr = 1;
}
}
/**
* @brief Set PMS address
*
* @param mspi_id mspi_id
* @param region_id region_id
* @param addr start addr
*/
__attribute__((always_inline))
static inline void psram_ctrlr_ll_set_pms_region_start_addr(uint32_t mspi_id, uint32_t region_id, uint32_t addr)
{
(void)mspi_id;
HAL_ASSERT(region_id < PSRAM_CTRLR_LL_PMS_REGION_NUMS);
SPIMEM0.smem_pmsn_addr[region_id].smem_pmsn_addr_s = addr;
}
/**
* @brief Set PMS size
*
* @param mspi_id mspi_id
* @param region_id region_id
* @param size size
*/
__attribute__((always_inline))
static inline void psram_ctrlr_ll_set_pms_region_size(uint32_t mspi_id, uint32_t region_id, uint32_t size)
{
(void)mspi_id;
HAL_ASSERT(region_id < PSRAM_CTRLR_LL_PMS_REGION_NUMS);
SPIMEM0.smem_pmsn_size[region_id].smem_pmsn_size = size;
}
/**
* @brief Get PMS address
*
* @param mspi_id mspi_id
* @param region_id region_id
*/
__attribute__((always_inline))
static inline uint32_t psram_ctrlr_ll_get_pms_region_start_addr(uint32_t mspi_id, uint32_t region_id)
{
(void)mspi_id;
HAL_ASSERT(region_id < PSRAM_CTRLR_LL_PMS_REGION_NUMS);
return SPIMEM0.smem_pmsn_addr[region_id].smem_pmsn_addr_s;
}
/**
* @brief Get PMS size
*
* @param mspi_id mspi_id
* @param region_id region_id
*/
__attribute__((always_inline))
static inline uint32_t psram_ctrlr_ll_get_pms_region_size(uint32_t mspi_id, uint32_t region_id)
{
(void)mspi_id;
HAL_ASSERT(region_id < PSRAM_CTRLR_LL_PMS_REGION_NUMS);
return SPIMEM0.smem_pmsn_size[region_id].smem_pmsn_size;
}
#ifdef __cplusplus
}
#endif