Update IDF, tools and toolchains

tools/sdk/esp32s2/include/spi_flash/include/esp_flash.h

@@ -34,7 +34,15 @@ typedef struct {
     uint32_t size;      ///< Size of the region
 } esp_flash_region_t;
 
-/** OS-level integration hooks for accessing flash chips inside a running OS */
+/** @brief OS-level integration hooks for accessing flash chips inside a running OS
+ *
+ * It's in the public header because some instances should be allocated statically in the startup
+ * code. May be updated according to hardware version and new flash chip feature requirements,
+ * shouldn't be treated as public API.
+ *
+ *  For advanced developers, you may replace some of them with your implementations at your own
+ *  risk.
+*/
 typedef struct {
     /**
      * Called before commencing any flash operation. Does not need to be
@@ -50,14 +58,29 @@ typedef struct {
 
     /** Delay for at least 'us' microseconds. Called in between 'start' and 'end'. */
     esp_err_t (*delay_us)(void *arg, unsigned us);
+
+    /** Called for get temp buffer when buffer from application cannot be directly read into/write from. */
+    void *(*get_temp_buffer)(void* arg, size_t reqest_size, size_t* out_size);
+
+    /** Called for release temp buffer. */
+    void (*release_temp_buffer)(void* arg, void *temp_buf);
+
+    /** Yield to other tasks. Called during erase operations. */
+    esp_err_t (*yield)(void *arg);
 } esp_flash_os_functions_t;
 
 /** @brief Structure to describe a SPI flash chip connected to the system.
 
-    Structure must be initialized before use (passed to esp_flash_init()).
+    Structure must be initialized before use (passed to esp_flash_init()). It's in the public
+    header because some instances should be allocated statically in the startup code. May be
+    updated according to hardware version and new flash chip feature requirements, shouldn't be
+    treated as public API.
+
+    For advanced developers, you may replace some of them with your implementations at your own
+    risk.
 */
 struct esp_flash_t {
-    spi_flash_host_driver_t *host;      ///< Pointer to hardware-specific "host_driver" structure. Must be initialized before used.
+    spi_flash_host_inst_t* host;   ///< Pointer to hardware-specific "host_driver" structure. Must be initialized before used.
     const spi_flash_chip_t *chip_drv;   ///< Pointer to chip-model-specific "adapter" structure. If NULL, will be detected during initialisation.
 
     const esp_flash_os_functions_t *os_func;    ///< Pointer to os-specific hook structure. Call ``esp_flash_init_os_functions()`` to setup this field, after the host is properly initialized.

tools/sdk/esp32s2/include/spi_flash/include/esp_spi_flash.h

@@ -341,6 +341,10 @@ typedef void (*spi_flash_op_unlock_func_t)(void);
  * @brief Function to protect SPI flash critical regions corruption.
  */
 typedef bool (*spi_flash_is_safe_write_address_t)(size_t addr, size_t size);
+/**
+ * @brief Function to yield to the OS during erase operation.
+ */
+typedef void (*spi_flash_os_yield_t)(void);
 
 /**
  * Structure holding SPI flash access critical sections management functions.
@@ -381,6 +385,7 @@ typedef struct {
 #if !CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED
     spi_flash_is_safe_write_address_t   is_safe_write_address; /**< checks flash write addresses.*/
 #endif
+    spi_flash_os_yield_t                yield;      /**< yield to the OS during flash erase */
 } spi_flash_guard_funcs_t;
 
 /**

tools/sdk/esp32s2/include/spi_flash/include/memspi_host_driver.h

@@ -28,9 +28,9 @@
         .supports_direct_write = spi_flash_hal_supports_direct_write, \
         .supports_direct_read = spi_flash_hal_supports_direct_read, \
         .program_page = spi_flash_hal_program_page, \
-        .max_write_bytes = SPI_FLASH_HAL_MAX_WRITE_BYTES, \
+        .write_data_slicer = memspi_host_write_data_slicer, \
         .read = spi_flash_hal_read, \
-        .max_read_bytes = SPI_FLASH_HAL_MAX_READ_BYTES, \
+        .read_data_slicer = memspi_host_read_data_slicer, \
         .host_idle = spi_flash_hal_host_idle, \
         .configure_host_io_mode = spi_flash_hal_configure_host_io_mode, \
         .poll_cmd_done = spi_flash_hal_poll_cmd_done, \
@@ -38,20 +38,19 @@
 }
 
 /// configuration for the memspi host
-typedef spi_flash_memspi_config_t memspi_host_config_t;
+typedef spi_flash_hal_config_t memspi_host_config_t;
 /// context for the memspi host
-typedef spi_flash_memspi_data_t memspi_host_data_t;
+typedef spi_flash_hal_context_t memspi_host_inst_t;
 
 /**
  * Initialize the memory SPI host.
  *
  * @param host Pointer to the host structure.
- * @param data Pointer to allocated space to hold the context of host driver.
  * @param cfg Pointer to configuration structure
  *
  * @return always return ESP_OK
  */
