eFuse Manager

Introduction

The eFuse Manager library is designed to structure access to eFuse bits and make using these easy. This library operates eFuse bits by a structure name which is assigned in eFuse table. This sections introduces some concepts used by eFuse Manager.

Hardware description

The ESP32 has a number of eFuses which can store system and user parameters. Each eFuse is a one-bit field which can be programmed to 1 after which it cannot be reverted back to 0. Some of system parameters are using these eFuse bits directly by hardware modules and have special place (for example EFUSE_BLK0).

For more details, see ESP32 Technical Reference Manual > eFuse Controller (eFuse) [PDF]. Some eFuse bits are available for user applications.

ESP32 has 4 eFuse blocks each of the size of 256 bits (not all bits are available):

EFUSE_BLK0 is used entirely for system purposes;
EFUSE_BLK1 is used for flash encrypt key. If not using that Flash Encryption feature, they can be used for another purpose;
EFUSE_BLK2 is used for security boot key. If not using that Secure Boot feature, they can be used for another purpose;
EFUSE_BLK3 can be partially reserved for the custom MAC address, or used entirely for user application. Note that some bits are already used in IDF.

Each block is divided into 8 32-bits registers.

eFuse Manager component

The component has API functions for reading and writing fields. Access to the fields is carried out through the structures that describe the location of the eFuse bits in the blocks. The component provides the ability to form fields of any length and from any number of individual bits. The description of the fields is made in a CSV file in a table form. To generate from a tabular form (CSV file) in the C-source uses the tool efuse_table_gen.py. The tool checks the CSV file for uniqueness of field names and bit intersection, in case of using a custom file from the user’s project directory, the utility will check with the common CSV file.

CSV files:

common (esp_efuse_table.csv) - contains eFuse fields which are used inside the IDF. C-source generation should be done manually when changing this file (run command idf.py efuse-common-table). Note that changes in this file can lead to incorrect operation.
custom - (optional and can be enabled by CONFIG_EFUSE_CUSTOM_TABLE) contains eFuse fields that are used by the user in their application. C-source generation should be done manually when changing this file and running idf.py efuse-custom-table.

Description CSV file

The CSV file contains a description of the eFuse fields. In the simple case, one field has one line of description. Table header:

# field_name,  efuse_block(EFUSE_BLK0..EFUSE_BLK3), bit_start(0..255),    bit_count(1..256),        comment

Individual params in CSV file the following meanings:

field_name: Name of field. The prefix ESP_EFUSE_ will be added to the name, and this field name will be available in the code. This name will be used to access the fields. The name must be unique for all fields. If the line has an empty name, then this line is combined with the previous field. This allows you to set an arbitrary order of bits in the field, and expand the field as well (see MAC_FACTORY field in the common table). The field_name supports structured format using . to show that the field belongs to another field (see WR_DIS and RD_DIS in the common table).
efuse_block: Block number. It determines where the eFuse bits will be placed for this field. Available EFUSE_BLK0..EFUSE_BLK3.
bit_start: Start bit number (0..255). The bit_start field can be omitted. In this case, it will be set to bit_start + bit_count from the previous record, if it has the same efuse_block. Otherwise (if efuse_block is different, or this is the first entry), an error will be generated.

bit_count: The number of bits to use in this field (1..-). This parameter can not be omitted. This field also may be MAX_BLK_LEN in this case, the field length will have the maximum block length, taking into account the coding scheme (applicable for ESP_EFUSE_SECURE_BOOT_KEY and ESP_EFUSE_ENCRYPT_FLASH_KEY fields). The value MAX_BLK_LEN depends on CONFIG_EFUSE_CODE_SCHEME_SELECTOR, will be replaced with “None” - 256, “3/4” - 192, “REPEAT” - 128.

comment: This param is using for comment field, it also move to C-header file. The comment field can be omitted.

If a non-sequential bit order is required to describe a field, then the field description in the following lines should be continued without specifying a name, this will indicate that it belongs to one field. For example two fields MAC_FACTORY and MAC_FACTORY_CRC:

# Factory MAC address #
#######################
MAC_FACTORY,            EFUSE_BLK0,    72,    8,    Factory MAC addr [0]
,                       EFUSE_BLK0,    64,    8,    Factory MAC addr [1]
,                       EFUSE_BLK0,    56,    8,    Factory MAC addr [2]
,                       EFUSE_BLK0,    48,    8,    Factory MAC addr [3]
,                       EFUSE_BLK0,    40,    8,    Factory MAC addr [4]
,                       EFUSE_BLK0,    32,    8,    Factory MAC addr [5]
MAC_FACTORY_CRC,        EFUSE_BLK0,    80,    8,    CRC8 for factory MAC address

This field will available in code as ESP_EFUSE_MAC_FACTORY and ESP_EFUSE_MAC_FACTORY_CRC.

Structured efuse fields

