mirror of
https://github.com/espressif/esp-idf
synced 2025-03-09 09:09:10 -04:00
4c38499303
- When flash encryption is enable to support reading a partition that is not marked as "encrypted", the `esp_partition_read()` API of bootloader build should be redirected to the `bootloader_flash_read()` API.
104 lines
3.8 KiB
C
104 lines
3.8 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
*/
|
|
|
|
#include "esp_partition.h"
|
|
#include "esp_flash_partitions.h" // esp_partition_table_verify
|
|
#include "bootloader_flash_priv.h" // bootloader_ssupport/bootloader_flash/include
|
|
#include "esp_log.h"
|
|
|
|
static const char* TAG = "partition_bootloader";
|
|
|
|
// populates the internal_partition_list from flash
|
|
const esp_partition_t* esp_partition_find_first(esp_partition_type_t type, esp_partition_subtype_t subtype, const char* label)
|
|
{
|
|
static esp_partition_t internal_partition = {0};
|
|
int partition_count = 0;
|
|
|
|
// Inspired by the implementation in bootloader_support component in bootloader_support.c
|
|
const esp_partition_info_t *partitions = NULL;
|
|
|
|
partitions = bootloader_mmap(ESP_PARTITION_TABLE_OFFSET, ESP_PARTITION_TABLE_MAX_LEN);
|
|
if (!partitions) {
|
|
ESP_LOGV(TAG, "bootloader_mmap(0x%x, 0x%x) failed", ESP_PARTITION_TABLE_OFFSET, ESP_PARTITION_TABLE_MAX_LEN);
|
|
return NULL;
|
|
}
|
|
ESP_LOGV(TAG, "mapped partition table 0x%x at 0x%x", ESP_PARTITION_TABLE_OFFSET, (intptr_t)partitions);
|
|
|
|
esp_err_t err = esp_partition_table_verify(partitions, true, &partition_count);
|
|
if (err != ESP_OK) {
|
|
ESP_LOGV(TAG, "Failed to verify partition table");
|
|
|
|
bootloader_munmap(partitions);
|
|
return NULL;
|
|
}
|
|
|
|
ESP_LOGV(TAG, "Partition Table:");
|
|
|
|
// in the loop, try to match the partition type, subtype and label
|
|
for (int i = 0; i < partition_count; i++) {
|
|
const esp_partition_info_t *partition = &partitions[i];
|
|
ESP_LOGV(TAG, "Partition table entry 0x%x", (intptr_t)partition);
|
|
ESP_LOGV(TAG, "type=%x subtype=%x label=%-16s", partition->type, partition->subtype, partition->label);
|
|
|
|
// if everything matches, populate the internal_partition
|
|
if (partition->type == type
|
|
&& partition->subtype == subtype
|
|
&& (!label || (label && (strncmp((char*) partition->label, label, sizeof(partition->label) - 1) == 0)))
|
|
) {
|
|
ESP_LOGV(TAG, "Matched", partition->type, partition->subtype, partition->label);
|
|
internal_partition.flash_chip = NULL; //esp_flash_default_chip;
|
|
internal_partition.type = partition->type;
|
|
internal_partition.subtype = partition->subtype;
|
|
internal_partition.address = partition->pos.offset;
|
|
internal_partition.size = partition->pos.size;
|
|
internal_partition.erase_size = SPI_FLASH_SEC_SIZE;
|
|
strncpy(internal_partition.label, (char*) partition->label, sizeof(internal_partition.label) - 1);
|
|
internal_partition.encrypted = partition->flags & PART_FLAG_ENCRYPTED;
|
|
internal_partition.readonly = partition->flags & PART_FLAG_READONLY;
|
|
|
|
bootloader_munmap(partitions);
|
|
return &internal_partition;
|
|
}
|
|
}
|
|
ESP_LOGV(TAG, "Nothing matched, end of partition table");
|
|
|
|
bootloader_munmap(partitions);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
esp_err_t esp_partition_read(const esp_partition_t *partition,
|
|
size_t src_offset, void *dst, size_t size)
|
|
{
|
|
assert(partition != NULL);
|
|
if (src_offset > partition->size) {
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
if (size > partition->size - src_offset) {
|
|
return ESP_ERR_INVALID_SIZE;
|
|
}
|
|
|
|
if (!partition->encrypted) {
|
|
return bootloader_flash_read(partition->address + src_offset, dst, size, false);
|
|
}
|
|
|
|
const void *buf;
|
|
|
|
// log call to mmap
|
|
ESP_LOGV(TAG, "mmap(0x%x, 0x%x)", partition->address + src_offset, size);
|
|
|
|
buf = bootloader_mmap(partition->address + src_offset, size);
|
|
|
|
if (buf == NULL) {
|
|
ESP_LOGV(TAG, "bootloader_mmap(0x%x, 0x%x) failed", partition->address, size);
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
memcpy(dst, buf, size);
|
|
bootloader_munmap(buf);
|
|
return ESP_OK;
|
|
}
|