alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

partition: use esp_partition_munmap instead of spi_flash_munmap

Browse Source
This commit is contained in:
Armando 2022-11-07 19:31:29 +08:00
parent 5bed8fab49
commit aba9f80cd2
9 changed files with 35 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
components/app_update/test_apps/main/test_switch_ota.c
View File

@ -69,11 +69,11 @@ static uint8_t get_boot_count_from_nvs(void)
static void copy_app_partition(esp_ota_handle_t update_handle, const esp_partition_t *curr_app)
{
const void *partition_bin = NULL;
spi_flash_mmap_handle_t data_map;
esp_partition_mmap_handle_t data_map;
ESP_LOGI(TAG, "start the copy process");
TEST_ESP_OK(esp_partition_mmap(curr_app, 0, curr_app->size, SPI_FLASH_MMAP_DATA, &partition_bin, &data_map));
TEST_ESP_OK(esp_partition_mmap(curr_app, 0, curr_app->size, ESP_PARTITION_MMAP_DATA, &partition_bin, &data_map));
TEST_ESP_OK(esp_ota_write(update_handle, (const void *)partition_bin, curr_app->size));
spi_flash_munmap(data_map);
esp_partition_munmap(data_map);
ESP_LOGI(TAG, "finish the copy process");
}
@ -85,15 +85,15 @@ static void copy_app_partition(esp_ota_handle_t update_handle, const esp_partiti
static void copy_app_partition_with_offset(esp_ota_handle_t update_handle, const esp_partition_t *curr_app)
{
const void *partition_bin = NULL;
spi_flash_mmap_handle_t data_map;
esp_partition_mmap_handle_t data_map;
ESP_LOGI(TAG, "start the copy process");
uint32_t offset = 0, bytes_to_write = curr_app->size;
uint32_t write_bytes;
while (bytes_to_write > 0) {
write_bytes = (bytes_to_write > (4 * 1024)) ? (4 * 1024) : bytes_to_write;
TEST_ESP_OK(esp_partition_mmap(curr_app, offset, write_bytes, SPI_FLASH_MMAP_DATA, &partition_bin, &data_map));
TEST_ESP_OK(esp_partition_mmap(curr_app, offset, write_bytes, ESP_PARTITION_MMAP_DATA, &partition_bin, &data_map));
TEST_ESP_OK(esp_ota_write_with_offset(update_handle, (const void *)partition_bin, write_bytes, offset));
spi_flash_munmap(data_map);
esp_partition_munmap(data_map);
bytes_to_write -= write_bytes;
offset += write_bytes;
}
@ -110,11 +110,11 @@ static void copy_app_partition_with_offset(esp_ota_handle_t update_handle, const
static void copy_partition(const esp_partition_t *dst_partition, const esp_partition_t *src_partition)
{
const void *partition_bin = NULL;
spi_flash_mmap_handle_t data_map;
TEST_ESP_OK(esp_partition_mmap(src_partition, 0, src_partition->size, SPI_FLASH_MMAP_DATA, &partition_bin, &data_map));
esp_partition_mmap_handle_t data_map;
TEST_ESP_OK(esp_partition_mmap(src_partition, 0, src_partition->size, ESP_PARTITION_MMAP_DATA, &partition_bin, &data_map));
TEST_ESP_OK(esp_partition_erase_range(dst_partition, 0, dst_partition->size));
TEST_ESP_OK(esp_partition_write(dst_partition, 0, (const void *)partition_bin, dst_partition->size));
spi_flash_munmap(data_map);
esp_partition_munmap(data_map);
}
#endif

6
components/esp_hw_support/test/test_spiram_cache_flush.c
View File

@ -126,14 +126,14 @@ TEST_CASE("Spiram cache flush on write/read", "[spiram]")
char buf[512];
const void *out;
spi_flash_mmap_handle_t handle;
esp_partition_mmap(part, 0, 512, SPI_FLASH_MMAP_DATA, &out, &handle);
esp_partition_mmap_handle_t handle;
esp_partition_mmap(part, 0, 512, ESP_PARTITION_MMAP_DATA, &out, &handle);
for (int i=0; i<CYCLES; i++) {
esp_partition_write(part, 0, buf, 512);
esp_partition_read(part, 0, buf, 512);
vTaskDelay(1);
}
spi_flash_munmap(handle);
esp_partition_munmap(handle);
printf("Checked memory %d and %d times.\n", res[0], res[1]);

2
components/esp_partition/partition_target.c
View File

@ -53,7 +53,7 @@ esp_err_t esp_partition_read(const esp_partition_t *partition,
return err;
}
memcpy(dst, buf, size);
spi_flash_munmap(handle);
esp_partition_munmap(handle);
return ESP_OK;
#else
return ESP_ERR_NOT_SUPPORTED;

9
components/espcoredump/src/core_dump_elf.c
View File

@ -6,7 +6,6 @@
#include <string.h>
#include "esp_attr.h"
#include "esp_partition.h"
#include "spi_flash_mmap.h"
#include "esp_flash_encrypt.h"
#include "sdkconfig.h"
#include "core_dump_checksum.h"
@ -645,7 +644,7 @@ esp_err_t esp_core_dump_write_elf(core_dump_write_config_t *write_cfg)
/* Below are the helper function to parse the core dump ELF stored in flash */
static esp_err_t elf_core_dump_image_mmap(spi_flash_mmap_handle_t* core_data_handle, const void **map_addr)
static esp_err_t elf_core_dump_image_mmap(esp_partition_mmap_handle_t* core_data_handle, const void **map_addr)
{
size_t out_size;
assert (core_data_handle);
@ -677,7 +676,7 @@ static esp_err_t elf_core_dump_image_mmap(spi_flash_mmap_handle_t* core_data_han
return ret;
}
/* map the full core dump parition, including the checksum. */
return esp_partition_mmap(core_part, 0, out_size, SPI_FLASH_MMAP_DATA,
return esp_partition_mmap(core_part, 0, out_size, ESP_PARTITION_MMAP_DATA,
map_addr, core_data_handle);
}
@ -708,7 +707,7 @@ esp_err_t esp_core_dump_get_summary(esp_core_dump_summary_t *summary)
elf_note *note;
const void *map_addr;
size_t consumed_note_sz;
spi_flash_mmap_handle_t core_data_handle;
esp_partition_mmap_handle_t core_data_handle;
if (!summary) {
return ESP_ERR_INVALID_ARG;
@ -766,7 +765,7 @@ esp_err_t esp_core_dump_get_summary(esp_core_dump_summary_t *summary)
}
}
}
spi_flash_munmap(core_data_handle);
esp_partition_munmap(core_data_handle);
return ESP_OK;
}

6
components/mqtt/test/test_mqtt.c
View File

@ -23,7 +23,7 @@
#include "test_mqtt_client_broker.h"
#include "test_mqtt_connection.h"
#include "esp_mac.h"
#include "spi_flash_mmap.h"
#include "esp_partition.h"
static void test_leak_setup(const char * file, long line)
{
@ -59,10 +59,10 @@ TEST_CASE("mqtt init and deinit", "[mqtt][leaks=0]")
static const char* this_bin_addr(void)
{
spi_flash_mmap_handle_t out_handle;
esp_partition_mmap_handle_t out_handle;
const void *binary_address;
const esp_partition_t* partition = esp_ota_get_running_partition();
esp_partition_mmap(partition, 0, partition->size, SPI_FLASH_MMAP_DATA, &binary_address, &out_handle);
esp_partition_mmap(partition, 0, partition->size, ESP_PARTITION_MMAP_DATA, &binary_address, &out_handle);
return binary_address;
}

6
components/mqtt/test/test_mqtt5.c
View File

@ -17,7 +17,7 @@
#include "test_mqtt5_client_broker.h"
#include "test_mqtt_connection.h"
#include "esp_mac.h"
#include "spi_flash_mmap.h"
#include "esp_partition.h"
static esp_mqtt5_user_property_item_t user_property_arr[3] = {
{"board", "esp32"},
@ -89,10 +89,10 @@ TEST_CASE("mqtt5 init and deinit", "[mqtt5][leaks=0]")
static const char* this_bin_addr(void)
{
spi_flash_mmap_handle_t out_handle;
esp_partition_mmap_handle_t out_handle;
const void *binary_address;
const esp_partition_t* partition = esp_ota_get_running_partition();
esp_partition_mmap(partition, 0, partition->size, SPI_FLASH_MMAP_DATA, &binary_address, &out_handle);
esp_partition_mmap(partition, 0, partition->size, ESP_PARTITION_MMAP_DATA, &binary_address, &out_handle);
return binary_address;
}

14
components/spi_flash/test_apps/flash_mmap/main/test_mmap.c
View File

@ -445,15 +445,15 @@ TEST_CASE("munmap followed by mmap flushes cache", "[spi_flash][mmap]")
const esp_partition_t *p = get_test_data_partition();
const uint32_t *data;
spi_flash_mmap_handle_t handle;
esp_partition_mmap_handle_t handle;
TEST_ESP_OK( esp_partition_mmap(p, 0, SPI_FLASH_MMU_PAGE_SIZE,
SPI_FLASH_MMAP_DATA, (const void **) &data, &handle) );
ESP_PARTITION_MMAP_DATA, (const void **) &data, &handle) );
uint32_t buf[16];
memcpy(buf, data, sizeof(buf));
spi_flash_munmap(handle);
esp_partition_munmap(handle);
TEST_ESP_OK( esp_partition_mmap(p, SPI_FLASH_MMU_PAGE_SIZE, SPI_FLASH_MMU_PAGE_SIZE,
SPI_FLASH_MMAP_DATA, (const void **) &data, &handle) );
ESP_PARTITION_MMAP_DATA, (const void **) &data, &handle) );
TEST_ASSERT_NOT_EQUAL(0, memcmp(buf, data, sizeof(buf)));
}
@ -467,9 +467,9 @@ TEST_CASE("no stale data read post mmap and write partition", "[spi_flash][mmap]
const esp_partition_t *p = get_test_data_partition();
const uint32_t *data;
spi_flash_mmap_handle_t handle;
esp_partition_mmap_handle_t handle;
TEST_ESP_OK(esp_partition_mmap(p, 0, SPI_FLASH_MMU_PAGE_SIZE,
SPI_FLASH_MMAP_DATA, (const void **) &data, &handle) );
ESP_PARTITION_MMAP_DATA, (const void **) &data, &handle) );
memcpy(read_data, data, sizeof(read_data));
TEST_ESP_OK(esp_partition_erase_range(p, 0, SPI_FLASH_MMU_PAGE_SIZE));
/* not using esp_partition_write here, since the partition in not marked as "encrypted"
@ -478,6 +478,6 @@ TEST_CASE("no stale data read post mmap and write partition", "[spi_flash][mmap]
/* This should retrigger actual flash content read */
memcpy(read_data, data, sizeof(read_data));
spi_flash_munmap(handle);
esp_partition_munmap(handle);
TEST_ASSERT_EQUAL(0, memcmp(buf, read_data, sizeof(buf)));
}