WR_DIS,                           EFUSE_BLK0,   0,    32,     Write protection
WR_DIS.RD_DIS,                    EFUSE_BLK0,   0,    1,      Write protection for RD_DIS
WR_DIS.FIELD_1,                   EFUSE_BLK0,   1,    1,      Write protection for FIELD_1
WR_DIS.FIELD_2,                   EFUSE_BLK0,   2,    4,      Write protection for FIELD_2 (includes B1 and B2)
WR_DIS.FIELD_2.B1,                EFUSE_BLK0,   2,    2,      Write protection for FIELD_2.B1
WR_DIS.FIELD_2.B2,                EFUSE_BLK0,   4,    2,      Write protection for FIELD_2.B2
WR_DIS.FIELD_3,                   EFUSE_BLK0,   5,    1,      Write protection for FIELD_3
WR_DIS.FIELD_3.ALIAS,             EFUSE_BLK0,   5,    1,      Write protection for FIELD_3 (just a alias for WR_DIS.FIELD_3)
WR_DIS.FIELD_4,                   EFUSE_BLK0,   7,    1,      Write protection for FIELD_4

The structured eFuse field looks like WR_DIS.RD_DIS where the dot points that this field belongs to the parent field - WR_DIS and can not be out of the parent’s range.

It is possible to use some levels of structured fields as WR_DIS.FIELD_2.B1 and B2. These fields should not be crossed each other and should be in the range of two fields: WR_DIS and WR_DIS.FIELD_2.

It is possible to create aliases for fields with the same range, see WR_DIS.FIELD_3 and WR_DIS.FIELD_3.ALIAS.

The IDF names for structured efuse fields should be unique. The efuse_table_gen tool will generate the final names where the dot will be replaced by _. The names for using in IDF are ESP_EFUSE_WR_DIS, ESP_EFUSE_WR_DIS_RD_DIS, ESP_EFUSE_WR_DIS_FIELD_2_B1, etc.

The efuse_table_gen tool checks that the fields do not overlap each other and must be within the range of a field if there is a violation, then throws the following error:

Field at USER_DATA, EFUSE_BLK3, 0, 256  intersected with  SERIAL_NUMBER, EFUSE_BLK3, 0, 32

Solution: Describe SERIAL_NUMBER to be included in USER_DATA. (USER_DATA.SERIAL_NUMBER).

Field at FEILD, EFUSE_BLK3, 0, 50  out of range  FEILD.MAJOR_NUMBER, EFUSE_BLK3, 60, 32

Solution: Change bit_start for FIELD.MAJOR_NUMBER from 60 to 0, so MAJOR_NUMBER is in the FEILD range.

efuse_table_gen.py tool

The tool is designed to generate C-source files from CSV file and validate fields. First of all, the check is carried out on the uniqueness of the names and overlaps of the field bits. If an additional custom file is used, it will be checked with the existing common file (esp_efuse_table.csv). In case of errors, a message will be displayed and the string that caused the error. C-source files contain structures of type esp_efuse_desc_t.

To generate a common files, use the following command idf.py efuse-common-table or:

cd $IDF_PATH/components/efuse/
./efuse_table_gen.py --idf_target esp32 esp32/esp_efuse_table.csv

After generation in the folder $IDF_PATH/components/efuse/esp32 create:

esp_efuse_table.c file.
In include folder esp_efuse_table.c file.

To generate a custom files, use the following command idf.py efuse-custom-table or:

cd $IDF_PATH/components/efuse/
./efuse_table_gen.py --idf_target esp32 esp32/esp_efuse_table.csv PROJECT_PATH/main/esp_efuse_custom_table.csv

After generation in the folder PROJECT_PATH/main create:

esp_efuse_custom_table.c file.
In include folder esp_efuse_custom_table.c file.

To use the generated fields, you need to include two files:

#include "esp_efuse.h"
#include "esp_efuse_table.h" // or "esp_efuse_custom_table.h"

Supported coding scheme

eFuse have three coding schemes:

None (value 0).
3/4 (value 1).
Repeat (value 2).

The coding scheme affects only EFUSE_BLK1, EFUSE_BLK2 and EFUSE_BLK3 blocks. EUSE_BLK0 block always has a coding scheme None. Coding changes the number of bits that can be written into a block, the block length is constant 256, some of these bits are used for encoding and not avaliable for the user.

When using a coding scheme, the length of the payload that can be written is limited (for more details 20.3.1.3 System Parameter coding_scheme):

None 256 bits.
3/4 192 bits.
Repeat 128 bits.

You can find out the coding scheme of your chip:

run a espefuse.py -p PORT summary command.
from esptool utility logs (during flashing).
calling the function in the code esp_efuse_get_coding_scheme() for the EFUSE_BLK3 block.

eFuse tables must always comply with the coding scheme in the chip. There is an CONFIG_EFUSE_CODE_SCHEME_SELECTOR option to select the coding type for tables in a Kconfig. When generating source files, if your tables do not follow the coding scheme, an error message will be displayed. Adjust the length or offset fields. If your program was compiled with None encoding and 3/4 is used in the chip, then the ESP_ERR_CODING error may occur when calling the eFuse API (the field is outside the block boundaries). If the field matches the new block boundaries, then the API will work without errors.

Also, 3/4 coding scheme imposes restrictions on writing bits belonging to one coding unit. The whole block with a length of 256 bits is divided into 4 coding units, and in each coding unit there are 6 bytes of useful data and 2 service bytes. These 2 service bytes contain the checksum of the previous 6 data bytes.

It turns out that only one field can be written into one coding unit. Repeated rewriting in one coding unit is prohibited. But if the record was made in advance or through a esp_efuse_write_block() function, then reading the fields belonging to one coding unit is possible.

In case 3/4 coding scheme, the writing process is divided into the coding units and we can not use the usual mode of writing some fields. We can prepare all the data for writing and burn it in one time. You can also use this mode for None coding scheme but it is not necessary. It is important for 3/4 coding scheme. The batch writing mode blocks esp_efuse_read_... operations.

