From e4b44f34888fcf575a4eabaf53c5130f4fbd4ee6 Mon Sep 17 00:00:00 2001 From: "Michael (XIAO Xufeng)" Date: Tue, 10 Sep 2019 14:34:06 +0800 Subject: [PATCH] esp_flash: fix coredump for legacy spi flash API When legacy mode is used, the coredump still fails during linking because "esp_flash_init_default_chip", "esp_flash_app_init" and "esp_flash_default_chip " are not compiled and linked. Instead of using ``if`` macros in callers, these functions are protected by ``if`` macros in the header, and also not compiled in the sources. "esp_flash_default_chip" variable is compiled with safe default value. --- components/esp32/cpu_start.c | 2 +- components/spi_flash/CMakeLists.txt | 13 ++-- components/spi_flash/esp_flash_api.c | 15 ++-- components/spi_flash/esp_flash_spi_init.c | 35 ++++++---- components/spi_flash/include/esp_flash.h | 27 -------- .../spi_flash/include/esp_flash_internal.h | 68 +++++++++++++++++++ 6 files changed, 106 insertions(+), 54 deletions(-) create mode 100644 components/spi_flash/include/esp_flash_internal.h diff --git a/components/esp32/cpu_start.c b/components/esp32/cpu_start.c index 221cb1deb..b55753a6d 100644 --- a/components/esp32/cpu_start.c +++ b/components/esp32/cpu_start.c @@ -43,7 +43,7 @@ #include "sdkconfig.h" #include "esp_system.h" #include "esp_spi_flash.h" -#include "esp_flash.h" +#include "esp_flash_internal.h" #include "nvs_flash.h" #include "esp_event.h" #include "esp_spi_flash.h" diff --git a/components/spi_flash/CMakeLists.txt b/components/spi_flash/CMakeLists.txt index 1a09d3e69..878b3c8cf 100644 --- a/components/spi_flash/CMakeLists.txt +++ b/components/spi_flash/CMakeLists.txt @@ -4,21 +4,24 @@ if(BOOTLOADER_BUILD) # need other parts of this component set(srcs "spi_flash_rom_patch.c") else() - set(srcs + set(srcs "cache_utils.c" "flash_mmap.c" "flash_ops.c" "partition.c" "spi_flash_rom_patch.c" + ) + # New implementation + list(APPEND srcs "spi_flash_chip_drivers.c" "spi_flash_chip_generic.c" "spi_flash_chip_issi.c" "spi_flash_os_func_app.c" "spi_flash_os_func_noos.c" - "memspi_host_driver.c") - if(NOT CONFIG_SPI_FLASH_USE_LEGACY_IMPL) - list(APPEND srcs "esp_flash_api.c" "esp_flash_spi_init.c") - endif() + "memspi_host_driver.c" + "esp_flash_api.c" + "esp_flash_spi_init.c" + ) set(priv_requires bootloader_support app_update soc) endif() diff --git a/components/spi_flash/esp_flash_api.c b/components/spi_flash/esp_flash_api.c index 146ebd12f..b350e3d0f 100644 --- a/components/spi_flash/esp_flash_api.c +++ b/components/spi_flash/esp_flash_api.c @@ -294,14 +294,15 @@ esp_err_t IRAM_ATTR esp_flash_erase_region(esp_flash_t *chip, uint32_t start, ui return ESP_ERR_INVALID_ARG; } - esp_err_t err = spiflash_start(chip); - if (err != ESP_OK) { - return err; - } - + esp_err_t err = ESP_OK; // Check for write protected regions overlapping the erase region if (chip->chip_drv->get_protected_regions != NULL && chip->chip_drv->num_protectable_regions > 0) { + + err = spiflash_start(chip); + if (err != ESP_OK) { + return err; + } uint64_t protected = 0; err = chip->chip_drv->get_protected_regions(chip, &protected); if (err == ESP_OK && protected != 0) { @@ -313,10 +314,10 @@ esp_err_t IRAM_ATTR esp_flash_erase_region(esp_flash_t *chip, uint32_t start, ui } } } + // Don't lock the SPI flash for the entire erase, as this may be very long + err = spiflash_end(chip, err); } - // Don't lock the SPI flash for the entire erase, as this may be very long - err = spiflash_end(chip, err); while (err == ESP_OK && len >= sector_size) { err = spiflash_start(chip); diff --git a/components/spi_flash/esp_flash_spi_init.c b/components/spi_flash/esp_flash_spi_init.c index ecd566686..dda02130d 100644 --- a/components/spi_flash/esp_flash_spi_init.c +++ b/components/spi_flash/esp_flash_spi_init.c @@ -23,7 +23,7 @@ #include "hal/spi_types.h" #include "driver/spi_common.h" -static const char TAG[] = "spi_flash"; +__attribute__((unused)) static const char TAG[] = "spi_flash"; #ifdef CONFIG_ESPTOOLPY_FLASHFREQ_80M #define DEFAULT_FLASH_SPEED ESP_FLASH_80MHZ @@ -49,6 +49,18 @@ static const char TAG[] = "spi_flash"; #define DEFAULT_FLASH_MODE SPI_FLASH_FASTRD #endif +#define ESP_FLASH_HOST_CONFIG_DEFAULT() (memspi_host_config_t){ \ + .host_id = SPI_HOST,\ + .speed = DEFAULT_FLASH_SPEED, \ + .cs_num = 0, \ + .iomux = false, \ + .input_delay_ns = 0,\ +} + + +esp_flash_t *esp_flash_default_chip = NULL; + + static IRAM_ATTR void cs_initialize(esp_flash_t *chip, const esp_flash_spi_device_config_t *config, bool use_iomux) { //Not using spicommon_cs_initialize since we don't want to put the whole @@ -151,29 +163,22 @@ esp_err_t spi_bus_remove_flash_device(esp_flash_t *chip) return ESP_OK; } -#define ESP_FLASH_HOST_CONFIG_DEFAULT() (memspi_host_config_t){ \ - .host_id = SPI_HOST,\ - .speed = DEFAULT_FLASH_SPEED, \ - .cs_num = 0, \ - .iomux = false, \ - .input_delay_ns = 0,\ -} - -static DRAM_ATTR spi_flash_host_driver_t esp_flash_default_host_drv = ESP_FLASH_DEFAULT_HOST_DRIVER(); - -static DRAM_ATTR memspi_host_data_t default_driver_data; /* The default (ie initial boot) no-OS ROM esp_flash_os_functions_t */ extern const esp_flash_os_functions_t esp_flash_noos_functions; +#ifndef CONFIG_SPI_FLASH_USE_LEGACY_IMPL + +static DRAM_ATTR memspi_host_data_t default_driver_data; +static DRAM_ATTR spi_flash_host_driver_t esp_flash_default_host_drv = ESP_FLASH_DEFAULT_HOST_DRIVER(); + + static DRAM_ATTR esp_flash_t default_chip = { .read_mode = DEFAULT_FLASH_MODE, .host = &esp_flash_default_host_drv, .os_func = &esp_flash_noos_functions, }; -esp_flash_t *esp_flash_default_chip = NULL; - esp_err_t esp_flash_init_default_chip() { memspi_host_config_t cfg = ESP_FLASH_HOST_CONFIG_DEFAULT(); @@ -204,3 +209,5 @@ esp_err_t esp_flash_app_init() { return esp_flash_init_os_functions(&default_chip, 0); } + +#endif diff --git a/components/spi_flash/include/esp_flash.h b/components/spi_flash/include/esp_flash.h index 95d815b7b..e5a3a1830 100644 --- a/components/spi_flash/include/esp_flash.h +++ b/components/spi_flash/include/esp_flash.h @@ -265,33 +265,6 @@ esp_err_t esp_flash_write_encrypted(esp_flash_t *chip, uint32_t address, const v */ extern esp_flash_t *esp_flash_default_chip; -/** @brief Initialise the default SPI flash chip - * - * Called by OS startup code. You do not need to call this in your own applications. - */ -esp_err_t esp_flash_init_default_chip(); - -/** - * Enable OS-level SPI flash protections in IDF - * - * Called by OS startup code. You do not need to call this in your own applications. - * - * @return ESP_OK if success, otherwise failed. See return value of ``esp_flash_init_os_functions``. - */ -esp_err_t esp_flash_app_init(); - -/** - * Enable OS-level SPI flash for a specific chip. - * - * @param chip The chip to init os functions. - * @param host_id Which SPI host to use, 1 for SPI1, 2 for SPI2 (HSPI), 3 for SPI3 (VSPI) - * - * @return - * - ESP_OK if success - * - ESP_ERR_INVALID_ARG if host_id is invalid - */ -esp_err_t esp_flash_init_os_functions(esp_flash_t *chip, int host_id); - #ifdef __cplusplus } diff --git a/components/spi_flash/include/esp_flash_internal.h b/components/spi_flash/include/esp_flash_internal.h new file mode 100644 index 000000000..b0d35f371 --- /dev/null +++ b/components/spi_flash/include/esp_flash_internal.h @@ -0,0 +1,68 @@ +// Copyright 2015-2019 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. + +#pragma once +#include "esp_err.h" +#include +#include +#include "sdkconfig.h" + +#include "esp_flash.h" + +/** Internal API, don't use in the applications */ + +#ifdef __cplusplus +extern "C" { +#endif + + +/** @brief Initialise the default SPI flash chip + * + * 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 + * + * Called by OS startup code. You do not need to call this in your own applications. + * + * @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 + +/** + * Initialize OS-level functions for a specific chip. + * + * @param chip The chip to init os functions. + * @param host_id Which SPI host to use, 1 for SPI1, 2 for SPI2 (HSPI), 3 for SPI3 (VSPI) + * + * @return + * - ESP_OK if success + * - ESP_ERR_INVALID_ARG if host_id is invalid + */ +esp_err_t esp_flash_init_os_functions(esp_flash_t *chip, int host_id); + + +#ifdef __cplusplus +} +#endif