5
examples/protocols/mqtt/ssl/main/app_main.c
View File

@ -13,7 +13,6 @@
#include <string.h>
#include "esp_system.h"
#include "esp_partition.h"
#include "spi_flash_mmap.h"
#include "nvs_flash.h"
#include "esp_event.h"
#include "esp_netif.h"
@ -41,10 +40,10 @@ extern const uint8_t mqtt_eclipseprojects_io_pem_end[] asm("_binary_mqtt_eclip
//
static void send_binary(esp_mqtt_client_handle_t client)
{
spi_flash_mmap_handle_t out_handle;
esp_partition_mmap_handle_t out_handle;
const void *binary_address;
const esp_partition_t *partition = esp_ota_get_running_partition();
esp_partition_mmap(partition, 0, partition->size, SPI_FLASH_MMAP_DATA, &binary_address, &out_handle);
esp_partition_mmap(partition, 0, partition->size, ESP_PARTITION_MMAP_DATA, &binary_address, &out_handle);
// sending only the configured portion of the partition (if it's less than the partition size)
int binary_size = MIN(CONFIG_BROKER_BIN_SIZE_TO_SEND, partition->size);
int msg_id = esp_mqtt_client_publish(client, "/topic/binary", binary_address, binary_size, 0, 0);

7
examples/storage/partition_api/partition_mmap/main/main.c
View File

@ -8,7 +8,6 @@
#include <string.h>
#include <assert.h>
#include "esp_partition.h"
#include "spi_flash_mmap.h"
#include "esp_log.h"
static const char *TAG = "example";
@ -36,10 +35,10 @@ void app_main(void)
ESP_LOGI(TAG, "Written sample data to partition: %s", store_data);
const void *map_ptr;
spi_flash_mmap_handle_t map_handle;
esp_partition_mmap_handle_t map_handle;
// Map the partition to data memory
ESP_ERROR_CHECK(esp_partition_mmap(partition, 0, partition->size, SPI_FLASH_MMAP_DATA, &map_ptr, &map_handle));
ESP_ERROR_CHECK(esp_partition_mmap(partition, 0, partition->size, ESP_PARTITION_MMAP_DATA, &map_ptr, &map_handle));
ESP_LOGI(TAG, "Mapped partition to data memory address %p", map_ptr);
// Read back the written verification data using the mapped memory pointer
@ -51,7 +50,7 @@ void app_main(void)
ESP_LOGI(TAG, "Data matches");
// Unmap mapped memory
spi_flash_munmap(map_handle);
esp_partition_munmap(map_handle);
ESP_LOGI(TAG, "Unmapped partition from data memory");
ESP_LOGI(TAG, "Example end");