After changing the coding scheme, run efuse_common_table and efuse_custom_table commands to check the tables of the new coding scheme.

To write some fields into one block, or different blocks in one time, you need to use the batch writing mode. Firstly set this mode through esp_efuse_batch_write_begin() function then write some fields as usual using the esp_efuse_write_... functions. At the end to burn them, call the esp_efuse_batch_write_commit() function. It burns prepared data to the eFuse blocks and disables the batch recording mode.

备注

If there is already pre-written data in the eFuse block using the 3/4 or Repeat encoding scheme, then it is not possible to write anything extra (even if the required bits are empty) without breaking the previous encoding data. This encoding data will be overwritten with new encoding data and completely destroyed (however, the payload eFuses are not damaged). It can be related to: CUSTOM_MAC, SPI_PAD_CONFIG_HD, SPI_PAD_CONFIG_CS, etc. Please contact Espressif to order the required pre-burnt eFuses.

FOR TESTING ONLY (NOT RECOMMENDED): You can ignore or suppress errors that violate encoding scheme data in order to burn the necessary bits in the eFuse block.

eFuse API

Access to the fields is via a pointer to the description structure. API functions have some basic operation:

esp_efuse_read_field_blob() - returns an array of read eFuse bits.
esp_efuse_read_field_cnt() - returns the number of bits programmed as “1”.
esp_efuse_write_field_blob() - writes an array.
esp_efuse_write_field_cnt() - writes a required count of bits as “1”.
esp_efuse_get_field_size() - returns the number of bits by the field name.
esp_efuse_read_reg() - returns value of eFuse register.
esp_efuse_write_reg() - writes value to eFuse register.
esp_efuse_get_coding_scheme() - returns eFuse coding scheme for blocks.
esp_efuse_read_block() - reads key to eFuse block starting at the offset and the required size.
esp_efuse_write_block() - writes key to eFuse block starting at the offset and the required size.
esp_efuse_batch_write_begin() - set the batch mode of writing fields.
esp_efuse_batch_write_commit() - writes all prepared data for batch writing mode and reset the batch writing mode.
esp_efuse_batch_write_cancel() - reset the batch writing mode and prepared data.
esp_efuse_get_key_dis_read() - Returns a read protection for the key block.
esp_efuse_set_key_dis_read() - Sets a read protection for the key block.
esp_efuse_get_key_dis_write() - Returns a write protection for the key block.
esp_efuse_set_key_dis_write() - Sets a write protection for the key block.
esp_efuse_get_key_purpose() - Returns the current purpose set for an eFuse key block.
esp_efuse_write_key() - Programs a block of key data to an eFuse block
esp_efuse_write_keys() - Programs keys to unused eFuse blocks
esp_efuse_find_purpose() - Finds a key block with the particular purpose set.
esp_efuse_get_keypurpose_dis_write() - Returns a write protection of the key purpose field for an eFuse key block (for esp32 always true).
esp_efuse_key_block_unused() - Returns true if the key block is unused, false otherwise.

For frequently used fields, special functions are made, like this esp_efuse_get_pkg_ver().

How to add a new field

Find a free bits for field. Show esp_efuse_table.csv file or run idf.py show-efuse-table or the next command:

$ ./efuse_table_gen.py esp32/esp_efuse_table.csv --info

Parsing efuse CSV input file $IDF_PATH/components/efuse/esp32/esp_efuse_table.csv ...
Verifying efuse table...
Max number of bits in BLK 192
Sorted efuse table:
#       field_name                      efuse_block     bit_start       bit_count
     WR_DIS_EFUSE_RD_DISABLE         EFUSE_BLK0         0               1
     WR_DIS_FLASH_CRYPT_CNT          EFUSE_BLK0         2               1
     WR_DIS_BLK1                     EFUSE_BLK0         7               1
     WR_DIS_BLK2                     EFUSE_BLK0         8               1
     WR_DIS_BLK3                     EFUSE_BLK0         9               1
     RD_DIS_BLK1                     EFUSE_BLK0         16              1
     RD_DIS_BLK2                     EFUSE_BLK0         17              1
     RD_DIS_BLK3                     EFUSE_BLK0         18              1
     FLASH_CRYPT_CNT                 EFUSE_BLK0         20              7
    UART_DOWNLOAD_DIS               EFUSE_BLK0         27              1
    MAC_FACTORY                     EFUSE_BLK0         32              8
    MAC_FACTORY                     EFUSE_BLK0         40              8
    MAC_FACTORY                     EFUSE_BLK0         48              8
    MAC_FACTORY                     EFUSE_BLK0         56              8
    MAC_FACTORY                     EFUSE_BLK0         64              8
    MAC_FACTORY                     EFUSE_BLK0         72              8
    MAC_FACTORY_CRC                 EFUSE_BLK0         80              8
    CHIP_VER_DIS_APP_CPU            EFUSE_BLK0         96              1
    CHIP_VER_DIS_BT                 EFUSE_BLK0         97              1
    CHIP_VER_PKG                    EFUSE_BLK0         98              1
    CHIP_VER_PKG                    EFUSE_BLK0        105              3
    CHIP_CPU_FREQ_LOW               EFUSE_BLK0        108              1
    CHIP_CPU_FREQ_RATED             EFUSE_BLK0        109              1
    CHIP_VER_REV1                   EFUSE_BLK0        111              1
    ADC_VREF_AND_SDIO_DREF          EFUSE_BLK0        136              6
    XPD_SDIO_REG                    EFUSE_BLK0        142              1
    SDIO_TIEH                       EFUSE_BLK0        143              1
    SDIO_FORCE                      EFUSE_BLK0        144              1
    CHIP_VER_REV2                   EFUSE_BLK0        180              1
    ENCRYPT_CONFIG                  EFUSE_BLK0        188              4
    CONSOLE_DEBUG_DISABLE           EFUSE_BLK0        194              1
    ABS_DONE_0                      EFUSE_BLK0        196              1
    ABS_DONE_1                      EFUSE_BLK0        197              1
    DISABLE_JTAG                    EFUSE_BLK0        198              1
    DISABLE_DL_ENCRYPT              EFUSE_BLK0        199              1
    DISABLE_DL_DECRYPT              EFUSE_BLK0        200              1
    DISABLE_DL_CACHE                EFUSE_BLK0        201              1
    ENCRYPT_FLASH_KEY               EFUSE_BLK1         0              192
    SECURE_BOOT_KEY                 EFUSE_BLK2         0              192
    MAC_CUSTOM_CRC                  EFUSE_BLK3         0               8
    MAC_CUSTOM                      EFUSE_BLK3         8               48
    ADC1_TP_LOW                     EFUSE_BLK3         96              7
    ADC1_TP_HIGH                    EFUSE_BLK3        103              9
    ADC2_TP_LOW                     EFUSE_BLK3        112              7
    ADC2_TP_HIGH                    EFUSE_BLK3        119              9
    SECURE_VERSION                  EFUSE_BLK3        128              32
    MAC_CUSTOM_VER                  EFUSE_BLK3        184              8