-esp_err_t memspi_host_init_pointers(spi_flash_host_driver_t *host, memspi_host_data_t *data, const memspi_host_config_t *cfg);
+esp_err_t memspi_host_init_pointers(memspi_host_inst_t *host, const memspi_host_config_t *cfg);
 
 /*******************************************************************************
  * NOTICE
@@ -66,7 +65,7 @@ esp_err_t memspi_host_init_pointers(spi_flash_host_driver_t *host, memspi_host_d
  * High speed implementation of RDID through memspi interface relying on the
  * ``common_command``.
  *
- * @param driver The driver context.
+ * @param host The driver context.
  * @param id Output of the read ID from the slave.
  *
  * @return
@@ -74,69 +73,106 @@ esp_err_t memspi_host_init_pointers(spi_flash_host_driver_t *host, memspi_host_d
  *  - ESP_ERR_FLASH_NO_RESPONSE: if no response from chip
  *  - or other cases from ``spi_hal_common_command``
  */
-esp_err_t memspi_host_read_id_hs(spi_flash_host_driver_t *driver, uint32_t *id);
+esp_err_t memspi_host_read_id_hs(spi_flash_host_inst_t *host, uint32_t *id);
 
 /**
  * High speed implementation of RDSR through memspi interface relying on the
  * ``common_command``.
  *
- * @param driver The driver context.
+ * @param host The driver context.
  * @param id Output of the read ID from the slave.
  *
  * @return
  *  - ESP_OK: if success
  *  - or other cases from ``spi_hal_common_command``
  */
-esp_err_t memspi_host_read_status_hs(spi_flash_host_driver_t *driver, uint8_t *out_sr);
+esp_err_t memspi_host_read_status_hs(spi_flash_host_inst_t *host, uint8_t *out_sr);
 
 /**
  * Flush the cache (if needed) after the contents are modified.
  *
- * @param driver The driver context.
+ * @param host The driver context.
  * @param addr Start address of the modified region
  * @param size Size of the region modified.
  *
  * @return always ESP_OK.
  */
-esp_err_t memspi_host_flush_cache(spi_flash_host_driver_t* driver, uint32_t addr, uint32_t size);
+esp_err_t memspi_host_flush_cache(spi_flash_host_inst_t *host, uint32_t addr, uint32_t size);
 
 /**
  *  Erase contents of entire chip.
  *
- * @param driver The driver context.
+ * @param host The driver context.
  */
-void memspi_host_erase_chip(spi_flash_host_driver_t *driver);
+void memspi_host_erase_chip(spi_flash_host_inst_t *host);
 
 /**
  *  Erase a sector starting from a given address.
  *
- * @param driver The driver context.
+ * @param host The driver context.
  * @param start_address Starting address of the sector.
  */
-void memspi_host_erase_sector(spi_flash_host_driver_t *driver, uint32_t start_address);
+void memspi_host_erase_sector(spi_flash_host_inst_t *host, uint32_t start_address);
 
 /**
  *  Erase a block starting from a given address.
  *
- * @param driver The driver context.
+ * @param host The driver context.
  * @param start_address Starting address of the block.
  */
-void memspi_host_erase_block(spi_flash_host_driver_t *driver, uint32_t start_address);
+void memspi_host_erase_block(spi_flash_host_inst_t *host, uint32_t start_address);
 
 /**
  * Program a page with contents of a buffer.
  *
- * @param driver The driver context.
+ * @param host The driver context.
  * @param buffer Buffer which contains the data to be flashed.
  * @param address Starting address of where to flash the data.
  * @param length The number of bytes to flash.
  */
