diff --git a/.gitlab/ci/target-test.yml b/.gitlab/ci/target-test.yml index 18b6c9fe66..b709e9a220 100644 --- a/.gitlab/ci/target-test.yml +++ b/.gitlab/ci/target-test.yml @@ -945,7 +945,7 @@ UT_C3_SDSPI: UT_S3: extends: .unit_test_esp32s3_template - parallel: 28 + parallel: 29 tags: - ESP32S3_IDF - UT_T1_1 diff --git a/components/app_update/esp_ota_ops.c b/components/app_update/esp_ota_ops.c index c81dff19f8..0a70c9837a 100644 --- a/components/app_update/esp_ota_ops.c +++ b/components/app_update/esp_ota_ops.c @@ -14,11 +14,10 @@ #include "esp_err.h" #include "esp_partition.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_image_format.h" #include "esp_secure_boot.h" #include "esp_flash_encrypt.h" -#include "esp_spi_flash.h" #include "sdkconfig.h" #include "esp_ota_ops.h" diff --git a/components/bootloader_support/bootloader_flash/include/bootloader_flash.h b/components/bootloader_support/bootloader_flash/include/bootloader_flash.h index 7c48728cf0..ade6ef01f6 100644 --- a/components/bootloader_support/bootloader_flash/include/bootloader_flash.h +++ b/components/bootloader_support/bootloader_flash/include/bootloader_flash.h @@ -7,7 +7,8 @@ #include #include -#include /* including in bootloader for error values */ +#include "spi_flash_mmap.h" /* including in bootloader for error values */ +#include "esp_private/spi_flash_os.h" #include "sdkconfig.h" #include "soc/soc_caps.h" #include "bootloader_flash_override.h" diff --git a/components/bootloader_support/bootloader_flash/include/bootloader_flash_priv.h b/components/bootloader_support/bootloader_flash/include/bootloader_flash_priv.h index 82d133b1ce..ab8f3695b5 100644 --- a/components/bootloader_support/bootloader_flash/include/bootloader_flash_priv.h +++ b/components/bootloader_support/bootloader_flash/include/bootloader_flash_priv.h @@ -10,7 +10,7 @@ #include #include #include -#include /* including in bootloader for error values */ +#include /* including in bootloader for error values */ #include "sdkconfig.h" #include "bootloader_flash.h" diff --git a/components/bootloader_support/bootloader_flash/src/bootloader_flash.c b/components/bootloader_support/bootloader_flash/src/bootloader_flash.c index d4de1858d8..1599729275 100644 --- a/components/bootloader_support/bootloader_flash/src/bootloader_flash.c +++ b/components/bootloader_support/bootloader_flash/src/bootloader_flash.c @@ -23,6 +23,9 @@ # define SPIFLASH SPIMEM1 #endif +// This dependency will be removed in the future. IDF-5025 +#include "esp_flash.h" + #include "esp_rom_spiflash.h" #ifdef CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH @@ -43,7 +46,7 @@ #define ESP_BOOTLOADER_SPIFLASH_QE_SR1_2BYTE BIT9 // QE position when you write 16 bits at one time. #ifndef BOOTLOADER_BUILD -/* Normal app version maps to esp_spi_flash.h operations... +/* Normal app version maps to spi_flash_mmap.h operations... */ static const char *TAG = "bootloader_mmap"; @@ -82,33 +85,31 @@ void bootloader_munmap(const void *mapping) esp_err_t bootloader_flash_read(size_t src, void *dest, size_t size, bool allow_decrypt) { if (allow_decrypt && esp_flash_encryption_enabled()) { - return spi_flash_read_encrypted(src, dest, size); + return esp_flash_read_encrypted(NULL, src, dest, size); } else { - return spi_flash_read(src, dest, size); + return esp_flash_read(NULL, dest, src, size); } } esp_err_t bootloader_flash_write(size_t dest_addr, void *src, size_t size, bool write_encrypted) { if (write_encrypted && !ENCRYPTION_IS_VIRTUAL) { -#if CONFIG_IDF_TARGET_ESP32 - return spi_flash_write_encrypted(dest_addr, src, size); -#else - return esp_rom_spiflash_write_encrypted(dest_addr, src, size); -#endif + return esp_flash_write_encrypted(NULL, dest_addr, src, size); } else { - return spi_flash_write(dest_addr, src, size); + return esp_flash_write(NULL, src, dest_addr, size); } } esp_err_t bootloader_flash_erase_sector(size_t sector) { - return spi_flash_erase_sector(sector); + // Will de-dependency IDF-5025 + return esp_flash_erase_region(NULL, sector * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE); } esp_err_t bootloader_flash_erase_range(uint32_t start_addr, uint32_t size) { - return spi_flash_erase_range(start_addr, size); + // Will de-dependency IDF-5025 + return esp_flash_erase_region(NULL, start_addr, size); } #else //BOOTLOADER_BUILD diff --git a/components/bootloader_support/include/esp_flash_encrypt.h b/components/bootloader_support/include/esp_flash_encrypt.h index cc1b33fbd6..35129c8b97 100644 --- a/components/bootloader_support/include/esp_flash_encrypt.h +++ b/components/bootloader_support/include/esp_flash_encrypt.h @@ -9,7 +9,7 @@ #include "esp_attr.h" #include "esp_err.h" #ifndef BOOTLOADER_BUILD -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #endif #include "hal/efuse_ll.h" #include "sdkconfig.h" diff --git a/components/bootloader_support/src/esp_image_format.c b/components/bootloader_support/src/esp_image_format.c index c404cdb550..bf79deb857 100644 --- a/components/bootloader_support/src/esp_image_format.c +++ b/components/bootloader_support/src/esp_image_format.c @@ -11,7 +11,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/components/bootloader_support/src/secure_boot_v1/secure_boot_signatures_bootloader.c b/components/bootloader_support/src/secure_boot_v1/secure_boot_signatures_bootloader.c index ae197dc613..f1c43f8b3b 100644 --- a/components/bootloader_support/src/secure_boot_v1/secure_boot_signatures_bootloader.c +++ b/components/bootloader_support/src/secure_boot_v1/secure_boot_signatures_bootloader.c @@ -11,7 +11,7 @@ #include "esp_log.h" #include "esp_image_format.h" #include "esp_secure_boot.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_fault.h" #include "esp32/rom/sha.h" #include "uECC_verify_antifault.h" diff --git a/components/driver/test/test_spi_master.c b/components/driver/test/test_spi_master.c index 734cb029d3..fd60d8c701 100644 --- a/components/driver/test/test_spi_master.c +++ b/components/driver/test/test_spi_master.c @@ -26,7 +26,7 @@ #include "test/test_common_spi.h" #include "soc/gpio_periph.h" #include "sdkconfig.h" -#include "../cache_utils.h" +#include "esp_private/cache_utils.h" #include "soc/soc_memory_layout.h" #include "esp_private/spi_common_internal.h" #include "esp_private/esp_clk.h" diff --git a/components/driver/test_apps/gpio/main/test_gpio.c b/components/driver/test_apps/gpio/main/test_gpio.c index d961bb930c..e3df964839 100644 --- a/components/driver/test_apps/gpio/main/test_gpio.c +++ b/components/driver/test_apps/gpio/main/test_gpio.c @@ -29,8 +29,9 @@ #include "sdkconfig.h" #include "esp_rom_uart.h" #include "esp_rom_sys.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_attr.h" +#include "esp_private/spi_flash_os.h" // Enable internal routing for the output and input gpio pins #define TEST_GPIO_INTERNAL_ROUTING 1 diff --git a/components/driver/test_apps/gptimer/main/test_gptimer_iram.c b/components/driver/test_apps/gptimer/main/test_gptimer_iram.c index aeef024aff..fcf3cce7d1 100644 --- a/components/driver/test_apps/gptimer/main/test_gptimer_iram.c +++ b/components/driver/test_apps/gptimer/main/test_gptimer_iram.c @@ -11,7 +11,8 @@ #include "freertos/semphr.h" #include "unity.h" #include "driver/gptimer.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" +#include "esp_flash.h" #include "soc/soc_caps.h" #if CONFIG_GPTIMER_ISR_IRAM_SAFE @@ -41,7 +42,7 @@ static void flash_read_task(void *varg) { read_task_arg_t *arg = (read_task_arg_t *)varg; for (size_t i = 0; i < arg->repeat_count; i++) { - TEST_ESP_OK(spi_flash_read(arg->flash_addr, arg->buf, arg->buf_size)); + TEST_ESP_OK(esp_flash_read(NULL, arg->buf, arg->flash_addr, arg->buf_size)); } xSemaphoreGive(arg->done_sem); vTaskDelete(NULL); diff --git a/components/driver/test_apps/i2s_test_apps/i2s/main/test_i2s_iram.c b/components/driver/test_apps/i2s_test_apps/i2s/main/test_i2s_iram.c index f53912461e..bda7d40e12 100644 --- a/components/driver/test_apps/i2s_test_apps/i2s/main/test_i2s_iram.c +++ b/components/driver/test_apps/i2s_test_apps/i2s/main/test_i2s_iram.c @@ -11,10 +11,10 @@ #include "freertos/semphr.h" #include "unity.h" #include "driver/i2s_std.h" -#include "esp_spi_flash.h" #include "esp_attr.h" #include "soc/soc_caps.h" #include "esp_private/i2s_platform.h" +#include "esp_private/spi_flash_os.h" #include "test_inc/test_i2s.h" #if CONFIG_I2S_ISR_IRAM_SAFE diff --git a/components/driver/test_apps/pulse_cnt/main/test_pulse_cnt_iram.c b/components/driver/test_apps/pulse_cnt/main/test_pulse_cnt_iram.c index 00f35f8024..98710b13a8 100644 --- a/components/driver/test_apps/pulse_cnt/main/test_pulse_cnt_iram.c +++ b/components/driver/test_apps/pulse_cnt/main/test_pulse_cnt_iram.c @@ -12,9 +12,10 @@ #include "unity.h" #include "driver/pulse_cnt.h" #include "driver/gpio.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_attr.h" #include "soc/soc_caps.h" +#include "esp_private/spi_flash_os.h" #include "test_pulse_cnt_board.h" #if CONFIG_PCNT_ISR_IRAM_SAFE diff --git a/components/esp_common/src/esp_err_to_name.c b/components/esp_common/src/esp_err_to_name.c index eb3e810e16..19c1ec5823 100644 --- a/components/esp_common/src/esp_err_to_name.c +++ b/components/esp_common/src/esp_err_to_name.c @@ -47,9 +47,6 @@ #if __has_include("esp_ping.h") #include "esp_ping.h" #endif -#if __has_include("esp_spi_flash.h") -#include "esp_spi_flash.h" -#endif #if __has_include("esp_tls_errors.h") #include "esp_tls_errors.h" #endif @@ -71,6 +68,9 @@ #if __has_include("soc/esp32s2/esp_ds.h") #include "soc/esp32s2/esp_ds.h" #endif +#if __has_include("spi_flash_mmap.h") +#include "spi_flash_mmap.h" +#endif #if __has_include("ulp_fsm_common.h") #include "ulp_fsm_common.h" #endif @@ -565,7 +565,7 @@ static const esp_err_msg_t esp_err_msg_table[] = { # ifdef ESP_ERR_FLASH_BASE ERR_TBL_IT(ESP_ERR_FLASH_BASE), /* 24576 0x6000 Starting number of flash error codes */ # endif - // components/spi_flash/include/esp_spi_flash.h + // components/spi_flash/include/spi_flash_mmap.h # ifdef ESP_ERR_FLASH_OP_FAIL ERR_TBL_IT(ESP_ERR_FLASH_OP_FAIL), /* 24577 0x6001 */ # endif diff --git a/components/esp_hw_support/port/esp32/cache_sram_mmu.c b/components/esp_hw_support/port/esp32/cache_sram_mmu.c index b6d91cb453..f784a11f79 100644 --- a/components/esp_hw_support/port/esp32/cache_sram_mmu.c +++ b/components/esp_hw_support/port/esp32/cache_sram_mmu.c @@ -9,7 +9,9 @@ #include "soc/dport_reg.h" #include "esp_attr.h" #include "string.h" -#include "esp_spi_flash.h" +#include "esp_private/spi_flash_os.h" +#include "esp_private/cache_utils.h" +#include "spi_flash_mmap.h" //Errors that can be returned #define MMU_SET_ADDR_ALIGNED_ERROR 1 diff --git a/components/esp_hw_support/test/test_spiram_cache_flush.c b/components/esp_hw_support/test/test_spiram_cache_flush.c index 4820cd7f14..0c2db7dbef 100644 --- a/components/esp_hw_support/test/test_spiram_cache_flush.c +++ b/components/esp_hw_support/test/test_spiram_cache_flush.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -19,7 +19,7 @@ This code tests the interaction between PSRAM and SPI flash routines. #include #include #include "esp_heap_caps.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_partition.h" #include "test_utils.h" #include "soc/soc.h" diff --git a/components/esp_lcd/test_apps/rgb_lcd/main/test_rgb_panel.c b/components/esp_lcd/test_apps/rgb_lcd/main/test_rgb_panel.c index b8b3a42056..06e4c02310 100644 --- a/components/esp_lcd/test_apps/rgb_lcd/main/test_rgb_panel.c +++ b/components/esp_lcd/test_apps/rgb_lcd/main/test_rgb_panel.c @@ -12,8 +12,9 @@ #include "esp_lcd_panel_ops.h" #include "esp_random.h" #include "esp_attr.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "test_rgb_board.h" +#include "esp_private/spi_flash_os.h" #if CONFIG_LCD_RGB_ISR_IRAM_SAFE #define TEST_LCD_CALLBACK_ATTR IRAM_ATTR diff --git a/components/esp_ringbuf/test/test_ringbuf.c b/components/esp_ringbuf/test/test_ringbuf.c index c66de51a54..4222ab2895 100644 --- a/components/esp_ringbuf/test/test_ringbuf.c +++ b/components/esp_ringbuf/test/test_ringbuf.c @@ -12,8 +12,9 @@ #include "freertos/semphr.h" #include "freertos/ringbuf.h" #include "driver/gptimer.h" +#include "esp_private/spi_flash_os.h" #include "esp_heap_caps.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "unity.h" #include "test_utils.h" #include "esp_rom_sys.h" diff --git a/components/esp_rom/esp32c2/ld/esp32c2.rom.api.ld b/components/esp_rom/esp32c2/ld/esp32c2.rom.api.ld index 73eb9147ff..8bf453a4d6 100644 --- a/components/esp_rom/esp32c2/ld/esp32c2.rom.api.ld +++ b/components/esp_rom/esp32c2/ld/esp32c2.rom.api.ld @@ -43,6 +43,7 @@ PROVIDE ( esp_rom_get_cpu_ticks_per_us = ets_get_cpu_frequency ); PROVIDE( esp_rom_spiflash_attach = spi_flash_attach ); PROVIDE ( esp_rom_spiflash_clear_bp = esp_rom_spiflash_unlock ); PROVIDE ( esp_rom_spiflash_write_enable = SPI_write_enable); +PROVIDE ( esp_rom_spiflash_erase_area = SPIEraseArea ); PROVIDE ( esp_rom_regi2c_read = rom_i2c_readReg ); PROVIDE ( esp_rom_regi2c_read_mask = rom_i2c_readReg_Mask ); diff --git a/components/esp_rom/esp32c3/ld/esp32c3.rom.api.ld b/components/esp_rom/esp32c3/ld/esp32c3.rom.api.ld index 7cb122d1c0..262451eb28 100644 --- a/components/esp_rom/esp32c3/ld/esp32c3.rom.api.ld +++ b/components/esp_rom/esp32c3/ld/esp32c3.rom.api.ld @@ -45,6 +45,7 @@ PROVIDE ( esp_rom_get_cpu_ticks_per_us = ets_get_cpu_frequency ); PROVIDE ( esp_rom_spiflash_clear_bp = esp_rom_spiflash_unlock ); PROVIDE ( esp_rom_spiflash_write_enable = SPI_write_enable ); +PROVIDE ( esp_rom_spiflash_erase_area = SPIEraseArea ); PROVIDE ( esp_rom_regi2c_read = rom_i2c_readReg ); PROVIDE ( esp_rom_regi2c_read_mask = rom_i2c_readReg_Mask ); diff --git a/components/esp_rom/esp32h2/ld/rev1/esp32h2.rom.api.ld b/components/esp_rom/esp32h2/ld/rev1/esp32h2.rom.api.ld index 4648d22f75..b5ea467270 100644 --- a/components/esp_rom/esp32h2/ld/rev1/esp32h2.rom.api.ld +++ b/components/esp_rom/esp32h2/ld/rev1/esp32h2.rom.api.ld @@ -48,6 +48,7 @@ PROVIDE ( esp_rom_get_cpu_ticks_per_us = ets_get_cpu_frequency ); PROVIDE ( esp_rom_spiflash_clear_bp = esp_rom_spiflash_unlock ); PROVIDE ( esp_rom_spiflash_write_enable = SPI_write_enable); +PROVIDE ( esp_rom_spiflash_erase_area = SPIEraseArea ); PROVIDE ( esp_rom_regi2c_read = rom_i2c_readReg ); PROVIDE ( esp_rom_regi2c_read_mask = rom_i2c_readReg_Mask ); diff --git a/components/esp_rom/esp32h2/ld/rev2/esp32h2.rom.api.ld b/components/esp_rom/esp32h2/ld/rev2/esp32h2.rom.api.ld index 4648d22f75..b5ea467270 100644 --- a/components/esp_rom/esp32h2/ld/rev2/esp32h2.rom.api.ld +++ b/components/esp_rom/esp32h2/ld/rev2/esp32h2.rom.api.ld @@ -48,6 +48,7 @@ PROVIDE ( esp_rom_get_cpu_ticks_per_us = ets_get_cpu_frequency ); PROVIDE ( esp_rom_spiflash_clear_bp = esp_rom_spiflash_unlock ); PROVIDE ( esp_rom_spiflash_write_enable = SPI_write_enable); +PROVIDE ( esp_rom_spiflash_erase_area = SPIEraseArea ); PROVIDE ( esp_rom_regi2c_read = rom_i2c_readReg ); PROVIDE ( esp_rom_regi2c_read_mask = rom_i2c_readReg_Mask ); diff --git a/components/esp_rom/esp32s2/ld/esp32s2.rom.spiflash.ld b/components/esp_rom/esp32s2/ld/esp32s2.rom.spiflash.ld index 197f7dcdca..4ff8dd8193 100644 --- a/components/esp_rom/esp32s2/ld/esp32s2.rom.spiflash.ld +++ b/components/esp_rom/esp32s2/ld/esp32s2.rom.spiflash.ld @@ -23,3 +23,4 @@ PROVIDE ( esp_rom_spiflash_wait_idle = SPI_Wait_Idle ); PROVIDE ( esp_rom_spiflash_config_readmode = SPIReadModeCnfig ); PROVIDE ( esp_rom_spiflash_erase_block = SPIEraseBlock ); PROVIDE ( esp_rom_spiflash_write_encrypted = SPI_Encrypt_Write ); +PROVIDE ( esp_rom_spiflash_erase_area = SPIEraseArea ); diff --git a/components/esp_rom/esp32s3/ld/esp32s3.rom.api.ld b/components/esp_rom/esp32s3/ld/esp32s3.rom.api.ld index 0ea0b477ef..0b27866678 100644 --- a/components/esp_rom/esp32s3/ld/esp32s3.rom.api.ld +++ b/components/esp_rom/esp32s3/ld/esp32s3.rom.api.ld @@ -49,6 +49,7 @@ PROVIDE ( esp_rom_get_cpu_ticks_per_us = ets_get_cpu_frequency ); PROVIDE( esp_rom_spiflash_attach = spi_flash_attach ); PROVIDE ( esp_rom_spiflash_clear_bp = esp_rom_spiflash_unlock ); PROVIDE ( esp_rom_spiflash_write_enable = SPI_write_enable); +PROVIDE ( esp_rom_spiflash_erase_area = SPIEraseArea ); PROVIDE ( esp_rom_regi2c_read = rom_i2c_readReg ); PROVIDE ( esp_rom_regi2c_read_mask = rom_i2c_readReg_Mask ); diff --git a/components/esp_system/esp_err.c b/components/esp_system/esp_err.c index 9df59f9290..2dcc3a5629 100644 --- a/components/esp_system/esp_err.c +++ b/components/esp_system/esp_err.c @@ -1,22 +1,15 @@ -// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at - -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +/* + * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ #include #include #include #include "esp_err.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" +#include "esp_private/cache_utils.h" #include "esp_rom_sys.h" diff --git a/components/esp_system/port/arch/riscv/panic_arch.c b/components/esp_system/port/arch/riscv/panic_arch.c index edaac9115f..69b99aa7d4 100644 --- a/components/esp_system/port/arch/riscv/panic_arch.c +++ b/components/esp_system/port/arch/riscv/panic_arch.c @@ -6,7 +6,7 @@ #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "soc/extmem_reg.h" #include "esp_private/panic_internal.h" diff --git a/components/esp_system/port/cpu_start.c b/components/esp_system/port/cpu_start.c index 80d98d8804..1e660d5427 100644 --- a/components/esp_system/port/cpu_start.c +++ b/components/esp_system/port/cpu_start.c @@ -72,7 +72,7 @@ #include "soc/periph_defs.h" #include "esp_cpu.h" #include "esp_private/esp_clk.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #if CONFIG_ESP32_TRAX || CONFIG_ESP32S2_TRAX || CONFIG_ESP32S3_TRAX #include "esp_private/trax.h" diff --git a/components/esp_system/port/panic_handler.c b/components/esp_system/port/panic_handler.c index 2570190d2f..0fe568f528 100644 --- a/components/esp_system/port/panic_handler.c +++ b/components/esp_system/port/panic_handler.c @@ -6,9 +6,10 @@ #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_ipc_isr.h" #include "esp_private/system_internal.h" +#include "esp_private/cache_utils.h" #include "soc/soc_memory_layout.h" #include "esp_cpu.h" diff --git a/components/esp_system/startup.c b/components/esp_system/startup.c index 5c46dee56f..e1c00d8fcd 100644 --- a/components/esp_system/startup.c +++ b/components/esp_system/startup.c @@ -23,7 +23,7 @@ #include "esp_system.h" #include "esp_log.h" #include "esp_heap_caps_init.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_flash_internal.h" #include "esp_newlib.h" #include "esp_timer.h" @@ -289,9 +289,9 @@ static void do_core_init(void) err = esp_pthread_init(); assert(err == ESP_OK && "Failed to init pthread module!"); - spi_flash_init(); - /* init default OS-aware flash access critical section */ - spi_flash_guard_set(&g_flash_guard_default_ops); +#if CONFIG_SPI_FLASH_ROM_IMPL + spi_flash_rom_impl_init(); +#endif esp_flash_app_init(); esp_err_t flash_ret = esp_flash_init_default_chip(); diff --git a/components/esp_timer/test/test_ets_timer.c b/components/esp_timer/test/test_ets_timer.c index 43e7a54d6a..a2e495a3fe 100644 --- a/components/esp_timer/test/test_ets_timer.c +++ b/components/esp_timer/test/test_ets_timer.c @@ -6,8 +6,9 @@ #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "freertos/semphr.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_rom_sys.h" +#include "esp_private/spi_flash_os.h" #if CONFIG_IDF_TARGET_ESP32 #include "esp32/rom/ets_sys.h" // for ETSTimer type #elif CONFIG_IDF_TARGET_ESP32S2 diff --git a/components/espcoredump/src/core_dump_elf.c b/components/espcoredump/src/core_dump_elf.c index a1986d687b..2cd0b53f30 100644 --- a/components/espcoredump/src/core_dump_elf.c +++ b/components/espcoredump/src/core_dump_elf.c @@ -7,7 +7,7 @@ #include "esp_attr.h" #include "esp_partition.h" #include "esp_ota_ops.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_flash_encrypt.h" #include "sdkconfig.h" #include "core_dump_checksum.h" diff --git a/components/espcoredump/src/core_dump_flash.c b/components/espcoredump/src/core_dump_flash.c index 18935e975f..7223d6e260 100644 --- a/components/espcoredump/src/core_dump_flash.c +++ b/components/espcoredump/src/core_dump_flash.c @@ -11,6 +11,7 @@ #include "esp_flash_internal.h" #include "esp_flash_encrypt.h" #include "esp_rom_crc.h" +#include "esp_private/spi_flash_os.h" #define BLANK_COREDUMP_SIZE 0xFFFFFFFF @@ -41,15 +42,9 @@ typedef struct _core_dump_flash_config_t /* Core dump flash data. */ static core_dump_flash_config_t s_core_flash_config; -#ifdef CONFIG_SPI_FLASH_USE_LEGACY_IMPL -#define ESP_COREDUMP_FLASH_WRITE(_off_, _data_, _len_) spi_flash_write(_off_, _data_, _len_) -#define ESP_COREDUMP_FLASH_WRITE_ENCRYPTED(_off_, _data_, _len_) spi_flash_write_encrypted(_off_, _data_, _len_) -#define ESP_COREDUMP_FLASH_ERASE(_off_, _len_) spi_flash_erase_range(_off_, _len_) -#else #define ESP_COREDUMP_FLASH_WRITE(_off_, _data_, _len_) esp_flash_write(esp_flash_default_chip, _data_, _off_, _len_) #define ESP_COREDUMP_FLASH_WRITE_ENCRYPTED(_off_, _data_, _len_) esp_flash_write_encrypted(esp_flash_default_chip, _off_, _data_, _len_) #define ESP_COREDUMP_FLASH_ERASE(_off_, _len_) esp_flash_erase_region(esp_flash_default_chip, _off_, _len_) -#endif esp_err_t esp_core_dump_image_check(void); static esp_err_t esp_core_dump_partition_and_size_get(const esp_partition_t **partition, uint32_t* size); diff --git a/components/fatfs/test_fatfs_host/sdkconfig/sdkconfig.h b/components/fatfs/test_fatfs_host/sdkconfig/sdkconfig.h index c3a1c768ac..50bce69332 100644 --- a/components/fatfs/test_fatfs_host/sdkconfig/sdkconfig.h +++ b/components/fatfs/test_fatfs_host/sdkconfig/sdkconfig.h @@ -9,8 +9,6 @@ #define CONFIG_PARTITION_TABLE_OFFSET 0x8000 #define CONFIG_ESPTOOLPY_FLASHSIZE "8MB" -//currently use the legacy implementation, since the stubs for new HAL are not done yet -#define CONFIG_SPI_FLASH_USE_LEGACY_IMPL 1 #define CONFIG_FATFS_VOLUME_COUNT 2 #define CONFIG_MMU_PAGE_SIZE 0X10000 // 64KB diff --git a/components/heap/test/test_aligned_alloc_caps.c b/components/heap/test/test_aligned_alloc_caps.c index 585061483a..60b8866f12 100644 --- a/components/heap/test/test_aligned_alloc_caps.c +++ b/components/heap/test/test_aligned_alloc_caps.c @@ -7,7 +7,7 @@ #include "unity.h" #include "esp_attr.h" #include "esp_heap_caps.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include #include #include diff --git a/components/heap/test/test_malloc_caps.c b/components/heap/test/test_malloc_caps.c index d4104fdf3a..0010327441 100644 --- a/components/heap/test/test_malloc_caps.c +++ b/components/heap/test/test_malloc_caps.c @@ -7,8 +7,9 @@ #include "unity.h" #include "esp_attr.h" #include "esp_heap_caps.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_memory_utils.h" +#include "esp_private/spi_flash_os.h" #include #include diff --git a/components/newlib/assert.c b/components/newlib/assert.c index 141cb3b39b..bb8449339a 100644 --- a/components/newlib/assert.c +++ b/components/newlib/assert.c @@ -7,8 +7,9 @@ #include #include #include "esp_system.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "soc/soc_memory_layout.h" +#include "esp_private/cache_utils.h" #define ASSERT_STR "assert failed: " #define CACHE_DISABLED_STR "" diff --git a/components/newlib/test/test_atomic.c b/components/newlib/test/test_atomic.c index acfec677aa..06f06c59a2 100644 --- a/components/newlib/test/test_atomic.c +++ b/components/newlib/test/test_atomic.c @@ -8,7 +8,7 @@ #include "esp_log.h" #include "esp_attr.h" #include "hal/cpu_hal.h" -#include "../cache_utils.h" +#include "esp_private/cache_utils.h" #define RECORD_TIME_PREPARE() uint32_t __t1, __t2 #define RECORD_TIME_START() do {__t1 = cpu_hal_get_cycle_count();}while(0) diff --git a/components/nvs_flash/src/nvs_page.hpp b/components/nvs_flash/src/nvs_page.hpp index c26499448f..1eed884d03 100644 --- a/components/nvs_flash/src/nvs_page.hpp +++ b/components/nvs_flash/src/nvs_page.hpp @@ -12,7 +12,7 @@ #include #include #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "compressed_enum_table.hpp" #include "intrusive_list.h" #include "nvs_item_hash_list.hpp" diff --git a/components/nvs_flash/test_nvs_host/sdkconfig.h b/components/nvs_flash/test_nvs_host/sdkconfig.h index 94c05d3209..0ecb2c18bb 100644 --- a/components/nvs_flash/test_nvs_host/sdkconfig.h +++ b/components/nvs_flash/test_nvs_host/sdkconfig.h @@ -1,6 +1,4 @@ #define CONFIG_NVS_ENCRYPTION 1 -//currently use the legacy implementation, since the stubs for new HAL are not done yet -#define CONFIG_SPI_FLASH_USE_LEGACY_IMPL 1 #define CONFIG_LOG_MAXIMUM_LEVEL 3 #define CONFIG_LOG_TIMESTAMP_SOURCE_RTOS 1 #define CONFIG_IDF_TARGET_LINUX 1 diff --git a/components/nvs_flash/test_nvs_host/spi_flash_emulation.h b/components/nvs_flash/test_nvs_host/spi_flash_emulation.h index f2aef6a011..f410434a5f 100644 --- a/components/nvs_flash/test_nvs_host/spi_flash_emulation.h +++ b/components/nvs_flash/test_nvs_host/spi_flash_emulation.h @@ -1,16 +1,8 @@ -// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at - -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +/* + * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ #ifndef spi_flash_emulation_h #define spi_flash_emulation_h @@ -18,7 +10,7 @@ #include #include #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "catch.hpp" using std::copy; diff --git a/components/spi_flash/CMakeLists.txt b/components/spi_flash/CMakeLists.txt index 515d09137e..480149f958 100644 --- a/components/spi_flash/CMakeLists.txt +++ b/components/spi_flash/CMakeLists.txt @@ -22,6 +22,7 @@ else() "flash_ops.c" "${target}/flash_ops_${target}.c" ) + set(srcs "partition.c" "partition_target.c" diff --git a/components/spi_flash/Kconfig b/components/spi_flash/Kconfig index 6bb4716299..4f7145ccbb 100644 --- a/components/spi_flash/Kconfig +++ b/components/spi_flash/Kconfig @@ -100,19 +100,10 @@ menu "SPI Flash driver" bool "Allowed" endchoice - config SPI_FLASH_USE_LEGACY_IMPL - bool "Use the legacy implementation before IDF v4.0" - default n - help - The implementation of SPI flash has been greatly changed in IDF v4.0. - Enable this option to use the legacy implementation. - config SPI_FLASH_SHARE_SPI1_BUS bool "Support other devices attached to SPI1 bus" default n - # The bus lock on SPI1 is meaningless when the legacy implementation is used, or the SPI - # driver does not support SPI1. - depends on !SPI_FLASH_USE_LEGACY_IMPL && !IDF_TARGET_ESP32S2 + depends on !IDF_TARGET_ESP32S2 help Each SPI bus needs a lock for arbitration among devices. This allows multiple devices on a same bus, but may reduce the speed of esp_flash driver access to the @@ -160,7 +151,7 @@ menu "SPI Flash driver" config SPI_FLASH_AUTO_SUSPEND bool "Auto suspend long erase/write operations (READ DOCS FIRST)" default n - depends on IDF_TARGET_ESP32C3 && !SPI_FLASH_USE_LEGACY_IMPL && !SPI_FLASH_ROM_IMPL + depends on IDF_TARGET_ESP32C3 && !SPI_FLASH_ROM_IMPL help This option is default n before ESP32-C3, because it needs bootloader support. @@ -191,14 +182,12 @@ menu "SPI Flash driver" config SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED bool "Flash timeout checkout disabled" - depends on !SPI_FLASH_USE_LEGACY_IMPL default n help This option is helpful if you are using a flash chip whose timeout is quite large or unpredictable. config SPI_FLASH_OVERRIDE_CHIP_DRIVER_LIST bool "Override default chip driver list" - depends on !SPI_FLASH_USE_LEGACY_IMPL default n help This option allows the chip driver list to be customized, instead of using the default list provided by diff --git a/components/spi_flash/cache_utils.c b/components/spi_flash/cache_utils.c index b28a26344c..e910979bc3 100644 --- a/components/spi_flash/cache_utils.c +++ b/components/spi_flash/cache_utils.c @@ -44,7 +44,7 @@ #endif #include "esp_attr.h" #include "esp_intr_alloc.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_log.h" #include "esp_cpu.h" diff --git a/components/spi_flash/cache_utils.h b/components/spi_flash/cache_utils.h deleted file mode 100644 index a2835ac7d2..0000000000 --- a/components/spi_flash/cache_utils.h +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef ESP_SPI_FLASH_CACHE_UTILS_H -#define ESP_SPI_FLASH_CACHE_UTILS_H - -#include "sdkconfig.h" -#include - -/** - * 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); -//enable cache wrap mode for instruction cache and data cache -esp_err_t esp_enable_cache_wrap(bool icache_wrap_enable, bool dcache_wrap_enable); -#endif - - -#endif //ESP_SPI_FLASH_CACHE_UTILS_H diff --git a/components/spi_flash/esp32/flash_ops_esp32.c b/components/spi_flash/esp32/flash_ops_esp32.c index e9ede64ded..b2251506a4 100644 --- a/components/spi_flash/esp32/flash_ops_esp32.c +++ b/components/spi_flash/esp32/flash_ops_esp32.c @@ -3,77 +3,3 @@ * * SPDX-License-Identifier: Apache-2.0 */ -#include -#include "esp_spi_flash.h" -#include "esp32/rom/cache.h" -#include "esp_rom_spiflash.h" - -static inline void IRAM_ATTR spi_flash_guard_start(void) -{ - const spi_flash_guard_funcs_t *ops = spi_flash_guard_get(); - if (ops && ops->start) { - ops->start(); - } -} - -static inline void IRAM_ATTR spi_flash_guard_end(void) -{ - const spi_flash_guard_funcs_t *ops = spi_flash_guard_get(); - if (ops && ops->end) { - ops->end(); - } -} - -extern void IRAM_ATTR flash_rom_init(void); -esp_rom_spiflash_result_t IRAM_ATTR spi_flash_write_encrypted_chip(size_t dest_addr, const void *src, size_t size) -{ - const uint8_t *ssrc = (const uint8_t *)src; - esp_rom_spiflash_result_t rc = ESP_ROM_SPIFLASH_RESULT_OK; - - assert((dest_addr % 16) == 0); - assert((size % 16) == 0); - - /* esp_rom_spiflash_write_encrypted encrypts data in RAM as it writes, - so copy to a temporary buffer - 32 bytes at a time. - - Each call to esp_rom_spiflash_write_encrypted takes a 32 byte "row" of - data to encrypt, and each row is two 16 byte AES blocks - that share a key (as derived from flash address). - */ - uint8_t encrypt_buf[32] __attribute__((aligned(4))); - uint32_t row_size; - for (size_t i = 0; i < size; i += row_size) { - uint32_t row_addr = dest_addr + i; - if (i == 0 && (row_addr % 32) != 0) { - /* writing to second block of a 32 byte row */ - row_size = 16; - row_addr -= 16; - /* copy to second block in buffer */ - memcpy(encrypt_buf + 16, ssrc + i, 16); - /* decrypt the first block from flash, will reencrypt to same bytes */ - spi_flash_read_encrypted(row_addr, encrypt_buf, 16); - } else if (size - i == 16) { - /* 16 bytes left, is first block of a 32 byte row */ - row_size = 16; - /* copy to first block in buffer */ - memcpy(encrypt_buf, ssrc + i, 16); - /* decrypt the second block from flash, will reencrypt to same bytes */ - spi_flash_read_encrypted(row_addr + 16, encrypt_buf + 16, 16); - } else { - /* Writing a full 32 byte row (2 blocks) */ - row_size = 32; - memcpy(encrypt_buf, ssrc + i, 32); - } - - spi_flash_guard_start(); - flash_rom_init(); - rc = esp_rom_spiflash_write_encrypted(row_addr, (uint32_t *)encrypt_buf, 32); - spi_flash_guard_end(); - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - break; - } - } - bzero(encrypt_buf, sizeof(encrypt_buf)); - - return rc; -} diff --git a/components/spi_flash/esp32c2/flash_ops_esp32c2.c b/components/spi_flash/esp32c2/flash_ops_esp32c2.c index 0a37f9ffd0..b5761527fc 100644 --- a/components/spi_flash/esp32c2/flash_ops_esp32c2.c +++ b/components/spi_flash/esp32c2/flash_ops_esp32c2.c @@ -7,7 +7,7 @@ #include #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "soc/system_reg.h" #include "soc/soc_memory_layout.h" #include "esp32c2/rom/cache.h" @@ -16,61 +16,11 @@ #include "esp_log.h" #include "esp_attr.h" #include "esp_rom_spiflash.h" - -static const char *TAG = "spiflash_esp32c2"; +#include "esp_private/spi_flash_os.h" #define SPICACHE SPIMEM0 #define SPIFLASH SPIMEM1 -extern void IRAM_ATTR flash_rom_init(void); -esp_rom_spiflash_result_t IRAM_ATTR spi_flash_write_encrypted_chip(size_t dest_addr, const void *src, size_t size) -{ - const spi_flash_guard_funcs_t *ops = spi_flash_guard_get(); - esp_rom_spiflash_result_t rc; - - assert((dest_addr % 16) == 0); - assert((size % 16) == 0); - - /* src needs to be 32 bit aligned */ - if (!esp_ptr_internal(src) || (intptr_t)src & 0x3) { - WORD_ALIGNED_ATTR uint8_t block[128]; // Need to buffer in RAM as we write - while (size > 0) { - size_t next_block = MIN(size, sizeof(block)); - memcpy(block, src, next_block); - - esp_rom_spiflash_result_t r = spi_flash_write_encrypted_chip(dest_addr, block, next_block); - if (r != ESP_ROM_SPIFLASH_RESULT_OK) { - return r; - } - - size -= next_block; - dest_addr += next_block; - src = ((uint8_t *)src) + next_block; - } - bzero(block, sizeof(block)); - - return ESP_ROM_SPIFLASH_RESULT_OK; - } else { // Already in internal memory - ESP_LOGV(TAG, "calling esp_rom_spiflash_write_encrypted addr 0x%x src %p size 0x%x", dest_addr, src, size); - -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL - /* The ROM function SPI_Encrypt_Write assumes ADDR_BITLEN is already set but new - implementation doesn't automatically set this to a usable value */ - SPIFLASH.user1.usr_addr_bitlen = 23; -#endif - - if (ops && ops->start) { - ops->start(); - } - flash_rom_init(); - rc = esp_rom_spiflash_write_encrypted(dest_addr, (uint32_t *)src, size); - if (ops && ops->end) { - ops->end(); - } - return rc; - } -} - #define FLASH_WRAP_CMD 0x77 esp_err_t spi_flash_wrap_set(spi_flash_wrap_mode_t mode) { diff --git a/components/spi_flash/esp32c3/flash_ops_esp32c3.c b/components/spi_flash/esp32c3/flash_ops_esp32c3.c index bdaa223ae5..3e74dc4b8c 100644 --- a/components/spi_flash/esp32c3/flash_ops_esp32c3.c +++ b/components/spi_flash/esp32c3/flash_ops_esp32c3.c @@ -7,7 +7,7 @@ #include #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "soc/system_reg.h" #include "soc/soc_memory_layout.h" #include "esp32c3/rom/cache.h" @@ -16,61 +16,11 @@ #include "esp_log.h" #include "esp_attr.h" #include "esp_rom_spiflash.h" - -static const char *TAG = "spiflash_c3"; +#include "esp_private/spi_flash_os.h" #define SPICACHE SPIMEM0 #define SPIFLASH SPIMEM1 -extern void IRAM_ATTR flash_rom_init(void); -esp_rom_spiflash_result_t IRAM_ATTR spi_flash_write_encrypted_chip(size_t dest_addr, const void *src, size_t size) -{ - const spi_flash_guard_funcs_t *ops = spi_flash_guard_get(); - esp_rom_spiflash_result_t rc; - - assert((dest_addr % 16) == 0); - assert((size % 16) == 0); - - /* src needs to be 32 bit aligned */ - if (!esp_ptr_internal(src) || (intptr_t)src & 0x3) { - WORD_ALIGNED_ATTR uint8_t block[128]; // Need to buffer in RAM as we write - while (size > 0) { - size_t next_block = MIN(size, sizeof(block)); - memcpy(block, src, next_block); - - esp_rom_spiflash_result_t r = spi_flash_write_encrypted_chip(dest_addr, block, next_block); - if (r != ESP_ROM_SPIFLASH_RESULT_OK) { - return r; - } - - size -= next_block; - dest_addr += next_block; - src = ((uint8_t *)src) + next_block; - } - bzero(block, sizeof(block)); - - return ESP_ROM_SPIFLASH_RESULT_OK; - } else { // Already in internal memory - ESP_LOGV(TAG, "calling esp_rom_spiflash_write_encrypted addr 0x%x src %p size 0x%x", dest_addr, src, size); - -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL - /* The ROM function SPI_Encrypt_Write assumes ADDR_BITLEN is already set but new - implementation doesn't automatically set this to a usable value */ - SPIFLASH.user1.usr_addr_bitlen = 23; -#endif - - if (ops && ops->start) { - ops->start(); - } - flash_rom_init(); - rc = esp_rom_spiflash_write_encrypted(dest_addr, (uint32_t *)src, size); - if (ops && ops->end) { - ops->end(); - } - return rc; - } -} - #define FLASH_WRAP_CMD 0x77 esp_err_t spi_flash_wrap_set(spi_flash_wrap_mode_t mode) { diff --git a/components/spi_flash/esp32h2/flash_ops_esp32h2.c b/components/spi_flash/esp32h2/flash_ops_esp32h2.c index ef1b5581a0..d4a636588c 100644 --- a/components/spi_flash/esp32h2/flash_ops_esp32h2.c +++ b/components/spi_flash/esp32h2/flash_ops_esp32h2.c @@ -7,7 +7,7 @@ #include #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "soc/system_reg.h" #include "soc/soc_memory_layout.h" #include "esp32h2/rom/cache.h" @@ -16,61 +16,11 @@ #include "esp_log.h" #include "esp_attr.h" #include "esp_rom_spiflash.h" - -static const char *TAG = "spiflash_h2"; +#include "esp_private/spi_flash_os.h" #define SPICACHE SPIMEM0 #define SPIFLASH SPIMEM1 -extern void IRAM_ATTR flash_rom_init(void); -esp_rom_spiflash_result_t IRAM_ATTR spi_flash_write_encrypted_chip(size_t dest_addr, const void *src, size_t size) -{ - const spi_flash_guard_funcs_t *ops = spi_flash_guard_get(); - esp_rom_spiflash_result_t rc; - - assert((dest_addr % 16) == 0); - assert((size % 16) == 0); - - /* src needs to be 32 bit aligned */ - if (!esp_ptr_internal(src) || (intptr_t)src & 0x3) { - WORD_ALIGNED_ATTR uint8_t block[128]; // Need to buffer in RAM as we write - while (size > 0) { - size_t next_block = MIN(size, sizeof(block)); - memcpy(block, src, next_block); - - esp_rom_spiflash_result_t r = spi_flash_write_encrypted_chip(dest_addr, block, next_block); - if (r != ESP_ROM_SPIFLASH_RESULT_OK) { - return r; - } - - size -= next_block; - dest_addr += next_block; - src = ((uint8_t *)src) + next_block; - } - bzero(block, sizeof(block)); - - return ESP_ROM_SPIFLASH_RESULT_OK; - } else { // Already in internal memory - ESP_LOGV(TAG, "calling esp_rom_spiflash_write_encrypted addr 0x%x src %p size 0x%x", dest_addr, src, size); - -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL - /* The ROM function SPI_Encrypt_Write assumes ADDR_BITLEN is already set but new - implementation doesn't automatically set this to a usable value */ - SPIFLASH.user1.usr_addr_bitlen = 23; -#endif - - if (ops && ops->start) { - ops->start(); - } - flash_rom_init(); - rc = esp_rom_spiflash_write_encrypted(dest_addr, (uint32_t *)src, size); - if (ops && ops->end) { - ops->end(); - } - return rc; - } -} - #define FLASH_WRAP_CMD 0x77 esp_err_t spi_flash_wrap_set(spi_flash_wrap_mode_t mode) { diff --git a/components/spi_flash/esp32s2/flash_ops_esp32s2.c b/components/spi_flash/esp32s2/flash_ops_esp32s2.c index 639637ca19..ef7a8eca25 100644 --- a/components/spi_flash/esp32s2/flash_ops_esp32s2.c +++ b/components/spi_flash/esp32s2/flash_ops_esp32s2.c @@ -7,7 +7,7 @@ #include #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "soc/system_reg.h" #include "soc/soc_memory_layout.h" #include "esp32s2/rom/cache.h" @@ -17,60 +17,9 @@ #include "esp_log.h" #include "esp_rom_spiflash.h" -static const char *TAG = "spiflash_s2"; - #define SPICACHE SPIMEM0 #define SPIFLASH SPIMEM1 -extern void IRAM_ATTR flash_rom_init(void); -esp_rom_spiflash_result_t IRAM_ATTR spi_flash_write_encrypted_chip(size_t dest_addr, const void *src, size_t size) -{ - const spi_flash_guard_funcs_t *ops = spi_flash_guard_get(); - esp_rom_spiflash_result_t rc; - - assert((dest_addr % 16) == 0); - assert((size % 16) == 0); - - if (!esp_ptr_internal(src)) { - uint8_t block[128]; // Need to buffer in RAM as we write - while (size > 0) { - size_t next_block = MIN(size, sizeof(block)); - memcpy(block, src, next_block); - - esp_rom_spiflash_result_t r = spi_flash_write_encrypted_chip(dest_addr, block, next_block); - if (r != ESP_ROM_SPIFLASH_RESULT_OK) { - return r; - } - - size -= next_block; - dest_addr += next_block; - src = ((uint8_t *)src) + next_block; - } - bzero(block, sizeof(block)); - - return ESP_ROM_SPIFLASH_RESULT_OK; - } - else { // Already in internal memory - ESP_LOGV(TAG, "calling SPI_Encrypt_Write addr 0x%x src %p size 0x%x", dest_addr, src, size); - -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL - /* The ROM function SPI_Encrypt_Write assumes ADDR_BITLEN is already set but new - implementation doesn't automatically set this to a usable value */ - SPIFLASH.user1.usr_addr_bitlen = 23; -#endif - - if (ops && ops->start) { - ops->start(); - } - flash_rom_init(); - rc = esp_rom_spiflash_write_encrypted(dest_addr, (uint32_t*)src, size); - if (ops && ops->end) { - ops->end(); - } - return rc; - } -} - esp_err_t spi_flash_wrap_set(spi_flash_wrap_mode_t mode) { return bootloader_flash_wrap_set(mode); diff --git a/components/spi_flash/esp32s3/flash_ops_esp32s3.c b/components/spi_flash/esp32s3/flash_ops_esp32s3.c index a2c0709266..2d114fa27f 100644 --- a/components/spi_flash/esp32s3/flash_ops_esp32s3.c +++ b/components/spi_flash/esp32s3/flash_ops_esp32s3.c @@ -7,7 +7,7 @@ #include #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "soc/system_reg.h" #include "soc/soc_memory_layout.h" #include "esp32s3/rom/cache.h" @@ -17,59 +17,9 @@ #include "esp_log.h" #include "esp_rom_spiflash.h" -static const char *TAG = "spiflash_s3"; - #define SPICACHE SPIMEM0 #define SPIFLASH SPIMEM1 -extern void IRAM_ATTR flash_rom_init(void); -esp_rom_spiflash_result_t IRAM_ATTR spi_flash_write_encrypted_chip(size_t dest_addr, const void *src, size_t size) -{ - const spi_flash_guard_funcs_t *ops = spi_flash_guard_get(); - esp_rom_spiflash_result_t rc; - - assert((dest_addr % 16) == 0); - assert((size % 16) == 0); - - if (!esp_ptr_internal(src)) { - uint8_t block[128]; // Need to buffer in RAM as we write - while (size > 0) { - size_t next_block = MIN(size, sizeof(block)); - memcpy(block, src, next_block); - - esp_rom_spiflash_result_t r = spi_flash_write_encrypted_chip(dest_addr, block, next_block); - if (r != ESP_ROM_SPIFLASH_RESULT_OK) { - return r; - } - - size -= next_block; - dest_addr += next_block; - src = ((uint8_t *)src) + next_block; - } - bzero(block, sizeof(block)); - - return ESP_ROM_SPIFLASH_RESULT_OK; - } else { // Already in internal memory - ESP_LOGV(TAG, "calling SPI_Encrypt_Write addr 0x%x src %p size 0x%x", dest_addr, src, size); - -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL - /* The ROM function SPI_Encrypt_Write assumes ADDR_BITLEN is already set but new - implementation doesn't automatically set this to a usable value */ - SPIFLASH.user1.usr_addr_bitlen = 23; -#endif - - if (ops && ops->start) { - ops->start(); - } - flash_rom_init(); - rc = esp_rom_spiflash_write_encrypted(dest_addr, (void *)src, size); - if (ops && ops->end) { - ops->end(); - } - return rc; - } -} - esp_err_t spi_flash_wrap_set(spi_flash_wrap_mode_t mode) { return bootloader_flash_wrap_set(mode); diff --git a/components/spi_flash/esp_flash_api.c b/components/spi_flash/esp_flash_api.c index 8787d20dad..a7bed139b2 100644 --- a/components/spi_flash/esp_flash_api.c +++ b/components/spi_flash/esp_flash_api.c @@ -16,6 +16,7 @@ #include "sdkconfig.h" #include "esp_flash_internal.h" #include "spi_flash_defs.h" +#include "spi_flash_mmap.h" #include "esp_rom_caps.h" #include "esp_rom_spiflash.h" #if CONFIG_IDF_TARGET_ESP32S2 @@ -1051,19 +1052,32 @@ inline static IRAM_ATTR bool regions_overlap(uint32_t a_start, uint32_t a_len,ui return (a_end > b_start && b_end > a_start); } -//currently the legacy implementation is used, from flash_ops.c -esp_err_t spi_flash_read_encrypted(size_t src, void *dstv, size_t size); - esp_err_t IRAM_ATTR esp_flash_read_encrypted(esp_flash_t *chip, uint32_t address, void *out_buffer, uint32_t length) { - /* - * Since currently this feature is supported only by the hardware, there - * is no way to support non-standard chips. We use the legacy - * implementation and skip the chip and driver layers. - */ esp_err_t err = rom_spiflash_api_funcs->chip_check(&chip); if (err != ESP_OK) return err; - return spi_flash_read_encrypted(address, out_buffer, length); + if (address + length > g_rom_flashchip.chip_size) { + return ESP_ERR_INVALID_SIZE; + } + if (length == 0) { + return ESP_OK; + } + if (out_buffer == NULL) { + return ESP_ERR_INVALID_ARG; + } + + const uint8_t *map; + spi_flash_mmap_handle_t map_handle; + size_t map_src = address & ~(SPI_FLASH_MMU_PAGE_SIZE - 1); + size_t map_size = length + (address - map_src); + + err = spi_flash_mmap(map_src, map_size, SPI_FLASH_MMAP_DATA, (const void **)&map, &map_handle); + if (err != ESP_OK) { + return err; + } + memcpy(out_buffer, map + (address - map_src), length); + spi_flash_munmap(map_handle); + return err; } // test only, non-public @@ -1115,7 +1129,6 @@ esp_err_t esp_flash_suspend_cmd_init(esp_flash_t* chip) return chip->chip_drv->sus_setup(chip); } -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL esp_err_t esp_flash_app_disable_protect(bool disable) { if (disable) { @@ -1124,65 +1137,3 @@ esp_err_t esp_flash_app_disable_protect(bool disable) return esp_flash_app_enable_os_functions(esp_flash_default_chip); } } -#endif - -/*------------------------------------------------------------------------------ - Adapter layer to original api before IDF v4.0 -------------------------------------------------------------------------------*/ - -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL - -/* Translate any ESP_ERR_FLASH_xxx error code (new API) to a generic ESP_ERR_xyz error code - */ -static IRAM_ATTR esp_err_t spi_flash_translate_rc(esp_err_t err) -{ - switch (err) { - case ESP_OK: - case ESP_ERR_INVALID_ARG: - case ESP_ERR_INVALID_SIZE: - case ESP_ERR_NO_MEM: - return err; - - case ESP_ERR_FLASH_NOT_INITIALISED: - case ESP_ERR_FLASH_PROTECTED: - return ESP_ERR_INVALID_STATE; - - case ESP_ERR_NOT_FOUND: - case ESP_ERR_FLASH_UNSUPPORTED_HOST: - case ESP_ERR_FLASH_UNSUPPORTED_CHIP: - return ESP_ERR_NOT_SUPPORTED; - - case ESP_ERR_FLASH_NO_RESPONSE: - return ESP_ERR_INVALID_RESPONSE; - - default: - ESP_EARLY_LOGE(TAG, "unexpected spi flash error code: 0x%x", err); - abort(); - } -} - -esp_err_t IRAM_ATTR spi_flash_erase_range(uint32_t start_addr, uint32_t size) -{ - esp_err_t err = esp_flash_erase_region(NULL, start_addr, size); - return spi_flash_translate_rc(err); -} - -esp_err_t IRAM_ATTR spi_flash_write(size_t dst, const void *srcv, size_t size) -{ - esp_err_t err = esp_flash_write(NULL, srcv, dst, size); - return spi_flash_translate_rc(err); -} - -esp_err_t IRAM_ATTR spi_flash_read(size_t src, void *dstv, size_t size) -{ - esp_err_t err = esp_flash_read(NULL, dstv, src, size); - return spi_flash_translate_rc(err); -} - -esp_err_t IRAM_ATTR spi_flash_write_encrypted(size_t dest_addr, const void *src, size_t size) -{ - esp_err_t err = esp_flash_write_encrypted(NULL, dest_addr, src, size); - return spi_flash_translate_rc(err); -} - -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL diff --git a/components/spi_flash/esp_flash_spi_init.c b/components/spi_flash/esp_flash_spi_init.c index cd367cf0b1..b4a03ace91 100644 --- a/components/spi_flash/esp_flash_spi_init.c +++ b/components/spi_flash/esp_flash_spi_init.c @@ -20,6 +20,8 @@ #include "esp_flash_internal.h" #include "esp_rom_gpio.h" #include "esp_private/spi_flash_os.h" +#include "esp_private/cache_utils.h" +#include "esp_spi_flash_counters.h" #include "esp_rom_spiflash.h" __attribute__((unused)) static const char TAG[] = "spi_flash"; @@ -29,8 +31,6 @@ __attribute__((unused)) static const char TAG[] = "spi_flash"; esp_flash_t *esp_flash_default_chip = NULL; #endif -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL - #if defined CONFIG_ESPTOOLPY_FLASHFREQ_120M #define DEFAULT_FLASH_SPEED 120 #elif defined CONFIG_ESPTOOLPY_FLASHFREQ_80M @@ -387,6 +387,11 @@ esp_err_t esp_flash_init_default_chip(void) esp_err_t esp_flash_app_init(void) { esp_err_t err = ESP_OK; + spi_flash_init_lock(); + spi_flash_guard_set(&g_flash_guard_default_ops); +#if CONFIG_SPI_FLASH_ENABLE_COUNTERS + spi_flash_reset_counters(); +#endif #if CONFIG_SPI_FLASH_SHARE_SPI1_BUS err = esp_flash_init_main_bus_lock(); if (err != ESP_OK) return err; @@ -394,5 +399,3 @@ esp_err_t esp_flash_app_init(void) err = esp_flash_app_enable_os_functions(&default_chip); return err; } - -#endif //!CONFIG_SPI_FLASH_USE_LEGACY_IMPL diff --git a/components/spi_flash/flash_mmap.c b/components/spi_flash/flash_mmap.c index 38ed5abe66..2a6eb3ce0d 100644 --- a/components/spi_flash/flash_mmap.c +++ b/components/spi_flash/flash_mmap.c @@ -15,11 +15,12 @@ #include "soc/mmu.h" #include "sdkconfig.h" #include "esp_attr.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_flash_encrypt.h" #include "esp_log.h" -#include "cache_utils.h" +#include "esp_private/cache_utils.h" #include "hal/mmu_ll.h" +#include "esp_rom_spiflash.h" #if CONFIG_IDF_TARGET_ESP32 #include "soc/dport_reg.h" @@ -129,7 +130,7 @@ esp_err_t IRAM_ATTR spi_flash_mmap(size_t src_addr, size_t size, spi_flash_mmap_ if (src_addr & INVALID_PHY_PAGE(CONFIG_MMU_PAGE_SIZE)) { return ESP_ERR_INVALID_ARG; } - if ((src_addr + size) > spi_flash_get_chip_size()) { + if ((src_addr + size) > g_rom_flashchip.chip_size) { return ESP_ERR_INVALID_ARG; } // region which should be mapped @@ -162,7 +163,7 @@ esp_err_t IRAM_ATTR spi_flash_mmap_pages(const int *pages, size_t page_count, sp return ESP_ERR_INVALID_ARG; } for (int i = 0; i < page_count; i++) { - if (pages[i] < 0 || pages[i]*SPI_FLASH_MMU_PAGE_SIZE >= spi_flash_get_chip_size()) { + if (pages[i] < 0 || pages[i]*SPI_FLASH_MMU_PAGE_SIZE >= g_rom_flashchip.chip_size) { return ESP_ERR_INVALID_ARG; } } diff --git a/components/spi_flash/flash_ops.c b/components/spi_flash/flash_ops.c index 464d671ad6..7389182099 100644 --- a/components/spi_flash/flash_ops.c +++ b/components/spi_flash/flash_ops.c @@ -17,7 +17,7 @@ #include #include "sdkconfig.h" #include "esp_attr.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_log.h" #include "esp_private/system_internal.h" #include "esp_private/spi_flash_os.h" @@ -41,14 +41,12 @@ #endif #include "esp_rom_spiflash.h" #include "esp_flash_partitions.h" -#include "cache_utils.h" +#include "esp_private/cache_utils.h" #include "esp_flash.h" #include "esp_attr.h" #include "bootloader_flash.h" #include "esp_compiler.h" -esp_rom_spiflash_result_t IRAM_ATTR spi_flash_write_encrypted_chip(size_t dest_addr, const void *src, size_t size); - /* bytes erased by SPIEraseBlock() ROM function */ #define BLOCK_ERASE_SIZE 65536 @@ -87,34 +85,29 @@ static spi_flash_counters_t s_flash_stats; #endif //CONFIG_SPI_FLASH_ENABLE_COUNTERS -#if CONFIG_SPI_FLASH_USE_LEGACY_IMPL -static esp_err_t spi_flash_translate_rc(esp_rom_spiflash_result_t rc); -#endif //CONFIG_SPI_FLASH_USE_LEGACY_IMPL -static bool is_safe_write_address(size_t addr, size_t size); -static void spi_flash_os_yield(void); - const DRAM_ATTR spi_flash_guard_funcs_t g_flash_guard_default_ops = { .start = spi_flash_disable_interrupts_caches_and_other_cpu, .end = spi_flash_enable_interrupts_caches_and_other_cpu, - .op_lock = spi_flash_op_lock, - .op_unlock = spi_flash_op_unlock, -#if !CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED - .is_safe_write_address = is_safe_write_address, -#endif - .yield = spi_flash_os_yield, }; const DRAM_ATTR spi_flash_guard_funcs_t g_flash_guard_no_os_ops = { .start = spi_flash_disable_interrupts_caches_and_other_cpu_no_os, .end = spi_flash_enable_interrupts_caches_no_os, - .op_lock = NULL, - .op_unlock = NULL, -#if !CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED - .is_safe_write_address = NULL, -#endif - .yield = NULL, }; +static const spi_flash_guard_funcs_t *s_flash_guard_ops; + +void IRAM_ATTR spi_flash_guard_set(const spi_flash_guard_funcs_t *funcs) +{ + s_flash_guard_ops = funcs; +} + +const spi_flash_guard_funcs_t *IRAM_ATTR spi_flash_guard_get(void) +{ + return s_flash_guard_ops; +} + + #ifdef CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS #define UNSAFE_WRITE_ADDRESS abort() #else @@ -122,20 +115,6 @@ const DRAM_ATTR spi_flash_guard_funcs_t g_flash_guard_no_os_ops = { #endif -/* CHECK_WRITE_ADDRESS macro to fail writes which land in the - bootloader, partition table, or running application region. -*/ -#if CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED -// Following helps in masking "unused variable" warning -#define CHECK_WRITE_ADDRESS(ADDR, SIZE) ({(void) guard;}) -#else /* FAILS or ABORTS */ -#define CHECK_WRITE_ADDRESS(ADDR, SIZE) do { \ - if (guard && guard->is_safe_write_address && !guard->is_safe_write_address(ADDR, SIZE)) { \ - return ESP_ERR_INVALID_ARG; \ - } \ - } while(0) -#endif // CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED - static __attribute__((unused)) bool is_safe_write_address(size_t addr, size_t size) { if (!esp_partition_main_flash_region_safe(addr, size)) { @@ -146,12 +125,23 @@ static __attribute__((unused)) bool is_safe_write_address(size_t addr, size_t si #if CONFIG_SPI_FLASH_ROM_IMPL #include "esp_heap_caps.h" -typedef void *(*malloc_internal_cb_t)(size_t size); void IRAM_ATTR *spi_flash_malloc_internal(size_t size) { return heap_caps_malloc(size, MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL); } + +void IRAM_ATTR spi_flash_rom_impl_init(void) +{ + spi_flash_guard_set(&g_flash_guard_default_ops); + + /* These two functions are in ROM only */ + extern void spi_flash_mmap_os_func_set(void *(*func1)(size_t size), void (*func2)(void *p)); + spi_flash_mmap_os_func_set(spi_flash_malloc_internal, heap_caps_free); + + extern esp_err_t spi_flash_mmap_page_num_init(uint32_t page_num); + spi_flash_mmap_page_num_init(128); +} #endif void IRAM_ATTR esp_mspi_pin_init(void) @@ -179,695 +169,6 @@ esp_err_t IRAM_ATTR spi_flash_init_chip_state(void) #endif // CONFIG_ESPTOOLPY_OCT_FLASH } -void spi_flash_init(void) -{ - spi_flash_init_lock(); -#if CONFIG_SPI_FLASH_ENABLE_COUNTERS - spi_flash_reset_counters(); -#endif - -#if CONFIG_SPI_FLASH_ROM_IMPL - spi_flash_guard_set(&g_flash_guard_default_ops); - - /* These two functions are in ROM only */ - extern void spi_flash_mmap_os_func_set(void *(*func1)(size_t size), void (*func2)(void *p)); - spi_flash_mmap_os_func_set(spi_flash_malloc_internal, heap_caps_free); - - extern esp_err_t spi_flash_mmap_page_num_init(uint32_t page_num); - spi_flash_mmap_page_num_init(128); -#endif -} - -#if !CONFIG_SPI_FLASH_ROM_IMPL - -static const spi_flash_guard_funcs_t *s_flash_guard_ops; - -void IRAM_ATTR spi_flash_guard_set(const spi_flash_guard_funcs_t *funcs) -{ - s_flash_guard_ops = funcs; -} - -const spi_flash_guard_funcs_t *IRAM_ATTR spi_flash_guard_get(void) -{ - return s_flash_guard_ops; -} - -#endif - -size_t IRAM_ATTR spi_flash_get_chip_size(void) -{ - return g_rom_flashchip.chip_size; -} - -static inline void IRAM_ATTR spi_flash_guard_start(void) -{ - const spi_flash_guard_funcs_t *guard = spi_flash_guard_get(); - if (guard && guard->start) { - guard->start(); - } -} - -static inline void IRAM_ATTR spi_flash_guard_end(void) -{ - const spi_flash_guard_funcs_t *guard = spi_flash_guard_get(); - if (guard && guard->end) { - guard->end(); - } -} - -static inline void IRAM_ATTR spi_flash_guard_op_lock(void) -{ - const spi_flash_guard_funcs_t *guard = spi_flash_guard_get(); - if (guard && guard->op_lock) { - guard->op_lock(); - } -} - -static inline void IRAM_ATTR spi_flash_guard_op_unlock(void) -{ - const spi_flash_guard_funcs_t *guard = spi_flash_guard_get(); - if (guard && guard->op_unlock) { - guard->op_unlock(); - } -} - -static void IRAM_ATTR spi_flash_os_yield(void) -{ -#ifdef CONFIG_SPI_FLASH_YIELD_DURING_ERASE - if (likely(xTaskGetSchedulerState() == taskSCHEDULER_RUNNING)) { - vTaskDelay(CONFIG_SPI_FLASH_ERASE_YIELD_TICKS); - } -#endif -} - -#ifdef CONFIG_SPI_FLASH_USE_LEGACY_IMPL -static esp_rom_spiflash_result_t IRAM_ATTR spi_flash_unlock(void) -{ - static bool unlocked = false; - if (!unlocked) { - spi_flash_guard_start(); - bootloader_flash_unlock(); - spi_flash_guard_end(); - unlocked = true; - } - return ESP_ROM_SPIFLASH_RESULT_OK; -} -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL - -esp_err_t IRAM_ATTR spi_flash_erase_sector(size_t sec) -{ - const spi_flash_guard_funcs_t *guard = spi_flash_guard_get(); - CHECK_WRITE_ADDRESS(sec * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE); - return spi_flash_erase_range(sec * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE); -} - -#ifdef CONFIG_SPI_FLASH_USE_LEGACY_IMPL -//deprecated, only used in compatible mode -esp_err_t IRAM_ATTR spi_flash_erase_range(size_t start_addr, size_t size) -{ - const spi_flash_guard_funcs_t *guard = spi_flash_guard_get(); - CHECK_WRITE_ADDRESS(start_addr, size); - if (start_addr % SPI_FLASH_SEC_SIZE != 0) { - return ESP_ERR_INVALID_ARG; - } - if (size % SPI_FLASH_SEC_SIZE != 0) { - return ESP_ERR_INVALID_SIZE; - } - if (size + start_addr > spi_flash_get_chip_size()) { - return ESP_ERR_INVALID_SIZE; - } - size_t start = start_addr / SPI_FLASH_SEC_SIZE; - size_t end = start + size / SPI_FLASH_SEC_SIZE; - const size_t sectors_per_block = BLOCK_ERASE_SIZE / SPI_FLASH_SEC_SIZE; - COUNTER_START(); - esp_rom_spiflash_result_t rc; - rc = spi_flash_unlock(); - if (rc == ESP_ROM_SPIFLASH_RESULT_OK) { -#ifdef CONFIG_SPI_FLASH_YIELD_DURING_ERASE - int64_t no_yield_time_us = 0; -#endif - for (size_t sector = start; sector != end && rc == ESP_ROM_SPIFLASH_RESULT_OK; ) { -#ifdef CONFIG_SPI_FLASH_YIELD_DURING_ERASE - int64_t start_time_us = esp_system_get_time(); -#endif - spi_flash_guard_start(); -#ifndef CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE - if (sector % sectors_per_block == 0 && end - sector >= sectors_per_block) { - rc = esp_rom_spiflash_erase_block(sector / sectors_per_block); - sector += sectors_per_block; - COUNTER_ADD_BYTES(erase, sectors_per_block * SPI_FLASH_SEC_SIZE); - } else -#endif - { - rc = esp_rom_spiflash_erase_sector(sector); - ++sector; - COUNTER_ADD_BYTES(erase, SPI_FLASH_SEC_SIZE); - } - spi_flash_guard_end(); -#ifdef CONFIG_SPI_FLASH_YIELD_DURING_ERASE - no_yield_time_us += (esp_system_get_time() - start_time_us); - if (no_yield_time_us / 1000 >= CONFIG_SPI_FLASH_ERASE_YIELD_DURATION_MS) { - no_yield_time_us = 0; - if (s_flash_guard_ops && s_flash_guard_ops->yield) { - s_flash_guard_ops->yield(); - } - } -#endif - } - } - COUNTER_STOP(erase); - - spi_flash_guard_start(); - // Ensure WEL is 0 after the operation, even if the erase failed. - esp_rom_spiflash_write_disable(); - spi_flash_check_and_flush_cache(start_addr, size); - spi_flash_guard_end(); - - return spi_flash_translate_rc(rc); -} - -/* Wrapper around esp_rom_spiflash_write() that verifies data as written if CONFIG_SPI_FLASH_VERIFY_WRITE is set. - - If CONFIG_SPI_FLASH_VERIFY_WRITE is not set, this is esp_rom_spiflash_write(). -*/ -static IRAM_ATTR esp_rom_spiflash_result_t spi_flash_write_inner(uint32_t target, const uint32_t *src_addr, int32_t len) -{ -#ifndef CONFIG_SPI_FLASH_VERIFY_WRITE - return esp_rom_spiflash_write(target, src_addr, len); -#else // CONFIG_SPI_FLASH_VERIFY_WRITE - esp_rom_spiflash_result_t res = ESP_ROM_SPIFLASH_RESULT_OK; - assert(len % sizeof(uint32_t) == 0); - - uint32_t before_buf[ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM / sizeof(uint32_t)]; - uint32_t after_buf[ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM / sizeof(uint32_t)]; - uint32_t *expected_buf = before_buf; - int32_t remaining = len; - for(int i = 0; i < len; i += sizeof(before_buf)) { - int i_w = i / sizeof(uint32_t); // index in words (i is an index in bytes) - int32_t read_len = MIN(sizeof(before_buf), remaining); - - // Read "before" contents from flash - res = esp_rom_spiflash_read(target + i, before_buf, read_len); - if (res != ESP_ROM_SPIFLASH_RESULT_OK) { - break; - } - - for (int r = 0; r < read_len; r += sizeof(uint32_t)) { - int r_w = r / sizeof(uint32_t); // index in words (r is index in bytes) - - uint32_t write = src_addr[i_w + r_w]; - uint32_t before = before_buf[r_w]; - uint32_t expected = write & before; -#ifdef CONFIG_SPI_FLASH_WARN_SETTING_ZERO_TO_ONE - if ((before & write) != write) { - spi_flash_guard_end(); - ESP_LOGW(TAG, "Write at offset 0x%x requests 0x%08x but will write 0x%08x -> 0x%08x", - target + i + r, write, before, before & write); - spi_flash_guard_start(); - } -#endif - expected_buf[r_w] = expected; - } - - res = esp_rom_spiflash_write(target + i, &src_addr[i_w], read_len); - if (res != ESP_ROM_SPIFLASH_RESULT_OK) { - break; - } - - res = esp_rom_spiflash_read(target + i, after_buf, read_len); - if (res != ESP_ROM_SPIFLASH_RESULT_OK) { - break; - } - - for (int r = 0; r < read_len; r += sizeof(uint32_t)) { - int r_w = r / sizeof(uint32_t); // index in words (r is index in bytes) - - uint32_t expected = expected_buf[r_w]; - uint32_t actual = after_buf[r_w]; - if (expected != actual) { -#ifdef CONFIG_SPI_FLASH_LOG_FAILED_WRITE - spi_flash_guard_end(); - ESP_LOGE(TAG, "Bad write at offset 0x%x expected 0x%08x readback 0x%08x", target + i + r, expected, actual); - spi_flash_guard_start(); -#endif - res = ESP_ROM_SPIFLASH_RESULT_ERR; - } - } - if (res != ESP_ROM_SPIFLASH_RESULT_OK) { - break; - } - remaining -= read_len; - } - return res; -#endif // CONFIG_SPI_FLASH_VERIFY_WRITE -} - - -esp_err_t IRAM_ATTR spi_flash_write(size_t dst, const void *srcv, size_t size) -{ - const spi_flash_guard_funcs_t *guard = spi_flash_guard_get(); - CHECK_WRITE_ADDRESS(dst, size); - // Out of bound writes are checked in ROM code, but we can give better - // error code here - if (dst + size > g_rom_flashchip.chip_size) { - return ESP_ERR_INVALID_SIZE; - } - if (size == 0) { - return ESP_OK; - } - - esp_rom_spiflash_result_t rc = ESP_ROM_SPIFLASH_RESULT_OK; - COUNTER_START(); - const uint8_t *srcc = (const uint8_t *) srcv; - /* - * Large operations are split into (up to) 3 parts: - * - Left padding: 4 bytes up to the first 4-byte aligned destination offset. - * - Middle part - * - Right padding: 4 bytes from the last 4-byte aligned offset covered. - */ - size_t left_off = dst & ~3U; - size_t left_size = MIN(((dst + 3) & ~3U) - dst, size); - size_t mid_off = left_size; - size_t mid_size = (size - left_size) & ~3U; - size_t right_off = left_size + mid_size; - size_t right_size = size - mid_size - left_size; - - rc = spi_flash_unlock(); - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - goto out; - } - if (left_size > 0) { - uint32_t t = 0xffffffff; - memcpy(((uint8_t *) &t) + (dst - left_off), srcc, left_size); - spi_flash_guard_start(); - rc = spi_flash_write_inner(left_off, &t, 4); - spi_flash_guard_end(); - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - goto out; - } - COUNTER_ADD_BYTES(write, 4); - } - if (mid_size > 0) { - /* If src buffer is 4-byte aligned as well and is not in a region that requires cache access to be enabled, we - * can write directly without buffering in RAM. */ -#ifdef ESP_PLATFORM - bool direct_write = esp_ptr_internal(srcc) - && esp_ptr_byte_accessible(srcc) - && ((uintptr_t) srcc + mid_off) % 4 == 0; -#else - bool direct_write = true; -#endif - while(mid_size > 0 && rc == ESP_ROM_SPIFLASH_RESULT_OK) { - uint32_t write_buf[8]; - uint32_t write_size = MIN(mid_size, MAX_WRITE_CHUNK); - const uint8_t *write_src = srcc + mid_off; - if (!direct_write) { - write_size = MIN(write_size, sizeof(write_buf)); - memcpy(write_buf, write_src, write_size); - write_src = (const uint8_t *)write_buf; - } - spi_flash_guard_start(); - rc = spi_flash_write_inner(dst + mid_off, (const uint32_t *) write_src, write_size); - spi_flash_guard_end(); - COUNTER_ADD_BYTES(write, write_size); - mid_size -= write_size; - mid_off += write_size; - } - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - goto out; - } - } - - if (right_size > 0) { - uint32_t t = 0xffffffff; - memcpy(&t, srcc + right_off, right_size); - spi_flash_guard_start(); - rc = spi_flash_write_inner(dst + right_off, &t, 4); - spi_flash_guard_end(); - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - goto out; - } - COUNTER_ADD_BYTES(write, 4); - } -out: - COUNTER_STOP(write); - - spi_flash_guard_start(); - // Ensure WEL is 0 after the operation, even if the write failed. - esp_rom_spiflash_write_disable(); - spi_flash_check_and_flush_cache(dst, size); - spi_flash_guard_end(); - - return spi_flash_translate_rc(rc); -} -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL - -#if !CONFIG_SPI_FLASH_USE_LEGACY_IMPL -#if !CONFIG_ESPTOOLPY_OCT_FLASH // Test for encryption on opi flash, IDF-3852. -extern void spi_common_set_dummy_output(esp_rom_spiflash_read_mode_t mode); -extern void spi_dummy_len_fix(uint8_t spi, uint8_t freqdiv); -void IRAM_ATTR flash_rom_init(void) -{ - uint32_t freqdiv = 0; - -#if CONFIG_IDF_TARGET_ESP32 - uint32_t dummy_bit = 0; -#if CONFIG_ESPTOOLPY_FLASHFREQ_80M - dummy_bit = ESP_ROM_SPIFLASH_DUMMY_LEN_PLUS_80M; -#elif CONFIG_ESPTOOLPY_FLASHFREQ_40M - dummy_bit = ESP_ROM_SPIFLASH_DUMMY_LEN_PLUS_40M; -#elif CONFIG_ESPTOOLPY_FLASHFREQ_26M - dummy_bit = ESP_ROM_SPIFLASH_DUMMY_LEN_PLUS_26M; -#elif CONFIG_ESPTOOLPY_FLASHFREQ_20M - dummy_bit = ESP_ROM_SPIFLASH_DUMMY_LEN_PLUS_20M; -#endif -#endif//CONFIG_IDF_TARGET_ESP32 - -#if CONFIG_ESPTOOLPY_FLASHFREQ_80M - freqdiv = 1; -#elif CONFIG_ESPTOOLPY_FLASHFREQ_40M - freqdiv = 2; -#elif CONFIG_ESPTOOLPY_FLASHFREQ_26M - freqdiv = 3; -#elif CONFIG_ESPTOOLPY_FLASHFREQ_20M - freqdiv = 4; -#endif - -#if !CONFIG_IDF_TARGET_ESP32S2 && !CONFIG_IDF_TARGET_ESP32 - esp_rom_spiflash_read_mode_t read_mode; -#if CONFIG_ESPTOOLPY_FLASHMODE_QIO - read_mode = ESP_ROM_SPIFLASH_QIO_MODE; -#elif CONFIG_ESPTOOLPY_FLASHMODE_QOUT - read_mode = ESP_ROM_SPIFLASH_QOUT_MODE; -#elif CONFIG_ESPTOOLPY_FLASHMODE_DIO - read_mode = ESP_ROM_SPIFLASH_DIO_MODE; -#elif CONFIG_ESPTOOLPY_FLASHMODE_DOUT - read_mode = ESP_ROM_SPIFLASH_DOUT_MODE; -#endif -#endif //!CONFIG_IDF_TARGET_ESP32S2 && !CONFIG_IDF_TARGET_ESP32 - -#if CONFIG_IDF_TARGET_ESP32 - g_rom_spiflash_dummy_len_plus[1] = dummy_bit; -#else - spi_dummy_len_fix(1, freqdiv); -#endif //CONFIG_IDF_TARGET_ESP32 - -#if !CONFIG_IDF_TARGET_ESP32S2 && !CONFIG_IDF_TARGET_ESP32 - spi_common_set_dummy_output(read_mode); -#endif //!CONFIG_IDF_TARGET_ESP32S2 - esp_rom_spiflash_config_clk(freqdiv, 1); -} -#endif //CONFIG_ESPTOOLPY_OCT_FLASH -#else -void IRAM_ATTR flash_rom_init(void) -{ - return; -} - -esp_err_t IRAM_ATTR spi_flash_write_encrypted(size_t dest_addr, const void *src, size_t size) -{ - esp_err_t err = ESP_OK; - const spi_flash_guard_funcs_t *guard = spi_flash_guard_get(); - CHECK_WRITE_ADDRESS(dest_addr, size); - if ((dest_addr % 16) != 0) { - return ESP_ERR_INVALID_ARG; - } - if ((size % 16) != 0) { - return ESP_ERR_INVALID_SIZE; - } - - COUNTER_START(); - esp_rom_spiflash_result_t rc = spi_flash_unlock(); - err = spi_flash_translate_rc(rc); - if (err != ESP_OK) { - goto fail; - } - -#ifndef CONFIG_SPI_FLASH_VERIFY_WRITE - err = spi_flash_write_encrypted_chip(dest_addr, src, size); - COUNTER_ADD_BYTES(write, size); - spi_flash_guard_start(); - esp_rom_spiflash_write_disable(); - spi_flash_check_and_flush_cache(dest_addr, size); - spi_flash_guard_end(); -#else - const uint32_t* src_w = (const uint32_t*)src; - uint32_t read_buf[ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM / sizeof(uint32_t)]; - int32_t remaining = size; - for(int i = 0; i < size; i += sizeof(read_buf)) { - int i_w = i / sizeof(uint32_t); // index in words (i is an index in bytes) - int32_t read_len = MIN(sizeof(read_buf), remaining); - - // Read "before" contents from flash - esp_err_t err = spi_flash_read(dest_addr + i, read_buf, read_len); - if (err != ESP_OK) { - break; - } - -#ifdef CONFIG_SPI_FLASH_WARN_SETTING_ZERO_TO_ONE - //The written data cannot be predicted, so warning is shown if any of the bits is not 1. - for (int r = 0; r < read_len; r += sizeof(uint32_t)) { - uint32_t before = read_buf[r / sizeof(uint32_t)]; - if (before != 0xFFFFFFFF) { - ESP_LOGW(TAG, "Encrypted write at offset 0x%x but not erased (0x%08x)", - dest_addr + i + r, before); - } - } -#endif - - err = spi_flash_write_encrypted_chip(dest_addr + i, src + i, read_len); - if (err != ESP_OK) { - break; - } - COUNTER_ADD_BYTES(write, size); - - spi_flash_guard_start(); - esp_rom_spiflash_write_disable(); - spi_flash_check_and_flush_cache(dest_addr, size); - spi_flash_guard_end(); - - err = spi_flash_read_encrypted(dest_addr + i, read_buf, read_len); - if (err != ESP_OK) { - break; - } - - for (int r = 0; r < read_len; r += sizeof(uint32_t)) { - int r_w = r / sizeof(uint32_t); // index in words (r is index in bytes) - - uint32_t expected = src_w[i_w + r_w]; - uint32_t actual = read_buf[r_w]; - if (expected != actual) { -#ifdef CONFIG_SPI_FLASH_LOG_FAILED_WRITE - ESP_LOGE(TAG, "Bad write at offset 0x%x expected 0x%08x readback 0x%08x", dest_addr + i + r, expected, actual); -#endif - err = ESP_FAIL; - } - } - if (err != ESP_OK) { - break; - } - remaining -= read_len; - } -#endif // CONFIG_SPI_FLASH_VERIFY_WRITE - -fail: - - COUNTER_STOP(write); - return err; -} - -esp_err_t IRAM_ATTR spi_flash_read(size_t src, void *dstv, size_t size) -{ - // Out of bound reads are checked in ROM code, but we can give better - // error code here - if (src + size > g_rom_flashchip.chip_size) { - return ESP_ERR_INVALID_SIZE; - } - if (size == 0) { - return ESP_OK; - } - - esp_rom_spiflash_result_t rc = ESP_ROM_SPIFLASH_RESULT_OK; - COUNTER_START(); - spi_flash_guard_start(); - /* To simplify boundary checks below, we handle small reads separately. */ - if (size < 16) { - uint32_t t[6]; /* Enough for 16 bytes + 4 on either side for padding. */ - uint32_t read_src = src & ~3U; - uint32_t left_off = src & 3U; - uint32_t read_size = (left_off + size + 3) & ~3U; - rc = esp_rom_spiflash_read(read_src, t, read_size); - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - goto out; - } - COUNTER_ADD_BYTES(read, read_size); -#ifdef ESP_PLATFORM - if (esp_ptr_external_ram(dstv)) { - spi_flash_guard_end(); - memcpy(dstv, ((uint8_t *) t) + left_off, size); - spi_flash_guard_start(); - } else { - memcpy(dstv, ((uint8_t *) t) + left_off, size); - } -#else - memcpy(dstv, ((uint8_t *) t) + left_off, size); -#endif - goto out; - } - uint8_t *dstc = (uint8_t *) dstv; - intptr_t dsti = (intptr_t) dstc; - /* - * Large operations are split into (up to) 3 parts: - * - The middle part: from the first 4-aligned position in src to the first - * 4-aligned position in dst. - */ - size_t src_mid_off = (src % 4 == 0 ? 0 : 4 - (src % 4)); - size_t dst_mid_off = (dsti % 4 == 0 ? 0 : 4 - (dsti % 4)); - size_t mid_size = (size - MAX(src_mid_off, dst_mid_off)) & ~3U; - /* - * - Once the middle part is in place, src_mid_off bytes from the preceding - * 4-aligned source location are added on the left. - */ - size_t pad_left_src = src & ~3U; - size_t pad_left_size = src_mid_off; - /* - * - Finally, the right part is added: from the end of the middle part to - * the end. Depending on the alignment of source and destination, this may - * be a 4 or 8 byte read from pad_right_src. - */ - size_t pad_right_src = (src + pad_left_size + mid_size) & ~3U; - size_t pad_right_off = (pad_right_src - src); - size_t pad_right_size = (size - pad_right_off); - -#ifdef ESP_PLATFORM - bool direct_read = esp_ptr_internal(dstc) - && esp_ptr_byte_accessible(dstc) - && ((uintptr_t) dstc + dst_mid_off) % 4 == 0; -#else - bool direct_read = true; -#endif - if (mid_size > 0) { - uint32_t mid_remaining = mid_size; - uint32_t mid_read = 0; - while (mid_remaining > 0) { - uint32_t read_size = MIN(mid_remaining, MAX_READ_CHUNK); - uint32_t read_buf[8]; - uint8_t *read_dst_final = dstc + dst_mid_off + mid_read; - uint8_t *read_dst = read_dst_final; - if (!direct_read) { - read_size = MIN(read_size, sizeof(read_buf)); - read_dst = (uint8_t *) read_buf; - } - rc = esp_rom_spiflash_read(src + src_mid_off + mid_read, - (uint32_t *) read_dst, read_size); - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - goto out; - } - mid_remaining -= read_size; - mid_read += read_size; - if (!direct_read) { - spi_flash_guard_end(); - memcpy(read_dst_final, read_buf, read_size); - spi_flash_guard_start(); - } else if (mid_remaining > 0) { - /* Drop guard momentarily, allows other tasks to preempt */ - spi_flash_guard_end(); - spi_flash_guard_start(); - } - } - COUNTER_ADD_BYTES(read, mid_size); - /* - * If offsets in src and dst are different, perform an in-place shift - * to put destination data into its final position. - * Note that the shift can be left (src_mid_off < dst_mid_off) or right. - */ - if (src_mid_off != dst_mid_off) { - if (!direct_read) { - spi_flash_guard_end(); - } - memmove(dstc + src_mid_off, dstc + dst_mid_off, mid_size); - if (!direct_read) { - spi_flash_guard_start(); - } - } - } - if (pad_left_size > 0) { - uint32_t t; - rc = esp_rom_spiflash_read(pad_left_src, &t, 4); - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - goto out; - } - COUNTER_ADD_BYTES(read, 4); - if (!direct_read) { - spi_flash_guard_end(); - } - memcpy(dstc, ((uint8_t *) &t) + (4 - pad_left_size), pad_left_size); - if (!direct_read) { - spi_flash_guard_start(); - } - } - if (pad_right_size > 0) { - uint32_t t[2]; - int32_t read_size = (pad_right_size <= 4 ? 4 : 8); - rc = esp_rom_spiflash_read(pad_right_src, t, read_size); - if (rc != ESP_ROM_SPIFLASH_RESULT_OK) { - goto out; - } - COUNTER_ADD_BYTES(read, read_size); - if (!direct_read) { - spi_flash_guard_end(); - } - memcpy(dstc + pad_right_off, t, pad_right_size); - if (!direct_read) { - spi_flash_guard_start(); - } - } -out: - spi_flash_guard_end(); - COUNTER_STOP(read); - return spi_flash_translate_rc(rc); -} -#endif // !CONFIG_SPI_FLASH_USE_LEGACY_IMPL - -esp_err_t IRAM_ATTR spi_flash_read_encrypted(size_t src, void *dstv, size_t size) -{ - if (src + size > g_rom_flashchip.chip_size) { - return ESP_ERR_INVALID_SIZE; - } - if (size == 0) { - return ESP_OK; - } - - esp_err_t err; - const uint8_t *map; - spi_flash_mmap_handle_t map_handle; - size_t map_src = src & ~(SPI_FLASH_MMU_PAGE_SIZE - 1); - size_t map_size = size + (src - map_src); - - err = spi_flash_mmap(map_src, map_size, SPI_FLASH_MMAP_DATA, (const void **)&map, &map_handle); - if (err != ESP_OK) { - return err; - } - memcpy(dstv, map + (src - map_src), size); - spi_flash_munmap(map_handle); - return err; -} - -#if CONFIG_SPI_FLASH_USE_LEGACY_IMPL -static esp_err_t IRAM_ATTR spi_flash_translate_rc(esp_rom_spiflash_result_t rc) -{ - switch (rc) { - case ESP_ROM_SPIFLASH_RESULT_OK: - return ESP_OK; - case ESP_ROM_SPIFLASH_RESULT_TIMEOUT: - return ESP_ERR_FLASH_OP_TIMEOUT; - case ESP_ROM_SPIFLASH_RESULT_ERR: - default: - return ESP_ERR_FLASH_OP_FAIL; - } -} -#endif //CONFIG_SPI_FLASH_USE_LEGACY_IMPL - #if CONFIG_SPI_FLASH_ENABLE_COUNTERS static inline void dump_counter(spi_flash_counter_t *counter, const char *name) @@ -895,11 +196,6 @@ void spi_flash_dump_counters(void) #endif //CONFIG_SPI_FLASH_ENABLE_COUNTERS -#if CONFIG_SPI_FLASH_USE_LEGACY_IMPL && !CONFIG_IDF_TARGET_ESP32 -// TODO esp32s2: Remove once ESP32-S2 & later chips has new SPI Flash API support -esp_flash_t *esp_flash_default_chip = NULL; -#endif - void IRAM_ATTR spi_flash_set_rom_required_regs(void) { #if CONFIG_ESPTOOLPY_OCT_FLASH diff --git a/components/spi_flash/include/esp_flash.h b/components/spi_flash/include/esp_flash.h index a203fe0a09..6f7bd5f27b 100644 --- a/components/spi_flash/include/esp_flash.h +++ b/components/spi_flash/include/esp_flash.h @@ -180,7 +180,7 @@ esp_err_t esp_flash_erase_chip(esp_flash_t *chip); /** @brief Erase a region of the flash chip * - * @param chip Pointer to identify flash chip. Must have been successfully initialised via esp_flash_init() + * @param chip Pointer to identify flash chip. If NULL, esp_flash_default_chip is substituted. Must have been successfully initialised via esp_flash_init() * @param start Address to start erasing flash. Must be sector aligned. * @param len Length of region to erase. Must also be sector aligned. * @@ -200,7 +200,7 @@ esp_err_t esp_flash_erase_region(esp_flash_t *chip, uint32_t start, uint32_t len /** @brief Read if the entire chip is write protected * - * @param chip Pointer to identify flash chip. Must have been successfully initialised via esp_flash_init() + * @param chip Pointer to identify flash chip. If NULL, esp_flash_default_chip is substituted. Must have been successfully initialised via esp_flash_init() * @param[out] write_protected Pointer to boolean, set to the value of the write protect flag. * * @note A correct result for this flag depends on the SPI flash chip model and chip_drv in use (via the 'chip->drv' @@ -212,7 +212,7 @@ esp_err_t esp_flash_get_chip_write_protect(esp_flash_t *chip, bool *write_protec /** @brief Set write protection for the SPI flash chip * - * @param chip Pointer to identify flash chip. Must have been successfully initialised via esp_flash_init() + * @param chip Pointer to identify flash chip. If NULL, esp_flash_default_chip is substituted. Must have been successfully initialised via esp_flash_init() * @param write_protect Boolean value for the write protect flag * * @note Correct behaviour of this function depends on the SPI flash chip model and chip_drv in use (via the 'chip->drv' @@ -272,7 +272,7 @@ esp_err_t esp_flash_set_protected_region(esp_flash_t *chip, const esp_flash_regi /** @brief Read data from the SPI flash chip * - * @param chip Pointer to identify flash chip. Must have been successfully initialised via esp_flash_init() + * @param chip Pointer to identify flash chip. If NULL, esp_flash_default_chip is substituted. Must have been successfully initialised via esp_flash_init() * @param buffer Pointer to a buffer where the data will be read. To get better performance, this should be in the DRAM and word aligned. * @param address Address on flash to read from. Must be less than chip->size field. * @param length Length (in bytes) of data to read. @@ -291,7 +291,7 @@ esp_err_t esp_flash_read(esp_flash_t *chip, void *buffer, uint32_t address, uint /** @brief Write data to the SPI flash chip * - * @param chip Pointer to identify flash chip. Must have been successfully initialised via esp_flash_init() + * @param chip Pointer to identify flash chip. If NULL, esp_flash_default_chip is substituted. Must have been successfully initialised via esp_flash_init() * @param address Address on flash to write to. Must be previously erased (SPI NOR flash can only write bits 1->0). * @param buffer Pointer to a buffer with the data to write. To get better performance, this should be in the DRAM and word aligned. * @param length Length (in bytes) of data to write. @@ -318,7 +318,6 @@ esp_err_t esp_flash_write(esp_flash_t *chip, const void *buffer, uint32_t addres * - ESP_OK: on success * - ESP_ERR_NOT_SUPPORTED: encrypted write not supported for this chip. * - ESP_ERR_INVALID_ARG: Either the address, buffer or length is invalid. - * - or other flash error code from spi_flash_write_encrypted(). */ esp_err_t esp_flash_write_encrypted(esp_flash_t *chip, uint32_t address, const void *buffer, uint32_t length); @@ -332,7 +331,6 @@ esp_err_t esp_flash_write_encrypted(esp_flash_t *chip, uint32_t address, const v * @return * - ESP_OK: on success * - ESP_ERR_NOT_SUPPORTED: encrypted read not supported for this chip. - * - or other flash error code from spi_flash_read_encrypted(). */ esp_err_t esp_flash_read_encrypted(esp_flash_t *chip, uint32_t address, void *out_buffer, uint32_t length); diff --git a/components/spi_flash/include/esp_flash_internal.h b/components/spi_flash/include/esp_flash_internal.h index 31dd6d8b1a..e329b4d5f0 100644 --- a/components/spi_flash/include/esp_flash_internal.h +++ b/components/spi_flash/include/esp_flash_internal.h @@ -24,11 +24,7 @@ extern "C" { * * Called by OS startup code. You do not need to call this in your own applications. */ -#ifdef CONFIG_SPI_FLASH_USE_LEGACY_IMPL -#define esp_flash_init_default_chip(...) ({ESP_OK;}) -#else esp_err_t esp_flash_init_default_chip(void); -#endif /** * Enable OS-level SPI flash protections in IDF @@ -37,11 +33,7 @@ esp_err_t esp_flash_init_default_chip(void); * * @return ESP_OK if success, otherwise failed. See return value of ``esp_flash_init_os_functions``. */ -#ifdef CONFIG_SPI_FLASH_USE_LEGACY_IMPL -#define esp_flash_app_init(...) ({ESP_OK;}) -#else esp_err_t esp_flash_app_init(void); -#endif /** * Disable (or enable) OS-level SPI flash protections in IDF @@ -50,11 +42,7 @@ esp_err_t esp_flash_app_init(void); * * @return always ESP_OK. */ -#ifdef CONFIG_SPI_FLASH_USE_LEGACY_IMPL -#define esp_flash_app_disable_protect(...) ({ESP_OK;}) -#else esp_err_t esp_flash_app_disable_protect(bool disable); -#endif /** * Initialize OS-level functions for a specific chip. diff --git a/components/spi_flash/include/esp_partition.h b/components/spi_flash/include/esp_partition.h index 792a31e363..f67247c6db 100644 --- a/components/spi_flash/include/esp_partition.h +++ b/components/spi_flash/include/esp_partition.h @@ -12,7 +12,7 @@ #include #include "esp_err.h" #include "esp_flash.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #ifdef __cplusplus extern "C" { @@ -229,9 +229,9 @@ esp_err_t esp_partition_read(const esp_partition_t* partition, * This can be done using esp_partition_erase_range function. * * Partitions marked with an encryption flag will automatically be - * written via the spi_flash_write_encrypted() function. If writing to + * written via the esp_flash_write_encrypted() function. If writing to * an encrypted partition, all write offsets and lengths must be - * multiples of 16 bytes. See the spi_flash_write_encrypted() function + * multiples of 16 bytes. See the esp_flash_write_encrypted() function * for more details. Unencrypted partitions do not have this * restriction. * @@ -403,7 +403,6 @@ bool esp_partition_check_identity(const esp_partition_t* partition_1, const esp_ * @param[out] out_partition Output, if non-NULL, receives the pointer to the resulting esp_partition_t structure * @return * - ESP_OK on success - * - ESP_ERR_NOT_SUPPORTED if CONFIG_CONFIG_SPI_FLASH_USE_LEGACY_IMPL is enabled * - ESP_ERR_NO_MEM if memory allocation has failed * - ESP_ERR_INVALID_ARG if the new partition overlaps another partition on the same flash chip * - ESP_ERR_INVALID_SIZE if the partition doesn't fit into the flash chip size diff --git a/components/spi_flash/include/esp_private/cache_utils.h b/components/spi_flash/include/esp_private/cache_utils.h index 198e1a00d6..ddb0a9259c 100644 --- a/components/spi_flash/include/esp_private/cache_utils.h +++ b/components/spi_flash/include/esp_private/cache_utils.h @@ -10,6 +10,7 @@ #include #include #include +#include "esp_err.h" #ifdef __cplusplus extern "C" { diff --git a/components/spi_flash/include/esp_private/spi_flash_os.h b/components/spi_flash/include/esp_private/spi_flash_os.h index d4c622bb50..45766c2393 100644 --- a/components/spi_flash/include/esp_private/spi_flash_os.h +++ b/components/spi_flash/include/esp_private/spi_flash_os.h @@ -139,6 +139,101 @@ esp_err_t spi_flash_enable_high_performance_mode(void); */ const spi_flash_hpm_dummy_conf_t *spi_flash_get_dummy(void); +typedef enum { + FLASH_WRAP_MODE_8B = 0, + FLASH_WRAP_MODE_16B = 2, + FLASH_WRAP_MODE_32B = 4, + FLASH_WRAP_MODE_64B = 6, + FLASH_WRAP_MODE_DISABLE = 1 +} spi_flash_wrap_mode_t; + +/** + * @brief set wrap mode of flash + * + * @param mode: wrap mode support disable, 16 32, 64 byte + * + * @return esp_err_t : ESP_OK for successful. + * + */ +esp_err_t spi_flash_wrap_set(spi_flash_wrap_mode_t mode); + +/** + * @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 diff --git a/components/spi_flash/include/esp_spi_flash.h b/components/spi_flash/include/esp_spi_flash.h index 30480b48c8..62c02075aa 100644 --- a/components/spi_flash/include/esp_spi_flash.h +++ b/components/spi_flash/include/esp_spi_flash.h @@ -1,421 +1,7 @@ /* - * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ - -#ifndef ESP_SPI_FLASH_H -#define ESP_SPI_FLASH_H - -#include -#include -#include -#include "esp_err.h" -#include "sdkconfig.h" -#include "esp_spi_flash_counters.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#include "sdkconfig.h" -#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 */ - -typedef enum { - FLASH_WRAP_MODE_8B = 0, - FLASH_WRAP_MODE_16B = 2, - FLASH_WRAP_MODE_32B = 4, - FLASH_WRAP_MODE_64B = 6, - FLASH_WRAP_MODE_DISABLE = 1 -} spi_flash_wrap_mode_t; - -/** - * @brief set wrap mode of flash - * - * @param mode: wrap mode support disable, 16 32, 64 byte - * - * @return esp_err_t : ESP_OK for successful. - * - */ -esp_err_t spi_flash_wrap_set(spi_flash_wrap_mode_t mode); - -/** - * @brief Initialize SPI flash access driver - * - * This function must be called exactly once, before any other - * spi_flash_* functions are called. - * Currently this function is called from startup code. There is - * no need to call it from application code. - * - */ -void spi_flash_init(void); - -/** - * @brief Get flash chip size, as set in binary image header - * - * @note This value does not necessarily match real flash size. - * - * @return size of flash chip, in bytes - */ -size_t spi_flash_get_chip_size(void); - -/** - * @brief Erase the Flash sector. - * - * @param sector: Sector number, the count starts at sector 0, 4KB per sector. - * - * @return esp_err_t - */ -esp_err_t spi_flash_erase_sector(size_t sector); - -/** - * @brief Erase a range of flash sectors - * - * @param start_address Address where erase operation has to start. - * Must be 4kB-aligned - * @param size Size of erased range, in bytes. Must be divisible by 4kB. - * - * @return esp_err_t - */ -esp_err_t spi_flash_erase_range(size_t start_address, size_t size); - - -/** - * @brief Write data to Flash. - * - * @note For fastest write performance, write a 4 byte aligned size at a - * 4 byte aligned offset in flash from a source buffer in DRAM. Varying any of - * these parameters will still work, but will be slower due to buffering. - * - * @note Writing more than 8KB at a time will be split into multiple - * write operations to avoid disrupting other tasks in the system. - * - * @param dest_addr Destination address in Flash. - * @param src Pointer to the source buffer. - * @param size Length of data, in bytes. - * - * @return esp_err_t - */ -esp_err_t spi_flash_write(size_t dest_addr, const void *src, size_t size); - - -/** - * @brief Write data encrypted to Flash. - * - * @note Flash encryption must be enabled for this function to work. - * - * @note Flash encryption must be enabled when calling this function. - * If flash encryption is disabled, the function returns - * ESP_ERR_INVALID_STATE. Use esp_flash_encryption_enabled() - * function to determine if flash encryption is enabled. - * - * @note Both dest_addr and size must be multiples of 16 bytes. For - * absolute best performance, both dest_addr and size arguments should - * be multiples of 32 bytes. - * - * @param dest_addr Destination address in Flash. Must be a multiple of 16 bytes. - * @param src Pointer to the source buffer. - * @param size Length of data, in bytes. Must be a multiple of 16 bytes. - * - * @return esp_err_t - */ -esp_err_t spi_flash_write_encrypted(size_t dest_addr, const void *src, size_t size); - -/** - * @brief Read data from Flash. - * - * @note For fastest read performance, all parameters should be - * 4 byte aligned. If source address and read size are not 4 byte - * aligned, read may be split into multiple flash operations. If - * destination buffer is not 4 byte aligned, a temporary buffer will - * be allocated on the stack. - * - * @note Reading more than 16KB of data at a time will be split - * into multiple reads to avoid disruption to other tasks in the - * system. Consider using spi_flash_mmap() to read large amounts - * of data. - * - * @param src_addr source address of the data in Flash. - * @param dest pointer to the destination buffer - * @param size length of data - * - * - * @return esp_err_t - */ -esp_err_t spi_flash_read(size_t src_addr, void *dest, size_t size); - - -/** - * @brief Read data from Encrypted Flash. - * - * If flash encryption is enabled, this function will transparently decrypt data as it is read. - * If flash encryption is not enabled, this function behaves the same as spi_flash_read(). - * - * See esp_flash_encryption_enabled() for a function to check if flash encryption is enabled. - * - * @param src source address of the data in Flash. - * @param dest pointer to the destination buffer - * @param size length of data - * - * @return esp_err_t - */ -esp_err_t spi_flash_read_encrypted(size_t src, void *dest, size_t size); - -/** - * @brief Enumeration which specifies memory space requested in an mmap call - */ -typedef enum { - SPI_FLASH_MMAP_DATA, /**< map to data memory (Vaddr0), allows byte-aligned access, 4 MB total */ - SPI_FLASH_MMAP_INST, /**< map to instruction memory (Vaddr1-3), allows only 4-byte-aligned access, 11 MB total */ -} spi_flash_mmap_memory_t; - -/** - * @brief Opaque handle for memory region obtained from spi_flash_mmap. - */ -typedef uint32_t spi_flash_mmap_handle_t; - -/** - * @brief Map region of flash memory into data or instruction address space - * - * This function allocates sufficient number of 64kB MMU pages and configures - * them to map the requested region of flash memory into the address space. - * It may reuse MMU pages which already provide the required mapping. - * - * As with any allocator, if mmap/munmap are heavily used then the address space - * may become fragmented. To troubleshoot issues with page allocation, use - * spi_flash_mmap_dump() function. - * - * @param src_addr Physical address in flash where requested region starts. - * This address *must* be aligned to 64kB boundary - * (SPI_FLASH_MMU_PAGE_SIZE) - * @param size Size of region to be mapped. This size will be rounded - * up to a 64kB boundary - * @param memory Address space where the region should be mapped (data or instruction) - * @param[out] out_ptr Output, pointer to the mapped memory region - * @param[out] out_handle Output, handle which should be used for spi_flash_munmap call - * - * @return ESP_OK on success, ESP_ERR_NO_MEM if pages can not be allocated - */ -esp_err_t spi_flash_mmap(size_t src_addr, size_t size, spi_flash_mmap_memory_t memory, - const void** out_ptr, spi_flash_mmap_handle_t* out_handle); - -/** - * @brief Map sequences of pages of flash memory into data or instruction address space - * - * This function allocates sufficient number of 64kB MMU pages and configures - * them to map the indicated pages of flash memory contiguously into address space. - * In this respect, it works in a similar way as spi_flash_mmap() but it allows mapping - * a (maybe non-contiguous) set of pages into a contiguous region of memory. - * - * @param pages An array of numbers indicating the 64kB pages in flash to be mapped - * contiguously into memory. These indicate the indexes of the 64kB pages, - * not the byte-size addresses as used in other functions. - * Array must be located in internal memory. - * @param page_count Number of entries in the pages array - * @param memory Address space where the region should be mapped (instruction or data) - * @param[out] out_ptr Output, pointer to the mapped memory region - * @param[out] out_handle Output, handle which should be used for spi_flash_munmap call - * - * @return - * - ESP_OK on success - * - ESP_ERR_NO_MEM if pages can not be allocated - * - ESP_ERR_INVALID_ARG if pagecount is zero or pages array is not in - * internal memory - */ -esp_err_t spi_flash_mmap_pages(const int *pages, size_t page_count, spi_flash_mmap_memory_t memory, - const void** out_ptr, spi_flash_mmap_handle_t* out_handle); - - -/** - * @brief Release region previously obtained using spi_flash_mmap - * - * @note Calling this function will not necessarily unmap memory region. - * Region will only be unmapped when there are no other handles which - * reference this region. In case of partially overlapping regions - * it is possible that memory will be unmapped partially. - * - * @param handle Handle obtained from spi_flash_mmap - */ -void spi_flash_munmap(spi_flash_mmap_handle_t handle); - -/** - * @brief Display information about mapped regions - * - * This function lists handles obtained using spi_flash_mmap, along with range - * of pages allocated to each handle. It also lists all non-zero entries of - * MMU table and corresponding reference counts. - */ -void spi_flash_mmap_dump(void); - -/** - * @brief get free pages number which can be mmap - * - * This function will return number of free pages available in mmu table. This could be useful - * before calling actual spi_flash_mmap (maps flash range to DCache or ICache memory) to check - * if there is sufficient space available for mapping. - * - * @param memory memory type of MMU table free page - * - * @return number of free pages which can be mmaped - */ -uint32_t spi_flash_mmap_get_free_pages(spi_flash_mmap_memory_t memory); - - -#define SPI_FLASH_CACHE2PHYS_FAIL UINT32_MAX /* flash_chip->size) { return ESP_ERR_INVALID_SIZE; diff --git a/components/spi_flash/partition_target.c b/components/spi_flash/partition_target.c index 166aab1351..cacdc3bba5 100644 --- a/components/spi_flash/partition_target.c +++ b/components/spi_flash/partition_target.c @@ -17,7 +17,7 @@ #include "esp_flash_encrypt.h" #include "esp_log.h" #include "esp_rom_md5.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "bootloader_common.h" #include "esp_ota_ops.h" @@ -35,11 +35,7 @@ esp_err_t esp_partition_read(const esp_partition_t *partition, } if (!partition->encrypted) { -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL return esp_flash_read(partition->flash_chip, dst, partition->address + src_offset, size); -#else - return spi_flash_read(partition->address + src_offset, dst, size); -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL } #if CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE @@ -76,23 +72,14 @@ esp_err_t esp_partition_write(const esp_partition_t *partition, } dst_offset = partition->address + dst_offset; if (!partition->encrypted) { -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL return esp_flash_write(partition->flash_chip, src, dst_offset, size); -#else - return spi_flash_write(dst_offset, src, size); -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL } #if CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE if (partition->flash_chip != esp_flash_default_chip) { return ESP_ERR_NOT_SUPPORTED; } - -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL return esp_flash_write_encrypted(partition->flash_chip, dst_offset, src, size); -#else - return spi_flash_write_encrypted(dst_offset, src, size); -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL #else return ESP_ERR_NOT_SUPPORTED; #endif // CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE @@ -109,11 +96,7 @@ esp_err_t esp_partition_read_raw(const esp_partition_t *partition, return ESP_ERR_INVALID_SIZE; } -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL return esp_flash_read(partition->flash_chip, dst, partition->address + src_offset, size); -#else - return spi_flash_read(partition->address + src_offset, dst, size); -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL } esp_err_t esp_partition_write_raw(const esp_partition_t *partition, @@ -128,11 +111,7 @@ esp_err_t esp_partition_write_raw(const esp_partition_t *partition, } dst_offset = partition->address + dst_offset; -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL return esp_flash_write(partition->flash_chip, src, dst_offset, size); -#else - return spi_flash_write(dst_offset, src, size); -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL } esp_err_t esp_partition_erase_range(const esp_partition_t *partition, @@ -151,11 +130,8 @@ esp_err_t esp_partition_erase_range(const esp_partition_t *partition, if (offset % SPI_FLASH_SEC_SIZE != 0) { return ESP_ERR_INVALID_ARG; } -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL + return esp_flash_erase_region(partition->flash_chip, partition->address + offset, size); -#else - return spi_flash_erase_range(partition->address + offset, size); -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL } /* diff --git a/components/spi_flash/sim/Makefile.files b/components/spi_flash/sim/Makefile.files index 0fdb0c759d..fa36a035e8 100644 --- a/components/spi_flash/sim/Makefile.files +++ b/components/spi_flash/sim/Makefile.files @@ -6,7 +6,6 @@ SOURCE_FILES := \ partition.c \ ../spi_flash/partition_target.c \ flash_ops.c \ - esp32/flash_ops_esp32.c \ ) \ INCLUDE_DIRS := \ @@ -16,6 +15,7 @@ INCLUDE_DIRS := \ ../private_include \ $(addprefix stubs/, \ app_update/include \ + bsd/include \ driver/include \ esp_timer/include \ freertos/include \ diff --git a/components/spi_flash/sim/flash_mock.cpp b/components/spi_flash/sim/flash_mock.cpp index 6e757d3aca..f047cd5cba 100644 --- a/components/spi_flash/sim/flash_mock.cpp +++ b/components/spi_flash/sim/flash_mock.cpp @@ -3,11 +3,13 @@ #include #include -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_partition.h" #include "esp_err.h" #include "esp_rom_spiflash.h" +#include "esp_flash.h" +#include "bsd_strings.h" SpiFlash spiflash = SpiFlash(); @@ -85,6 +87,11 @@ esp_rom_spiflash_result_t esp_rom_spiflash_read(uint32_t target, uint32_t *dest, return spiflash.read(target, dest, len); } +extern "C" esp_err_t esp_flash_read(esp_flash_t *chip, void *buffer, uint32_t address, uint32_t length) +{ + return spiflash.read(address, buffer, length); +} + esp_rom_spiflash_result_t esp_rom_spiflash_erase_block(uint32_t block) { return spiflash.erase_block(block); @@ -100,11 +107,29 @@ esp_rom_spiflash_result_t esp_rom_spiflash_erase_page(uint32_t page) return spiflash.erase_page(page); } +extern "C" esp_err_t esp_flash_erase_region(esp_flash_t *chip, uint32_t start_addr, uint32_t size) +{ + size_t start = start_addr / SPI_FLASH_SEC_SIZE; + size_t end = start + size / SPI_FLASH_SEC_SIZE; + const size_t sectors_per_block = 65536 / SPI_FLASH_SEC_SIZE; + esp_rom_spiflash_result_t rc = ESP_ROM_SPIFLASH_RESULT_OK; + for (size_t sector = start; sector != end && rc == ESP_ROM_SPIFLASH_RESULT_OK; ) { + rc = spiflash.erase_sector(sector); + ++sector; + } + return rc; +} + esp_rom_spiflash_result_t esp_rom_spiflash_write(uint32_t target, const uint32_t *src, int32_t len) { return spiflash.write(target, src, len); } +extern "C" esp_err_t esp_flash_write(esp_flash_t *chip, const void *buffer, uint32_t address, uint32_t length) +{ + return spiflash.write(address, buffer, length); +} + esp_rom_spiflash_result_t esp_rom_spiflash_write_encrypted(uint32_t flash_addr, uint32_t *data, uint32_t len) { return spiflash.write(flash_addr, data, len); diff --git a/components/spi_flash/sim/flash_mock_util.c b/components/spi_flash/sim/flash_mock_util.c index a6c1a0dd60..b84e2307c8 100644 --- a/components/spi_flash/sim/flash_mock_util.c +++ b/components/spi_flash/sim/flash_mock_util.c @@ -1,4 +1,4 @@ -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_partition.h" #include "esp_err.h" diff --git a/components/spi_flash/sim/stubs/Makefile.files b/components/spi_flash/sim/stubs/Makefile.files index a241826811..dd6591666d 100644 --- a/components/spi_flash/sim/stubs/Makefile.files +++ b/components/spi_flash/sim/stubs/Makefile.files @@ -5,12 +5,14 @@ SOURCE_FILES := \ esp32/crc.cpp \ esp32/esp_random.c \ esp_timer/src/esp_timer.c \ + bsd/strlcpy.c\ bootloader_support/src/bootloader_common.c INCLUDE_DIRS := \ ../include \ ../private_include \ app_update/include \ + bsd/include \ driver/include \ esp_timer/include \ freertos/include \ diff --git a/components/spi_flash/spi_flash_os_func_app.c b/components/spi_flash/spi_flash_os_func_app.c index 01e2ecd7d6..75824da138 100644 --- a/components/spi_flash/spi_flash_os_func_app.c +++ b/components/spi_flash/spi_flash_os_func_app.c @@ -8,7 +8,6 @@ #include //For max/min #include "esp_attr.h" #include "esp_private/system_internal.h" -#include "esp_spi_flash.h" //for ``g_flash_guard_default_ops`` #include "esp_flash.h" #include "esp_flash_partitions.h" #include "freertos/FreeRTOS.h" @@ -19,6 +18,7 @@ #include "esp_compiler.h" #include "esp_rom_sys.h" #include "esp_private/spi_flash_os.h" +#include "esp_private/cache_utils.h" #include "esp_private/spi_common_internal.h" @@ -61,14 +61,14 @@ static inline bool on_spi1_check_yield(spi1_app_func_arg_t* ctx); IRAM_ATTR static void cache_enable(void* arg) { #ifndef CONFIG_SPI_FLASH_AUTO_SUSPEND - g_flash_guard_default_ops.end(); + spi_flash_enable_interrupts_caches_and_other_cpu(); #endif } IRAM_ATTR static void cache_disable(void* arg) { #ifndef CONFIG_SPI_FLASH_AUTO_SUSPEND - g_flash_guard_default_ops.start(); + spi_flash_disable_interrupts_caches_and_other_cpu(); #endif } diff --git a/components/spi_flash/test/CMakeLists.txt b/components/spi_flash/test/CMakeLists.txt index 30b3479006..7ae600b5b2 100644 --- a/components/spi_flash/test/CMakeLists.txt +++ b/components/spi_flash/test/CMakeLists.txt @@ -1,9 +1,4 @@ -if(CONFIG_SPI_FLASH_USE_LEGACY_IMPL) - set(exclude_srcs "test_esp_flash.c" "test_partition_ext.c") -endif() - idf_component_register(SRC_DIRS "." - EXCLUDE_SRCS "${exclude_srcs}" PRIV_INCLUDE_DIRS "." PRIV_REQUIRES cmock test_utils spi_flash bootloader_support app_update driver esp_timer) diff --git a/components/spi_flash/test/test_cache_disabled.c b/components/spi_flash/test/test_cache_disabled.c index c9d51c2139..afafe6461a 100644 --- a/components/spi_flash/test/test_cache_disabled.c +++ b/components/spi_flash/test/test_cache_disabled.c @@ -12,11 +12,11 @@ #include #include -#include +#include #include #include -#include "../cache_utils.h" +#include "esp_private/cache_utils.h" static QueueHandle_t result_queue; diff --git a/components/spi_flash/test/test_flash_encryption.c b/components/spi_flash/test/test_flash_encryption.c index 673e00aed9..e9759a133e 100644 --- a/components/spi_flash/test/test_flash_encryption.c +++ b/components/spi_flash/test/test_flash_encryption.c @@ -5,7 +5,7 @@ #include #include -#include +#include #include #include #include @@ -39,10 +39,9 @@ static void verify_erased_flash(size_t offset, size_t length) uint8_t *readback = (uint8_t *)heap_caps_malloc(SPI_FLASH_SEC_SIZE, MALLOC_CAP_32BIT | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL); printf("verify erased 0x%x - 0x%x\n", offset, offset + length); TEST_ASSERT_EQUAL_HEX(ESP_OK, - spi_flash_read(offset, readback, length)); + esp_flash_read(NULL, readback, offset, length)); for (int i = 0; i < length; i++) { - char message[32]; - TEST_ASSERT_EQUAL_HEX_MESSAGE(0xFF, readback[i], message); + TEST_ASSERT_EQUAL_HEX8(0xFF, readback[i]); } free(readback); } @@ -52,7 +51,7 @@ TEST_CASE("test 16 byte encrypted writes", "[flash_encryption][test_env=UT_T1_Fl setup_tests(); TEST_ASSERT_EQUAL_HEX(ESP_OK, - spi_flash_erase_sector(start / SPI_FLASH_SEC_SIZE)); + esp_flash_erase_region(NULL, start, SPI_FLASH_SEC_SIZE)); uint8_t fortyeight_bytes[0x30]; // 0, 1, 2, 3, 4... 47 for(int i = 0; i < sizeof(fortyeight_bytes); i++) { @@ -61,10 +60,10 @@ TEST_CASE("test 16 byte encrypted writes", "[flash_encryption][test_env=UT_T1_Fl /* Verify unaligned start or length fails */ TEST_ASSERT_EQUAL_HEX(ESP_ERR_INVALID_ARG, - spi_flash_write_encrypted(start+1, fortyeight_bytes, 32)); + esp_flash_write_encrypted(NULL, start + 1, fortyeight_bytes, 32)); TEST_ASSERT_EQUAL_HEX(ESP_ERR_INVALID_SIZE, - spi_flash_write_encrypted(start, fortyeight_bytes, 15)); + esp_flash_write_encrypted(NULL, start, fortyeight_bytes, 15)); /* ensure nothing happened to the flash yet */ verify_erased_flash(start, 0x20); @@ -73,9 +72,9 @@ TEST_CASE("test 16 byte encrypted writes", "[flash_encryption][test_env=UT_T1_Fl test_encrypted_write(start, fortyeight_bytes, 0x20); verify_erased_flash(start + 0x20, 0x20); - /* Slip in an unaligned spi_flash_read_encrypted() test */ + /* Slip in an unaligned esp_flash_read_encrypted() test */ uint8_t buf[0x10]; - spi_flash_read_encrypted(start+0x10, buf, 0x10); + esp_flash_read_encrypted(NULL, start+0x10, buf, 0x10); TEST_ASSERT_EQUAL_HEX8_ARRAY(fortyeight_bytes+0x10, buf, 16); /* Write 16 bytes unaligned */ @@ -100,10 +99,10 @@ static void test_encrypted_write(size_t offset, const uint8_t *data, size_t leng uint8_t readback[length]; printf("encrypt %d bytes at 0x%x\n", length, offset); TEST_ASSERT_EQUAL_HEX(ESP_OK, - spi_flash_write_encrypted(offset, data, length)); + esp_flash_write_encrypted(NULL, offset, data, length)); TEST_ASSERT_EQUAL_HEX(ESP_OK, - spi_flash_read_encrypted(offset, readback, length)); + esp_flash_read_encrypted(NULL, offset, readback, length)); TEST_ASSERT_EQUAL_HEX8_ARRAY(data, readback, length); } @@ -118,13 +117,13 @@ TEST_CASE("test read & write random encrypted data", "[flash_encryption][test_en setup_tests(); - esp_err_t err = spi_flash_erase_sector(start / SPI_FLASH_SEC_SIZE); + esp_err_t err = esp_flash_erase_region(NULL, start, SPI_FLASH_SEC_SIZE); TEST_ESP_OK(err); //initialize the buffer to compare uint8_t *cmp_buf = heap_caps_malloc(SPI_FLASH_SEC_SIZE, MALLOC_CAP_32BIT | MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL); assert(((intptr_t)cmp_buf % 4) == 0); - err = spi_flash_read_encrypted(start, cmp_buf, SPI_FLASH_SEC_SIZE); + err = esp_flash_read_encrypted(NULL, start, cmp_buf, SPI_FLASH_SEC_SIZE); TEST_ESP_OK(err); srand(789); @@ -148,7 +147,7 @@ TEST_CASE("test read & write random encrypted data", "[flash_encryption][test_en } printf("write %d bytes to 0x%08x...\n", len, start + offset); - err = spi_flash_write_encrypted(start + offset, data_buf, len); + err = esp_flash_write_encrypted(NULL, start + offset, data_buf, len); TEST_ESP_OK(err); memcpy(cmp_buf + offset, data_buf, len); @@ -162,7 +161,7 @@ TEST_CASE("test read & write random encrypted data", "[flash_encryption][test_en len = SPI_FLASH_SEC_SIZE - offset; } - err = spi_flash_read_encrypted(start + offset, data_buf, len); + err = esp_flash_read_encrypted(NULL, start + offset, data_buf, len); TEST_ESP_OK(err); printf("compare %d bytes at 0x%08x...\n", len, start + offset); @@ -174,8 +173,6 @@ TEST_CASE("test read & write random encrypted data", "[flash_encryption][test_en free(cmp_buf); } -#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL - static char TAG[] = "flash_encrypt_test"; static const char plainttext_data[] = "$$$$#### Welcome! This is flash encryption test, ..., ..., hello_world. &&&&***"; @@ -198,7 +195,7 @@ TEST_CASE("test 16 byte encrypted writes (esp_flash)", "[esp_flash_enc][flash_en setup_tests(); TEST_ASSERT_EQUAL_HEX(ESP_OK, - spi_flash_erase_sector(start / SPI_FLASH_SEC_SIZE)); + esp_flash_erase_region(NULL, start, SPI_FLASH_SEC_SIZE)); uint8_t fortyeight_bytes[0x30]; // 0, 1, 2, 3, 4... 47 for(int i = 0; i < sizeof(fortyeight_bytes); i++) { @@ -245,7 +242,7 @@ TEST_CASE("test read & write encrypted data(32 bytes alianed address)", "[esp_fl { setup_tests(); - TEST_ESP_OK(spi_flash_erase_sector(start / SPI_FLASH_SEC_SIZE)); + TEST_ESP_OK(esp_flash_erase_region(NULL, start, SPI_FLASH_SEC_SIZE)); start = (start + 31) & (~31); // round up to 32 byte boundary ESP_LOG_BUFFER_HEXDUMP(TAG, plainttext_data, sizeof(plainttext_data), ESP_LOG_INFO); @@ -270,7 +267,7 @@ TEST_CASE("test read & write encrypted data(32 bytes alianed address)", "[esp_fl TEST_CASE("test read & write encrypted data(16 bytes alianed but 32 bytes unaligned)", "[esp_flash_enc][flash_encryption][test_env=UT_T1_FlashEncryption]") { setup_tests(); - TEST_ESP_OK(spi_flash_erase_sector(start/SPI_FLASH_SEC_SIZE)); + TEST_ESP_OK(esp_flash_erase_region(NULL, start, SPI_FLASH_SEC_SIZE)); do { start++; } while ((start % 16) != 0); @@ -327,5 +324,5 @@ TEST_CASE("test read & write encrypted data with large buffer(n*64+32+16)", "[es TEST_ASSERT_EQUAL_HEX8_ARRAY(buf, large_const_buffer, sizeof(large_const_buffer)); free(buf); } -#endif // CONFIG_SPI_FLASH_USE_LEGACY_IMPL + #endif // CONFIG_SECURE_FLASH_ENC_ENABLED diff --git a/components/spi_flash/test/test_large_flash_writes.c b/components/spi_flash/test/test_large_flash_writes.c index 30701cd02d..7305f64d69 100644 --- a/components/spi_flash/test/test_large_flash_writes.c +++ b/components/spi_flash/test/test_large_flash_writes.c @@ -15,10 +15,10 @@ #include #include -#include +#include #include #include "esp_rom_spiflash.h" -#include "../cache_utils.h" +#include "esp_private/cache_utils.h" #include "soc/timer_periph.h" static const uint8_t large_const_buffer[16400] = { @@ -34,13 +34,13 @@ static const uint8_t large_const_buffer[16400] = { static void test_write_large_buffer(const uint8_t *source, size_t length); -TEST_CASE("Test spi_flash_write large const buffer", "[spi_flash][esp_flash]") +TEST_CASE("Test flash write large const buffer", "[spi_flash][esp_flash]") { // buffer in flash test_write_large_buffer(large_const_buffer, sizeof(large_const_buffer)); } -TEST_CASE("Test spi_flash_write large RAM buffer", "[spi_flash][esp_flash]") +TEST_CASE("Test flash write large RAM buffer", "[spi_flash][esp_flash]") { // buffer in RAM uint8_t *source_buf = malloc(sizeof(large_const_buffer)); @@ -60,12 +60,12 @@ static void test_write_large_buffer(const uint8_t *source, size_t length) uint8_t *buf = malloc(length); TEST_ASSERT_NOT_NULL(buf); - ESP_ERROR_CHECK( spi_flash_erase_range(part->address, (length + SPI_FLASH_SEC_SIZE) & ~(SPI_FLASH_SEC_SIZE-1)) ); + TEST_ESP_OK( esp_flash_erase_region(NULL, part->address, (length + SPI_FLASH_SEC_SIZE) & ~(SPI_FLASH_SEC_SIZE-1)) ); // note writing to unaligned address - ESP_ERROR_CHECK( spi_flash_write(part->address + 1, source, length) ); + TEST_ESP_OK( esp_flash_write(NULL, source, part->address + 1, length) ); - ESP_ERROR_CHECK( spi_flash_read(part->address + 1, buf, length) ); + TEST_ESP_OK( esp_flash_read(NULL, buf, part->address + 1, length) ); TEST_ASSERT_EQUAL_HEX8_ARRAY(source, buf, length); @@ -74,12 +74,11 @@ static void test_write_large_buffer(const uint8_t *source, size_t length) // check nothing was written at beginning or end uint8_t ends[8]; - ESP_ERROR_CHECK( spi_flash_read(part->address, ends, sizeof(ends)) ); + TEST_ESP_OK( esp_flash_read(NULL, ends, part->address, sizeof(ends)) ); TEST_ASSERT_EQUAL_HEX8(0xFF, ends[0]); TEST_ASSERT_EQUAL_HEX8(source[0] , ends[1]); - ESP_ERROR_CHECK( spi_flash_read(part->address + length, ends, sizeof(ends)) ); - + TEST_ESP_OK( esp_flash_read(NULL, ends, part->address + length, sizeof(ends)) ); TEST_ASSERT_EQUAL_HEX8(source[length-1], ends[0]); TEST_ASSERT_EQUAL_HEX8(0xFF, ends[1]); TEST_ASSERT_EQUAL_HEX8(0xFF, ends[2]); diff --git a/components/spi_flash/test/test_mmap.c b/components/spi_flash/test/test_mmap.c index 80f496b573..0587ac6999 100644 --- a/components/spi_flash/test/test_mmap.c +++ b/components/spi_flash/test/test_mmap.c @@ -6,7 +6,7 @@ #include #include -#include +#include #include #include #include @@ -28,9 +28,9 @@ static spi_flash_mmap_handle_t handle1, handle2, handle3; static esp_err_t spi_flash_read_maybe_encrypted(size_t src_addr, void *des_addr, size_t size) { if (!esp_flash_encryption_enabled()) { - return spi_flash_read(src_addr, des_addr, size); + return esp_flash_read(NULL, des_addr, src_addr, size); } else { - return spi_flash_read_encrypted(src_addr, des_addr, size); + return esp_flash_read_encrypted(NULL, src_addr, des_addr, size); } } @@ -39,9 +39,9 @@ static esp_err_t spi_flash_read_maybe_encrypted(size_t src_addr, void *des_addr, static esp_err_t spi_flash_write_maybe_encrypted(size_t des_addr, const void *src_addr, size_t size) { if (!esp_flash_encryption_enabled()) { - return spi_flash_write(des_addr, src_addr, size); + return esp_flash_write(NULL, src_addr, des_addr, size); } else { - return spi_flash_write_encrypted(des_addr, src_addr, size); + return esp_flash_write_encrypted(NULL, des_addr, src_addr, size); } } @@ -78,7 +78,7 @@ static void setup_mmap_tests(void) uint32_t sector_offs = abs_sector * SPI_FLASH_SEC_SIZE; bool sector_needs_write = false; - ESP_ERROR_CHECK( spi_flash_read_maybe_encrypted(sector_offs, buffer, sizeof(buffer)) ); + TEST_ESP_OK( spi_flash_read_maybe_encrypted(sector_offs, buffer, sizeof(buffer)) ); for (uint32_t word = 0; word < 1024; ++word) { uint32_t val = rand(); @@ -92,8 +92,8 @@ static void setup_mmap_tests(void) } /* Only rewrite the sector if it has changed */ if (sector_needs_write) { - ESP_ERROR_CHECK( spi_flash_erase_sector((uint16_t) abs_sector) ); - ESP_ERROR_CHECK( spi_flash_write_maybe_encrypted(sector_offs, (const uint8_t *) buffer, sizeof(buffer)) ); + TEST_ESP_OK( esp_flash_erase_region(NULL, (uint16_t) abs_sector * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE) ); + TEST_ESP_OK( spi_flash_write_maybe_encrypted(sector_offs, (const uint8_t *) buffer, sizeof(buffer)) ); } } } @@ -105,7 +105,7 @@ TEST_CASE("Can mmap into data address space", "[spi_flash][mmap]") printf("Mapping %x (+%x)\n", start, end - start); const void *ptr1; - ESP_ERROR_CHECK( spi_flash_mmap(start, end - start, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); + TEST_ESP_OK( spi_flash_mmap(start, end - start, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); printf("mmap_res: handle=%d ptr=%p\n", handle1, ptr1); spi_flash_mmap_dump(); @@ -123,7 +123,7 @@ TEST_CASE("Can mmap into data address space", "[spi_flash][mmap]") } printf("Mapping %x (+%x)\n", start - 0x10000, 0x20000); const void *ptr2; - ESP_ERROR_CHECK( spi_flash_mmap(start - 0x10000, 0x20000, SPI_FLASH_MMAP_DATA, &ptr2, &handle2) ); + TEST_ESP_OK( spi_flash_mmap(start - 0x10000, 0x20000, SPI_FLASH_MMAP_DATA, &ptr2, &handle2) ); printf("mmap_res: handle=%d ptr=%p\n", handle2, ptr2); TEST_ASSERT_EQUAL_HEX32(start - 0x10000, spi_flash_cache2phys(ptr2)); @@ -133,7 +133,7 @@ TEST_CASE("Can mmap into data address space", "[spi_flash][mmap]") printf("Mapping %x (+%x)\n", start, 0x10000); const void *ptr3; - ESP_ERROR_CHECK( spi_flash_mmap(start, 0x10000, SPI_FLASH_MMAP_DATA, &ptr3, &handle3) ); + TEST_ESP_OK( spi_flash_mmap(start, 0x10000, SPI_FLASH_MMAP_DATA, &ptr3, &handle3) ); printf("mmap_res: handle=%d ptr=%p\n", handle3, ptr3); TEST_ASSERT_EQUAL_HEX32(start, spi_flash_cache2phys(ptr3)); @@ -172,7 +172,7 @@ TEST_CASE("Can mmap into instruction address space", "[spi_flash][mmap]") printf("Mapping %x (+%x)\n", start, end - start); spi_flash_mmap_handle_t handle1; const void *ptr1; - ESP_ERROR_CHECK( spi_flash_mmap(start, end - start, SPI_FLASH_MMAP_INST, &ptr1, &handle1) ); + TEST_ESP_OK( spi_flash_mmap(start, end - start, SPI_FLASH_MMAP_INST, &ptr1, &handle1) ); printf("mmap_res: handle=%d ptr=%p\n", handle1, ptr1); spi_flash_mmap_dump(); @@ -189,7 +189,7 @@ TEST_CASE("Can mmap into instruction address space", "[spi_flash][mmap]") printf("Mapping %x (+%x)\n", start - 0x10000, 0x20000); spi_flash_mmap_handle_t handle2; const void *ptr2; - ESP_ERROR_CHECK( spi_flash_mmap(start - 0x10000, 0x20000, SPI_FLASH_MMAP_INST, &ptr2, &handle2) ); + TEST_ESP_OK( spi_flash_mmap(start - 0x10000, 0x20000, SPI_FLASH_MMAP_INST, &ptr2, &handle2) ); printf("mmap_res: handle=%d ptr=%p\n", handle2, ptr2); TEST_ASSERT_EQUAL_HEX32(start - 0x10000, spi_flash_cache2phys(ptr2)); @@ -200,7 +200,7 @@ TEST_CASE("Can mmap into instruction address space", "[spi_flash][mmap]") printf("Mapping %x (+%x)\n", start, 0x10000); spi_flash_mmap_handle_t handle3; const void *ptr3; - ESP_ERROR_CHECK( spi_flash_mmap(start, 0x10000, SPI_FLASH_MMAP_INST, &ptr3, &handle3) ); + TEST_ESP_OK( spi_flash_mmap(start, 0x10000, SPI_FLASH_MMAP_INST, &ptr3, &handle3) ); printf("mmap_res: handle=%d ptr=%p\n", handle3, ptr3); TEST_ASSERT_EQUAL_HEX32(start, spi_flash_cache2phys(ptr3)); @@ -246,7 +246,7 @@ TEST_CASE("Can mmap unordered pages into contiguous memory", "[spi_flash][mmap]" spi_flash_mmap_handle_t handle1; const void *ptr1; - ESP_ERROR_CHECK( spi_flash_mmap_pages(pages, nopages, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); + TEST_ESP_OK( spi_flash_mmap_pages(pages, nopages, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); printf("mmap_res: handle=%d ptr=%p\n", handle1, ptr1); spi_flash_mmap_dump(); @@ -278,10 +278,10 @@ TEST_CASE("flash_mmap invalidates just-written data", "[spi_flash][mmap]") TEST_IGNORE_MESSAGE("flash encryption enabled, spi_flash_write_encrypted() test won't pass as-is"); } - ESP_ERROR_CHECK( spi_flash_erase_sector(start / SPI_FLASH_SEC_SIZE) ); + TEST_ESP_OK( esp_flash_erase_region(NULL, start, SPI_FLASH_SEC_SIZE) ); /* map erased test region to ptr1 */ - ESP_ERROR_CHECK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); + TEST_ESP_OK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); printf("mmap_res ptr1: handle=%d ptr=%p\n", handle1, ptr1); /* verify it's all 0xFF */ @@ -296,14 +296,14 @@ TEST_CASE("flash_mmap invalidates just-written data", "[spi_flash][mmap]") /* write flash region to 0xEE */ uint8_t buf[test_size]; memset(buf, 0xEE, test_size); - ESP_ERROR_CHECK( spi_flash_write(start, buf, test_size) ); + TEST_ESP_OK( esp_flash_write(NULL, buf, start, test_size) ); /* re-map the test region at ptr1. this is a fresh mmap call so should trigger a cache flush, ensuring we see the updated flash. */ - ESP_ERROR_CHECK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); + TEST_ESP_OK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); printf("mmap_res ptr1 #2: handle=%d ptr=%p\n", handle1, ptr1); /* assert that ptr1 now maps to the new values on flash, @@ -322,7 +322,7 @@ TEST_CASE("flash_mmap can mmap after get enough free MMU pages", "[spi_flash][mm printf("Mapping %x (+%x)\n", start, end - start); const void *ptr1; - ESP_ERROR_CHECK( spi_flash_mmap(start, end - start, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); + TEST_ESP_OK( spi_flash_mmap(start, end - start, SPI_FLASH_MMAP_DATA, &ptr1, &handle1) ); printf("mmap_res: handle=%d ptr=%p\n", handle1, ptr1); spi_flash_mmap_dump(); @@ -339,12 +339,14 @@ TEST_CASE("flash_mmap can mmap after get enough free MMU pages", "[spi_flash][mm } } uint32_t free_pages = spi_flash_mmap_get_free_pages(SPI_FLASH_MMAP_DATA); - uint32_t flash_pages = spi_flash_get_chip_size() / SPI_FLASH_MMU_PAGE_SIZE; + uint32_t flash_size; + TEST_ESP_OK(esp_flash_get_size(NULL, &flash_size)); + uint32_t flash_pages = flash_size / SPI_FLASH_MMU_PAGE_SIZE; free_pages = (free_pages > flash_pages) ? flash_pages : free_pages; printf("Mapping %x (+%x)\n", 0, free_pages * SPI_FLASH_MMU_PAGE_SIZE); const void *ptr2; - ESP_ERROR_CHECK( spi_flash_mmap(0, free_pages * SPI_FLASH_MMU_PAGE_SIZE, SPI_FLASH_MMAP_DATA, &ptr2, &handle2) ); + TEST_ESP_OK( spi_flash_mmap(0, free_pages * SPI_FLASH_MMU_PAGE_SIZE, SPI_FLASH_MMAP_DATA, &ptr2, &handle2) ); printf("mmap_res: handle=%d ptr=%p\n", handle2, ptr2); spi_flash_mmap_dump(); @@ -409,7 +411,7 @@ TEST_CASE("mmap consistent with phys2cache/cache2phys", "[spi_flash][mmap]") TEST_ASSERT_EQUAL_HEX(SPI_FLASH_CACHE2PHYS_FAIL, spi_flash_cache2phys(ptr)); - ESP_ERROR_CHECK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr, &handle1) ); + TEST_ESP_OK( spi_flash_mmap(start, test_size, SPI_FLASH_MMAP_DATA, &ptr, &handle1) ); TEST_ASSERT_NOT_NULL(ptr); TEST_ASSERT_NOT_EQUAL(0, handle1); diff --git a/components/spi_flash/test/test_out_of_bounds_write.c b/components/spi_flash/test/test_out_of_bounds_write.c index bc4a5d5745..9854335321 100644 --- a/components/spi_flash/test/test_out_of_bounds_write.c +++ b/components/spi_flash/test/test_out_of_bounds_write.c @@ -1,7 +1,7 @@ #include #include "unity.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_ota_ops.h" #if CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS || CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS @@ -16,18 +16,18 @@ static const char *data = "blah blah blah"; TEST_CASE("can't overwrite bootloader", TEST_TAGS) { - TEST_ESP_ERR(ESP_ERR_INVALID_ARG, spi_flash_write(0x1000, data, strlen(data))); - TEST_ESP_ERR(ESP_ERR_INVALID_ARG, spi_flash_write(0x0FF8, data, strlen(data))); - TEST_ESP_ERR(ESP_ERR_INVALID_ARG, spi_flash_write(0x1400, data, strlen(data))); - TEST_ESP_ERR(ESP_ERR_INVALID_ARG, spi_flash_erase_range(0x8000, 0x2000)); - TEST_ESP_ERR(ESP_ERR_INVALID_ARG, spi_flash_erase_range(0x7000, 0x2000)); + TEST_ESP_ERR(ESP_ERR_INVALID_ARG, esp_flash_write(NULL, data, 0x1000, strlen(data))); + TEST_ESP_ERR(ESP_ERR_INVALID_ARG, esp_flash_write(NULL, data, 0x0FF8, strlen(data))); + TEST_ESP_ERR(ESP_ERR_INVALID_ARG, esp_flash_write(NULL, data, 0x1400, strlen(data))); + TEST_ESP_ERR(ESP_ERR_INVALID_ARG, esp_flash_erase_region(NULL, 0x8000, 0x2000)); + TEST_ESP_ERR(ESP_ERR_INVALID_ARG, esp_flash_erase_region(NULL, 0x7000, 0x2000)); } TEST_CASE("can't overwrite current running app", TEST_TAGS) { const esp_partition_t *p = esp_ota_get_running_partition(); - TEST_ESP_ERR(ESP_ERR_INVALID_ARG, spi_flash_write(p->address + 1024, data, strlen(data))); - TEST_ESP_ERR(ESP_ERR_INVALID_ARG, spi_flash_erase_range(p->address + 4096, 8192)); + TEST_ESP_ERR(ESP_ERR_INVALID_ARG, esp_flash_write(NULL, data, p->address + 1024, strlen(data))); + TEST_ESP_ERR(ESP_ERR_INVALID_ARG, esp_flash_erase_region(NULL, p->address + 4096, 8192)); } #endif // FAILS || ABORTS diff --git a/components/spi_flash/test/test_partitions.c b/components/spi_flash/test/test_partitions.c index c766a29a1c..d916de7c74 100644 --- a/components/spi_flash/test/test_partitions.c +++ b/components/spi_flash/test/test_partitions.c @@ -123,7 +123,8 @@ TEST_CASE("Test esp_partition_get_sha256() that it can handle a big partition", spi_flash_mmap_handle_t handle; uint8_t sha256[32] = { 0 }; - size_t size_flash_chip = spi_flash_get_chip_size(); + uint32_t size_flash_chip; + esp_flash_get_size(NULL, &size_flash_chip); printf("size_flash_chip = %d bytes\n", size_flash_chip); diff --git a/components/spi_flash/test/test_read_write.c b/components/spi_flash/test/test_read_write.c index 590a38b429..a3e2b9d739 100644 --- a/components/spi_flash/test/test_read_write.c +++ b/components/spi_flash/test/test_read_write.c @@ -14,8 +14,8 @@ #include #include -#include -#include "../cache_utils.h" +#include +#include "esp_private/cache_utils.h" #include "soc/timer_periph.h" #include "esp_attr.h" #include "esp_heap_caps.h" @@ -69,7 +69,6 @@ static int cmp_or_dump(const void *a, const void *b, size_t len) return r; } - static void IRAM_ATTR test_read(int src_off, int dst_off, int len) { uint32_t src_buf[16]; @@ -78,7 +77,7 @@ static void IRAM_ATTR test_read(int src_off, int dst_off, int len) fprintf(stderr, "src=%d dst=%d len=%d\n", src_off, dst_off, len); memset(src_buf, 0xAA, sizeof(src_buf)); fill(((char *) src_buf) + src_off, src_off, len); - ESP_ERROR_CHECK(spi_flash_erase_sector((start + src_off) / SPI_FLASH_SEC_SIZE)); + ESP_ERROR_CHECK(esp_flash_erase_region(NULL, (start + src_off) & ~(0x10000 - 1), SPI_FLASH_SEC_SIZE)); spi_flash_disable_interrupts_caches_and_other_cpu(); esp_rom_spiflash_result_t rc = esp_rom_spiflash_write(start, src_buf, sizeof(src_buf)); spi_flash_enable_interrupts_caches_and_other_cpu(); @@ -86,7 +85,7 @@ static void IRAM_ATTR test_read(int src_off, int dst_off, int len) memset(dst_buf, 0x55, sizeof(dst_buf)); memset(dst_gold, 0x55, sizeof(dst_gold)); fill(dst_gold + dst_off, src_off, len); - ESP_ERROR_CHECK(spi_flash_read(start + src_off, dst_buf + dst_off, len)); + ESP_ERROR_CHECK(esp_flash_read(NULL, dst_buf + dst_off, start + src_off, len)); TEST_ASSERT_EQUAL_INT(cmp_or_dump(dst_buf, dst_gold, sizeof(dst_buf)), 0); } @@ -209,7 +208,7 @@ static void IRAM_ATTR test_write(int dst_off, int src_off, int len) memset(src_buf, 0x55, sizeof(src_buf)); fill(src_buf + src_off, src_off, len); // Fills with 0xff - ESP_ERROR_CHECK(spi_flash_erase_sector((start + dst_off) / SPI_FLASH_SEC_SIZE)); + ESP_ERROR_CHECK(esp_flash_erase_region(NULL, (start + src_off) & ~(0x10000 - 1), SPI_FLASH_SEC_SIZE)); memset(dst_gold, 0xff, sizeof(dst_gold)); if (len > 0) { int pad_left_off = (dst_off & ~3U); @@ -220,7 +219,7 @@ static void IRAM_ATTR test_write(int dst_off, int src_off, int len) } fill(dst_gold + dst_off, src_off, len); } - ESP_ERROR_CHECK(spi_flash_write(start + dst_off, src_buf + src_off, len)); + ESP_ERROR_CHECK(esp_flash_write(NULL, src_buf + src_off, start + dst_off, len)); fix_rom_func(); @@ -232,7 +231,7 @@ static void IRAM_ATTR test_write(int dst_off, int src_off, int len) TEST_ASSERT_EQUAL_INT(cmp_or_dump(dst_buf, dst_gold, sizeof(dst_buf)), 0); } -TEST_CASE("Test spi_flash_write", "[spi_flash][esp_flash]") +TEST_CASE("Test esp_flash_write", "[spi_flash][esp_flash]") { setup_tests(); #if CONFIG_SPI_FLASH_MINIMAL_TEST @@ -288,19 +287,19 @@ TEST_CASE("Test spi_flash_write", "[spi_flash][esp_flash]") #define TEST_SOC_IRAM_ADDR (SOC_IRAM_LOW + 0x8000) #define TEST_SOC_RTC_IRAM_ADDR (SOC_RTC_IRAM_LOW) #define TEST_SOC_RTC_DRAM_ADDR (SOC_RTC_DRAM_LOW) - ESP_ERROR_CHECK(spi_flash_write(start, (char *) TEST_SOC_IROM_ADDR, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) TEST_SOC_IRAM_ADDR, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) TEST_SOC_CACHE_RAM_BANK0_ADDR, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) TEST_SOC_CACHE_RAM_BANK1_ADDR, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) TEST_SOC_CACHE_RAM_BANK2_ADDR, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) TEST_SOC_CACHE_RAM_BANK3_ADDR, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) TEST_SOC_RTC_IRAM_ADDR, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) TEST_SOC_RTC_DRAM_ADDR, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) TEST_SOC_IROM_ADDR, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) TEST_SOC_IRAM_ADDR, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) TEST_SOC_CACHE_RAM_BANK0_ADDR, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) TEST_SOC_CACHE_RAM_BANK1_ADDR, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) TEST_SOC_CACHE_RAM_BANK2_ADDR, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) TEST_SOC_CACHE_RAM_BANK3_ADDR, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) TEST_SOC_RTC_IRAM_ADDR, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) TEST_SOC_RTC_DRAM_ADDR, start, 16)); #else - ESP_ERROR_CHECK(spi_flash_write(start, (char *) 0x40000000, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) 0x40070000, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) 0x40078000, 16)); - ESP_ERROR_CHECK(spi_flash_write(start, (char *) 0x40080000, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) 0x40000000, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) 0x40070000, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) 0x40078000, start, 16)); + ESP_ERROR_CHECK(esp_flash_write(NULL, (char *) 0x40080000, start, 16)); #endif } @@ -314,15 +313,15 @@ TEST_CASE("spi_flash_read can read into buffer in external RAM", "[spi_flash]") uint8_t* buf_int = (uint8_t*) heap_caps_malloc(SPI_FLASH_SEC_SIZE, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT); TEST_ASSERT_NOT_NULL(buf_int); - TEST_ESP_OK(spi_flash_read(0x1000, buf_int, SPI_FLASH_SEC_SIZE)); - TEST_ESP_OK(spi_flash_read(0x1000, buf_ext, SPI_FLASH_SEC_SIZE)); + TEST_ESP_OK(esp_flash_read(NULL, buf_int, 0x1000, SPI_FLASH_SEC_SIZE)); + TEST_ESP_OK(esp_flash_read(NULL, buf_ext, 0x1000, SPI_FLASH_SEC_SIZE)); TEST_ASSERT_EQUAL(0, memcmp(buf_ext, buf_int, SPI_FLASH_SEC_SIZE)); free(buf_ext); free(buf_int); } -TEST_CASE("spi_flash_write can write from external RAM buffer", "[spi_flash]") +TEST_CASE("esp_flash_write can write from external RAM buffer", "[spi_flash]") { uint32_t* buf_ext = (uint32_t*) heap_caps_malloc(SPI_FLASH_SEC_SIZE, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT); TEST_ASSERT_NOT_NULL(buf_ext); @@ -339,11 +338,11 @@ TEST_CASE("spi_flash_write can write from external RAM buffer", "[spi_flash]") /* Write to flash from buf_ext */ const esp_partition_t *part = get_test_data_partition(); - TEST_ESP_OK(spi_flash_erase_range(part->address, SPI_FLASH_SEC_SIZE)); - TEST_ESP_OK(spi_flash_write(part->address, buf_ext, SPI_FLASH_SEC_SIZE)); + TEST_ESP_OK(esp_flash_erase_region(NULL, part->address & ~(0x10000 - 1), SPI_FLASH_SEC_SIZE)); + TEST_ESP_OK(esp_flash_write(NULL, buf_ext, part->address, SPI_FLASH_SEC_SIZE)); /* Read back to buf_int and compare */ - TEST_ESP_OK(spi_flash_read(part->address, buf_int, SPI_FLASH_SEC_SIZE)); + TEST_ESP_OK(esp_flash_read(NULL, buf_int, part->address, SPI_FLASH_SEC_SIZE)); TEST_ASSERT_EQUAL(0, memcmp(buf_ext, buf_int, SPI_FLASH_SEC_SIZE)); free(buf_ext); @@ -364,10 +363,10 @@ TEST_CASE("spi_flash_read less than 16 bytes into buffer in external RAM", "[spi } const esp_partition_t *part = get_test_data_partition(); - TEST_ESP_OK(spi_flash_erase_range(part->address, SPI_FLASH_SEC_SIZE)); - TEST_ESP_OK(spi_flash_write(part->address, data_8, MIN_BLOCK_SIZE)); - TEST_ESP_OK(spi_flash_read(part->address, buf_ext_8, MIN_BLOCK_SIZE)); - TEST_ESP_OK(spi_flash_read(part->address, buf_int_8, MIN_BLOCK_SIZE)); + TEST_ESP_OK(esp_flash_erase_region(NULL, part->address & ~(0x10000 - 1), SPI_FLASH_SEC_SIZE)); + TEST_ESP_OK(esp_flash_write(NULL, data_8, part->address, MIN_BLOCK_SIZE)); + TEST_ESP_OK(esp_flash_read(NULL, buf_ext_8, part->address, MIN_BLOCK_SIZE)); + TEST_ESP_OK(esp_flash_read(NULL, buf_int_8, part->address, MIN_BLOCK_SIZE)); TEST_ASSERT_EQUAL(0, memcmp(buf_ext_8, data_8, MIN_BLOCK_SIZE)); TEST_ASSERT_EQUAL(0, memcmp(buf_int_8, data_8, MIN_BLOCK_SIZE)); diff --git a/components/spi_flash/test/test_spi_flash.c b/components/spi_flash/test/test_spi_flash.c index a3aab60bb2..5879b9b96a 100644 --- a/components/spi_flash/test/test_spi_flash.c +++ b/components/spi_flash/test/test_spi_flash.c @@ -5,7 +5,7 @@ #include #include -#include +#include #include #include "esp_intr_alloc.h" #include "test_utils.h" @@ -47,7 +47,7 @@ static void flash_test_task(void *arg) const uint32_t sector = start / SPI_FLASH_SEC_SIZE + ctx->offset; printf("t%d\n", sector); printf("es%d\n", sector); - if (spi_flash_erase_sector(sector) != ESP_OK) { + if (esp_flash_erase_region(NULL, sector * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE) != ESP_OK) { ctx->fail = true; printf("Erase failed\r\n"); xSemaphoreGive(ctx->done); @@ -59,7 +59,7 @@ static void flash_test_task(void *arg) uint32_t val = 0xabcd1234; for (uint32_t offset = 0; offset < SPI_FLASH_SEC_SIZE; offset += 4) { - if (spi_flash_write(sector * SPI_FLASH_SEC_SIZE + offset, (const uint8_t *) &val, 4) != ESP_OK) { + if (esp_flash_write(NULL, (const uint8_t *) &val, sector * SPI_FLASH_SEC_SIZE + offset, 4) != ESP_OK) { printf("Write failed at offset=%d\r\n", offset); ctx->fail = true; break; @@ -71,7 +71,7 @@ static void flash_test_task(void *arg) uint32_t val_read; for (uint32_t offset = 0; offset < SPI_FLASH_SEC_SIZE; offset += 4) { - if (spi_flash_read(sector * SPI_FLASH_SEC_SIZE + offset, (uint8_t *) &val_read, 4) != ESP_OK) { + if (esp_flash_read(NULL, (uint8_t *) &val_read, sector * SPI_FLASH_SEC_SIZE + offset, 4) != ESP_OK) { printf("Read failed at offset=%d\r\n", offset); ctx->fail = true; break; @@ -151,7 +151,7 @@ static uint32_t measure_erase(const esp_partition_t* part) time_meas_ctx_t time_ctx = {.name = "erase", .len = total_len}; time_measure_start(&time_ctx); - esp_err_t err = spi_flash_erase_range(part->address, total_len); + esp_err_t err = esp_flash_erase_region(NULL, part->address, total_len); TEST_ESP_OK(err); return time_measure_end(&time_ctx); } @@ -170,7 +170,7 @@ static uint32_t measure_write(const char* name, const esp_partition_t* part, con while (len) { int len_write = MIN(seg_len, len); - esp_err_t err = spi_flash_write(part->address + offset, data_to_write + offset, len_write); + esp_err_t err = esp_flash_write(NULL, data_to_write + offset, part->address + offset, len_write); TEST_ESP_OK(err); offset += len_write; @@ -192,7 +192,7 @@ static uint32_t measure_read(const char* name, const esp_partition_t* part, uint while (len) { int len_read = MIN(seg_len, len); - esp_err_t err = spi_flash_read(part->address + offset, data_read + offset, len_read); + esp_err_t err = esp_flash_read(NULL, data_read + offset, part->address + offset, len_read); TEST_ESP_OK(err); offset += len_read; @@ -294,7 +294,7 @@ TEST_CASE("spi_flash deadlock with high priority busy-waiting task", "[spi_flash for (int i = 0; i < 1000; i++) { uint32_t dummy; - TEST_ESP_OK(spi_flash_read(0, &dummy, sizeof(dummy))); + TEST_ESP_OK(esp_flash_read(NULL, &dummy, 0, sizeof(dummy))); } arg.done = true; diff --git a/components/spiffs/esp_spiffs.c b/components/spiffs/esp_spiffs.c index 0709efc356..aecd8f4184 100644 --- a/components/spiffs/esp_spiffs.c +++ b/components/spiffs/esp_spiffs.c @@ -9,7 +9,7 @@ #include "spiffs_nucleus.h" #include "esp_log.h" #include "esp_partition.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_image_format.h" #include "freertos/FreeRTOS.h" #include "freertos/task.h" diff --git a/components/wear_levelling/SPI_Flash.cpp b/components/wear_levelling/SPI_Flash.cpp index 695b1979a3..3a9192085c 100644 --- a/components/wear_levelling/SPI_Flash.cpp +++ b/components/wear_levelling/SPI_Flash.cpp @@ -7,7 +7,8 @@ #include "esp_log.h" #include "SPI_Flash.h" #include "spi_flash_mmap.h" -#include "esp_rom_spiflash.h" +#include "esp_flash.h" + static const char *TAG = "spi_flash"; SPI_Flash::SPI_Flash() @@ -16,12 +17,14 @@ SPI_Flash::SPI_Flash() size_t SPI_Flash::chip_size() { - return g_rom_flashchip.chip_size; + uint32_t chip_size; + esp_flash_get_size(NULL, &chip_size); + return chip_size; } esp_err_t SPI_Flash::erase_sector(size_t sector) { - esp_err_t result = esp_rom_spiflash_erase_sector(sector); + esp_err_t result = esp_flash_erase_region(NULL, sector * SPI_FLASH_SEC_SIZE, SPI_FLASH_SEC_SIZE);; if (result == ESP_OK) { ESP_LOGV(TAG, "erase_sector - sector=0x%08x, result=0x%08x", sector, result); } else { @@ -33,7 +36,7 @@ esp_err_t SPI_Flash::erase_range(size_t start_address, size_t size) { size = (size + SPI_FLASH_SEC_SIZE - 1) / SPI_FLASH_SEC_SIZE; size = size * SPI_FLASH_SEC_SIZE; - esp_err_t result = esp_rom_spiflash_erase_area(start_address, size); + esp_err_t result = esp_flash_erase_region(NULL, start_address, size); if (result == ESP_OK) { ESP_LOGV(TAG, "erase_range - start_address=0x%08x, size=0x%08x, result=0x%08x", start_address, size, result); } else { @@ -44,7 +47,7 @@ esp_err_t SPI_Flash::erase_range(size_t start_address, size_t size) esp_err_t SPI_Flash::write(size_t dest_addr, const void *src, size_t size) { - esp_err_t result = esp_rom_spiflash_write(dest_addr, (uint32_t*)src, size); + esp_err_t result = esp_flash_write(NULL, src, dest_addr, size); if (result == ESP_OK) { ESP_LOGV(TAG, "write - dest_addr=0x%08x, size=0x%08x, result=0x%08x", dest_addr, size, result); } else { @@ -55,7 +58,7 @@ esp_err_t SPI_Flash::write(size_t dest_addr, const void *src, size_t size) esp_err_t SPI_Flash::read(size_t src_addr, void *dest, size_t size) { - esp_err_t result = esp_rom_spiflash_read(src_addr, (uint32_t*)dest, size); + esp_err_t result = esp_flash_read(NULL, dest, src_addr, size); if (result == ESP_OK) { ESP_LOGV(TAG, "read - src_addr=0x%08x, size=0x%08x, result=0x%08x", src_addr, size, result); } else { diff --git a/docs/en/migration-guides/peripherals.rst b/docs/en/migration-guides/peripherals.rst index 7f5fbdf647..b050656700 100644 --- a/docs/en/migration-guides/peripherals.rst +++ b/docs/en/migration-guides/peripherals.rst @@ -35,14 +35,27 @@ ENUM type ``esp_flash_speed_t`` has been deprecated. From now on, you can direct Breaking changes in legacy APIs ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -In order to make spi_flash driver more stable, legacy spi_flash driver is removed on v5.0. Legacy spi_flash driver refers to default spi_flash driver since v3.0 and spi_flash driver with configuration option ``CONFIG_SPI_FLASH_USE_LEGACY_IMPL`` switched on on v4.0 series. The major breaking change is we don't support legacy spi_flash driver on v5.0 anymore. Therefore, the configuration option ``CONFIG_SPI_FLASH_USE_LEGACY_IMPL`` is removed. After that, following functions will no longer exist. But meanwhile, you can use our new APIs instead. +In order to make spi_flash driver more stable, legacy spi_flash driver is removed on v5.0. Legacy spi_flash driver refers to default spi_flash driver since v3.0 and spi_flash driver with configuration option ``CONFIG_SPI_FLASH_USE_LEGACY_IMPL`` switched on on v4.0 series. The major breaking change is legacy spi_flash driver is not supported on new version anymore. Therefore, the configuration option ``CONFIG_SPI_FLASH_USE_LEGACY_IMPL`` is removed. After that, following functions will no longer exist. But meanwhile, you can use our new APIs instead. -- ``spi_flash_erase_sector`` is replaced by ``esp_flash_erase_region``. -- ``spi_flash_erase_range`` is replaced by ``esp_flash_erase_region``. -- ``spi_flash_write`` is replaced by ``esp_flash_write``. -- ``spi_flash_read`` is replaced by ``esp_flash_read``. -- ``spi_flash_write_encrypted`` is replaced by ``esp_flash_write_encrypted`` -- ``spi_flash_read_encrypted`` is replaced by ``esp_flash_read_encrypted`` ++---------------------------------+-------------------------------+ +| Removed items | Replacement | ++=================================+===============================+ +| ``spi_flash_erase_sector()`` | ``esp_flash_erase_region`` | ++---------------------------------+-------------------------------+ +| ``spi_flash_erase_range()`` | ``esp_flash_erase_region`` | ++---------------------------------+-------------------------------+ +| ``spi_flash_write`` | ``esp_flash_write`` | ++---------------------------------+-------------------------------+ +| ``spi_flash_read()`` | ``esp_flash_read`` | ++---------------------------------+-------------------------------+ +| ``spi_flash_write_encrypted()`` | ``esp_flash_write_encrypted`` | ++---------------------------------+-------------------------------+ +| ``spi_flash_read_encrypted`` | ``esp_flash_read_encrypted`` | ++---------------------------------+-------------------------------+ + +.. note:: + + New functions with prefix ``esp_flash`` accept an additional ``esp_flash_t*`` parameter. You can simply set it to NULL means that the function will operate the main flash(``esp_flash_default_chip``) Header ``esp_spi_flash.h`` has been deprecated, system functions are no longer public. To make use of flash memory mapping APIs, you should include ``spi_flash_mmap.h`` instead. diff --git a/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32 index c79ba9dd54..80e6ca1b8a 100644 --- a/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32 @@ -977,7 +977,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32c3 index 2f5502b148..00d0a32678 100644 --- a/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32c3 @@ -968,7 +968,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_ancs/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32 index 7d2ca35224..13439a5e96 100644 --- a/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32 @@ -981,7 +981,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32c3 index 2f5502b148..00d0a32678 100644 --- a/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32c3 @@ -968,7 +968,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_compatibility_test/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_eddystone/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_eddystone/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/ble_eddystone/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_eddystone/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_eddystone/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_eddystone/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_eddystone/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_eddystone/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32 index e7e2797202..d0662c2a1b 100644 --- a/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32 @@ -981,7 +981,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_hid_device_demo/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32 index abf8c614ee..bd03a47811 100644 --- a/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32 @@ -978,7 +978,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_ibeacon/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32 index 5d5d405cc1..d73d80a241 100644 --- a/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32 @@ -980,7 +980,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_spp_client/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32 index abf8c614ee..bd03a47811 100644 --- a/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32 @@ -978,7 +978,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_spp_server/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32 index 5d5d405cc1..d73d80a241 100644 --- a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32 @@ -980,7 +980,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_client/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32 index abf8c614ee..bd03a47811 100644 --- a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32 @@ -978,7 +978,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/ble_throughput/throughput_server/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32 index 5d5d405cc1..d73d80a241 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32 @@ -980,7 +980,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/gatt_client/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32 index 79dfffd59e..842f088817 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32 @@ -976,7 +976,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/gatt_security_client/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32 index 496e78a5d1..753a4182c3 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32 @@ -980,7 +980,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/gatt_security_server/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32 index abf8c614ee..bd03a47811 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32 @@ -978,7 +978,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/gatt_server/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32 index abf8c614ee..bd03a47811 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32 @@ -978,7 +978,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/gatt_server_service_table/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32 b/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32 index 5d5d405cc1..d73d80a241 100644 --- a/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32 @@ -980,7 +980,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble/gattc_multi_connect/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults b/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults index 35a72ea5d3..d58a19c299 100644 --- a/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults +++ b/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults @@ -958,7 +958,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults.esp32c3 index d4e18adf6b..422c60178b 100644 --- a/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults.esp32s3 index 2500f6e6e9..d1977d7f77 100644 --- a/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble_50/ble50_security_client/sdkconfig.defaults.esp32s3 @@ -1102,7 +1102,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults b/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults index 245237f314..4704403e4f 100644 --- a/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults +++ b/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults @@ -961,7 +961,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults.esp32c3 index d4e18adf6b..422c60178b 100644 --- a/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults.esp32s3 index 2500f6e6e9..d1977d7f77 100644 --- a/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble_50/ble50_security_server/sdkconfig.defaults.esp32s3 @@ -1102,7 +1102,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults b/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults index 88cc288a64..dfc81e92dd 100644 --- a/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults +++ b/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults @@ -949,7 +949,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults.esp32c3 index d4e18adf6b..422c60178b 100644 --- a/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults.esp32s3 index 2500f6e6e9..d1977d7f77 100644 --- a/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble_50/multi-adv/sdkconfig.defaults.esp32s3 @@ -1102,7 +1102,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults b/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults index 88cc288a64..dfc81e92dd 100644 --- a/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults +++ b/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults @@ -949,7 +949,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults.esp32c3 index d4e18adf6b..422c60178b 100644 --- a/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults.esp32s3 index 2500f6e6e9..d1977d7f77 100644 --- a/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble_50/peroidic_adv/sdkconfig.defaults.esp32s3 @@ -1102,7 +1102,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults b/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults index 88cc288a64..dfc81e92dd 100644 --- a/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults +++ b/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults @@ -949,7 +949,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults.esp32c3 index d4e18adf6b..422c60178b 100644 --- a/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults.esp32s3 index 2500f6e6e9..d1977d7f77 100644 --- a/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/ble_50/peroidic_sync/sdkconfig.defaults.esp32s3 @@ -1102,7 +1102,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defaults.esp32c3 b/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defaults.esp32c3 index 09ebc8cea7..2798d6a1ed 100644 --- a/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defaults.esp32c3 @@ -967,7 +967,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defaults.esp32s3 b/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defaults.esp32s3 index db313f6508..c7d91fb218 100644 --- a/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defaults.esp32s3 @@ -1113,7 +1113,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defauts.esp32 b/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defauts.esp32 index 027f7d41d0..d5dee954b9 100644 --- a/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defauts.esp32 +++ b/examples/bluetooth/bluedroid/coex/gattc_gatts_coex/sdkconfig.defauts.esp32 @@ -980,7 +980,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/blufi/sdkconfig.defaults.esp32 b/examples/bluetooth/blufi/sdkconfig.defaults.esp32 index 2975bd5228..7ed1884f19 100644 --- a/examples/bluetooth/blufi/sdkconfig.defaults.esp32 +++ b/examples/bluetooth/blufi/sdkconfig.defaults.esp32 @@ -966,7 +966,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/blufi/sdkconfig.defaults.esp32c3 b/examples/bluetooth/blufi/sdkconfig.defaults.esp32c3 index a476d0d093..92d007bd01 100644 --- a/examples/bluetooth/blufi/sdkconfig.defaults.esp32c3 +++ b/examples/bluetooth/blufi/sdkconfig.defaults.esp32c3 @@ -953,7 +953,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/blufi/sdkconfig.defaults.esp32s3 b/examples/bluetooth/blufi/sdkconfig.defaults.esp32s3 index 465fea0214..241c4d62b6 100644 --- a/examples/bluetooth/blufi/sdkconfig.defaults.esp32s3 +++ b/examples/bluetooth/blufi/sdkconfig.defaults.esp32s3 @@ -1098,7 +1098,6 @@ CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y # CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set # CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set -# CONFIG_SPI_FLASH_USE_LEGACY_IMPL is not set # CONFIG_SPI_FLASH_SHARE_SPI1_BUS is not set # CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y diff --git a/examples/bluetooth/nimble/throughput_app/blecent_throughput/components/cmd_system/cmd_system.c b/examples/bluetooth/nimble/throughput_app/blecent_throughput/components/cmd_system/cmd_system.c index 5809725305..ba00456063 100644 --- a/examples/bluetooth/nimble/throughput_app/blecent_throughput/components/cmd_system/cmd_system.c +++ b/examples/bluetooth/nimble/throughput_app/blecent_throughput/components/cmd_system/cmd_system.c @@ -11,7 +11,7 @@ #include "esp_console.h" #include "esp_chip_info.h" #include "esp_sleep.h" -#include "esp_spi_flash.h" +#include "esp_flash.h" #include "driver/rtc_io.h" #include "driver/uart.h" #include "argtable3/argtable3.h" @@ -53,7 +53,12 @@ void register_system(void) static int get_version(int argc, char **argv) { esp_chip_info_t info; + uint32_t flash_size; esp_chip_info(&info); + if(esp_flash_get_size(NULL, &flash_size) != ESP_OK) { + printf("Get flash size failed"); + return 1; + } printf("IDF Version:%s\r\n", esp_get_idf_version()); printf("Chip info:\r\n"); printf("\tmodel:%s\r\n", info.model == CHIP_ESP32 ? "ESP32" : "Unknow"); @@ -63,7 +68,7 @@ static int get_version(int argc, char **argv) info.features & CHIP_FEATURE_BLE ? "/BLE" : "", info.features & CHIP_FEATURE_BT ? "/BT" : "", info.features & CHIP_FEATURE_EMB_FLASH ? "/Embedded-Flash:" : "/External-Flash:", - spi_flash_get_chip_size() / (1024 * 1024), " MB"); + flash_size / (1024 * 1024), " MB"); printf("\trevision number:%d\r\n", info.revision); return 0; } diff --git a/examples/build_system/cmake/idf_as_lib/main.c b/examples/build_system/cmake/idf_as_lib/main.c index c069d36833..f44455df0a 100644 --- a/examples/build_system/cmake/idf_as_lib/main.c +++ b/examples/build_system/cmake/idf_as_lib/main.c @@ -9,7 +9,7 @@ #include "freertos/task.h" #include "esp_chip_info.h" #include "esp_system.h" -#include "esp_spi_flash.h" +#include "esp_flash.h" void app_main(void) { @@ -17,6 +17,7 @@ void app_main(void) /* Print chip information */ esp_chip_info_t chip_info; + uint32_t flash_size; esp_chip_info(&chip_info); printf("This is ESP32 chip with %d CPU cores, WiFi%s%s, ", chip_info.cores, @@ -24,8 +25,12 @@ void app_main(void) (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : ""); printf("silicon revision %d, ", chip_info.revision); + if(esp_flash_get_size(NULL, &flash_size) != ESP_OK) { + printf("Get flash size failed"); + return; + } - printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024), + printf("%dMB %s flash\n", flash_size / (1024 * 1024), (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external"); for (int i = 10; i >= 0; i--) { diff --git a/examples/build_system/cmake/idf_as_lib/stubs/esp32/flash_ops.c b/examples/build_system/cmake/idf_as_lib/stubs/esp32/flash_ops.c index 28c3a41499..e2156e3f57 100644 --- a/examples/build_system/cmake/idf_as_lib/stubs/esp32/flash_ops.c +++ b/examples/build_system/cmake/idf_as_lib/stubs/esp32/flash_ops.c @@ -4,7 +4,7 @@ * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" int spi_flash_get_chip_size(void) { diff --git a/examples/get-started/hello_world/main/hello_world_main.c b/examples/get-started/hello_world/main/hello_world_main.c index 0625d2bfde..915866a4c2 100644 --- a/examples/get-started/hello_world/main/hello_world_main.c +++ b/examples/get-started/hello_world/main/hello_world_main.c @@ -9,7 +9,7 @@ #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_chip_info.h" -#include "esp_spi_flash.h" +#include "esp_flash.h" void app_main(void) { @@ -17,6 +17,7 @@ void app_main(void) /* Print chip information */ esp_chip_info_t chip_info; + uint32_t flash_size; esp_chip_info(&chip_info); printf("This is %s chip with %d CPU core(s), WiFi%s%s, ", CONFIG_IDF_TARGET, @@ -25,8 +26,12 @@ void app_main(void) (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : ""); printf("silicon revision %d, ", chip_info.revision); + if(esp_flash_get_size(NULL, &flash_size) != ESP_OK) { + printf("Get flash size failed"); + return; + } - printf("%uMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024), + printf("%uMB %s flash\n", flash_size / (1024 * 1024), (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external"); printf("Minimum free heap size: %d bytes\n", esp_get_minimum_free_heap_size()); diff --git a/examples/peripherals/i2s/i2s_adc_dac/main/app_main.c b/examples/peripherals/i2s/i2s_adc_dac/main/app_main.c index b198aeea24..e04b713728 100644 --- a/examples/peripherals/i2s/i2s_adc_dac/main/app_main.c +++ b/examples/peripherals/i2s/i2s_adc_dac/main/app_main.c @@ -12,7 +12,7 @@ #include #include "freertos/FreeRTOS.h" #include "freertos/task.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_err.h" #include "esp_log.h" #include "esp_partition.h" diff --git a/examples/peripherals/secure_element/atecc608_ecdsa/main/ecdsa_example_main.c b/examples/peripherals/secure_element/atecc608_ecdsa/main/ecdsa_example_main.c index f3df138428..4f0ad17a42 100644 --- a/examples/peripherals/secure_element/atecc608_ecdsa/main/ecdsa_example_main.c +++ b/examples/peripherals/secure_element/atecc608_ecdsa/main/ecdsa_example_main.c @@ -16,7 +16,7 @@ #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_system.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_log.h" /* Cryptoauthlib includes */ diff --git a/examples/security/flash_encryption/main/flash_encrypt_main.c b/examples/security/flash_encryption/main/flash_encrypt_main.c index c666fa4d31..5467d1edd1 100644 --- a/examples/security/flash_encryption/main/flash_encrypt_main.c +++ b/examples/security/flash_encryption/main/flash_encrypt_main.c @@ -12,7 +12,7 @@ #include "soc/efuse_reg.h" #include "esp_efuse.h" #include "esp_chip_info.h" -#include "esp_spi_flash.h" +#include "esp_flash.h" #include "esp_partition.h" #include "esp_flash_encrypt.h" #include "esp_efuse_table.h" @@ -91,6 +91,7 @@ static void example_print_chip_info(void) { /* Print chip information */ esp_chip_info_t chip_info; + uint32_t flash_size; esp_chip_info(&chip_info); printf("This is %s chip with %d CPU core(s), WiFi%s%s, ", CONFIG_IDF_TARGET, @@ -99,8 +100,12 @@ static void example_print_chip_info(void) (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : ""); printf("silicon revision %d, ", chip_info.revision); + if(esp_flash_get_size(NULL, &flash_size) != ESP_OK) { + printf("Get flash size failed"); + return; + } - printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024), + printf("%dMB %s flash\n", flash_size / (1024 * 1024), (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external"); } @@ -147,7 +152,7 @@ static void example_read_write_flash(void) ESP_ERROR_CHECK(esp_partition_read(partition, 0, read_data, data_size)); ESP_LOG_BUFFER_HEXDUMP(TAG, read_data, data_size, ESP_LOG_INFO); - printf("Reading with spi_flash_read:\n"); - ESP_ERROR_CHECK(spi_flash_read(partition->address, read_data, data_size)); + printf("Reading with esp_flash_read:\n"); + ESP_ERROR_CHECK(esp_flash_read(NULL, read_data, partition->address, data_size)); ESP_LOG_BUFFER_HEXDUMP(TAG, read_data, data_size, ESP_LOG_INFO); } diff --git a/examples/security/flash_encryption/pytest_flash_encryption.py b/examples/security/flash_encryption/pytest_flash_encryption.py index 88cedac921..ba102f0f47 100644 --- a/examples/security/flash_encryption/pytest_flash_encryption.py +++ b/examples/security/flash_encryption/pytest_flash_encryption.py @@ -57,7 +57,7 @@ def test_examples_security_flash_encryption(dut: Dut) -> None: plain_hex_str, 'with esp_partition_read', plain_hex_str, - 'with spi_flash_read', + 'with esp_flash_read', expected_str, # The status of NVS encryption for the "nvs" partition 'NVS partition "nvs" is encrypted.', diff --git a/examples/storage/custom_flash_driver/sdkconfig.defaults b/examples/storage/custom_flash_driver/sdkconfig.defaults index c9b189d9ea..796387dbd8 100644 --- a/examples/storage/custom_flash_driver/sdkconfig.defaults +++ b/examples/storage/custom_flash_driver/sdkconfig.defaults @@ -1,2 +1 @@ -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=n CONFIG_SPI_FLASH_OVERRIDE_CHIP_DRIVER_LIST=y diff --git a/examples/system/console/advanced/components/cmd_system/cmd_system.c b/examples/system/console/advanced/components/cmd_system/cmd_system.c index 47fbc2808f..cf8a882fca 100644 --- a/examples/system/console/advanced/components/cmd_system/cmd_system.c +++ b/examples/system/console/advanced/components/cmd_system/cmd_system.c @@ -15,7 +15,7 @@ #include "esp_console.h" #include "esp_chip_info.h" #include "esp_sleep.h" -#include "esp_spi_flash.h" +#include "esp_flash.h" #include "driver/rtc_io.h" #include "driver/uart.h" #include "argtable3/argtable3.h" @@ -68,6 +68,7 @@ static int get_version(int argc, char **argv) { const char *model; esp_chip_info_t info; + uint32_t flash_size; esp_chip_info(&info); switch(info.model) { @@ -91,6 +92,10 @@ static int get_version(int argc, char **argv) break; } + if(esp_flash_get_size(NULL, &flash_size) != ESP_OK) { + printf("Get flash size failed"); + return 1; + } printf("IDF Version:%s\r\n", esp_get_idf_version()); printf("Chip info:\r\n"); printf("\tmodel:%s\r\n", model); @@ -100,7 +105,7 @@ static int get_version(int argc, char **argv) info.features & CHIP_FEATURE_BLE ? "/BLE" : "", info.features & CHIP_FEATURE_BT ? "/BT" : "", info.features & CHIP_FEATURE_EMB_FLASH ? "/Embedded-Flash:" : "/External-Flash:", - spi_flash_get_chip_size() / (1024 * 1024), " MB"); + flash_size / (1024 * 1024), " MB"); printf("\trevision number:%d\r\n", info.revision); return 0; } diff --git a/tools/mocks/spi_flash/CMakeLists.txt b/tools/mocks/spi_flash/CMakeLists.txt index 91b008cf3a..ceae52f0d5 100644 --- a/tools/mocks/spi_flash/CMakeLists.txt +++ b/tools/mocks/spi_flash/CMakeLists.txt @@ -21,4 +21,4 @@ idf_component_mock(INCLUDE_DIRS ${include_dirs} MOCK_HEADER_FILES ${original_spi_flash_dir}/include/esp_partition.h ${original_spi_flash_dir}/include/esp_flash.h - ${original_spi_flash_dir}/include/esp_spi_flash.h) + ${original_spi_flash_dir}/include/spi_flash_mmap.h) diff --git a/tools/test_apps/security/secure_boot/main/secure_boot_main.c b/tools/test_apps/security/secure_boot/main/secure_boot_main.c index fc30075f6a..4ffba89024 100644 --- a/tools/test_apps/security/secure_boot/main/secure_boot_main.c +++ b/tools/test_apps/security/secure_boot/main/secure_boot_main.c @@ -13,7 +13,7 @@ #include "esp_efuse.h" #include "esp_secure_boot.h" #include "esp_chip_info.h" -#include "esp_spi_flash.h" +#include "esp_flash.h" #include "esp_log.h" #include "esp_efuse_table.h" #include @@ -36,12 +36,17 @@ static void example_print_chip_info(void) { /* Print chip information */ esp_chip_info_t chip_info; + uint32_t flash_size; esp_chip_info(&chip_info); printf("This is %s chip with %d CPU cores\n", CONFIG_IDF_TARGET, chip_info.cores); printf("silicon revision %d, ", chip_info.revision); + if(esp_flash_get_size(NULL, &flash_size) != ESP_OK) { + printf("Get flash size failed"); + return; + } - printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024), + printf("%dMB %s flash\n", flash_size / (1024 * 1024), (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external"); } diff --git a/tools/test_apps/security/secure_boot/main/secure_boot_main_esp32.c b/tools/test_apps/security/secure_boot/main/secure_boot_main_esp32.c index 094c56ccd3..db71dfb9e0 100644 --- a/tools/test_apps/security/secure_boot/main/secure_boot_main_esp32.c +++ b/tools/test_apps/security/secure_boot/main/secure_boot_main_esp32.c @@ -13,7 +13,7 @@ #include "hal/efuse_ll.h" #include "esp_efuse.h" #include "esp_chip_info.h" -#include "esp_spi_flash.h" +#include "esp_flash.h" #include "esp_log.h" #include "esp_efuse_table.h" #include @@ -36,6 +36,7 @@ static void example_print_chip_info(void) { /* Print chip information */ esp_chip_info_t chip_info; + uint32_t flash_size; esp_chip_info(&chip_info); printf("This is ESP32 chip with %d CPU cores, WiFi%s%s, ", chip_info.cores, @@ -43,8 +44,12 @@ static void example_print_chip_info(void) (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : ""); printf("silicon revision %d, ", chip_info.revision); + if(esp_flash_get_size(NULL, &flash_size) != ESP_OK) { + printf("Get flash size failed"); + return; + } - printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024), + printf("%dMB %s flash\n", flash_size / (1024 * 1024), (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external"); } diff --git a/tools/test_apps/system/flash_psram/main/test_flash_psram.c b/tools/test_apps/system/flash_psram/main/test_flash_psram.c index 2fb38e096b..cf24dcabac 100644 --- a/tools/test_apps/system/flash_psram/main/test_flash_psram.c +++ b/tools/test_apps/system/flash_psram/main/test_flash_psram.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -12,6 +12,8 @@ #include "esp_system.h" #include "esp_check.h" #include "esp_attr.h" +#include "esp_flash.h" +#include "esp_partition.h" #if CONFIG_IDF_TARGET_ESP32S3 #include "esp32s3/rom/spi_flash.h" #include "esp32s3/rom/opi_flash.h" @@ -72,33 +74,38 @@ static esp_err_t spi0_psram_test(void) #define SPI1_FLASH_TEST_LEN 512 #define SECTOR_LEN 4096 #define SPI1_FLASH_TEST_NUM (SECTOR_LEN / SPI1_FLASH_TEST_LEN) -#define SPI1_FLASH_TEST_ADDR 0x200000 +#define SPI1_FLASH_TEST_ADDR 0x2a0000 extern void spi_flash_disable_interrupts_caches_and_other_cpu(void); extern void spi_flash_enable_interrupts_caches_and_other_cpu(void); -static DRAM_ATTR uint8_t rd_buf[SPI1_FLASH_TEST_LEN]; -static DRAM_ATTR uint8_t wr_buf[SPI1_FLASH_TEST_LEN]; +static uint8_t rd_buf[SPI1_FLASH_TEST_LEN]; +static uint8_t wr_buf[SPI1_FLASH_TEST_LEN]; + +static const esp_partition_t *get_test_flash_partition(void) +{ + /* This finds "flash_test" partition defined in partition_table_unit_test_app.csv */ + const esp_partition_t *result = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, + ESP_PARTITION_SUBTYPE_ANY, "flash_test"); + assert(result != NULL); /* means partition table set wrong */ + return result; +} static NOINLINE_ATTR IRAM_ATTR esp_err_t spi1_flash_test(void) { printf(DRAM_STR("----------SPI1 Flash Test----------\n")); //We need to use SPI1 - spi_flash_disable_interrupts_caches_and_other_cpu(); - uint32_t sector_num = SPI1_FLASH_TEST_ADDR / SECTOR_LEN; - esp_rom_spiflash_erase_sector(sector_num); - spi_flash_enable_interrupts_caches_and_other_cpu(); + const esp_partition_t* part = get_test_flash_partition(); + esp_flash_erase_region(part->flash_chip, part->address, part->size); for (int i = 0; i < SPI1_FLASH_TEST_NUM; i++) { for (int j = i + 10; j < SPI1_FLASH_TEST_LEN; j++) { wr_buf[j] = j; } - spi_flash_disable_interrupts_caches_and_other_cpu(); - uint32_t test_flash_addr = SPI1_FLASH_TEST_ADDR + i * SPI1_FLASH_TEST_LEN; - esp_rom_spiflash_write(test_flash_addr, (uint32_t*)wr_buf, SPI1_FLASH_TEST_LEN); - esp_rom_spiflash_read(test_flash_addr, (uint32_t*)rd_buf, SPI1_FLASH_TEST_LEN); - spi_flash_enable_interrupts_caches_and_other_cpu(); + uint32_t test_flash_addr = SPI1_FLASH_TEST_ADDR; + esp_flash_write(part->flash_chip, wr_buf, part->address, sizeof(wr_buf)); + esp_flash_read(part->flash_chip, rd_buf, part->address, sizeof(rd_buf)); if (memcmp(wr_buf, rd_buf, SPI1_FLASH_TEST_LEN) != 0) { printf(DRAM_STR("error happened between 0x%x and 0x%x!!!!\n"), test_flash_addr, test_flash_addr + SPI1_FLASH_TEST_LEN); diff --git a/tools/test_apps/system/flash_psram/partitions.csv b/tools/test_apps/system/flash_psram/partitions.csv new file mode 100644 index 0000000000..f236288aad --- /dev/null +++ b/tools/test_apps/system/flash_psram/partitions.csv @@ -0,0 +1,6 @@ +# Name, Type, SubType, Offset, Size, Flags +# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap +nvs, data, nvs, 0x9000, 0x6000, +phy_init, data, phy, 0xf000, 0x1000, +factory, app, factory, 0x10000, 1M, +flash_test, data, fat, , 512K, diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr index 537b02e9fd..85f4adc6e7 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr @@ -1,5 +1,7 @@ # Legacy, F4R4, Flash 120M SDR, PSRAM disable -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_120M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_120sdr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_120sdr index 85e19ab0ab..8a9f5d4520 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_120sdr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_120sdr @@ -1,6 +1,8 @@ # Legacy, F4R4, Flash 120M SDR, PSRAM 120M SDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_120M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y CONFIG_SPIRAM=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_40sdr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_40sdr index c779d7d2e6..6af77f08da 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_40sdr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_40sdr @@ -1,6 +1,8 @@ # Legacy, F4R4, Flash 120M SDR, PSRAM 40M SDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_120M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y CONFIG_SPIRAM=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_os_silent b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_os_silent index 41cbec6a1e..0a5cdf1d50 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_os_silent +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_120sdr_os_silent @@ -4,6 +4,8 @@ CONFIG_COMPILER_OPTIMIZATION_SIZE=y CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT=y -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_120M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_40sdr_120sdr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_40sdr_120sdr index 9e408da935..7a1d6cb5c9 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_40sdr_120sdr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_40sdr_120sdr @@ -1,6 +1,8 @@ # Legacy, F4R4, Flash 40M SDR, PSRAM 120M SDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_40M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y CONFIG_SPIRAM=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_80sdr_80sdr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_80sdr_80sdr index 41c3388fe2..466aa5a33d 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_80sdr_80sdr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r4_80sdr_80sdr @@ -1,6 +1,8 @@ # Legacy, F4R4, Flash 80M SDR, PSRAM 80M SDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_80M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y CONFIG_SPIRAM=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_120sdr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_120sdr index 2caeb8de79..27b14db382 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_120sdr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_120sdr @@ -1,5 +1,7 @@ # Legacy, F4R8, Flash 120M SDR, PSRAM disable -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_120M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_80sdr_40ddr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_80sdr_40ddr index 4ce21489ae..72baf2d0e1 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_80sdr_40ddr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_80sdr_40ddr @@ -1,6 +1,8 @@ # Legacy, F4R8, Flash 80M SDR, PSRAM 40M DDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_80M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y CONFIG_SPIRAM=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_80sdr_80ddr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_80sdr_80ddr index dbb62379c0..59434041a7 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_80sdr_80ddr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f4r8_80sdr_80ddr @@ -1,6 +1,8 @@ # Legacy, F4R8, Flash 80M SDR, PSRAM 80M DDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_FLASHFREQ_80M=y CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y CONFIG_SPIRAM=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_120sdr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_120sdr index 7d8f3419ef..774de2b9da 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_120sdr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_120sdr @@ -1,6 +1,8 @@ # Legacy, F8R8, Flash 120M SDR, PSRAM disable -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_OCT_FLASH=y CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR=y CONFIG_ESPTOOLPY_FLASHFREQ_120M=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_40ddr_40ddr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_40ddr_40ddr index 77b1112f34..0643c26397 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_40ddr_40ddr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_40ddr_40ddr @@ -1,6 +1,8 @@ # Legacy, F8R8, Flash 40M DDR, PSRAM 40M DDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_OCT_FLASH=y CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_DTR=y CONFIG_ESPTOOLPY_FLASHFREQ_40M=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_40ddr_80ddr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_40ddr_80ddr index f8a649f1c4..e208933fbb 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_40ddr_80ddr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_40ddr_80ddr @@ -1,6 +1,8 @@ # Legacy, F8R8, Flash 40M DDR, PSRAM 80M DDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_OCT_FLASH=y CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_DTR=y CONFIG_ESPTOOLPY_FLASHFREQ_40M=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_40ddr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_40ddr index 199bb5ea97..c56905ccb0 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_40ddr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_40ddr @@ -1,6 +1,8 @@ # Legacy, F8R8, Flash 80M DDR, PSRAM 40M DDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_OCT_FLASH=y CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_DTR=y CONFIG_ESPTOOLPY_FLASHFREQ_80M=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_80ddr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_80ddr index f522595b60..022bd0a12d 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_80ddr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_80ddr @@ -1,6 +1,8 @@ # Legacy, F8R8, Flash 80M DDR, PSRAM 80M DDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_OCT_FLASH=y CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_DTR=y CONFIG_ESPTOOLPY_FLASHFREQ_80M=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_80ddr_ecc b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_80ddr_ecc index 381cc7e987..f9dd19e0c8 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_80ddr_ecc +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80ddr_80ddr_ecc @@ -1,6 +1,8 @@ # Legacy, F8R8, Flash 80M DDR, PSRAM 80M DDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_OCT_FLASH=y CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_DTR=y CONFIG_ESPTOOLPY_FLASHFREQ_80M=y diff --git a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80sdr_80ddr b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80sdr_80ddr index 6e08bfbae5..ffb1487d21 100644 --- a/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80sdr_80ddr +++ b/tools/test_apps/system/flash_psram/sdkconfig.ci.f8r8_80sdr_80ddr @@ -1,6 +1,8 @@ # Legacy, F8R8, Flash 80M SDR, PSRAM 80M DDR -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" CONFIG_ESPTOOLPY_OCT_FLASH=y CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR=y CONFIG_ESPTOOLPY_FLASHFREQ_80M=y diff --git a/tools/test_apps/system/gdb_loadable_elf/main/hello_world_main.c b/tools/test_apps/system/gdb_loadable_elf/main/hello_world_main.c index 57dec8d9d6..0e056579bb 100644 --- a/tools/test_apps/system/gdb_loadable_elf/main/hello_world_main.c +++ b/tools/test_apps/system/gdb_loadable_elf/main/hello_world_main.c @@ -11,7 +11,7 @@ #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_chip_info.h" -#include "esp_spi_flash.h" +#include "esp_flash.h" void app_main(void) { @@ -19,6 +19,7 @@ void app_main(void) /* Print chip information */ esp_chip_info_t chip_info; + uint32_t flash_size; esp_chip_info(&chip_info); printf("This is %s chip with %d CPU cores, WiFi%s%s, ", CONFIG_IDF_TARGET, @@ -27,8 +28,12 @@ void app_main(void) (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : ""); printf("silicon revision %d, ", chip_info.revision); + if(esp_flash_get_size(NULL, &flash_size) != ESP_OK) { + printf("Get flash size failed"); + return; + } - printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024), + printf("%dMB %s flash\n", flash_size / (1024 * 1024), (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external"); printf("Free heap: %d\n", esp_get_free_heap_size()); diff --git a/tools/test_apps/system/longjmp_test/main/hello_world_main.c b/tools/test_apps/system/longjmp_test/main/hello_world_main.c index ebd2cec22d..b49cb4724c 100644 --- a/tools/test_apps/system/longjmp_test/main/hello_world_main.c +++ b/tools/test_apps/system/longjmp_test/main/hello_world_main.c @@ -11,7 +11,7 @@ #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_system.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp_timer.h" #include diff --git a/tools/test_apps/system/memprot/main/esp32s2/test_memprot_main.c b/tools/test_apps/system/memprot/main/esp32s2/test_memprot_main.c index 1c6d52f7c3..bcee035e0f 100644 --- a/tools/test_apps/system/memprot/main/esp32s2/test_memprot_main.c +++ b/tools/test_apps/system/memprot/main/esp32s2/test_memprot_main.c @@ -3,7 +3,7 @@ #include #include "sdkconfig.h" #include "esp_log.h" -#include "esp_spi_flash.h" +#include "spi_flash_mmap.h" #include "esp32s2/memprot.h" #include "soc/soc.h" diff --git a/tools/unit-test-app/configs/spi_flash_legacy b/tools/unit-test-app/configs/spi_flash_legacy deleted file mode 100644 index 01bde84327..0000000000 --- a/tools/unit-test-app/configs/spi_flash_legacy +++ /dev/null @@ -1,4 +0,0 @@ -# This config is for all targets -TEST_COMPONENTS=spi_flash -CONFIG_SPIRAM=y -CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y