Used bits in efuse table:
EFUSE_BLK0
[0 0] [2 2] [7 9] [16 18] [20 27] [32 87] [96 98] [105 109] [111 111] [136 144] [180 180] [188 191] [194 194] [196 201]

EFUSE_BLK1
[0 191]

EFUSE_BLK2
[0 191]

EFUSE_BLK3
[0 55] [96 159] [184 191]

Note: Not printed ranges are free for using. (bits in EFUSE_BLK0 are reserved for Espressif)

The number of bits not included in square brackets is free (some bits are reserved for Espressif). All fields are checked for overlapping.

To add fields to an existing field, use the Structured efuse fields technique. For example, adding the fields: SERIAL_NUMBER, MODEL_NUMBER and HARDWARE REV to an existing USER_DATA field. Use . (dot) to show an attachment in a field.

USER_DATA.SERIAL_NUMBER,                  EFUSE_BLK3,    0,  32,
USER_DATA.MODEL_NUMBER,                   EFUSE_BLK3,    32, 10,
USER_DATA.HARDWARE_REV,                   EFUSE_BLK3,    42, 10,

Fill a line for field: field_name, efuse_block, bit_start, bit_count, comment.
Run a show_efuse_table command to check eFuse table. To generate source files run efuse_common_table or efuse_custom_table command.

You may get errors such as intersects with or out of range. Please see how to solve them in the Structured efuse fields article.

Bit Order

The eFuses bit order is little endian (see the example below), it means that eFuse bits are read and written from LSB to MSB:

$ espefuse.py dump

USER_DATA      (BLOCK3          ) [3 ] read_regs: 03020100 07060504 0B0A0908 0F0E0D0C 13121111 17161514 1B1A1918 1F1E1D1C
BLOCK4         (BLOCK4          ) [4 ] read_regs: 03020100 07060504 0B0A0908 0F0E0D0C 13121111 17161514 1B1A1918 1F1E1D1C

where is the register representation:

EFUSE_RD_USR_DATA0_REG = 0x03020100
EFUSE_RD_USR_DATA1_REG = 0x07060504
EFUSE_RD_USR_DATA2_REG = 0x0B0A0908
EFUSE_RD_USR_DATA3_REG = 0x0F0E0D0C
EFUSE_RD_USR_DATA4_REG = 0x13121111
EFUSE_RD_USR_DATA5_REG = 0x17161514
EFUSE_RD_USR_DATA6_REG = 0x1B1A1918
EFUSE_RD_USR_DATA7_REG = 0x1F1E1D1C

where is the byte representation:

byte[0] = 0x00, byte[1] = 0x01, ... byte[3] = 0x03, byte[4] = 0x04, ..., byte[31] = 0x1F

For example, csv file describes the USER_DATA field, which occupies all 256 bits (a whole block).

USER_DATA,          EFUSE_BLK3,    0,  256,     User data
USER_DATA.FIELD1,   EFUSE_BLK3,    16,  16,     Field1

ID,                 EFUSE_BLK4,    8,  3,      ID bit[0..2]
,                   EFUSE_BLK4,    16, 2,      ID bit[3..4]
,                   EFUSE_BLK4,    32, 3,      ID bit[5..7]

Thus, reading the eFuse USER_DATA block written as above gives the following results:

uint8_t buf[32] = { 0 };
esp_efuse_read_field_blob(ESP_EFUSE_USER_DATA, &buf, sizeof(buf) * 8);
// buf[0] = 0x00, buf[1] = 0x01, ... buf[31] = 0x1F

