mirror of
https://github.com/espressif/esp-idf.git
synced 2026-10-03 03:31:41 +03:00
refactor(spi_flash): move os layer to esp_mspi and chip configs to spi_flash
Also fixes the implicit dependency on esp_partition.
This commit is contained in:
armando
committed by
Armando (Dou Yiwen)
Armando (Dou Yiwen)
parent
c565262ded
commit
6e3abd12a1
@@ -87,7 +87,7 @@ struct esp_flash_t {
|
||||
spi_flash_host_inst_t* host; ///< Pointer to hardware-specific "host_driver" structure. Must be initialized before used.
|
||||
const spi_flash_chip_t *chip_drv; ///< Pointer to chip-model-specific "adapter" structure. If NULL, will be detected during initialisation.
|
||||
|
||||
const esp_flash_os_functions_t *os_func; ///< Pointer to os-specific hook structure. Call ``esp_flash_init_os_functions()`` to setup this field, after the host is properly initialized.
|
||||
const esp_flash_os_functions_t *os_func; ///< Pointer to os-specific hook structure.
|
||||
void *os_func_data; ///< Pointer to argument for os-specific hooks. Left NULL and will be initialized with ``os_func``.
|
||||
|
||||
esp_flash_io_mode_t read_mode; ///< Configured SPI flash read mode. Set before ``esp_flash_init`` is called.
|
||||
|
||||
@@ -1,87 +1,9 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
|
||||
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#include "soc/soc_caps.h"
|
||||
|
||||
#pragma once
|
||||
|
||||
/* SPI commands (actual on-wire commands not SPI controller bitmasks)
|
||||
Suitable for use with spi_flash_hal_common_command static function.
|
||||
*/
|
||||
#define CMD_RDID 0x9F
|
||||
#define CMD_RDUID 0x4B /* Read the flash unique ID*/
|
||||
#define CMD_WRSR 0x01
|
||||
#define SR_WIP (1<<0) /* Status register write-in-progress bit */
|
||||
#define SR_WREN (1<<1) /* Status register write enable bit */
|
||||
#define CMD_WRSR2 0x31 /* Not all SPI flash uses this command */
|
||||
#define CMD_WREN 0x06
|
||||
#define CMD_WRDI 0x04
|
||||
#define CMD_RDSR 0x05
|
||||
#define CMD_RDSR2 0x35 /* Not all SPI flash uses this command */
|
||||
#define CMD_RDSCUR 0x2B /* MXIC-specific, read security register */
|
||||
#define CMD_8READ 0xEC /* MXIC-specific, 8 I/O read */
|
||||
#define CMD_8DTRD 0xEE /* MXIC-specific, 8 I/O DTR read */
|
||||
#define CMD_RDFR 0x48 /* ISSI-specific, read function register */
|
||||
|
||||
#define CMD_FASTRD_QIO 0xEB
|
||||
#define CMD_FASTRD_QIO_4B 0xEC
|
||||
#define CMD_FASTRD_QUAD 0x6B
|
||||
#define CMD_FASTRD_QUAD_4B 0x6C
|
||||
#define CMD_FASTRD_DIO 0xBB
|
||||
#define CMD_FASTRD_DIO_4B 0xBC
|
||||
#define CMD_FASTRD_DUAL 0x3B
|
||||
#define CMD_FASTRD_DUAL_4B 0x3C
|
||||
#define CMD_FASTRD 0x0B
|
||||
#define CMD_FASTRD_4B 0x0C
|
||||
#define CMD_READ 0x03 /* Speed limited */
|
||||
#define CMD_READ_4B 0x13 /* Speed limited */
|
||||
|
||||
#define CMD_CHIP_ERASE 0xC7
|
||||
#define CMD_SECTOR_ERASE 0x20
|
||||
#define CMD_SECTOR_ERASE_4B 0x21
|
||||
#define CMD_LARGE_BLOCK_ERASE 0xD8 /* 64KB block erase command */
|
||||
#define CMD_LARGE_BLOCK_ERASE_4B 0xDC /* 64KB block erase command */
|
||||
#define CMD_PROGRAM_PAGE 0x02
|
||||
#define CMD_PROGRAM_PAGE_4B 0x12
|
||||
#define CMD_SUSPEND 0x75
|
||||
#define CMD_RESUME 0x7A
|
||||
#define CMD_HPMEN 0xA3 /* Enable High Performance mode on flash */
|
||||
#define CMD_WRAP 0x77
|
||||
#define CMD_BURST_RD 0xC0 /* wrap(0x77) and burst read are functionally same. But commands and formats is different */
|
||||
|
||||
#define CMD_RST_EN 0x66
|
||||
#define CMD_RST_DEV 0x99
|
||||
|
||||
#define CMD_RDSFDP 0x5A /* Read the SFDP of the flash */
|
||||
|
||||
#define SPI_FLASH_DIO_DUMMY_BITLEN 4
|
||||
#define SPI_FLASH_QIO_DUMMY_BITLEN 6
|
||||
#define SPI_FLASH_DIO_ADDR_BITLEN 24
|
||||
#define SPI_FLASH_QIO_ADDR_BITLEN 24
|
||||
#define SPI_FLASH_QOUT_ADDR_BITLEN 24
|
||||
#define SPI_FLASH_QOUT_DUMMY_BITLEN 8
|
||||
#define SPI_FLASH_DOUT_ADDR_BITLEN 24
|
||||
#define SPI_FLASH_DOUT_DUMMY_BITLEN 8
|
||||
#define SPI_FLASH_FASTRD_ADDR_BITLEN 24
|
||||
#define SPI_FLASH_FASTRD_DUMMY_BITLEN 8
|
||||
#define SPI_FLASH_SLOWRD_ADDR_BITLEN 24
|
||||
#define SPI_FLASH_SLOWRD_DUMMY_BITLEN 0
|
||||
#define SPI_FLASH_OPISTR_ADDR_BITLEN 32
|
||||
#define SPI_FLASH_OPISTR_DUMMY_BITLEN 20
|
||||
#define SPI_FLASH_OPIDTR_ADDR_BITLEN 32
|
||||
#define SPI_FLASH_OPIDTR_DUMMY_BITLEN 40
|
||||
#define SPI_FLASH_QIO_HPM_DUMMY_BITLEN 10
|
||||
#define SPI_FLASH_DIO_HPM_DUMMY_BITLEN 8
|
||||
|
||||
// Flash vendors.
|
||||
#define SPI_FLASH_GD 0xC8
|
||||
#define SPI_FLASH_ISSI 0x9D
|
||||
#define SPI_FLASH_MXIC 0xC2
|
||||
#define SPI_FLASH_XMC_1 0x20
|
||||
#define SPI_FLASH_XMC_2 0x46
|
||||
#define SPI_FLASH_WINBOND 0xEF
|
||||
#define SPI_FLASH_TH 0xCD
|
||||
#define SPI_FLASH_BY 0x68
|
||||
#include <spi_flash_defs.h>
|
||||
|
||||
@@ -1,105 +0,0 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "sdkconfig.h"
|
||||
#include "esp_err.h"
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Structure for flash dummy bits.
|
||||
* For some flash chips, dummy bits are configurable under different conditions.
|
||||
*/
|
||||
typedef struct {
|
||||
uint8_t dio_dummy;
|
||||
uint8_t dout_dummy;
|
||||
uint8_t qio_dummy;
|
||||
uint8_t qout_dummy;
|
||||
uint8_t fastrd_dummy;
|
||||
} spi_flash_hpm_dummy_conf_t;
|
||||
|
||||
typedef enum {
|
||||
SPI_FLASH_HPM_CMD_NEEDED, // Means that in the certain condition, flash needs to enter the high performance mode by command.
|
||||
SPI_FLASH_HPM_DUMMY_NEEDED, // Means that in the certain condition, flash needs to enter the high performance mode by adjusting dummy.
|
||||
SPI_FLASH_HPM_WRITE_SR_NEEDED, // Means that in the certain condition, flash needs to enter the high performance mode by writing status register.
|
||||
SPI_FLASH_HPM_UNNEEDED, // Means that flash doesn't need to enter the high performance mode.
|
||||
SPI_FLASH_HPM_BEYOND_LIMIT, // Means that flash has no capability to meet that condition.
|
||||
} spi_flash_requirement_t;
|
||||
|
||||
typedef void (*spi_flash_hpm_enable_fn_t)(void);
|
||||
typedef esp_err_t (*spi_flash_hpf_check_fn_t)(void);
|
||||
typedef void (*spi_flash_get_chip_dummy_fn_t)(spi_flash_hpm_dummy_conf_t *dummy_conf);
|
||||
typedef esp_err_t (*spi_flash_hpm_probe_fn_t)(uint32_t flash_id);
|
||||
typedef spi_flash_requirement_t (*spi_flash_hpm_chip_requirement_check_t)(uint32_t flash_id, uint32_t freq_mhz, int voltage_mv, int temperature);
|
||||
|
||||
typedef struct __attribute__((packed))
|
||||
{
|
||||
const char *method; /* Flash HPM method */
|
||||
spi_flash_hpm_probe_fn_t probe;
|
||||
spi_flash_hpm_chip_requirement_check_t chip_hpm_requirement_check;
|
||||
spi_flash_hpm_enable_fn_t flash_hpm_enable;
|
||||
spi_flash_hpf_check_fn_t flash_hpf_check;
|
||||
spi_flash_get_chip_dummy_fn_t flash_get_dummy;
|
||||
} spi_flash_hpm_info_t;
|
||||
|
||||
/**
|
||||
* @brief Enum for user to select valid wrap size.
|
||||
*/
|
||||
typedef enum {
|
||||
FLASH_WRAP_SIZE_8B = 8,
|
||||
FLASH_WRAP_SIZE_16B = 16,
|
||||
FLASH_WRAP_SIZE_32B = 32,
|
||||
FLASH_WRAP_SIZE_64B = 64,
|
||||
} spi_flash_wrap_size_t;
|
||||
|
||||
/**
|
||||
* @brief Probe flash wrap method
|
||||
*
|
||||
* @param flash_id Flash chip ID
|
||||
*
|
||||
* @return ESP_OK: If succeed
|
||||
*/
|
||||
typedef esp_err_t (*spi_flash_wrap_probe_fn_t)(uint32_t flash_id);
|
||||
|
||||
/**
|
||||
* @brief Set flash wrap
|
||||
*
|
||||
* @param wrap_size: wrap_size
|
||||
*
|
||||
* @return ESP_OK: If succeed
|
||||
*/
|
||||
typedef esp_err_t (*spi_flash_wrap_set_fn_t)(spi_flash_wrap_size_t wrap_size);
|
||||
|
||||
/**
|
||||
* @brief Clear flash wrap.
|
||||
*
|
||||
* @return ESP_OK: If succeed
|
||||
*/
|
||||
typedef esp_err_t (*spi_flash_wrap_clr_fn_t)(void);
|
||||
|
||||
typedef struct __attribute__((packed))
|
||||
{
|
||||
const char *method;
|
||||
spi_flash_wrap_probe_fn_t probe;
|
||||
spi_flash_wrap_set_fn_t chip_wrap_set;
|
||||
spi_flash_wrap_clr_fn_t chip_wrap_clr;
|
||||
} spi_flash_wrap_info_t;
|
||||
|
||||
/**
|
||||
* Array of known flash chips and method to enable flash high performance mode.
|
||||
*
|
||||
* Users can override this array.
|
||||
*/
|
||||
extern const spi_flash_hpm_info_t __attribute__((weak)) spi_flash_hpm_enable_list[];
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -30,6 +30,8 @@ enum {
|
||||
};
|
||||
|
||||
//The ROM code has already taken 1 and 2, to avoid possible conflicts, start from 3.
|
||||
#define ESP_ERR_FLASH_OP_FAIL (ESP_ERR_FLASH_BASE+1) ///< aligned with rom
|
||||
#define ESP_ERR_FLASH_OP_TIMEOUT (ESP_ERR_FLASH_BASE+2) ///< aligned with rom
|
||||
#define ESP_ERR_FLASH_NOT_INITIALISED (ESP_ERR_FLASH_BASE+3) ///< esp_flash_chip_t structure not correctly initialised by esp_flash_init().
|
||||
#define ESP_ERR_FLASH_UNSUPPORTED_HOST (ESP_ERR_FLASH_BASE+4) ///< Requested operation isn't supported via this host SPI bus (chip->spi field).
|
||||
#define ESP_ERR_FLASH_UNSUPPORTED_CHIP (ESP_ERR_FLASH_BASE+5) ///< Requested operation isn't supported by this model of SPI flash chip.
|
||||
|
||||
@@ -1,124 +0,0 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "sdkconfig.h"
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* This header file contains declarations of cache manipulation functions
|
||||
* used both in flash_ops.c and flash_mmap.c.
|
||||
*
|
||||
* These functions are considered internal and are not designed to be called from applications.
|
||||
*/
|
||||
|
||||
// Init mutex protecting access to spi_flash_* APIs
|
||||
void spi_flash_init_lock(void);
|
||||
|
||||
// Take mutex protecting access to spi_flash_* APIs
|
||||
void spi_flash_op_lock(void);
|
||||
|
||||
// Release said mutex
|
||||
void spi_flash_op_unlock(void);
|
||||
|
||||
// Suspend the scheduler on both CPUs, disable cache.
|
||||
// Contrary to its name this doesn't do anything with interrupts, yet.
|
||||
// Interrupt disabling capability will be added once we implement
|
||||
// interrupt allocation API.
|
||||
void spi_flash_disable_interrupts_caches_and_other_cpu(void);
|
||||
|
||||
// Enable cache, enable interrupts (to be added in future), resume scheduler
|
||||
void spi_flash_enable_interrupts_caches_and_other_cpu(void);
|
||||
|
||||
// Disables non-IRAM interrupt handlers on current CPU and caches on both CPUs.
|
||||
// This function is implied to be called when other CPU is not running or running code from IRAM.
|
||||
void spi_flash_disable_interrupts_caches_and_other_cpu_no_os(void);
|
||||
|
||||
// Enable cache, enable interrupts on current CPU.
|
||||
// This function is implied to be called when other CPU is not running or running code from IRAM.
|
||||
void spi_flash_enable_interrupts_caches_no_os(void);
|
||||
|
||||
// Mark the pages containing a flash region as having been
|
||||
// erased or written to. This means the flash cache needs
|
||||
// to be evicted before these pages can be flash_mmap()ed again,
|
||||
// as they may contain stale data
|
||||
//
|
||||
// Only call this while holding spi_flash_op_lock()
|
||||
// Returns true if cache was flushed, false otherwise
|
||||
bool spi_flash_check_and_flush_cache(size_t start_addr, size_t length);
|
||||
|
||||
//config cache mode
|
||||
#if !CONFIG_IDF_TARGET_ESP32
|
||||
//config instrcutin cache size and cache block size by menuconfig
|
||||
void esp_config_instruction_cache_mode(void);
|
||||
//config data cache size and cache block size by menuconfig
|
||||
void esp_config_data_cache_mode(void);
|
||||
#endif
|
||||
|
||||
#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C2
|
||||
/**
|
||||
* @brief enable cache wrap mode for i/d shared cache
|
||||
* @param icache_wrap_enable enable cache wrap mode for i/d shared cache
|
||||
* @return ESP_OK on success, ESP_FAIL otherwise
|
||||
*/
|
||||
esp_err_t esp_enable_cache_wrap(bool icache_wrap_enable);
|
||||
#elif CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32S2
|
||||
/**
|
||||
* @brief enable cache wrap mode for instruction cache and data cache
|
||||
* @param icache_wrap_enable enable cache wrap mode for i cache
|
||||
* @param dcache_wrap_enable enable cache wrap mode for d cache
|
||||
* @return ESP_OK on success, ESP_FAIL otherwise
|
||||
*/
|
||||
esp_err_t esp_enable_cache_wrap(bool icache_wrap_enable, bool dcache_wrap_enable);
|
||||
#endif
|
||||
|
||||
/** @brief Check at runtime if flash cache is enabled on both CPUs
|
||||
*
|
||||
* @return true if both CPUs have flash cache enabled, false otherwise.
|
||||
*/
|
||||
bool spi_flash_cache_enabled(void);
|
||||
|
||||
/**
|
||||
* @brief Re-enable cache for the core defined as cpuid parameter.
|
||||
*
|
||||
* @param cpuid the core number to enable instruction cache for
|
||||
*/
|
||||
void spi_flash_enable_cache(uint32_t cpuid);
|
||||
|
||||
/**
|
||||
* @brief Suspend the Cache access to external memory.
|
||||
*
|
||||
* @note Callers must disable branch prediction around this window when
|
||||
* SOC_BRANCH_PREDICTOR_SUPPORTED, otherwise speculative fetches can
|
||||
* raise cache access-fail errors while the cache is suspended.
|
||||
*
|
||||
* @param cpuid the core number to enable the cache for, meaning less on shared cache.
|
||||
* @param saved_state Cache status hold by hal (Used only on ROM impl. in idf, this param unused)
|
||||
*/
|
||||
void spi_flash_disable_cache(uint32_t cpuid, uint32_t *saved_state);
|
||||
|
||||
/**
|
||||
* @brief Resume the Cache access to external memory.
|
||||
*
|
||||
* @note Callers that disabled branch prediction for the suspend window must
|
||||
* re-enable it after this call when SOC_BRANCH_PREDICTOR_SUPPORTED.
|
||||
*
|
||||
* @param cpuid the core number to enable the cache for, meaning less on shared cache.
|
||||
* @param saved_state Cache status hold by hal (Used only on ROM impl. in idf, this param unused)
|
||||
*/
|
||||
void spi_flash_restore_cache(uint32_t cpuid, uint32_t saved_state);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
|
||||
* SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -20,19 +20,44 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
//-----------------------------ESP FLASH UTILITIES-------------------------------------//
|
||||
/**
|
||||
* @brief Initialize main flash
|
||||
* @note Only call this function to initialize the main flash (flash chip on SPI1 CS0).
|
||||
*
|
||||
* @param chip Pointer to main SPI flash(SPI1 CS0) chip to use.
|
||||
* @return ESP_OK on success, or a flash error code if initialisation fails.
|
||||
*/
|
||||
esp_err_t esp_flash_init_main(esp_flash_t *chip);
|
||||
|
||||
/** @brief Initialise the default SPI flash chip
|
||||
/**
|
||||
* @brief Initialize the bus lock on the SPI1 bus. Should be called if drivers (including esp_flash)
|
||||
* wants to use SPI1 bus.
|
||||
*
|
||||
* @note When using legacy spi flash API, the bus lock will not be available on SPI1 bus.
|
||||
*
|
||||
* @return esp_err_t always ESP_OK.
|
||||
*/
|
||||
esp_err_t esp_flash_app_init_os_functions(void);
|
||||
|
||||
#if CONFIG_SPI_FLASH_ROM_IMPL
|
||||
/**
|
||||
* @brief Initialize ROM API functions structure
|
||||
*
|
||||
* This function initializes the ROM API functions structure, either by pointing
|
||||
* to a custom structure or by patching the ROM structure in RAM.
|
||||
*/
|
||||
void esp_flash_rom_api_funcs_init(void);
|
||||
#endif // CONFIG_SPI_FLASH_ROM_IMPL
|
||||
|
||||
//-----------------------------ESP FLASH OS LAYER-------------------------------------//
|
||||
/**
|
||||
* @brief Initialise the default SPI flash chip
|
||||
*
|
||||
* Called by OS startup code. You do not need to call this in your own applications.
|
||||
*/
|
||||
esp_err_t esp_flash_init_default_chip(void);
|
||||
|
||||
/**
|
||||
* @brief Initialize main flash
|
||||
* @param chip Pointer to main SPI flash(SPI1 CS0) chip to use..
|
||||
*/
|
||||
esp_err_t esp_flash_init_main(esp_flash_t *chip);
|
||||
|
||||
/**
|
||||
* Enable OS-level SPI flash protections in IDF
|
||||
*
|
||||
@@ -76,16 +101,6 @@ esp_err_t esp_flash_init_os_functions(esp_flash_t *chip, int host_id, spi_bus_lo
|
||||
*/
|
||||
esp_err_t esp_flash_deinit_os_functions(esp_flash_t* chip, spi_bus_lock_dev_handle_t* out_dev_handle);
|
||||
|
||||
/**
|
||||
* @brief Initialize the bus lock on the SPI1 bus. Should be called if drivers (including esp_flash)
|
||||
* wants to use SPI1 bus.
|
||||
*
|
||||
* @note When using legacy spi flash API, the bus lock will not be available on SPI1 bus.
|
||||
*
|
||||
* @return esp_err_t always ESP_OK.
|
||||
*/
|
||||
esp_err_t esp_flash_app_init_os_functions(void);
|
||||
|
||||
/**
|
||||
* Initialize OS-level functions for the main flash chip.
|
||||
*
|
||||
@@ -126,15 +141,45 @@ esp_err_t esp_flash_app_disable_os_functions(esp_flash_t* chip);
|
||||
*/
|
||||
esp_err_t esp_flash_set_dangerous_write_protection(esp_flash_t *chip, const bool protect);
|
||||
|
||||
#if CONFIG_SPI_FLASH_ROM_IMPL
|
||||
/**
|
||||
* @brief Initialize ROM API functions structure
|
||||
*
|
||||
* This function initializes the ROM API functions structure, either by pointing
|
||||
* to a custom structure or by patching the ROM structure in RAM.
|
||||
* @brief Partition operations
|
||||
*/
|
||||
void esp_flash_rom_api_funcs_init(void);
|
||||
#endif // CONFIG_SPI_FLASH_ROM_IMPL
|
||||
typedef struct esp_flash_partition_ops_s {
|
||||
/**
|
||||
* @brief Check if the main flash region is safe to write/erase.
|
||||
*
|
||||
* @param[in] start_addr Start address of the region
|
||||
* @param[in] size Size of the region
|
||||
* @return true if the region is safe to write/erase, false otherwise
|
||||
*/
|
||||
bool (*check_main_flash_region_safe)(size_t start_addr, size_t size);
|
||||
|
||||
/**
|
||||
* @brief Check if a region is writable
|
||||
*
|
||||
* @param[in] start_addr Start address of the region
|
||||
* @param[in] size Size of the region
|
||||
* @return true if the region is writable/eraseable, false otherwise
|
||||
*/
|
||||
bool (*check_region_writable)(size_t start_addr, size_t size);
|
||||
} esp_flash_partition_ops_t;
|
||||
|
||||
/**
|
||||
* @brief Register a callback to determine whether a flash region is safe to write/erase.
|
||||
*
|
||||
* This allows upper-layer components (e.g. esp_partition) to inject partition-aware
|
||||
* write protection logic without creating a circular dependency.
|
||||
*
|
||||
* The main flash chip must always register valid ops. For external flash chips
|
||||
* calling this is optional; if not called, partition protection stays disabled
|
||||
* (the default set by the OS-functions constructor).
|
||||
*
|
||||
* @param chip Pointer to the flash chip. Must not be NULL.
|
||||
* @param ops Partition operations. Must not be NULL and both callbacks must be set.
|
||||
* @return ESP_OK on success, ESP_ERR_INVALID_ARG if chip or ops is invalid,
|
||||
* ESP_ERR_INVALID_STATE if the flash OS functions are not initialized.
|
||||
*/
|
||||
esp_err_t esp_flash_register_partition_ops(esp_flash_t *chip, esp_flash_partition_ops_t *ops);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
|
||||
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
@@ -7,7 +7,6 @@
|
||||
#pragma once
|
||||
|
||||
#include "sdkconfig.h"
|
||||
#include "esp_flash.h"
|
||||
#include "esp_attr.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
@@ -1,299 +0,0 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2019-2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* System level MSPI APIs (private)
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "sdkconfig.h"
|
||||
#include "esp_rom_spiflash.h"
|
||||
#include "esp_err.h"
|
||||
#include "soc/soc_caps.h"
|
||||
#include "soc/clk_tree_defs.h"
|
||||
|
||||
#include "hal/spi_flash_hal.h"
|
||||
|
||||
#include "esp_flash.h"
|
||||
#include "esp_flash_chips/esp_flash_types.h"
|
||||
#include "esp_flash_chips/spi_flash_override.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Type of MSPI IO
|
||||
typedef enum {
|
||||
ESP_MSPI_IO_CLK = 0,
|
||||
ESP_MSPI_IO_Q,
|
||||
ESP_MSPI_IO_D,
|
||||
ESP_MSPI_IO_CS0, /* cs for spi flash */
|
||||
ESP_MSPI_IO_HD,
|
||||
ESP_MSPI_IO_WP,
|
||||
#if SOC_SPI_MEM_SUPPORT_FLASH_OPI_MODE
|
||||
ESP_MSPI_IO_DQS,
|
||||
ESP_MSPI_IO_D4,
|
||||
ESP_MSPI_IO_D5,
|
||||
ESP_MSPI_IO_D6,
|
||||
ESP_MSPI_IO_D7,
|
||||
#endif // SOC_SPI_MEM_SUPPORT_FLASH_OPI_MODE
|
||||
#if CONFIG_SPIRAM
|
||||
ESP_MSPI_IO_CS1, /* cs for spi ram */
|
||||
#endif
|
||||
ESP_MSPI_IO_MAX, /* Maximum IO MSPI occupied */
|
||||
} esp_mspi_io_t;
|
||||
|
||||
/**
|
||||
* @brief To setup Flash chip
|
||||
*/
|
||||
esp_err_t spi_flash_init_chip_state(void);
|
||||
|
||||
/**
|
||||
* @brief To initislize the MSPI pins
|
||||
*/
|
||||
void esp_mspi_pin_init(void);
|
||||
|
||||
/**
|
||||
* @brief Reserve MSPI IOs
|
||||
*/
|
||||
void esp_mspi_pin_reserve(void);
|
||||
|
||||
/**
|
||||
* @brief Get the number of the GPIO corresponding to the given MSPI io
|
||||
*
|
||||
* @param[in] io MSPI io
|
||||
*
|
||||
* @return MSPI IO number
|
||||
*/
|
||||
uint8_t esp_mspi_get_io(esp_mspi_io_t io);
|
||||
|
||||
/**
|
||||
* @brief Set SPI1 registers to make ROM functions work
|
||||
* @note This function is used for setting SPI1 registers to the state that ROM SPI functions work
|
||||
*/
|
||||
void spi_flash_set_rom_required_regs(void);
|
||||
|
||||
/**
|
||||
* @brief Should be only used by SPI1 Flash driver to know the necessary timing registers
|
||||
* @param out_timing_config Pointer to timing_tuning parameters.
|
||||
*/
|
||||
void spi_timing_get_flash_timing_param(spi_flash_hal_timing_config_t *out_timing_config);
|
||||
|
||||
/**
|
||||
* @brief Get the knowledge if the Flash timing is tuned or not
|
||||
*/
|
||||
bool spi_flash_timing_is_tuned(void);
|
||||
|
||||
/**
|
||||
* @brief Set Flash chip specifically required MSPI register settings here
|
||||
*/
|
||||
void spi_flash_set_vendor_required_regs(void);
|
||||
|
||||
/**
|
||||
* @brief Judge whether need to reset flash when brownout.
|
||||
* Set` flash_brownout_needs_reset` inside the function if really need reset.
|
||||
*/
|
||||
void spi_flash_needs_reset_check(void);
|
||||
|
||||
/**
|
||||
* @brief Set flag to reset flash. set when erase chip or program chip
|
||||
*
|
||||
* @param bool status. True if flash is eraing. False if flash is not erasing.
|
||||
*
|
||||
* @return None.
|
||||
*/
|
||||
void spi_flash_set_erasing_flag(bool status);
|
||||
|
||||
/**
|
||||
* @brief Judge whether need to reset flash when brownout.
|
||||
*
|
||||
* @return true if need reset, otherwise false.
|
||||
*/
|
||||
bool spi_flash_brownout_need_reset(void);
|
||||
|
||||
/**
|
||||
* @brief Check whether esp-chip supports 32bit address properly
|
||||
*
|
||||
* @return ESP_OK for supported, ESP_ERR_NOT_SUPPORTED for not supported
|
||||
*/
|
||||
esp_err_t esp_mspi_32bit_address_flash_feature_check(void);
|
||||
|
||||
#if CONFIG_SPI_FLASH_HPM_ON
|
||||
/**
|
||||
* @brief Enable SPI flash high performance mode.
|
||||
*
|
||||
* @note 1. When `CONFIG_SPI_FLASH_HPM_ON` is True, caller can always call this function without taking whether the used
|
||||
* frequency falls into the HPM range into consideration.
|
||||
* 2. However, caller shouldn't attempt to call this function on Octal flash. `CONFIG_SPI_FLASH_HPM_ON` may be
|
||||
* True when `CONFIG_ESPTOOLPY_FLASH_MODE_AUTO_DETECT && !CONFIG_ESPTOOLPY_OCT_FLASH`
|
||||
*
|
||||
* @return ESP_OK if success.
|
||||
*/
|
||||
esp_err_t spi_flash_enable_high_performance_mode(void);
|
||||
|
||||
/**
|
||||
* @brief Get the flash dummy through this function
|
||||
* This can be used when one flash has several dummy configurations to enable the high performance mode.
|
||||
* @note Don't forget to subtract one when assign to the register of mspi e.g. if the value you get is 4, (4-1=3) should be assigned to the register.
|
||||
*
|
||||
* @return Pointer to spi_flash_hpm_dummy_conf_t.
|
||||
*/
|
||||
const spi_flash_hpm_dummy_conf_t *spi_flash_hpm_get_dummy(void);
|
||||
|
||||
/**
|
||||
* @brief Used to judge whether flash works under HPM mode with dummy adjustment.
|
||||
*
|
||||
* @return true Yes, and work under HPM with adjusting dummy. Otherwise, false.
|
||||
*/
|
||||
bool spi_flash_hpm_dummy_adjust(void);
|
||||
#endif //CONFIG_SPI_FLASH_HPM_ON
|
||||
|
||||
#if CONFIG_ESP_SLEEP_SET_FLASH_DPD
|
||||
|
||||
/**
|
||||
* @brief Get the duration of entering deep power-down mode.
|
||||
*
|
||||
* @return Entering deep power-down mode time(tDp), in microseconds.
|
||||
*/
|
||||
uint32_t spi_flash_dpd_get_enter_duration(void);
|
||||
|
||||
/**
|
||||
* @brief Get the duration of exiting deep power-down mode.
|
||||
*
|
||||
* @return Exiting deep power-down mode time(tRES1), in microseconds.
|
||||
*/
|
||||
uint32_t spi_flash_dpd_get_exit_duration(void);
|
||||
|
||||
/**
|
||||
* @brief Enable or disable SPI flash deep power-down mode.
|
||||
*
|
||||
* @param enable True to enter deep power-down mode, false to exit.
|
||||
* @param wait_delay If true, wait tDP (enter) or tRES1 (exit) after the command.
|
||||
* If false, skip the delay; the caller must ensure timing is met elsewhere
|
||||
*
|
||||
* @note If using self-provided flash (not the chip’s factory-default flash), consult its datasheet to use this API safely.
|
||||
*
|
||||
* @return ESP_OK if success.
|
||||
*/
|
||||
esp_err_t spi_flash_enable_deep_power_down_mode(bool enable, bool wait_delay);
|
||||
#endif
|
||||
|
||||
#if SOC_SPI_MEM_SUPPORT_WRAP
|
||||
/**
|
||||
* @brief set wrap size of flash
|
||||
*
|
||||
* @param wrap_size: wrap mode support disable, 16 32, 64 byte
|
||||
*
|
||||
* @return esp_err_t : ESP_OK for successful.
|
||||
*
|
||||
*/
|
||||
esp_err_t spi_flash_wrap_enable(spi_flash_wrap_size_t wrap_size);
|
||||
|
||||
/**
|
||||
* @brief Probe flash wrap method
|
||||
*
|
||||
* @return esp_err_t: ESP_OK for success
|
||||
*/
|
||||
esp_err_t spi_flash_wrap_probe(void);
|
||||
|
||||
/**
|
||||
* @brief disable cache wrap
|
||||
*/
|
||||
esp_err_t spi_flash_wrap_disable(void);
|
||||
|
||||
/**
|
||||
* @brief Check whether flash and esp chip supports wrap mode.
|
||||
*
|
||||
* @param wrap_size wrap size.
|
||||
* @return true: wrap support, otherwise, false.
|
||||
*/
|
||||
bool spi_flash_support_wrap_size(uint32_t wrap_size);
|
||||
|
||||
#endif //SOC_SPI_MEM_SUPPORT_WRAP
|
||||
|
||||
/**
|
||||
* @brief SPI flash critical section enter function.
|
||||
*
|
||||
*/
|
||||
typedef void (*spi_flash_guard_start_func_t)(void);
|
||||
/**
|
||||
* @brief SPI flash critical section exit function.
|
||||
*/
|
||||
typedef void (*spi_flash_guard_end_func_t)(void);
|
||||
|
||||
/**
|
||||
* Structure holding SPI flash access critical sections management functions.
|
||||
*
|
||||
* Flash API uses two types of flash access management functions:
|
||||
* 1) Functions which prepare/restore flash cache and interrupts before calling
|
||||
* appropriate ROM functions (SPIWrite, SPIRead and SPIEraseBlock):
|
||||
* - 'start' function should disables flash cache and non-IRAM interrupts and
|
||||
* is invoked before the call to one of ROM function above.
|
||||
* - 'end' function should restore state of flash cache and non-IRAM interrupts and
|
||||
* is invoked after the call to one of ROM function above.
|
||||
* These two functions are not recursive.
|
||||
*
|
||||
* Different versions of the guarding functions should be used depending on the context of
|
||||
* execution (with or without functional OS). In normal conditions when flash API is called
|
||||
* from task the functions use OS primitives. When there is no OS at all or when
|
||||
* it is not guaranteed that OS is functional (accessing flash from exception handler) these
|
||||
* functions cannot use OS primitives or even does not need them (multithreaded access is not possible).
|
||||
*
|
||||
* @note Structure and corresponding guard functions should not reside in flash.
|
||||
* For example structure can be placed in DRAM and functions in IRAM sections.
|
||||
*/
|
||||
typedef struct {
|
||||
spi_flash_guard_start_func_t start; /**< critical section start function. */
|
||||
spi_flash_guard_end_func_t end; /**< critical section end function. */
|
||||
} spi_flash_guard_funcs_t;
|
||||
|
||||
|
||||
/**
|
||||
* @brief Sets guard functions to access flash.
|
||||
*
|
||||
* @note Pointed structure and corresponding guard functions should not reside in flash.
|
||||
* For example structure can be placed in DRAM and functions in IRAM sections.
|
||||
*
|
||||
* @param funcs pointer to structure holding flash access guard functions.
|
||||
*/
|
||||
void spi_flash_guard_set(const spi_flash_guard_funcs_t* funcs);
|
||||
|
||||
/**
|
||||
* @brief Get the guard functions used for flash access
|
||||
*
|
||||
* @return The guard functions that were set via spi_flash_guard_set(). These functions
|
||||
* can be called if implementing custom low-level SPI flash operations.
|
||||
*/
|
||||
const spi_flash_guard_funcs_t *spi_flash_guard_get(void);
|
||||
|
||||
/**
|
||||
* @brief Default OS-aware flash access guard functions
|
||||
*/
|
||||
extern const spi_flash_guard_funcs_t g_flash_guard_default_ops;
|
||||
|
||||
/**
|
||||
* @brief Non-OS flash access guard functions
|
||||
*
|
||||
* @note This version of flash guard functions is to be used when no OS is present or from panic handler.
|
||||
* It does not use any OS primitives and IPC and implies that only calling CPU is active.
|
||||
*/
|
||||
extern const spi_flash_guard_funcs_t g_flash_guard_no_os_ops;
|
||||
|
||||
/**
|
||||
* @brief This function is used to re-initialize the flash mmap when using ROM flash
|
||||
* implementations.
|
||||
*
|
||||
* @note Only called in startup. User should not call this function.
|
||||
*/
|
||||
void spi_flash_rom_impl_init(void);
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -21,14 +21,12 @@
|
||||
#include "esp_attr.h"
|
||||
#include "sdkconfig.h"
|
||||
#include "esp_spi_flash_counters.h"
|
||||
#include "hal/esp_flash_err.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define ESP_ERR_FLASH_OP_FAIL (ESP_ERR_FLASH_BASE + 1)
|
||||
#define ESP_ERR_FLASH_OP_TIMEOUT (ESP_ERR_FLASH_BASE + 2)
|
||||
|
||||
#define SPI_FLASH_SEC_SIZE 4096 /**< SPI Flash sector size */
|
||||
|
||||
#define SPI_FLASH_MMU_PAGE_SIZE CONFIG_MMU_PAGE_SIZE /**< Flash cache MMU mapping page size */
|
||||
@@ -166,7 +164,6 @@ void spi_flash_mmap_dump(void);
|
||||
*/
|
||||
uint32_t spi_flash_mmap_get_free_pages(spi_flash_mmap_memory_t memory);
|
||||
|
||||
|
||||
#define SPI_FLASH_CACHE2PHYS_FAIL UINT32_MAX /*<! Result from spi_flash_cache2phys() if flash cache address is invalid */
|
||||
|
||||
/**
|
||||
|
||||
Reference in New Issue
Block a user