mirror of
https://github.com/espressif/ESP8266_RTOS_SDK.git
synced 2025-05-21 17:16:29 +08:00
Merge branch 'feature/add_partition_driver' into 'master'
Add partition driver See merge request sdk/ESP8266_RTOS_SDK!219
This commit is contained in:
Wu Jian Gang
@ -27,11 +27,10 @@
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/queue.h>
|
||||
|
||||
#include "esp_wifi.h"
|
||||
|
||||
#include "queue.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
@ -27,8 +27,8 @@
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/queue.h>
|
||||
|
||||
#include "queue.h"
|
||||
#include "esp_wifi.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
@ -1,236 +0,0 @@
|
||||
/*
|
||||
* ESPRSSIF MIT License
|
||||
*
|
||||
* Copyright (c) 2015 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
|
||||
*
|
||||
* Permission is hereby granted for use on ESPRESSIF SYSTEMS ESP8266 only, in which case,
|
||||
* it is free of charge, to any person obtaining a copy of this software and associated
|
||||
* documentation files (the "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
|
||||
* to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all copies or
|
||||
* substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _SYS_QUEUE_H_
|
||||
#define _SYS_QUEUE_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define QMD_SAVELINK(name, link)
|
||||
#define TRASHIT(x)
|
||||
|
||||
/*
|
||||
* Singly-linked List declarations.
|
||||
*/
|
||||
#define SLIST_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *slh_first; /* first element */ \
|
||||
}
|
||||
|
||||
#define SLIST_HEAD_INITIALIZER(head) \
|
||||
{ NULL }
|
||||
|
||||
#define SLIST_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *sle_next; /* next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Singly-linked List functions.
|
||||
*/
|
||||
#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
|
||||
|
||||
#define SLIST_FIRST(head) ((head)->slh_first)
|
||||
|
||||
#define SLIST_FOREACH(var, head, field) \
|
||||
for ((var) = SLIST_FIRST((head)); \
|
||||
(var); \
|
||||
(var) = SLIST_NEXT((var), field))
|
||||
|
||||
#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = SLIST_FIRST((head)); \
|
||||
(var) && ((tvar) = SLIST_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
|
||||
for ((varp) = &SLIST_FIRST((head)); \
|
||||
((var) = *(varp)) != NULL; \
|
||||
(varp) = &SLIST_NEXT((var), field))
|
||||
|
||||
#define SLIST_INIT(head) do { \
|
||||
SLIST_FIRST((head)) = NULL; \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
|
||||
SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \
|
||||
SLIST_NEXT((slistelm), field) = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_INSERT_HEAD(head, elm, field) do { \
|
||||
SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
|
||||
SLIST_FIRST((head)) = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
|
||||
|
||||
#define SLIST_REMOVE(head, elm, type, field) do { \
|
||||
QMD_SAVELINK(oldnext, (elm)->field.sle_next); \
|
||||
if (SLIST_FIRST((head)) == (elm)) { \
|
||||
SLIST_REMOVE_HEAD((head), field); \
|
||||
} \
|
||||
else { \
|
||||
struct type *curelm = SLIST_FIRST((head)); \
|
||||
while (SLIST_NEXT(curelm, field) != (elm)) \
|
||||
curelm = SLIST_NEXT(curelm, field); \
|
||||
SLIST_REMOVE_AFTER(curelm, field); \
|
||||
} \
|
||||
TRASHIT(*oldnext); \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_REMOVE_AFTER(elm, field) do { \
|
||||
SLIST_NEXT(elm, field) = \
|
||||
SLIST_NEXT(SLIST_NEXT(elm, field), field); \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_REMOVE_HEAD(head, field) do { \
|
||||
SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Singly-linked Tail queue declarations.
|
||||
*/
|
||||
#define STAILQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *stqh_first; /* first element */ \
|
||||
struct type **stqh_last; /* addr of last next element */ \
|
||||
}
|
||||
|
||||
#define STAILQ_HEAD_INITIALIZER(head) \
|
||||
{ NULL, &(head).stqh_first }
|
||||
|
||||
#define STAILQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *stqe_next; /* next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Singly-linked Tail queue functions.
|
||||
*/
|
||||
#define STAILQ_CONCAT(head1, head2) do { \
|
||||
if (!STAILQ_EMPTY((head2))) { \
|
||||
*(head1)->stqh_last = (head2)->stqh_first; \
|
||||
(head1)->stqh_last = (head2)->stqh_last; \
|
||||
STAILQ_INIT((head2)); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
|
||||
|
||||
#define STAILQ_FIRST(head) ((head)->stqh_first)
|
||||
|
||||
#define STAILQ_FOREACH(var, head, field) \
|
||||
for((var) = STAILQ_FIRST((head)); \
|
||||
(var); \
|
||||
(var) = STAILQ_NEXT((var), field))
|
||||
|
||||
|
||||
#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = STAILQ_FIRST((head)); \
|
||||
(var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
#define STAILQ_INIT(head) do { \
|
||||
STAILQ_FIRST((head)) = NULL; \
|
||||
(head)->stqh_last = &STAILQ_FIRST((head)); \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
|
||||
if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
|
||||
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
|
||||
STAILQ_NEXT((tqelm), field) = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_INSERT_HEAD(head, elm, field) do { \
|
||||
if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
|
||||
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
|
||||
STAILQ_FIRST((head)) = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_INSERT_TAIL(head, elm, field) do { \
|
||||
STAILQ_NEXT((elm), field) = NULL; \
|
||||
*(head)->stqh_last = (elm); \
|
||||
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_LAST(head, type, field) \
|
||||
(STAILQ_EMPTY((head))? \
|
||||
NULL : \
|
||||
((struct type *)(void *)\
|
||||
((char *)((head)->stqh_last) - __offsetof(struct type, field))))
|
||||
|
||||
#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
|
||||
|
||||
#define STAILQ_REMOVE(head, elm, type, field) do { \
|
||||
QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \
|
||||
if (STAILQ_FIRST((head)) == (elm)) { \
|
||||
STAILQ_REMOVE_HEAD((head), field); \
|
||||
} \
|
||||
else { \
|
||||
struct type *curelm = STAILQ_FIRST((head)); \
|
||||
while (STAILQ_NEXT(curelm, field) != (elm)) \
|
||||
curelm = STAILQ_NEXT(curelm, field); \
|
||||
STAILQ_REMOVE_AFTER(head, curelm, field); \
|
||||
} \
|
||||
TRASHIT(*oldnext); \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_REMOVE_HEAD(head, field) do { \
|
||||
if ((STAILQ_FIRST((head)) = \
|
||||
STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
|
||||
(head)->stqh_last = &STAILQ_FIRST((head)); \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_REMOVE_AFTER(head, elm, field) do { \
|
||||
if ((STAILQ_NEXT(elm, field) = \
|
||||
STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \
|
||||
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_SWAP(head1, head2, type) do { \
|
||||
struct type *swap_first = STAILQ_FIRST(head1); \
|
||||
struct type **swap_last = (head1)->stqh_last; \
|
||||
STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \
|
||||
(head1)->stqh_last = (head2)->stqh_last; \
|
||||
STAILQ_FIRST(head2) = swap_first; \
|
||||
(head2)->stqh_last = swap_last; \
|
||||
if (STAILQ_EMPTY(head1)) \
|
||||
(head1)->stqh_last = &STAILQ_FIRST(head1); \
|
||||
if (STAILQ_EMPTY(head2)) \
|
||||
(head2)->stqh_last = &STAILQ_FIRST(head2); \
|
||||
} while (0)
|
||||
|
||||
#define STAILQ_INSERT_CHAIN_HEAD(head, elm_chead, elm_ctail, field) do { \
|
||||
if ((STAILQ_NEXT(elm_ctail, field) = STAILQ_FIRST(head)) == NULL ) { \
|
||||
(head)->stqh_last = &STAILQ_NEXT(elm_ctail, field); \
|
||||
} \
|
||||
STAILQ_FIRST(head) = (elm_chead); \
|
||||
} while (0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* !_SYS_QUEUE_H_ */
|
||||
@ -3,3 +3,5 @@
|
||||
#
|
||||
|
||||
COMPONENT_SRCDIRS := src
|
||||
|
||||
CFLAGS += -DPARTITION_QUEUE_HEADER=\"sys/queue.h\"
|
||||
|
||||
73
components/spi_flash/include/esp_flash_data_types.h
Normal file
73
components/spi_flash/include/esp_flash_data_types.h
Normal file
@ -0,0 +1,73 @@
|
||||
// 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_BIN_TYPES_H__
|
||||
#define __ESP_BIN_TYPES_H__
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#define ESP_PARTITION_TABLE_ADDR 0x8000
|
||||
#define ESP_PARTITION_MAGIC 0x50AA
|
||||
|
||||
/* OTA selection structure (two copies in the OTA data partition.)
|
||||
Size of 32 bytes is friendly to flash encryption */
|
||||
typedef struct {
|
||||
uint32_t ota_seq;
|
||||
uint8_t seq_label[24];
|
||||
uint32_t crc; /* CRC32 of ota_seq field only */
|
||||
} esp_ota_select_entry_t;
|
||||
|
||||
|
||||
typedef struct {
|
||||
uint32_t offset;
|
||||
uint32_t size;
|
||||
} esp_partition_pos_t;
|
||||
|
||||
/* Structure which describes the layout of partition table entry.
|
||||
* See docs/partition_tables.rst for more information about individual fields.
|
||||
*/
|
||||
typedef struct {
|
||||
uint16_t magic;
|
||||
uint8_t type;
|
||||
uint8_t subtype;
|
||||
esp_partition_pos_t pos;
|
||||
uint8_t label[16];
|
||||
uint32_t flags;
|
||||
} esp_partition_info_t;
|
||||
|
||||
#define PART_TYPE_APP 0x00
|
||||
#define PART_SUBTYPE_FACTORY 0x00
|
||||
#define PART_SUBTYPE_OTA_FLAG 0x10
|
||||
#define PART_SUBTYPE_OTA_MASK 0x0f
|
||||
#define PART_SUBTYPE_TEST 0x20
|
||||
|
||||
#define PART_TYPE_DATA 0x01
|
||||
#define PART_SUBTYPE_DATA_OTA 0x00
|
||||
#define PART_SUBTYPE_DATA_RF 0x01
|
||||
#define PART_SUBTYPE_DATA_WIFI 0x02
|
||||
|
||||
#define PART_TYPE_END 0xff
|
||||
#define PART_SUBTYPE_END 0xff
|
||||
|
||||
#define PART_FLAG_ENCRYPTED (1<<0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //__ESP_BIN_TYPES_H__
|
||||
297
components/spi_flash/include/esp_partition.h
Normal file
297
components/spi_flash/include/esp_partition.h
Normal file
@ -0,0 +1,297 @@
|
||||
// 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_PARTITION_H__
|
||||
#define __ESP_PARTITION_H__
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include "esp_err.h"
|
||||
#include "esp_spi_flash.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @file esp_partition.h
|
||||
* @brief Partition APIs
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* @brief Partition type
|
||||
* @note Keep this enum in sync with PartitionDefinition class gen_esp32part.py
|
||||
*/
|
||||
typedef enum {
|
||||
ESP_PARTITION_TYPE_APP = 0x00, //!< Application partition type
|
||||
ESP_PARTITION_TYPE_DATA = 0x01, //!< Data partition type
|
||||
} esp_partition_type_t;
|
||||
|
||||
/**
|
||||
* @brief Partition subtype
|
||||
* @note Keep this enum in sync with PartitionDefinition class gen_esp32part.py
|
||||
*/
|
||||
typedef enum {
|
||||
ESP_PARTITION_SUBTYPE_APP_FACTORY = 0x00, //!< Factory application partition
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_MIN = 0x10, //!< Base for OTA partition subtypes
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_0 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 0, //!< OTA partition 0
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_1 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 1, //!< OTA partition 1
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_2 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 2, //!< OTA partition 2
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_3 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 3, //!< OTA partition 3
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_4 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 4, //!< OTA partition 4
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_5 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 5, //!< OTA partition 5
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_6 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 6, //!< OTA partition 6
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_7 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 7, //!< OTA partition 7
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_8 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 8, //!< OTA partition 8
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_9 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 9, //!< OTA partition 9
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_10 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 10,//!< OTA partition 10
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_11 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 11,//!< OTA partition 11
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_12 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 12,//!< OTA partition 12
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_13 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 13,//!< OTA partition 13
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_14 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 14,//!< OTA partition 14
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_15 = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 15,//!< OTA partition 15
|
||||
ESP_PARTITION_SUBTYPE_APP_OTA_MAX = ESP_PARTITION_SUBTYPE_APP_OTA_MIN + 16,//!< Max subtype of OTA partition
|
||||
ESP_PARTITION_SUBTYPE_APP_TEST = 0x20, //!< Test application partition
|
||||
|
||||
ESP_PARTITION_SUBTYPE_DATA_OTA = 0x00, //!< OTA selection partition
|
||||
ESP_PARTITION_SUBTYPE_DATA_PHY = 0x01, //!< PHY init data partition
|
||||
ESP_PARTITION_SUBTYPE_DATA_NVS = 0x02, //!< NVS partition
|
||||
ESP_PARTITION_SUBTYPE_DATA_COREDUMP = 0x03, //!< COREDUMP partition
|
||||
|
||||
ESP_PARTITION_SUBTYPE_DATA_ESPHTTPD = 0x80, //!< ESPHTTPD partition
|
||||
ESP_PARTITION_SUBTYPE_DATA_FAT = 0x81, //!< FAT partition
|
||||
ESP_PARTITION_SUBTYPE_DATA_SPIFFS = 0x82, //!< SPIFFS partition
|
||||
|
||||
ESP_PARTITION_SUBTYPE_ANY = 0xff, //!< Used to search for partitions with any subtype
|
||||
} esp_partition_subtype_t;
|
||||
|
||||
/**
|
||||
* @brief Convenience macro to get esp_partition_subtype_t value for the i-th OTA partition
|
||||
*/
|
||||
#define ESP_PARTITION_SUBTYPE_OTA(i) ((esp_partition_subtype_t)(ESP_PARTITION_SUBTYPE_APP_OTA_MIN + ((i) & 0xf)))
|
||||
|
||||
/**
|
||||
* @brief Opaque partition iterator type
|
||||
*/
|
||||
typedef struct esp_partition_iterator_opaque_* esp_partition_iterator_t;
|
||||
|
||||
/**
|
||||
* @brief partition information structure
|
||||
*
|
||||
* This is not the format in flash, that format is esp_partition_info_t.
|
||||
*
|
||||
* However, this is the format used by this API.
|
||||
*/
|
||||
typedef struct {
|
||||
esp_partition_type_t type; /*!< partition type (app/data) */
|
||||
esp_partition_subtype_t subtype; /*!< partition subtype */
|
||||
uint32_t address; /*!< starting address of the partition in flash */
|
||||
uint32_t size; /*!< size of the partition, in bytes */
|
||||
char label[17]; /*!< partition label, zero-terminated ASCII string */
|
||||
bool encrypted; /*!< flag is set to true if partition is encrypted */
|
||||
} esp_partition_t;
|
||||
|
||||
/**
|
||||
* @brief Find partition based on one or more parameters
|
||||
*
|
||||
* @param type Partition type, one of esp_partition_type_t values
|
||||
* @param subtype Partition subtype, one of esp_partition_subtype_t values.
|
||||
* To find all partitions of given type, use
|
||||
* ESP_PARTITION_SUBTYPE_ANY.
|
||||
* @param label (optional) Partition label. Set this value if looking
|
||||
* for partition with a specific name. Pass NULL otherwise.
|
||||
*
|
||||
* @return iterator which can be used to enumerate all the partitions found,
|
||||
* or NULL if no partitions were found.
|
||||
* Iterator obtained through this function has to be released
|
||||
* using esp_partition_iterator_release when not used any more.
|
||||
*/
|
||||
esp_partition_iterator_t esp_partition_find(esp_partition_type_t type, esp_partition_subtype_t subtype, const char* label);
|
||||
|
||||
/**
|
||||
* @brief Find first partition based on one or more parameters
|
||||
*
|
||||
* @param type Partition type, one of esp_partition_type_t values
|
||||
* @param subtype Partition subtype, one of esp_partition_subtype_t values.
|
||||
* To find all partitions of given type, use
|
||||
* ESP_PARTITION_SUBTYPE_ANY.
|
||||
* @param label (optional) Partition label. Set this value if looking
|
||||
* for partition with a specific name. Pass NULL otherwise.
|
||||
*
|
||||
* @return pointer to esp_partition_t structure, or NULL if no partition is found.
|
||||
* This pointer is valid for the lifetime of the application.
|
||||
*/
|
||||
const esp_partition_t* esp_partition_find_first(esp_partition_type_t type, esp_partition_subtype_t subtype, const char* label);
|
||||
|
||||
/**
|
||||
* @brief Get esp_partition_t structure for given partition
|
||||
*
|
||||
* @param iterator Iterator obtained using esp_partition_find. Must be non-NULL.
|
||||
*
|
||||
* @return pointer to esp_partition_t structure. This pointer is valid for the lifetime
|
||||
* of the application.
|
||||
*/
|
||||
const esp_partition_t* esp_partition_get(esp_partition_iterator_t iterator);
|
||||
|
||||
/**
|
||||
* @brief Move partition iterator to the next partition found
|
||||
*
|
||||
* Any copies of the iterator will be invalid after this call.
|
||||
*
|
||||
* @param iterator Iterator obtained using esp_partition_find. Must be non-NULL.
|
||||
*
|
||||
* @return NULL if no partition was found, valid esp_partition_iterator_t otherwise.
|
||||
*/
|
||||
esp_partition_iterator_t esp_partition_next(esp_partition_iterator_t iterator);
|
||||
|
||||
/**
|
||||
* @brief Release partition iterator
|
||||
*
|
||||
* @param iterator Iterator obtained using esp_partition_find. Must be non-NULL.
|
||||
*
|
||||
*/
|
||||
void esp_partition_iterator_release(esp_partition_iterator_t iterator);
|
||||
|
||||
/**
|
||||
* @brief Verify partition data
|
||||
*
|
||||
* Given a pointer to partition data, verify this partition exists in the partition table (all fields match.)
|
||||
*
|
||||
* This function is also useful to take partition data which may be in a RAM buffer and convert it to a pointer to the
|
||||
* permanent partition data stored in flash.
|
||||
*
|
||||
* Pointers returned from this function can be compared directly to the address of any pointer returned from
|
||||
* esp_partition_get(), as a test for equality.
|
||||
*
|
||||
* @param partition Pointer to partition data to verify. Must be non-NULL. All fields of this structure must match the
|
||||
* partition table entry in flash for this function to return a successful match.
|
||||
*
|
||||
* @return
|
||||
* - If partition not found, returns NULL.
|
||||
* - If found, returns a pointer to the esp_partition_t structure in flash. This pointer is always valid for the lifetime of the application.
|
||||
*/
|
||||
const esp_partition_t *esp_partition_verify(const esp_partition_t *partition);
|
||||
|
||||
/**
|
||||
* @brief Read data from the partition
|
||||
*
|
||||
* @param partition Pointer to partition structure obtained using
|
||||
* esp_partition_find_first or esp_partition_get.
|
||||
* Must be non-NULL.
|
||||
* @param dst Pointer to the buffer where data should be stored.
|
||||
* Pointer must be non-NULL and buffer must be at least 'size' bytes long.
|
||||
* @param src_offset Address of the data to be read, relative to the
|
||||
* beginning of the partition.
|
||||
* @param size Size of data to be read, in bytes.
|
||||
*
|
||||
* @return ESP_OK, if data was read successfully;
|
||||
* ESP_ERR_INVALID_ARG, if src_offset exceeds partition size;
|
||||
* ESP_ERR_INVALID_SIZE, if read would go out of bounds of the partition;
|
||||
* or one of error codes from lower-level flash driver.
|
||||
*/
|
||||
esp_err_t esp_partition_read(const esp_partition_t* partition,
|
||||
size_t src_offset, void* dst, size_t size);
|
||||
|
||||
/**
|
||||
* @brief Write data to the partition
|
||||
*
|
||||
* Before writing data to flash, corresponding region of flash needs to be erased.
|
||||
* 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
|
||||
* an encrypted partition, all write offsets and lengths must be
|
||||
* multiples of 16 bytes. See the spi_flash_write_encrypted() function
|
||||
* for more details. Unencrypted partitions do not have this
|
||||
* restriction.
|
||||
*
|
||||
* @param partition Pointer to partition structure obtained using
|
||||
* esp_partition_find_first or esp_partition_get.
|
||||
* Must be non-NULL.
|
||||
* @param dst_offset Address where the data should be written, relative to the
|
||||
* beginning of the partition.
|
||||
* @param src Pointer to the source buffer. Pointer must be non-NULL and
|
||||
* buffer must be at least 'size' bytes long.
|
||||
* @param size Size of data to be written, in bytes.
|
||||
*
|
||||
* @note Prior to writing to flash memory, make sure it has been erased with
|
||||
* esp_partition_erase_range call.
|
||||
*
|
||||
* @return ESP_OK, if data was written successfully;
|
||||
* ESP_ERR_INVALID_ARG, if dst_offset exceeds partition size;
|
||||
* ESP_ERR_INVALID_SIZE, if write would go out of bounds of the partition;
|
||||
* or one of error codes from lower-level flash driver.
|
||||
*/
|
||||
esp_err_t esp_partition_write(const esp_partition_t* partition,
|
||||
size_t dst_offset, const void* src, size_t size);
|
||||
|
||||
/**
|
||||
* @brief Erase part of the partition
|
||||
*
|
||||
* @param partition Pointer to partition structure obtained using
|
||||
* esp_partition_find_first or esp_partition_get.
|
||||
* Must be non-NULL.
|
||||
* @param start_addr Address where erase operation should start. Must be aligned
|
||||
* to 4 kilobytes.
|
||||
* @param size Size of the range which should be erased, in bytes.
|
||||
* Must be divisible by 4 kilobytes.
|
||||
*
|
||||
* @return ESP_OK, if the range was erased successfully;
|
||||
* ESP_ERR_INVALID_ARG, if iterator or dst are NULL;
|
||||
* ESP_ERR_INVALID_SIZE, if erase would go out of bounds of the partition;
|
||||
* or one of error codes from lower-level flash driver.
|
||||
*/
|
||||
esp_err_t esp_partition_erase_range(const esp_partition_t* partition,
|
||||
uint32_t start_addr, uint32_t size);
|
||||
|
||||
#ifdef CONFIG_ENABLE_FLASH_MMAP
|
||||
/**
|
||||
* @brief Configure MMU to map partition into data memory
|
||||
*
|
||||
* Unlike spi_flash_mmap function, which requires a 64kB aligned base address,
|
||||
* this function doesn't impose such a requirement.
|
||||
* If offset results in a flash address which is not aligned to 64kB boundary,
|
||||
* address will be rounded to the lower 64kB boundary, so that mapped region
|
||||
* includes requested range.
|
||||
* Pointer returned via out_ptr argument will be adjusted to point to the
|
||||
* requested offset (not necessarily to the beginning of mmap-ed region).
|
||||
*
|
||||
* To release mapped memory, pass handle returned via out_handle argument to
|
||||
* spi_flash_munmap function.
|
||||
*
|
||||
* @param partition Pointer to partition structure obtained using
|
||||
* esp_partition_find_first or esp_partition_get.
|
||||
* Must be non-NULL.
|
||||
* @param offset Offset from the beginning of partition where mapping should start.
|
||||
* @param size Size of the area to be mapped.
|
||||
* @param memory Memory space where the region should be mapped
|
||||
* @param out_ptr Output, pointer to the mapped memory region
|
||||
* @param out_handle Output, handle which should be used for spi_flash_munmap call
|
||||
*
|
||||
* @return ESP_OK, if successful
|
||||
*/
|
||||
esp_err_t esp_partition_mmap(const esp_partition_t* partition, uint32_t offset, uint32_t size,
|
||||
spi_flash_mmap_memory_t memory,
|
||||
const void** out_ptr, spi_flash_mmap_handle_t* out_handle);
|
||||
|
||||
#endif /* CONFIG_ENABLE_FLASH_MMAP */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* __ESP_PARTITION_H__ */
|
||||
370
components/spi_flash/src/partition.c
Normal file
370
components/spi_flash/src/partition.c
Normal file
@ -0,0 +1,370 @@
|
||||
// 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.
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/lock.h>
|
||||
|
||||
#include "esp_attr.h"
|
||||
#include "esp_flash_data_types.h"
|
||||
#include "esp_spi_flash.h"
|
||||
#include "esp_partition.h"
|
||||
#ifdef CONFIG_ENABLE_FLASH_ENCRYPT
|
||||
#include "esp_flash_encrypt.h"
|
||||
#endif
|
||||
#include "esp_log.h"
|
||||
|
||||
|
||||
#ifndef NDEBUG
|
||||
// Enable built-in checks in queue.h in debug builds
|
||||
#define INVARIANTS
|
||||
#endif
|
||||
#if defined(PARTITION_QUEUE_HEADER)
|
||||
#include PARTITION_QUEUE_HEADER
|
||||
#else
|
||||
#include "rom/queue.h"
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct partition_list_item_ {
|
||||
esp_partition_t info;
|
||||
SLIST_ENTRY(partition_list_item_) next;
|
||||
} partition_list_item_t;
|
||||
|
||||
typedef struct esp_partition_iterator_opaque_ {
|
||||
esp_partition_type_t type; // requested type
|
||||
esp_partition_subtype_t subtype; // requested subtype
|
||||
const char* label; // requested label (can be NULL)
|
||||
partition_list_item_t* next_item; // next item to iterate to
|
||||
esp_partition_t* info; // pointer to info (it is redundant, but makes code more readable)
|
||||
} esp_partition_iterator_opaque_t;
|
||||
|
||||
|
||||
static esp_partition_iterator_opaque_t* iterator_create(esp_partition_type_t type, esp_partition_subtype_t subtype, const char* label);
|
||||
static esp_err_t load_partitions();
|
||||
|
||||
|
||||
static SLIST_HEAD(partition_list_head_, partition_list_item_) s_partition_list =
|
||||
SLIST_HEAD_INITIALIZER(s_partition_list);
|
||||
static _lock_t s_partition_list_lock;
|
||||
|
||||
|
||||
esp_partition_iterator_t esp_partition_find(esp_partition_type_t type,
|
||||
esp_partition_subtype_t subtype, const char* label)
|
||||
{
|
||||
if (SLIST_EMPTY(&s_partition_list)) {
|
||||
// only lock if list is empty (and check again after acquiring lock)
|
||||
_lock_acquire(&s_partition_list_lock);
|
||||
esp_err_t err = ESP_OK;
|
||||
if (SLIST_EMPTY(&s_partition_list)) {
|
||||
err = load_partitions();
|
||||
}
|
||||
_lock_release(&s_partition_list_lock);
|
||||
if (err != ESP_OK) {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
// create an iterator pointing to the start of the list
|
||||
// (next item will be the first one)
|
||||
esp_partition_iterator_t it = iterator_create(type, subtype, label);
|
||||
// advance iterator to the next item which matches constraints
|
||||
it = esp_partition_next(it);
|
||||
// if nothing found, it == NULL and iterator has been released
|
||||
return it;
|
||||
}
|
||||
|
||||
esp_partition_iterator_t esp_partition_next(esp_partition_iterator_t it)
|
||||
{
|
||||
assert(it);
|
||||
// iterator reached the end of linked list?
|
||||
if (it->next_item == NULL) {
|
||||
esp_partition_iterator_release(it);
|
||||
return NULL;
|
||||
}
|
||||
_lock_acquire(&s_partition_list_lock);
|
||||
for (; it->next_item != NULL; it->next_item = SLIST_NEXT(it->next_item, next)) {
|
||||
esp_partition_t* p = &it->next_item->info;
|
||||
if (it->type != p->type) {
|
||||
continue;
|
||||
}
|
||||
if (it->subtype != 0xff && it->subtype != p->subtype) {
|
||||
continue;
|
||||
}
|
||||
if (it->label != NULL && strcmp(it->label, p->label) != 0) {
|
||||
continue;
|
||||
}
|
||||
// all constraints match, bail out
|
||||
break;
|
||||
}
|
||||
_lock_release(&s_partition_list_lock);
|
||||
if (it->next_item == NULL) {
|
||||
esp_partition_iterator_release(it);
|
||||
return NULL;
|
||||
}
|
||||
it->info = &it->next_item->info;
|
||||
it->next_item = SLIST_NEXT(it->next_item, next);
|
||||
return it;
|
||||
}
|
||||
|
||||
const esp_partition_t* esp_partition_find_first(esp_partition_type_t type,
|
||||
esp_partition_subtype_t subtype, const char* label)
|
||||
{
|
||||
esp_partition_iterator_t it = esp_partition_find(type, subtype, label);
|
||||
if (it == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
const esp_partition_t* res = esp_partition_get(it);
|
||||
esp_partition_iterator_release(it);
|
||||
return res;
|
||||
}
|
||||
|
||||
static esp_partition_iterator_opaque_t* iterator_create(esp_partition_type_t type,
|
||||
esp_partition_subtype_t subtype, const char* label)
|
||||
{
|
||||
esp_partition_iterator_opaque_t* it =
|
||||
(esp_partition_iterator_opaque_t*) malloc(sizeof(esp_partition_iterator_opaque_t));
|
||||
it->type = type;
|
||||
it->subtype = subtype;
|
||||
it->label = label;
|
||||
it->next_item = SLIST_FIRST(&s_partition_list);
|
||||
it->info = NULL;
|
||||
return it;
|
||||
}
|
||||
|
||||
// Create linked list of partition_list_item_t structures.
|
||||
// This function is called only once, with s_partition_list_lock taken.
|
||||
static esp_err_t load_partitions()
|
||||
{
|
||||
#ifdef CONFIG_ENABLE_FLASH_MMAP
|
||||
const uint32_t* ptr;
|
||||
|
||||
spi_flash_mmap_handle_t handle;
|
||||
// map 64kB block where partition table is located
|
||||
esp_err_t err = spi_flash_mmap(ESP_PARTITION_TABLE_ADDR & 0xffff0000,
|
||||
SPI_FLASH_SEC_SIZE, SPI_FLASH_MMAP_DATA, (const void**) &ptr, &handle);
|
||||
if (err != ESP_OK) {
|
||||
return err;
|
||||
}
|
||||
|
||||
// calculate partition address within mmap-ed region
|
||||
const esp_partition_info_t* it = (const esp_partition_info_t*)
|
||||
(ptr + (ESP_PARTITION_TABLE_ADDR & 0xffff) / sizeof(*ptr));
|
||||
#else
|
||||
esp_err_t ret;
|
||||
uint32_t *ptr;
|
||||
const size_t read_size = SPI_FLASH_SEC_SIZE;
|
||||
|
||||
ptr = malloc(read_size);
|
||||
if (!ptr)
|
||||
return ESP_ERR_NO_MEM;
|
||||
ret = spi_flash_read(ESP_PARTITION_TABLE_ADDR, ptr, read_size);
|
||||
if (ret != ESP_OK) {
|
||||
free(ptr);
|
||||
return ret;
|
||||
}
|
||||
// calculate partition address within mmap-ed region
|
||||
const esp_partition_info_t* it = (const esp_partition_info_t*)ptr;
|
||||
#endif
|
||||
const esp_partition_info_t* end = it + SPI_FLASH_SEC_SIZE / sizeof(*it);
|
||||
// tail of the linked list of partitions
|
||||
partition_list_item_t* last = NULL;
|
||||
for (; it != end; ++it) {
|
||||
if (it->magic != ESP_PARTITION_MAGIC) {
|
||||
break;
|
||||
}
|
||||
// allocate new linked list item and populate it with data from partition table
|
||||
partition_list_item_t* item = (partition_list_item_t*) malloc(sizeof(partition_list_item_t));
|
||||
item->info.address = it->pos.offset;
|
||||
item->info.size = it->pos.size;
|
||||
item->info.type = it->type;
|
||||
item->info.subtype = it->subtype;
|
||||
#ifdef CONFIG_ENABLE_FLASH_ENCRYPT
|
||||
item->info.encrypted = it->flags & PART_FLAG_ENCRYPTED;
|
||||
if (esp_flash_encryption_enabled() && (
|
||||
it->type == PART_TYPE_APP
|
||||
|| (it->type == PART_TYPE_DATA && it->subtype == PART_SUBTYPE_DATA_OTA))) {
|
||||
/* If encryption is turned on, all app partitions and OTA data
|
||||
are always encrypted */
|
||||
item->info.encrypted = true;
|
||||
}
|
||||
else
|
||||
item->info.encrypted = false;
|
||||
#endif
|
||||
|
||||
// it->label may not be zero-terminated
|
||||
strncpy(item->info.label, (const char*) it->label, sizeof(it->label));
|
||||
item->info.label[sizeof(it->label)] = 0;
|
||||
// add it to the list
|
||||
if (last == NULL) {
|
||||
SLIST_INSERT_HEAD(&s_partition_list, item, next);
|
||||
} else {
|
||||
SLIST_INSERT_AFTER(last, item, next);
|
||||
}
|
||||
last = item;
|
||||
}
|
||||
#ifdef CONFIG_ENABLE_FLASH_MMAP
|
||||
spi_flash_munmap(handle);
|
||||
#else
|
||||
free(ptr);
|
||||
#endif
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
void esp_partition_iterator_release(esp_partition_iterator_t iterator)
|
||||
{
|
||||
// iterator == NULL is okay
|
||||
free(iterator);
|
||||
}
|
||||
|
||||
const esp_partition_t* esp_partition_get(esp_partition_iterator_t iterator)
|
||||
{
|
||||
assert(iterator != NULL);
|
||||
return iterator->info;
|
||||
}
|
||||
|
||||
const esp_partition_t *esp_partition_verify(const esp_partition_t *partition)
|
||||
{
|
||||
assert(partition != NULL);
|
||||
const char *label = (strlen(partition->label) > 0) ? partition->label : NULL;
|
||||
esp_partition_iterator_t it = esp_partition_find(partition->type,
|
||||
partition->subtype,
|
||||
label);
|
||||
while (it != NULL) {
|
||||
const esp_partition_t *p = esp_partition_get(it);
|
||||
/* Can't memcmp() whole structure here as padding contents may be different */
|
||||
if (p->address == partition->address
|
||||
&& partition->size == p->size
|
||||
#ifdef CONFIG_ENABLE_FLASH_ENCRYPT
|
||||
&& partition->encrypted == p->encrypted
|
||||
#endif
|
||||
) {
|
||||
esp_partition_iterator_release(it);
|
||||
return p;
|
||||
}
|
||||
it = esp_partition_next(it);
|
||||
}
|
||||
esp_partition_iterator_release(it);
|
||||
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 (src_offset + size > partition->size) {
|
||||
return ESP_ERR_INVALID_SIZE;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_ENABLE_FLASH_ENCRYPT
|
||||
if (!partition->encrypted) {
|
||||
return spi_flash_read(partition->address + src_offset, dst, size);
|
||||
} else {
|
||||
/* Encrypted partitions need to be read via a cache mapping */
|
||||
const void *buf;
|
||||
spi_flash_mmap_handle_t handle;
|
||||
esp_err_t err;
|
||||
|
||||
err = esp_partition_mmap(partition, src_offset, size,
|
||||
SPI_FLASH_MMAP_DATA, &buf, &handle);
|
||||
if (err != ESP_OK) {
|
||||
return err;
|
||||
}
|
||||
memcpy(dst, buf, size);
|
||||
spi_flash_munmap(handle);
|
||||
return ESP_OK;
|
||||
}
|
||||
#else
|
||||
return spi_flash_read(partition->address + src_offset, dst, size);
|
||||
#endif
|
||||
}
|
||||
|
||||
esp_err_t esp_partition_write(const esp_partition_t* partition,
|
||||
size_t dst_offset, const void* src, size_t size)
|
||||
{
|
||||
assert(partition != NULL);
|
||||
if (dst_offset > partition->size) {
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
if (dst_offset + size > partition->size) {
|
||||
return ESP_ERR_INVALID_SIZE;
|
||||
}
|
||||
dst_offset = partition->address + dst_offset;
|
||||
#ifdef CONFIG_ENABLE_FLASH_ENCRYPT
|
||||
if (partition->encrypted) {
|
||||
return spi_flash_write_encrypted(dst_offset, src, size);
|
||||
} else {
|
||||
return spi_flash_write(dst_offset, src, size);
|
||||
}
|
||||
#else
|
||||
return spi_flash_write(dst_offset, src, size);
|
||||
#endif
|
||||
}
|
||||
|
||||
esp_err_t esp_partition_erase_range(const esp_partition_t* partition,
|
||||
size_t start_addr, size_t size)
|
||||
{
|
||||
assert(partition != NULL);
|
||||
if (start_addr > partition->size) {
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
if (start_addr + size > partition->size) {
|
||||
return ESP_ERR_INVALID_SIZE;
|
||||
}
|
||||
if (size % SPI_FLASH_SEC_SIZE != 0) {
|
||||
return ESP_ERR_INVALID_SIZE;
|
||||
}
|
||||
if (start_addr % SPI_FLASH_SEC_SIZE != 0) {
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
return spi_flash_erase_range(partition->address + start_addr, size);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Note: current implementation ignores the possibility of multiple regions in the same partition being
|
||||
* mapped. Reference counting and address space re-use is delegated to spi_flash_mmap.
|
||||
*
|
||||
* If this becomes a performance issue (i.e. if we need to map multiple regions within the partition),
|
||||
* we can add esp_partition_mmapv which will accept an array of offsets and sizes, and return array of
|
||||
* mmaped pointers, and a single handle for all these regions.
|
||||
*/
|
||||
#ifdef CONFIG_ENABLE_FLASH_MMAP
|
||||
esp_err_t esp_partition_mmap(const esp_partition_t* partition, uint32_t offset, uint32_t size,
|
||||
spi_flash_mmap_memory_t memory,
|
||||
const void** out_ptr, spi_flash_mmap_handle_t* out_handle)
|
||||
{
|
||||
assert(partition != NULL);
|
||||
if (offset > partition->size) {
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
if (offset + size > partition->size) {
|
||||
return ESP_ERR_INVALID_SIZE;
|
||||
}
|
||||
size_t phys_addr = partition->address + offset;
|
||||
// offset within 64kB block
|
||||
size_t region_offset = phys_addr & 0xffff;
|
||||
size_t mmap_addr = phys_addr & 0xffff0000;
|
||||
esp_err_t rc = spi_flash_mmap(mmap_addr, size+region_offset, memory, out_ptr, out_handle);
|
||||
// adjust returned pointer to point to the correct offset
|
||||
if (rc == ESP_OK) {
|
||||
*out_ptr = (void*) (((ptrdiff_t) *out_ptr) + region_offset);
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user