uint32_t field1 = 0;
size_t field1_size = ESP_EFUSE_USER_DATA[0]->bit_count; // can be used for this case because it only consists of one entry
esp_efuse_read_field_blob(ESP_EFUSE_USER_DATA, &field1, field1_size);
// field1 = 0x0302

uint32_t field1_1 = 0;
esp_efuse_read_field_blob(ESP_EFUSE_USER_DATA, &field1_1, 2); // reads only first 2 bits
// field1 = 0x0002

uint8_t id = 0;
size_t id_size = esp_efuse_get_field_size(ESP_EFUSE_ID); // returns 6
// size_t id_size = ESP_EFUSE_USER_DATA[0]->bit_count; // can NOT be used because it consists of 3 entries. It returns 3 not 6.
esp_efuse_read_field_blob(ESP_EFUSE_ID, &id, id_size);
// id = 0x91
// b'100 10  001
//   [3] [2] [3]

uint8_t id_1 = 0;
esp_efuse_read_field_blob(ESP_EFUSE_ID, &id_1, 3);
// id = 0x01
// b'001

Debug eFuse & Unit tests

Virtual eFuses

The Kconfig option CONFIG_EFUSE_VIRTUAL will virtualize eFuse values inside the eFuse Manager, so writes are emulated and no eFuse values are permanently changed. This can be useful for debugging app and unit tests. During startup, the eFuses are copied to RAM. All eFuse operations (read and write) are performed with RAM instead of the real eFuse registers.

In addition to the CONFIG_EFUSE_VIRTUAL option there is CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH option that adds a feature to keep eFuses in flash memory. To use this mode the partition_table should have the efuse partition. partition.csv: "efuse_em, data, efuse, , 0x2000,". During startup, the eFuses are copied from flash or, in case if flash is empty, from real eFuse to RAM and then update flash. This option allows keeping eFuses after reboots (possible to test secure_boot and flash_encryption features with this option).

espefuse.py

esptool includes a useful tool for reading/writing ESP32 eFuse bits - espefuse.py.

espefuse.py -p PORT summary

Connecting........__
Detecting chip type... ESP32
espefuse.py v3.1-dev
EFUSE_NAME (Block)                       Description  = [Meaningful Value] [Readable/Writeable] (Hex Value)
----------------------------------------------------------------------------------------
Calibration fuses:
BLK3_PART_RESERVE (BLOCK0):              BLOCK3 partially served for ADC calibration data   = True R/W (0b1)
ADC_VREF (BLOCK0):                       Voltage reference calibration                      = 1114 R/W (0b00010)
ADC1_TP_LOW (BLOCK3):                    ADC1 150mV reading                                 = 346 R/W (0b0010001)
ADC1_TP_HIGH (BLOCK3):                   ADC1 850mV reading                                 = 3285 R/W (0b000000101)
ADC2_TP_LOW (BLOCK3):                    ADC2 150mV reading                                 = 449 R/W (0b0000111)
ADC2_TP_HIGH (BLOCK3):                   ADC2 850mV reading                                 = 3362 R/W (0b111110101)

Config fuses:
XPD_SDIO_FORCE (BLOCK0):                 Ignore MTDI pin (GPIO12) for VDD_SDIO on reset     = False R/W (0b0)
XPD_SDIO_REG (BLOCK0):                   If XPD_SDIO_FORCE, enable VDD_SDIO reg on reset    = False R/W (0b0)
XPD_SDIO_TIEH (BLOCK0):                  If XPD_SDIO_FORCE & XPD_SDIO_REG                   = 1.8V R/W (0b0)
CLK8M_FREQ (BLOCK0):                     8MHz clock freq override                           = 53 R/W (0x35)
SPI_PAD_CONFIG_CLK (BLOCK0):             Override SD_CLK pad (GPIO6/SPICLK)                 = 0 R/W (0b00000)
SPI_PAD_CONFIG_Q (BLOCK0):               Override SD_DATA_0 pad (GPIO7/SPIQ)                = 0 R/W (0b00000)
SPI_PAD_CONFIG_D (BLOCK0):               Override SD_DATA_1 pad (GPIO8/SPID)                = 0 R/W (0b00000)
SPI_PAD_CONFIG_HD (BLOCK0):              Override SD_DATA_2 pad (GPIO9/SPIHD)               = 0 R/W (0b00000)
SPI_PAD_CONFIG_CS0 (BLOCK0):             Override SD_CMD pad (GPIO11/SPICS0)                = 0 R/W (0b00000)
DISABLE_SDIO_HOST (BLOCK0):              Disable SDIO host                                  = False R/W (0b0)

Efuse fuses:
WR_DIS (BLOCK0):                         Efuse write disable mask                           = 0 R/W (0x0000)
RD_DIS (BLOCK0):                         Efuse read disable mask                            = 0 R/W (0x0)
CODING_SCHEME (BLOCK0):                  Efuse variable block length scheme
= 3/4 (BLK1-3 len=192 bits) R/W (0b01)
KEY_STATUS (BLOCK0):                     Usage of efuse block 3 (reserved)                  = False R/W (0b0)