-void memspi_host_program_page(spi_flash_host_driver_t *driver, const void *buffer, uint32_t address, uint32_t length);
+void memspi_host_program_page(spi_flash_host_inst_t *host, const void *buffer, uint32_t address, uint32_t length);
 
 /**
  * Set ability to write to chip.
  *
- * @param driver The driver context.
+ * @param host The driver context.
  * @param wp Enable or disable write protect (true - enable, false - disable).
  */
-esp_err_t memspi_host_set_write_protect(spi_flash_host_driver_t *driver, bool wp);
+esp_err_t memspi_host_set_write_protect(spi_flash_host_inst_t *host, bool wp);
+
+/**
+ * Read data to buffer.
+ *
+ * @param host The driver context.
+ * @param buffer Buffer which contains the data to be read.
+ * @param address Starting address of where to read the data.
+ * @param length The number of bytes to read.
+ */
+esp_err_t memspi_host_read(spi_flash_host_inst_t *host, void *buffer, uint32_t address, uint32_t read_len);
+
+/**
+ * @brief Slicer for read data used in non-encrypted regions. This slicer does nothing but
+ *        limit the length to the maximum size the host supports.
+ *
+ * @param address Flash address to read
+ * @param len Length to read
+ * @param align_address Output of the address to read, should be equal to the input `address`
+ * @param page_size Physical SPI flash page size
+ *
+ * @return Length that can actually be read in one `read` call in `spi_flash_host_driver_t`.
+ */
+int memspi_host_read_data_slicer(spi_flash_host_inst_t *host, uint32_t address, uint32_t len, uint32_t *align_address, uint32_t page_size);
+
+/**
+ * @brief Slicer for write data used in non-encrypted regions. This slicer limit the length to the
+ *        maximum size the host supports, and truncate if the write data lie accross the page boundary
+ *        (256 bytes)
+ *
+ * @param address Flash address to write
+ * @param len Length to write
+ * @param align_address Output of the address to write, should be equal to the input `address`
+ * @param page_size Physical SPI flash page size
+ *
+ * @return Length that can actually be written in one `program_page` call in `spi_flash_host_driver_t`.
+ */
+int memspi_host_write_data_slicer(spi_flash_host_inst_t *host, uint32_t address, uint32_t len, uint32_t *align_address, uint32_t page_size);

tools/sdk/esp32s2/include/spi_flash/include/spi_flash_chip_driver.h

@@ -19,6 +19,16 @@ struct esp_flash_t;
 typedef struct esp_flash_t esp_flash_t;
 
 typedef struct spi_flash_chip_t spi_flash_chip_t;
+
+/** Timeout configurations for flash operations, all in us */
+typedef struct {
+    uint32_t chip_erase_timeout;    ///< Timeout for chip erase operation
+    uint32_t block_erase_timeout;   ///< Timeout for block erase operation
+    uint32_t sector_erase_timeout;  ///< Timeout for sector erase operation
+    uint32_t idle_timeout;          ///< Default timeout for other commands to be sent by host and get done by flash
+    uint32_t page_program_timeout;  ///< Timeout for page program operation
+} flash_chip_op_timeout_t;
+
 /** @brief SPI flash chip driver definition structure.
  *
  * The chip driver structure contains chip-specific pointers to functions to perform SPI flash operations, and some
@@ -38,6 +48,7 @@ typedef struct spi_flash_chip_t spi_flash_chip_t;
  */
 struct spi_flash_chip_t {
     const char *name; ///< Name of the chip driver
+    const flash_chip_op_timeout_t *timeout; ///< Timeout configuration for this chip
     /* Probe to detect if a supported SPI flash chip is found.
      *
      * Attempts to configure 'chip' with these operations and probes for a matching SPI flash chip.

tools/sdk/esp32s2/include/spi_flash/include/spi_flash_chip_generic.h

@@ -368,3 +368,6 @@ esp_err_t spi_flash_common_set_io_mode(esp_flash_t *chip, esp_flash_wrsr_func_t
  *      - or other error passed from the ``configure_host_mode`` function of host driver
  */
 esp_err_t spi_flash_chip_generic_config_host_io_mode(esp_flash_t *chip);
+
+/// Default timeout configuration used by most chips
+const flash_chip_op_timeout_t spi_flash_chip_generic_timeout;