wehub-resource-sync
993 lines
40 KiB
C
993 lines
40 KiB
C
/*
|
||
* SPDX-FileCopyrightText: 2017-2026 Espressif Systems (Shanghai) CO LTD
|
||
*
|
||
* SPDX-License-Identifier: Apache-2.0
|
||
*/
|
||
|
||
#pragma once
|
||
|
||
#include <stdbool.h>
|
||
#include <stdint.h>
|
||
|
||
#include "esp_err.h"
|
||
#include "esp_assert.h"
|
||
#include "esp_log.h"
|
||
#include "soc/soc_caps.h"
|
||
#include "sdkconfig.h"
|
||
#include "esp_efuse_chip.h"
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
#define ESP_ERR_EFUSE 0x1600 /*!< Base error code for efuse api. */
|
||
#define ESP_OK_EFUSE_CNT (ESP_ERR_EFUSE + 0x01) /*!< OK the required number of bits is set. */
|
||
#define ESP_ERR_EFUSE_CNT_IS_FULL (ESP_ERR_EFUSE + 0x02) /*!< Error field is full. */
|
||
#define ESP_ERR_EFUSE_REPEATED_PROG (ESP_ERR_EFUSE + 0x03) /*!< Error repeated programming of programmed bits is strictly forbidden. */
|
||
#define ESP_ERR_CODING (ESP_ERR_EFUSE + 0x04) /*!< Error while a encoding operation. */
|
||
#define ESP_ERR_NOT_ENOUGH_UNUSED_KEY_BLOCKS (ESP_ERR_EFUSE + 0x05) /*!< Error not enough unused key blocks available */
|
||
#define ESP_ERR_DAMAGED_READING (ESP_ERR_EFUSE + 0x06) /*!< Error. Burn or reset was done during a reading operation leads to damage read data. This error is internal to the efuse component and not returned by any public API. */
|
||
#define ESP_ERR_BURN_WR_DIS (ESP_ERR_EFUSE + 0x07) /*!< Error to burn WR_DIS field. */
|
||
|
||
/**
|
||
* @brief Type definition for an eFuse field
|
||
*/
|
||
typedef struct {
|
||
esp_efuse_block_t efuse_block: 7; /**< Block of eFuse */
|
||
uint16_t bit_start: 9; /**< Start bit [0..511] */
|
||
uint16_t bit_count; /**< Length of bit field [1..-]*/
|
||
} esp_efuse_desc_t;
|
||
|
||
ESP_STATIC_ASSERT(sizeof(esp_efuse_desc_t) == sizeof(uint32_t), "esp_efuse_desc_t should be 32 bits");
|
||
|
||
/**
|
||
* @brief Type definition for ROM log scheme
|
||
*/
|
||
typedef enum {
|
||
ESP_EFUSE_ROM_LOG_ALWAYS_ON, /**< Always enable ROM logging */
|
||
ESP_EFUSE_ROM_LOG_ON_GPIO_LOW, /**< ROM logging is enabled when specific GPIO level is low during start up */
|
||
ESP_EFUSE_ROM_LOG_ON_GPIO_HIGH, /**< ROM logging is enabled when specific GPIO level is high during start up */
|
||
ESP_EFUSE_ROM_LOG_ALWAYS_OFF /**< Disable ROM logging permanently */
|
||
} esp_efuse_rom_log_scheme_t;
|
||
|
||
#if CONFIG_ESP32_REV_MIN_FULL >= 300 || !CONFIG_IDF_TARGET_ESP32
|
||
/**
|
||
* @brief Pointers to the trusted key digests.
|
||
*
|
||
* The number of digests depends on the SOC's capabilities.
|
||
*/
|
||
typedef struct {
|
||
const void *key_digests[SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS]; /**< Pointers to the key digests */
|
||
} esp_secure_boot_key_digests_t;
|
||
#endif
|
||
|
||
/**
|
||
* @brief Reads bits from EFUSE field and writes it into an array.
|
||
*
|
||
* The number of read bits will be limited to the minimum value
|
||
* from the description of the bits in "field" structure or "dst_size_bits" required size.
|
||
* Use "esp_efuse_get_field_size()" function to determine the length of the field.
|
||
*
|
||
* @note Please note that reading in the batch mode does not show uncommitted changes.
|
||
*
|
||
* @param[in] field A pointer to the structure describing the fields of efuse.
|
||
* @param[out] dst A pointer to array that will contain the result of reading.
|
||
* @param[in] dst_size_bits The number of bits required to read.
|
||
* If the requested number of bits is greater than the field,
|
||
* the number will be limited to the field size.
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
*/
|
||
esp_err_t esp_efuse_read_field_blob(const esp_efuse_desc_t* field[], void* dst, size_t dst_size_bits);
|
||
|
||
|
||
/**
|
||
* @brief Read a single bit eFuse field as a boolean value.
|
||
*
|
||
* @note The value must exist and must be a single bit wide. If there is any possibility of an error
|
||
* in the provided arguments, call esp_efuse_read_field_blob() and check the returned value instead.
|
||
*
|
||
* @note If assertions are enabled and the parameter is invalid, execution will abort
|
||
* @note Please note that reading in the batch mode does not show uncommitted changes.
|
||
*
|
||
* @param[in] field A pointer to the structure describing the fields of efuse.
|
||
* @return
|
||
* - true: The field parameter is valid and the bit is set.
|
||
* - false: The bit is not set, or the parameter is invalid and assertions are disabled.
|
||
*
|
||
*/
|
||
bool esp_efuse_read_field_bit(const esp_efuse_desc_t *field[]);
|
||
|
||
/**
|
||
* @brief Reads bits from EFUSE field and returns number of bits programmed as "1".
|
||
*
|
||
* If the bits are set not sequentially, they will still be counted.
|
||
* @note Please note that reading in the batch mode does not show uncommitted changes.
|
||
*
|
||
* @param[in] field A pointer to the structure describing the fields of efuse.
|
||
* @param[out] out_cnt A pointer that will contain the number of programmed as "1" bits.
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
*/
|
||
esp_err_t esp_efuse_read_field_cnt(const esp_efuse_desc_t* field[], size_t* out_cnt);
|
||
|
||
/**
|
||
* @brief Writes array to EFUSE field.
|
||
*
|
||
* The number of write bits will be limited to the minimum value
|
||
* from the description of the bits in "field" structure or "src_size_bits" required size.
|
||
* Use "esp_efuse_get_field_size()" function to determine the length of the field.
|
||
* After the function is completed, the writing registers are cleared.
|
||
* @param[in] field A pointer to the structure describing the fields of efuse.
|
||
* @param[in] src A pointer to array that contains the data for writing.
|
||
* @param[in] src_size_bits The number of bits required to write.
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
*/
|
||
esp_err_t esp_efuse_write_field_blob(const esp_efuse_desc_t* field[], const void* src, size_t src_size_bits);
|
||
|
||
/**
|
||
* @brief Writes a required count of bits as "1" to EFUSE field.
|
||
*
|
||
* If there are no free bits in the field to set the required number of bits to "1",
|
||
* ESP_ERR_EFUSE_CNT_IS_FULL error is returned, the field will not be partially recorded.
|
||
* After the function is completed, the writing registers are cleared.
|
||
* @param[in] field A pointer to the structure describing the fields of efuse.
|
||
* @param[in] cnt Required number of programmed as "1" bits.
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_CNT_IS_FULL: Not all requested cnt bits is set.
|
||
*/
|
||
esp_err_t esp_efuse_write_field_cnt(const esp_efuse_desc_t* field[], size_t cnt);
|
||
|
||
/**
|
||
* @brief Write a single bit eFuse field to 1
|
||
*
|
||
* For use with eFuse fields that are a single bit. This function will write the bit to value 1 if
|
||
* it is not already set, or does nothing if the bit is already set.
|
||
*
|
||
* This is equivalent to calling esp_efuse_write_field_cnt() with the cnt parameter equal to 1,
|
||
* except that it will return ESP_OK if the field is already set to 1.
|
||
*
|
||
* @param[in] field Pointer to the structure describing the efuse field.
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed, or the bit was already set to value 1.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments, including if the efuse field is not 1 bit wide.
|
||
*/
|
||
esp_err_t esp_efuse_write_field_bit(const esp_efuse_desc_t* field[]);
|
||
|
||
/**
|
||
* @brief Sets a write protection for the whole block.
|
||
*
|
||
* After that, it is impossible to write to this block.
|
||
* The write protection does not apply to block 0.
|
||
* @param[in] blk Block number of eFuse. (EFUSE_BLK1, EFUSE_BLK2 and EFUSE_BLK3)
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_CNT_IS_FULL: Not all requested cnt bits is set.
|
||
* - ESP_ERR_NOT_SUPPORTED: The block does not support this command.
|
||
* - ESP_ERR_BURN_WR_DIS: Failed to burn WR_DIS field.
|
||
*/
|
||
esp_err_t esp_efuse_set_write_protect(esp_efuse_block_t blk);
|
||
|
||
/**
|
||
* @brief Sets a read protection for the whole block.
|
||
*
|
||
* After that, it is impossible to read from this block.
|
||
* The read protection does not apply to block 0.
|
||
* @param[in] blk Block number of eFuse. (EFUSE_BLK1, EFUSE_BLK2 and EFUSE_BLK3)
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_CNT_IS_FULL: Not all requested cnt bits is set.
|
||
* - ESP_ERR_NOT_SUPPORTED: The block does not support this command.
|
||
*/
|
||
esp_err_t esp_efuse_set_read_protect(esp_efuse_block_t blk);
|
||
|
||
/**
|
||
* @brief Returns the number of bits used by field.
|
||
*
|
||
* @param[in] field A pointer to the structure describing the fields of efuse.
|
||
*
|
||
* @return Returns the number of bits used by field.
|
||
*/
|
||
int esp_efuse_get_field_size(const esp_efuse_desc_t* field[]);
|
||
|
||
/**
|
||
* @brief Returns value of efuse register.
|
||
*
|
||
* This is a thread-safe implementation.
|
||
* Example: EFUSE_BLK2_RDATA3_REG where (blk=2, num_reg=3)
|
||
* @note Please note that reading in the batch mode does not show uncommitted changes.
|
||
*
|
||
* @param[in] blk Block number of eFuse.
|
||
* @param[in] num_reg The register number in the block.
|
||
*
|
||
* @return Value of register
|
||
*/
|
||
uint32_t esp_efuse_read_reg(esp_efuse_block_t blk, unsigned int num_reg);
|
||
|
||
/**
|
||
* @brief Write value to efuse register.
|
||
*
|
||
* Apply a coding scheme if necessary.
|
||
* This is a thread-safe implementation.
|
||
* Example: EFUSE_BLK3_WDATA0_REG where (blk=3, num_reg=0)
|
||
* @param[in] blk Block number of eFuse.
|
||
* @param[in] num_reg The register number in the block.
|
||
* @param[in] val Value to write.
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
*/
|
||
esp_err_t esp_efuse_write_reg(esp_efuse_block_t blk, unsigned int num_reg, uint32_t val);
|
||
|
||
/**
|
||
* @brief Return efuse coding scheme for blocks.
|
||
*
|
||
* @note The coding scheme is applicable only to 1, 2 and 3 blocks. For 0 block, the coding scheme is always ``NONE``.
|
||
*
|
||
* @param[in] blk Block number of eFuse.
|
||
* @return Return efuse coding scheme for blocks
|
||
*/
|
||
esp_efuse_coding_scheme_t esp_efuse_get_coding_scheme(esp_efuse_block_t blk);
|
||
|
||
/**
|
||
* @brief Read key to efuse block starting at the offset and the required size.
|
||
*
|
||
* @note Please note that reading in the batch mode does not show uncommitted changes.
|
||
*
|
||
* @param[in] blk Block number of eFuse.
|
||
* @param[in] dst_key A pointer to array that will contain the result of reading.
|
||
* @param[in] offset_in_bits Start bit in block.
|
||
* @param[in] size_bits The number of bits required to read.
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
*/
|
||
esp_err_t esp_efuse_read_block(esp_efuse_block_t blk, void* dst_key, size_t offset_in_bits, size_t size_bits);
|
||
|
||
/**
|
||
* @brief Write key to efuse block starting at the offset and the required size.
|
||
*
|
||
* @param[in] blk Block number of eFuse.
|
||
* @param[in] src_key A pointer to array that contains the key for writing.
|
||
* @param[in] offset_in_bits Start bit in block.
|
||
* @param[in] size_bits The number of bits required to write.
|
||
*
|
||
* @return
|
||
* - ESP_OK: The operation was successfully completed.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits
|
||
*/
|
||
esp_err_t esp_efuse_write_block(esp_efuse_block_t blk, const void* src_key, size_t offset_in_bits, size_t size_bits);
|
||
|
||
/**
|
||
* @brief Returns chip package from efuse
|
||
*
|
||
* @return chip package
|
||
*/
|
||
uint32_t esp_efuse_get_pkg_ver(void);
|
||
|
||
#if SOC_RECOVERY_BOOTLOADER_SUPPORTED || __DOXYGEN__
|
||
/**
|
||
* @brief Sets the recovery bootloader flash offset in eFuse.
|
||
*
|
||
* This function is used to set the flash offset in eFuse for the recovery bootloader.
|
||
* If an offset is already set in eFuse, it will be validated against the provided offset.
|
||
*
|
||
* @param offset Flash offset where the recovery bootloader is located.
|
||
* @return
|
||
* - ESP_OK: Successfully set or given offset is already set.
|
||
* - ESP_ERR_NOT_ALLOWED: Recovery bootloader feature is disabled in eFuse.
|
||
* - ESP_FAIL: Failed to update the recovery bootloader flash offset.
|
||
* - Error code from eFuse read/write operations if an error occurs.
|
||
*/
|
||
esp_err_t esp_efuse_set_recovery_bootloader_offset(const uint32_t offset);
|
||
#endif // SOC_RECOVERY_BOOTLOADER_SUPPORTED
|
||
|
||
/**
|
||
* @brief Reset efuse write registers
|
||
*
|
||
* Efuse write registers are written to zero, to negate
|
||
* any changes that have been staged here.
|
||
*
|
||
* @note This function is not threadsafe, if calling code updates
|
||
* efuse values from multiple tasks then this is caller's
|
||
* responsibility to serialise.
|
||
*/
|
||
void esp_efuse_reset(void);
|
||
|
||
#ifdef CONFIG_IDF_TARGET_ESP32
|
||
/**
|
||
* @brief Disable BASIC ROM Console via efuse
|
||
*
|
||
* By default, if booting from flash fails the ESP32 will boot a
|
||
* BASIC console in ROM.
|
||
*
|
||
* Call this function (from bootloader or app) to permanently disable the console on this chip.
|
||
*
|
||
*/
|
||
void esp_efuse_disable_basic_rom_console(void);
|
||
#endif
|
||
|
||
|
||
/**
|
||
* @brief Disable ROM Download Mode via eFuse
|
||
*
|
||
* Permanently disables the ROM Download Mode feature. Once disabled, if the SoC is booted with
|
||
* strapping pins set for ROM Download Mode then an error is printed instead.
|
||
*
|
||
* @note Not all SoCs support this option. An error will be returned if called on an ESP32
|
||
* with a silicon revision lower than 3, as these revisions do not support this option.
|
||
*
|
||
* @note If ROM Download Mode is already disabled, this function does nothing and returns success.
|
||
*
|
||
* @return
|
||
* - ESP_OK If the eFuse was successfully burned, or had already been burned.
|
||
* - ESP_ERR_NOT_SUPPORTED (ESP32 only) This SoC is not capable of disabling UART download mode
|
||
* - ESP_ERR_INVALID_STATE (ESP32 only) This eFuse is write protected and cannot be written
|
||
*/
|
||
esp_err_t esp_efuse_disable_rom_download_mode(void);
|
||
|
||
/**
|
||
* @brief Set boot ROM log scheme via eFuse
|
||
*
|
||
* @note By default, the boot ROM will always print to console. This API can be called to set the log scheme only once per chip,
|
||
* once the value is changed from the default it can't be changed again.
|
||
*
|
||
* @param log_scheme Supported ROM log scheme
|
||
* @return
|
||
* - ESP_OK If the eFuse was successfully burned, or had already been burned.
|
||
* - ESP_ERR_NOT_SUPPORTED (ESP32 only) This SoC is not capable of setting ROM log scheme
|
||
* - ESP_ERR_INVALID_STATE This eFuse is write protected or has been burned already
|
||
*/
|
||
esp_err_t esp_efuse_set_rom_log_scheme(esp_efuse_rom_log_scheme_t log_scheme);
|
||
|
||
#if SOC_SUPPORTS_SECURE_DL_MODE
|
||
/**
|
||
* @brief Switch ROM Download Mode to Secure Download mode via eFuse
|
||
*
|
||
* Permanently enables Secure Download mode. This mode limits the use of ROM Download Mode functions
|
||
* to simple flash read, write and erase operations, plus a command to return a summary of currently
|
||
* enabled security features.
|
||
*
|
||
* @note If Secure Download mode is already enabled, this function does nothing and returns success.
|
||
*
|
||
* @note If UART DL mode is completely disabled then Secure Download mode can not be enabled
|
||
* and this API simply returns success.
|
||
*
|
||
* @return
|
||
* - ESP_OK If the eFuse was successfully burned, or had already been burned, or UART DL mode is already disabled.
|
||
* - Other errors If an error occurred while burning ESP_EFUSE_ENABLE_SECURITY_DOWNLOAD.
|
||
*/
|
||
esp_err_t esp_efuse_enable_rom_secure_download_mode(void);
|
||
#endif
|
||
|
||
|
||
/**
|
||
* @brief Return secure_version from efuse field.
|
||
* @return Secure version from efuse field
|
||
*/
|
||
uint32_t esp_efuse_read_secure_version(void);
|
||
|
||
/**
|
||
* @brief Check secure_version from app and secure_version and from efuse field.
|
||
*
|
||
* @param secure_version Secure version from app.
|
||
* @return
|
||
* - True: If version of app is equal or more then secure_version from efuse.
|
||
*/
|
||
bool esp_efuse_check_secure_version(uint32_t secure_version);
|
||
|
||
/**
|
||
* @brief Write efuse field by secure_version value.
|
||
*
|
||
* Update the secure_version value is available if the coding scheme is None.
|
||
* Note: Do not use this function in your applications. This function is called as part of the other API.
|
||
*
|
||
* @param[in] secure_version Secure version from app.
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_FAIL: secure version of app cannot be set to efuse field.
|
||
* - ESP_ERR_NOT_SUPPORTED: Anti rollback is not supported with the 3/4 and Repeat coding scheme.
|
||
*/
|
||
esp_err_t esp_efuse_update_secure_version(uint32_t secure_version);
|
||
|
||
#if defined(BOOTLOADER_BUILD) && defined(CONFIG_EFUSE_VIRTUAL) && !defined(CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH)
|
||
/**
|
||
* @brief Initializes eFuses API to keep eFuses in RAM.
|
||
*
|
||
* This function just copies all eFuses to RAM. IDF eFuse APIs perform all operators with RAM instead of real eFuse.
|
||
* (Used only in bootloader).
|
||
*/
|
||
void esp_efuse_init_virtual_mode_in_ram(void);
|
||
#endif
|
||
|
||
#ifdef CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH
|
||
/**
|
||
* @brief Initializes variables: offset and size to simulate the work of an eFuse.
|
||
*
|
||
* Note: To simulate the work of an eFuse need to set CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH option
|
||
* and to add in the partition.csv file a line `efuse_em, data, efuse, , 0x2000,`.
|
||
*
|
||
* @param[in] offset The starting address of the partition where the eFuse data will be located.
|
||
* @param[in] size The size of the partition.
|
||
*/
|
||
void esp_efuse_init_virtual_mode_in_flash(uint32_t offset, uint32_t size);
|
||
#endif
|
||
|
||
/**
|
||
* @brief Set the batch mode of writing fields.
|
||
*
|
||
* This mode allows you to write the fields in the batch mode when need to burn several efuses at one time.
|
||
* To enable batch mode call begin() then perform as usually the necessary operations
|
||
* read and write and at the end call commit() to actually burn all written efuses.
|
||
* The batch mode can be used nested. The commit will be done by the last commit() function.
|
||
* The number of begin() functions should be equal to the number of commit() functions.
|
||
*
|
||
* @note Please note that reading in the batch mode does not show uncommitted changes.
|
||
*
|
||
* Note: If batch mode is enabled by the first task, at this time the second task cannot write/read efuses.
|
||
* The second task will wait for the first task to complete the batch operation.
|
||
*
|
||
* \code{c}
|
||
* // Example of using the batch writing mode.
|
||
*
|
||
* // set the batch writing mode
|
||
* esp_efuse_batch_write_begin();
|
||
*
|
||
* // use any writing functions as usual
|
||
* esp_efuse_write_field_blob(ESP_EFUSE_...);
|
||
* esp_efuse_write_field_cnt(ESP_EFUSE_...);
|
||
* esp_efuse_set_write_protect(EFUSE_BLKx);
|
||
* esp_efuse_write_reg(EFUSE_BLKx, ...);
|
||
* esp_efuse_write_block(EFUSE_BLKx, ...);
|
||
* esp_efuse_write(ESP_EFUSE_1, 3); // ESP_EFUSE_1 == 1, here we write a new value = 3. The changes will be burn by the commit() function.
|
||
* esp_efuse_read_...(ESP_EFUSE_1); // this function returns ESP_EFUSE_1 == 1 because uncommitted changes are not readable, it will be available only after commit.
|
||
* ...
|
||
*
|
||
* // esp_efuse_batch_write APIs can be called recursively.
|
||
* esp_efuse_batch_write_begin();
|
||
* esp_efuse_set_write_protect(EFUSE_BLKx);
|
||
* esp_efuse_batch_write_commit(); // the burn will be skipped here, it will be done in the last commit().
|
||
*
|
||
* ...
|
||
*
|
||
* // Write all of these fields to the efuse registers
|
||
* esp_efuse_batch_write_commit();
|
||
* esp_efuse_read_...(ESP_EFUSE_1); // this function returns ESP_EFUSE_1 == 3.
|
||
*
|
||
* \endcode
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
*/
|
||
esp_err_t esp_efuse_batch_write_begin(void);
|
||
|
||
/**
|
||
* @brief Reset the batch mode of writing fields.
|
||
*
|
||
* It will reset the batch writing mode and any written changes.
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_STATE: The batch mode was not set.
|
||
*/
|
||
esp_err_t esp_efuse_batch_write_cancel(void);
|
||
|
||
/**
|
||
* @brief Writes all prepared data for the batch mode.
|
||
*
|
||
* Must be called to ensure changes are written to the efuse registers.
|
||
* After this the batch writing mode will be reset.
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_STATE: The deferred writing mode was not set.
|
||
* - ESP_FAIL: Failed to write efuse fields.
|
||
* - ESP_ERR_BURN_WR_DIS: Failed to burn WR_DIS field.
|
||
*/
|
||
esp_err_t esp_efuse_batch_write_commit(void);
|
||
|
||
/**
|
||
* @brief Checks that the given block is empty.
|
||
*
|
||
* @return
|
||
* - True: The block is empty.
|
||
* - False: The block is not empty or was an error.
|
||
*/
|
||
bool esp_efuse_block_is_empty(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Returns a read protection for the key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @return True: The key block is read protected
|
||
* False: The key block is readable.
|
||
*/
|
||
bool esp_efuse_get_key_dis_read(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Sets a read protection for the key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
*/
|
||
esp_err_t esp_efuse_set_key_dis_read(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Returns a write protection for the key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @return True: The key block is write protected
|
||
* False: The key block is writeable.
|
||
*/
|
||
bool esp_efuse_get_key_dis_write(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Sets a write protection for the key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
* - ESP_ERR_BURN_WR_DIS: Failed to burn WR_DIS field.
|
||
*/
|
||
esp_err_t esp_efuse_set_key_dis_write(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Returns true if the key block is unused, false otherwise.
|
||
*
|
||
* An unused key block is all zero content, not read or write protected,
|
||
* and has purpose 0 (ESP_EFUSE_KEY_PURPOSE_USER)
|
||
*
|
||
* @param block key block to check.
|
||
*
|
||
* @return
|
||
* - True if key block is unused,
|
||
* - False if key block is used or the specified block index is not a key block.
|
||
*/
|
||
bool esp_efuse_key_block_unused(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Find a key block with the particular purpose set.
|
||
*
|
||
* @param[in] purpose Purpose to search for.
|
||
* @param[out] block Pointer in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX which will be set to the key block if found.
|
||
* Can be NULL, if only need to test the key block exists.
|
||
*
|
||
* @return
|
||
* - True: If found,
|
||
* - False: If not found (value at block pointer is unchanged).
|
||
*/
|
||
bool esp_efuse_find_purpose(esp_efuse_purpose_t purpose, esp_efuse_block_t *block);
|
||
|
||
/**
|
||
* @brief Returns a write protection of the key purpose field for an efuse key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @note For ESP32: no keypurpose, it returns always True.
|
||
*
|
||
* @return True: The key purpose is write protected.
|
||
* False: The key purpose is writeable.
|
||
*/
|
||
bool esp_efuse_get_keypurpose_dis_write(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Returns the current purpose set for an efuse key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @return
|
||
* - Value: If Successful, it returns the value of the purpose related to the given key block.
|
||
* - ESP_EFUSE_KEY_PURPOSE_MAX: Otherwise.
|
||
*/
|
||
esp_efuse_purpose_t esp_efuse_get_key_purpose(esp_efuse_block_t block);
|
||
|
||
#if SOC_EFUSE_KEY_PURPOSE_FIELD
|
||
/**
|
||
* @brief Returns a pointer to a key purpose for an efuse key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* To get the value of this field use esp_efuse_read_field_blob() or esp_efuse_get_key_purpose().
|
||
*
|
||
* @return Pointer: If Successful returns a pointer to the corresponding efuse field otherwise NULL.
|
||
*/
|
||
const esp_efuse_desc_t **esp_efuse_get_purpose_field(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Returns a pointer to a key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @return Pointer: If Successful returns a pointer to the corresponding efuse field otherwise NULL.
|
||
*/
|
||
const esp_efuse_desc_t** esp_efuse_get_key(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Sets a key purpose for an efuse key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
* @param[in] purpose Key purpose.
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
*/
|
||
esp_err_t esp_efuse_set_key_purpose(esp_efuse_block_t block, esp_efuse_purpose_t purpose);
|
||
|
||
/**
|
||
* @brief Sets a write protection of the key purpose field for an efuse key block.
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
* - ESP_ERR_BURN_WR_DIS: Failed to burn WR_DIS field.
|
||
*/
|
||
esp_err_t esp_efuse_set_keypurpose_dis_write(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Search for an unused key block and return the first one found.
|
||
*
|
||
* See esp_efuse_key_block_unused for a description of an unused key block.
|
||
*
|
||
* @return First unused key block, or EFUSE_BLK_KEY_MAX if no unused key block is found.
|
||
*/
|
||
esp_efuse_block_t esp_efuse_find_unused_key_block(void);
|
||
|
||
/**
|
||
* @brief Return the number of unused efuse key blocks in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*/
|
||
unsigned esp_efuse_count_unused_key_blocks(void);
|
||
|
||
#endif // SOC_EFUSE_KEY_PURPOSE_FIELD
|
||
|
||
#if SOC_SUPPORT_SECURE_BOOT_REVOKE_KEY
|
||
/**
|
||
* @brief Returns the status of the Secure Boot public key digest revocation bit.
|
||
*
|
||
* @param[in] num_digest The number of digest in range 0..2
|
||
*
|
||
* @return
|
||
* - True: If key digest is revoked,
|
||
* - False; If key digest is not revoked.
|
||
*/
|
||
bool esp_efuse_get_digest_revoke(unsigned num_digest);
|
||
|
||
/**
|
||
* @brief Sets the Secure Boot public key digest revocation bit.
|
||
*
|
||
* @param[in] num_digest The number of digest in range 0..2
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
*/
|
||
esp_err_t esp_efuse_set_digest_revoke(unsigned num_digest);
|
||
|
||
/**
|
||
* @brief Returns a write protection of the Secure Boot public key digest revocation bit.
|
||
*
|
||
* @param[in] num_digest The number of digest in range 0..2
|
||
*
|
||
* @return True: The revocation bit is write protected.
|
||
* False: The revocation bit is writeable.
|
||
*/
|
||
bool esp_efuse_get_write_protect_of_digest_revoke(unsigned num_digest);
|
||
|
||
/**
|
||
* @brief Sets a write protection of the Secure Boot public key digest revocation bit.
|
||
*
|
||
* @param[in] num_digest The number of digest in range 0..2
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
* - ESP_ERR_BURN_WR_DIS: Failed to burn WR_DIS field.
|
||
*/
|
||
esp_err_t esp_efuse_set_write_protect_of_digest_revoke(unsigned num_digest);
|
||
|
||
#endif // SOC_SUPPORT_SECURE_BOOT_REVOKE_KEY
|
||
|
||
/**
|
||
* @brief Program a block of key data to an efuse block
|
||
*
|
||
* The burn of a key, protection bits, and a purpose happens in batch mode.
|
||
*
|
||
* @note This API also enables the read protection efuse bit for certain key blocks like XTS-AES, HMAC, ECDSA etc.
|
||
* This ensures that the key is only accessible to hardware peripheral.
|
||
*
|
||
* @note For SoC's with capability `SOC_EFUSE_ECDSA_USE_HARDWARE_K` (e.g., ESP32-H2), this API writes an additional
|
||
* efuse bit for ECDSA key purpose to enforce hardware TRNG generated k mode in the peripheral.
|
||
*
|
||
* @param[in] block Block to read purpose for. Must be in range EFUSE_BLK_KEY0 to EFUSE_BLK_KEY_MAX. Key block must be unused (esp_efuse_key_block_unused).
|
||
* @param[in] purpose Purpose to set for this key. Purpose must be already unset.
|
||
* @param[in] key Pointer to data to write.
|
||
* @param[in] key_size_bytes Bytes length of data to write.
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_INVALID_STATE: Error in efuses state, unused block not found.
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
* - ESP_ERR_BURN_WR_DIS: Failed to burn WR_DIS field.
|
||
*/
|
||
esp_err_t esp_efuse_write_key(esp_efuse_block_t block, esp_efuse_purpose_t purpose, const void *key, size_t key_size_bytes);
|
||
|
||
/**
|
||
* @brief Program keys to unused efuse blocks
|
||
*
|
||
* The burn of keys, protection bits, and purposes happens in batch mode.
|
||
*
|
||
* @note This API also enables the read protection efuse bit for certain key blocks like XTS-AES, HMAC, ECDSA etc.
|
||
* This ensures that the key is only accessible to hardware peripheral.
|
||
*
|
||
* @note For SoC's with capability `SOC_EFUSE_ECDSA_USE_HARDWARE_K` (e.g., ESP32-H2), this API writes an additional
|
||
* efuse bit for ECDSA key purpose to enforce hardware TRNG generated k mode in the peripheral.
|
||
*
|
||
* @param[in] purposes Array of purposes (purpose[number_of_keys]).
|
||
* @param[in] keys Array of keys (uint8_t keys[number_of_keys][32]). Each key is 32 bytes long.
|
||
* @param[in] number_of_keys The number of keys to write (up to 6 keys).
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_ERR_INVALID_ARG: Error in the passed arguments.
|
||
* - ESP_ERR_INVALID_STATE: Error in efuses state, unused block not found.
|
||
* - ESP_ERR_NOT_ENOUGH_UNUSED_KEY_BLOCKS: Error not enough unused key blocks available
|
||
* - ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.
|
||
* - ESP_ERR_CODING: Error range of data does not match the coding scheme.
|
||
* - ESP_ERR_BURN_WR_DIS: Failed to burn WR_DIS field.
|
||
*/
|
||
esp_err_t esp_efuse_write_keys(const esp_efuse_purpose_t purposes[], uint8_t keys[][32], unsigned number_of_keys);
|
||
|
||
|
||
#if CONFIG_ESP32_REV_MIN_FULL >= 300 || !CONFIG_IDF_TARGET_ESP32
|
||
/**
|
||
* @brief Read key digests from efuse. Any revoked/missing digests will be marked as NULL
|
||
*
|
||
* @param[out] trusted_key_digests Trusted keys digests, stored in this parameter after successfully
|
||
* completing this function.
|
||
* The number of digests depends on the SOC's capabilities.
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_FAIL: If trusted_keys is NULL or there is no valid digest.
|
||
*/
|
||
esp_err_t esp_secure_boot_read_key_digests(esp_secure_boot_key_digests_t *trusted_key_digests);
|
||
#endif
|
||
|
||
/**
|
||
* @brief Checks eFuse errors in BLOCK0.
|
||
*
|
||
* @note Refers to ESP32-C3 only.
|
||
*
|
||
* It does a BLOCK0 check if eFuse EFUSE_ERR_RST_ENABLE is set.
|
||
* If BLOCK0 has an error, it prints the error and returns ESP_FAIL, which should be treated as esp_restart.
|
||
*
|
||
* @return
|
||
* - ESP_OK: No errors in BLOCK0.
|
||
* - ESP_FAIL: Error in BLOCK0 requiring reboot.
|
||
*/
|
||
esp_err_t esp_efuse_check_errors(void);
|
||
|
||
/**
|
||
* @brief Destroys the data in the given efuse block, if possible.
|
||
*
|
||
* Data destruction occurs through the following steps:
|
||
* 1) Destroy data in the block:
|
||
* - If write protection is inactive for the block, then unset bits are burned.
|
||
* - If write protection is active, the block remains unaltered.
|
||
* 2) Set read protection for the block if possible (check write-protection for RD_DIS).
|
||
* In this case, data becomes inaccessible, and the software reads it as all zeros.
|
||
* If write protection is enabled and read protection can not be set,
|
||
* data in the block remains readable (returns an error).
|
||
*
|
||
* Do not use the batch mode with this function as it does the burning itself!
|
||
*
|
||
* @param[in] block A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successful.
|
||
* - ESP_FAIL: Data remained readable because the block is write-protected
|
||
* and read protection can not be set.
|
||
*/
|
||
esp_err_t esp_efuse_destroy_block(esp_efuse_block_t block);
|
||
|
||
/**
|
||
* @brief Checks if flash encryption is enabled.
|
||
*
|
||
* This function checks if the current eFuse configuration supports flash encryption.
|
||
*/
|
||
bool esp_efuse_is_flash_encryption_enabled(void);
|
||
|
||
#if SOC_ECDSA_SUPPORTED
|
||
/**
|
||
* @brief Checks if 192-bit ECDSA curve operations are supported.
|
||
*
|
||
* This function checks if the current eFuse configuration supports 192-bit ECDSA curve operations.
|
||
*/
|
||
bool esp_efuse_is_ecdsa_p192_curve_supported(void);
|
||
|
||
/**
|
||
* @brief Checks if 256-bit ECDSA curve operations are supported.
|
||
*
|
||
* This function checks if the current eFuse configuration supports 256-bit ECDSA curve operations.
|
||
*/
|
||
bool esp_efuse_is_ecdsa_p256_curve_supported(void);
|
||
#endif /* SOC_ECDSA_SUPPORTED*/
|
||
|
||
#if SOC_ECDSA_P192_CURVE_DEFAULT_DISABLED
|
||
typedef enum {
|
||
ESP_EFUSE_ECDSA_CURVE_MODE_ALLOW_ONLY_P256_BIT = 0,
|
||
ESP_EFUSE_ECDSA_CURVE_MODE_ALLOW_ONLY_P192_BIT = 1,
|
||
ESP_EFUSE_ECDSA_CURVE_MODE_ALLOW_BOTH_P192_P256_BIT = 2,
|
||
ESP_EFUSE_ECDSA_CURVE_MODE_ALLOW_ONLY_P256_BIT_LOCKED = 3,
|
||
} esp_efuse_ecdsa_curve_mode_t;
|
||
|
||
/**
|
||
* @brief Enables 192-bit ECDSA curve operations by setting the appropriate eFuse value.
|
||
*
|
||
* This function enables support for 192-bit ECDSA curve operations by configuring the
|
||
* ECDSA curve mode eFuse. It checks the current curve mode and attempts to set it to
|
||
* allow both P192 and P256 operations if not already set.
|
||
*
|
||
* @return
|
||
* - ESP_OK: Successfully enabled 192-bit ECDSA operations or already enabled
|
||
* - ESP_FAIL: Failed to enable operations due to write protection
|
||
* - Other error codes: Failed to read/write eFuse
|
||
*/
|
||
esp_err_t esp_efuse_enable_ecdsa_p192_curve_mode(void);
|
||
#endif
|
||
|
||
/**
|
||
* @brief Flags specifying which source(s) to use when dumping eFUSE data.
|
||
*/
|
||
|
||
/**
|
||
* @brief Prefix used in device log lines to trigger automatic token decoding in idf.py monitor.
|
||
*/
|
||
#define ESP_EFUSE_MONITOR_EXECUTE_ESPEFUSE_SUMMARY "IDF_MONITOR_EXECUTE_ESPEFUSE_SUMMARY"
|
||
|
||
/**
|
||
* @brief Prefix used in device log lines to trigger token dump decoding in idf.py monitor.
|
||
*/
|
||
#define ESP_EFUSE_MONITOR_EXECUTE_ESPEFUSE_DUMP "IDF_MONITOR_EXECUTE_ESPEFUSE_DUMP"
|
||
|
||
/**
|
||
* @brief Recommended minimum buffer length for esp_efuse_token_dump().
|
||
*/
|
||
#define ESP_EFUSE_TOKEN_DUMP_MIN_LEN 512
|
||
|
||
typedef enum {
|
||
ESP_EFUSE_TOKEN_FROM_READ = 1, /**< Dump from the eFUSE read registers (the final, permanently programmed values). */
|
||
ESP_EFUSE_TOKEN_FROM_STAGED = 2, /**< Dump from write/staging registers or programming buffer (pending or staged writes). This can expose keys in plaintext because it shows values that are not yet burned and not yet read-protected. Requires CONFIG_EFUSE_ENABLE_STAGED_TOKEN_API. */
|
||
ESP_EFUSE_TOKEN_FROM_READ_STAGED = ESP_EFUSE_TOKEN_FROM_READ | ESP_EFUSE_TOKEN_FROM_STAGED, /**< Combine both read and staged sources to show committed and pending values. The staged portion can expose keys in plaintext because it shows values that are not yet burned and not yet read-protected. Requires CONFIG_EFUSE_ENABLE_STAGED_TOKEN_API. */
|
||
} esp_efuse_token_type_t;
|
||
|
||
/**
|
||
* @brief Print a single-line dump token that serializes all eFuse blocks.
|
||
*
|
||
* Token formats (null-terminated strings):
|
||
* - Read efuse area EFSR:chip_name:chip_version:b64_blocks:b64_cerr:b64_crc32
|
||
* - Staged efuse area EFSW:chip_name:chip_version:b64_blocks:b64_cerr:b64_crc32
|
||
* - Combination of two areas (read and staged) EFSRW:...
|
||
*
|
||
* This token is useful when a host tool cannot read the device directly (for example,
|
||
* when UART download mode is disabled, secure download is enabled).
|
||
* Copy the entire token string and decode it on a host that has access to espefuse.
|
||
*
|
||
* Example (decode token and show only active fields):
|
||
* @code
|
||
* espefuse --token EFSR:esp32:300:AAABAAAAAAAAAAAAAIAAAAAAAAAAABAAAAAAAA::oKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr8:::fPaC-A summary --active
|
||
* @endcode
|
||
*
|
||
* Where:
|
||
* - token_marker = EFSR, EFSW, or EFSRW
|
||
* - chip_name = CONFIG_IDF_TARGET (e.g., "esp32c5")
|
||
* - chip_version = chip version (e.g., "100" for v1.0). version = major wafer version * 100 + minor wafer version.
|
||
* - b64_blocks = concatenation of all blocks’ 32-bit words (little-endian byte order),
|
||
* encoded as Base64URL without padding, for BLK0..BLK_MAX-1.
|
||
* - b64_cerr = optional coding-error snapshot.
|
||
* - b64_crc32 = crc32("token_marker:chip:ver:b64_blocks:b64_cerr:")
|
||
* b64 - base 64 format (Base64URL, UNPADDED)
|
||
*
|
||
* @note Dump modes that include staged data (ESP_EFUSE_TOKEN_FROM_STAGED and
|
||
* ESP_EFUSE_TOKEN_FROM_READ_STAGED) can expose sensitive data, including
|
||
* plaintext key material, because they show values before they are
|
||
* burned and before read-protection is applied. Treat EFSW/EFSRW tokens
|
||
* as sensitive artifacts and enable them only with CONFIG_EFUSE_ENABLE_STAGED_TOKEN_API.
|
||
*
|
||
* @note When @p buf is NULL, the token is printed with esp_log() using a
|
||
* non-constrained logging configuration. If the token must be emitted
|
||
* from a constrained environment, pass a buffer to this function and
|
||
* print or transport the resulting token with a constrained-safe method.
|
||
*
|
||
* @param dump_type Select which efuse data to dump: read, staged writes, or both.
|
||
* @param buf Buffer to store the resulting token string. If NULL, output goes to console.
|
||
* @param buf_len Length of the buffer. Must be at least ESP_EFUSE_TOKEN_DUMP_MIN_LEN bytes to hold
|
||
* the full token for esp32xx series.
|
||
*
|
||
* @return
|
||
* - ESP_OK on success.
|
||
* - ESP_ERR_NOT_SUPPORTED if @p dump_type requests staged data and
|
||
* CONFIG_EFUSE_ENABLE_STAGED_TOKEN_API is disabled to avoid exposing
|
||
* staged values, including plaintext key material, before burn/read-protect.
|
||
* - ESP_ERR_INVALID_ARG if @p dump_type is invalid.
|
||
* - ESP_ERR_INVALID_SIZE if buf_len is too small
|
||
*/
|
||
esp_err_t esp_efuse_token_dump(esp_efuse_token_type_t dump_type, char *buf, size_t buf_len);
|
||
|
||
/**
|
||
* @brief Burns the EFSW token dump
|
||
*
|
||
* @note The EFSW token dump can be produced from a host or from-device utility. Examples:
|
||
* - Host: `espefuse burn-bit BLOCK2 1 --show-token`
|
||
* - Device: `esp_efuse_token_dump(ESP_EFUSE_TOKEN_FROM_STAGED, buf, len)`
|
||
*
|
||
* EFSW:chip_name:chip_version:b64_blocks::b64_crc32
|
||
*
|
||
* The function validates:
|
||
* - Token marker EFSW
|
||
* - Chip name (must match CONFIG_IDF_TARGET)
|
||
* - Chip version is validated unless ignore_ver is set to true. The major version must be equal.
|
||
* - Chip version unless ignore_ver is true
|
||
* - CRC32
|
||
*
|
||
* @param token_in Null-terminated EFSW token string.
|
||
* @param ignore_ver If true, skip enforcing the wafer chip version in the token.
|
||
*
|
||
* @return
|
||
* - ESP_OK on success (token parsed and write efuse area is populated).
|
||
* - ESP_ERR_INVALID_ARG on format/mismatch errors (bad token marker/chip/ver/layout)
|
||
* - ESP_ERR_INVALID_CRC if CRC verification fails
|
||
* - ESP_ERR_INVALID_VERSION if chip version mismatches and ignore_ver is false
|
||
* - Other esp_err_t from lower layers if writing/burning fails
|
||
*/
|
||
esp_err_t esp_efuse_token_burn(const char *token_in, bool ignore_ver);
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|