Identity fuses:
MAC (BLOCK0):                            Factory MAC Address
= 84:0d:8e:18:8e:44 (CRC 0xad OK) R/W
MAC_CRC (BLOCK0):                        CRC8 for factory MAC address                       = 173 R/W (0xad)
CHIP_VER_REV1 (BLOCK0):                  Silicon Revision 1                                 = True R/W (0b1)
CHIP_VER_REV2 (BLOCK0):                  Silicon Revision 2                                 = False R/W (0b0)
CHIP_VERSION (BLOCK0):                   Reserved for future chip versions                  = 2 R/W (0b10)
CHIP_PACKAGE (BLOCK0):                   Chip package identifier                            = 0 R/W (0b000)
MAC_VERSION (BLOCK3):                    Version of the MAC field                           = 0 R/W (0x00)

Security fuses:
FLASH_CRYPT_CNT (BLOCK0):                Flash encryption mode counter                      = 0 R/W (0b0000000)
UART_DOWNLOAD_DIS (BLOCK0):              Disable UART download mode (ESP32 rev3 only)       = False R/W (0b0)
FLASH_CRYPT_CONFIG (BLOCK0):             Flash encryption config (key tweak bits)           = 0 R/W (0x0)
CONSOLE_DEBUG_DISABLE (BLOCK0):          Disable ROM BASIC interpreter fallback             = True R/W (0b1)
ABS_DONE_0 (BLOCK0):                     Secure boot V1 is enabled for bootloader image     = False R/W (0b0)
ABS_DONE_1 (BLOCK0):                     Secure boot V2 is enabled for bootloader image     = False R/W (0b0)
JTAG_DISABLE (BLOCK0):                   Disable JTAG                                       = False R/W (0b0)
DISABLE_DL_ENCRYPT (BLOCK0):             Disable flash encryption in UART bootloader        = False R/W (0b0)
DISABLE_DL_DECRYPT (BLOCK0):             Disable flash decryption in UART bootloader        = False R/W (0b0)
DISABLE_DL_CACHE (BLOCK0):               Disable flash cache in UART bootloader             = False R/W (0b0)
BLOCK1 (BLOCK1):                         Flash encryption key
= 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 R/W
BLOCK2 (BLOCK2):                         Secure boot key
= 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 R/W
BLOCK3 (BLOCK3):                         Variable Block 3
= 00 00 00 00 00 00 00 00 00 00 00 00 91 02 87 fa 00 00 00 00 00 00 00 00 R/W

Flash voltage (VDD_SDIO) determined by GPIO12 on reset (High for 1.8V, Low/NC for 3.3V).

To get a dump for all eFuse registers.

espefuse.py -p PORT dump

Connecting........_
Detecting chip type... ESP32
BLOCK0          (                ) [0 ] read_regs: 00000000 8e188e44 00ad840d 0000e000 00000235 00000000 00000005
BLOCK1          (flash_encryption) [1 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK2          (secure_boot_v1 s) [2 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK3          (                ) [3 ] read_regs: 00000000 00000000 00000000 fa870291 00000000 00000000
espefuse.py v3.1-dev

Header File

components/efuse/esp32/include/esp_efuse.h

Enumerations

enum esp_efuse_block_t

Type of eFuse blocks for ESP32.

Values:

enumerator EFUSE_BLK0: Number of eFuse block. Reserved.

enumerator EFUSE_BLK1: Number of eFuse block. Used for Flash Encryption. If not using that Flash Encryption feature, they can be used for another purpose.

enumerator EFUSE_BLK_KEY0: Number of eFuse block. Used for Flash Encryption. If not using that Flash Encryption feature, they can be used for another purpose.

enumerator EFUSE_BLK_ENCRYPT_FLASH: Number of eFuse block. Used for Flash Encryption. If not using that Flash Encryption feature, they can be used for another purpose.

enumerator EFUSE_BLK2: Number of eFuse block. Used for Secure Boot. If not using that Secure Boot feature, they can be used for another purpose.

enumerator EFUSE_BLK_KEY1: Number of eFuse block. Used for Secure Boot. If not using that Secure Boot feature, they can be used for another purpose.

enumerator EFUSE_BLK_SECURE_BOOT: Number of eFuse block. Used for Secure Boot. If not using that Secure Boot feature, they can be used for another purpose.

enumerator EFUSE_BLK3: Number of eFuse block. Uses for the purpose of the user.

enumerator EFUSE_BLK_KEY2: Number of eFuse block. Uses for the purpose of the user.

enumerator EFUSE_BLK_KEY_MAX

enumerator EFUSE_BLK_MAX

enum esp_efuse_coding_scheme_t

Type of coding scheme.

Values:

enumerator EFUSE_CODING_SCHEME_NONE: None

enumerator EFUSE_CODING_SCHEME_3_4: 3/4 coding

enumerator EFUSE_CODING_SCHEME_REPEAT: Repeat coding

enum esp_efuse_purpose_t

Type of key purpose (virtual because ESP32 has only fixed purposes for blocks)

Values:

enumerator ESP_EFUSE_KEY_PURPOSE_USER: BLOCK3

enumerator ESP_EFUSE_KEY_PURPOSE_SYSTEM: BLOCK0

enumerator ESP_EFUSE_KEY_PURPOSE_FLASH_ENCRYPTION: BLOCK1

enumerator ESP_EFUSE_KEY_PURPOSE_SECURE_BOOT_V2: BLOCK2

enumerator ESP_EFUSE_KEY_PURPOSE_MAX: MAX PURPOSE

Header File

components/efuse/include/esp_efuse.h

Functions

esp_err_t esp_efuse_read_field_blob(const esp_efuse_desc_t *field[], void *dst, size_t dst_size_bits)

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.

备注

Please note that reading in the batch mode does not show uncommitted changes.

参数

field – [in] A pointer to the structure describing the fields of efuse.
dst – [out] A pointer to array that will contain the result of reading.
dst_size_bits – [in] 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.

返回

ESP_OK: The operation was successfully completed.
ESP_ERR_INVALID_ARG: Error in the passed arguments.

bool esp_efuse_read_field_bit(const esp_efuse_desc_t *field[])

Read a single bit eFuse field as a boolean value.

备注

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.

备注

If assertions are enabled and the parameter is invalid, execution will abort

备注

Please note that reading in the batch mode does not show uncommitted changes.

参数

field – [in] A pointer to the structure describing the fields of efuse.

返回

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.

esp_err_t esp_efuse_read_field_cnt(const esp_efuse_desc_t *field[], size_t *out_cnt)

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.

备注

Please note that reading in the batch mode does not show uncommitted changes.

参数

field – [in] A pointer to the structure describing the fields of efuse.
out_cnt – [out] A pointer that will contain the number of programmed as “1” bits.

返回

ESP_OK: The operation was successfully completed.
ESP_ERR_INVALID_ARG: Error in the passed arguments.

esp_err_t esp_efuse_write_field_blob(const esp_efuse_desc_t *field[], const void *src, size_t src_size_bits)

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.

参数

field – [in] A pointer to the structure describing the fields of efuse.
src – [in] A pointer to array that contains the data for writing.
src_size_bits – [in] The number of bits required to write.

返回

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_cnt(const esp_efuse_desc_t *field[], size_t cnt)

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.

参数

field – [in] A pointer to the structure describing the fields of efuse.
cnt – [in] Required number of programmed as “1” bits.

返回

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_bit(const esp_efuse_desc_t *field[])

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.

参数

field – [in] Pointer to the structure describing the efuse field.

返回

ESP_OK: The operation was successfully completed, or the bit was already set to value 1.
ESP_ERR_INVALID_ARG: Error in the passed arugments, including if the efuse field is not 1 bit wide.

esp_err_t esp_efuse_set_write_protect(esp_efuse_block_t blk)

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.

参数

blk – [in] Block number of eFuse. (EFUSE_BLK1, EFUSE_BLK2 and EFUSE_BLK3)

返回

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)

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.

参数

blk – [in] Block number of eFuse. (EFUSE_BLK1, EFUSE_BLK2 and EFUSE_BLK3)

返回

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.

int esp_efuse_get_field_size(const esp_efuse_desc_t *field[])

Returns the number of bits used by field.

参数: field – [in] A pointer to the structure describing the fields of efuse.
返回: Returns the number of bits used by field.

uint32_t esp_efuse_read_reg(esp_efuse_block_t blk, unsigned int num_reg)

Returns value of efuse register.

This is a thread-safe implementation. Example: EFUSE_BLK2_RDATA3_REG where (blk=2, num_reg=3)

备注

Please note that reading in the batch mode does not show uncommitted changes.

参数

blk – [in] Block number of eFuse.
num_reg – [in] The register number in the block.

返回

Value of register

esp_err_t esp_efuse_write_reg(esp_efuse_block_t blk, unsigned int num_reg, uint32_t val)

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)

参数

blk – [in] Block number of eFuse.
num_reg – [in] The register number in the block.
val – [in] Value to write.

返回

ESP_OK: The operation was successfully completed.
ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.

esp_efuse_coding_scheme_t esp_efuse_get_coding_scheme(esp_efuse_block_t blk)

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.

参数: blk – [in] Block number of eFuse.
返回: Return efuse coding scheme for blocks

esp_err_t esp_efuse_read_block(esp_efuse_block_t blk, void *dst_key, size_t offset_in_bits, size_t size_bits)

Read key to efuse block starting at the offset and the required size.

备注

Please note that reading in the batch mode does not show uncommitted changes.

参数

blk – [in] Block number of eFuse.
dst_key – [in] A pointer to array that will contain the result of reading.
offset_in_bits – [in] Start bit in block.
size_bits – [in] The number of bits required to read.

返回

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_write_block(esp_efuse_block_t blk, const void *src_key, size_t offset_in_bits, size_t size_bits)

Write key to efuse block starting at the offset and the required size.

参数

blk – [in] Block number of eFuse.
src_key – [in] A pointer to array that contains the key for writing.
offset_in_bits – [in] Start bit in block.
size_bits – [in] The number of bits required to write.

返回

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

uint32_t esp_efuse_get_pkg_ver(void)

Returns chip package from efuse.

返回: chip package

void esp_efuse_reset(void)

Reset efuse write registers.

Efuse write registers are written to zero, to negate any changes that have been staged here.

备注

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_disable_basic_rom_console(void)

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.

esp_err_t esp_efuse_disable_rom_download_mode(void)

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.

备注

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.

备注

If ROM Download Mode is already disabled, this function does nothing and returns success.

返回

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_set_rom_log_scheme(esp_efuse_rom_log_scheme_t log_scheme)

Set boot ROM log scheme via eFuse.

备注

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.

参数

log_scheme – Supported ROM log scheme

返回

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

uint32_t esp_efuse_read_secure_version(void)

Return secure_version from efuse field.

返回: Secure version from efuse field

bool esp_efuse_check_secure_version(uint32_t secure_version)

Check secure_version from app and secure_version and from efuse field.

参数

secure_version – Secure version from app.

返回

True: If version of app is equal or more then secure_version from efuse.

esp_err_t esp_efuse_update_secure_version(uint32_t secure_version)

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.

参数

secure_version – [in] Secure version from app.

返回

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_batch_write_begin(void)

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: 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.

// 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.

备注

Please note that reading in the batch mode does not show uncommitted changes.

返回

ESP_OK: Successful.

esp_err_t esp_efuse_batch_write_cancel(void)

Reset the batch mode of writing fields.

It will reset the batch writing mode and any written changes.

返回

ESP_OK: Successful.
ESP_ERR_INVALID_STATE: Tha batch mode was not set.

esp_err_t esp_efuse_batch_write_commit(void)

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.

返回

ESP_OK: Successful.
ESP_ERR_INVALID_STATE: The deferred writing mode was not set.

bool esp_efuse_block_is_empty(esp_efuse_block_t block)

Checks that the given block is empty.

返回

True: The block is empty.
False: The block is not empty or was an error.

bool esp_efuse_get_key_dis_read(esp_efuse_block_t block)

Returns a read protection for the key block.

参数: block – [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
返回: True: The key block is read protected False: The key block is readable.

esp_err_t esp_efuse_set_key_dis_read(esp_efuse_block_t block)

Sets a read protection for the key block.

参数

block – [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX

返回

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.

bool esp_efuse_get_key_dis_write(esp_efuse_block_t block)

Returns a write protection for the key block.

参数: block – [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
返回: True: The key block is write protected False: The key block is writeable.

esp_err_t esp_efuse_set_key_dis_write(esp_efuse_block_t block)

Sets a write protection for the key block.

参数

block – [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX

返回

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.

bool esp_efuse_key_block_unused(esp_efuse_block_t block)

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)

参数

block – key block to check.

返回

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_find_purpose(esp_efuse_purpose_t purpose, esp_efuse_block_t *block)

Find a key block with the particular purpose set.

参数

purpose – [in] Purpose to search for.
block – [out] 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.

返回

True: If found,
False: If not found (value at block pointer is unchanged).

bool esp_efuse_get_keypurpose_dis_write(esp_efuse_block_t block)

Returns a write protection of the key purpose field for an efuse key block.

备注

For ESP32: no keypurpose, it returns always True.

参数: block – [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
返回: True: The key purpose is write protected. False: The key purpose is writeable.

esp_efuse_purpose_t esp_efuse_get_key_purpose(esp_efuse_block_t block)

Returns the current purpose set for an efuse key block.

参数

block – [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX

返回

Value: If Successful, it returns the value of the purpose related to the given key block.
ESP_EFUSE_KEY_PURPOSE_MAX: Otherwise.

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)

Program a block of key data to an efuse block.

The burn of a key, protection bits, and a purpose happens in batch mode.

参数

block – [in] 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).
purpose – [in] Purpose to set for this key. Purpose must be already unset.
key – [in] Pointer to data to write.
key_size_bytes – [in] Bytes length of data to write.

返回

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_t esp_efuse_write_keys(const esp_efuse_purpose_t purposes[], uint8_t keys[][32], unsigned number_of_keys)

Program keys to unused efuse blocks.

The burn of keys, protection bits, and purposes happens in batch mode.

参数

purposes – [in] Array of purposes (purpose[number_of_keys]).
keys – [in] Array of keys (uint8_t keys[number_of_keys][32]). Each key is 32 bytes long.
number_of_keys – [in] The number of keys to write (up to 6 keys).

返回

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_t esp_efuse_check_errors(void)

Checks eFuse errors in BLOCK0.

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.

备注

Refers to ESP32-C3 only.

返回

ESP_OK: No errors in BLOCK0.
ESP_FAIL: Error in BLOCK0 requiring reboot.

Structures

struct esp_efuse_desc_t

Type definition for an eFuse field.

Public Members

esp_efuse_block_t efuse_block: Block of eFuse

uint8_t bit_start: Start bit [0..255]

uint16_t bit_count: Length of bit field [1..-]

Macros

ESP_ERR_EFUSE: Base error code for efuse api.

ESP_OK_EFUSE_CNT: OK the required number of bits is set.

ESP_ERR_EFUSE_CNT_IS_FULL: Error field is full.

ESP_ERR_EFUSE_REPEATED_PROG: Error repeated programming of programmed bits is strictly forbidden.

ESP_ERR_CODING: Error while a encoding operation.

ESP_ERR_NOT_ENOUGH_UNUSED_KEY_BLOCKS: Error not enough unused key blocks available

ESP_ERR_DAMAGED_READING: 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.

Enumerations

enum esp_efuse_rom_log_scheme_t

Type definition for ROM log scheme.

Values:

enumerator ESP_EFUSE_ROM_LOG_ALWAYS_ON: Always enable ROM logging

enumerator ESP_EFUSE_ROM_LOG_ON_GPIO_LOW: ROM logging is enabled when specific GPIO level is low during start up

enumerator ESP_EFUSE_ROM_LOG_ON_GPIO_HIGH: ROM logging is enabled when specific GPIO level is high during start up

enumerator ESP_EFUSE_ROM_LOG_ALWAYS_OFF: Disable ROM logging permanently

提供有关此文档的反馈