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-S2 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-S2 Technical Reference Manual > eFuse Controller (eFuse) [PDF]. Some eFuse bits are available for user applications.
ESP32-S2 has 11 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 entirely for system purposes;
EFUSE_BLK2 is used entirely for system purposes;
EFUSE_BLK3 (also named EFUSE_BLK_USER_DATA) can be used for user purposes;
EFUSE_BLK4 (also named EFUSE_BLK_KEY0) can be used as key (for secure_boot or flash_encryption) or for user purposes;
EFUSE_BLK5 (also named EFUSE_BLK_KEY1) can be used as key (for secure_boot or flash_encryption) or for user purposes;
EFUSE_BLK6 (also named EFUSE_BLK_KEY2) can be used as key (for secure_boot or flash_encryption) or for user purposes;
EFUSE_BLK7 (also named EFUSE_BLK_KEY3) can be used as key (for secure_boot or flash_encryption) or for user purposes;
EFUSE_BLK8 (also named EFUSE_BLK_KEY4) can be used as key (for secure_boot or flash_encryption) or for user purposes;
EFUSE_BLK9 (also named EFUSE_BLK_KEY5) can be used as key (for secure_boot or flash_encryption) or for user purposes;
EFUSE_BLK10 (also named EFUSE_BLK_SYS_DATA_PART2) is reseved for system purposes.
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_BLK10), 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_FACTORYfield in the common table). The field_name supports structured format using . to show that the field belongs to another field (seeWR_DISandRD_DISin the common table).- efuse_block
Block number. It determines where the eFuse bits will be placed for this field. Available EFUSE_BLK0..EFUSE_BLK10.
- 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_LENin this case, the field length will have the maximum block length.
- 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 esp32s2 esp32s2/esp_efuse_table.csv
After generation in the folder $IDF_PATH/components/efuse/esp32s2 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 esp32s2 esp32s2/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
Coding schemes are used to protect against data corruption. ESP32-S2 supports two coding schemes:
None. EFUSE_BLK0 is stored with four backups, meaning each bit is stored four times. This backup scheme is automatically applied by the hardware and is not visible to software. EFUSE_BLK0 can be written many times.RS. EFUSE_BLK1 - EFUSE_BLK10 use Reed-Solomon coding scheme that supports up to 5 bytes of automatic error correction. Software will encode the 32-byte EFUSE_BLKx using RS (44, 32) to generate a 12-byte check code, and then burn the EFUSE_BLKx and the check code into eFuse at the same time. The eFuse Controller automatically decodes the RS encoding and applies error correction when reading back the eFuse block. Because the RS check codes are generated across the entire 256-bit eFuse block, each block can only be written to one time.
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 Reed-Solomon 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 blockesp_efuse_write_keys()- Programs keys to unused eFuse blocksesp_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().
eFuse API for keys
EFUSE_BLK_KEY0 - EFUSE_BLK_KEY5 are intended to keep up to 6 keys with a length of 256-bits. Each key has an ESP_EFUSE_KEY_PURPOSE_x field which defines the purpose of these keys. The purpose field is described in esp_efuse_purpose_t.
The purposes like ESP_EFUSE_KEY_PURPOSE_XTS_AES_... are used for flash encryption.
The purposes like ESP_EFUSE_KEY_PURPOSE_SECURE_BOOT_DIGEST... are used for secure boot.
There are some eFuse APIs useful to work with states of keys.
esp_efuse_get_purpose_field()- Returns a pointer to a key purpose for an eFuse key block.esp_efuse_get_key()- Returns a pointer to a key block.esp_efuse_set_key_purpose()- Sets a key purpose for an eFuse key block.esp_efuse_set_keypurpose_dis_write()- Sets a write protection of the key purpose field for an eFuse key block.esp_efuse_find_unused_key_block()- Search for an unused key block and return the first one found.esp_efuse_count_unused_key_blocks()- Returns the number of unused eFuse key blocks in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
esp_efuse_get_digest_revoke()- Returns the status of the Secure Boot public key digest revocation bit.esp_efuse_set_digest_revoke()- Sets the Secure Boot public key digest revocation bit.esp_efuse_get_write_protect_of_digest_revoke()- Returns a write protection of the Secure Boot public key digest revocation bit.esp_efuse_set_write_protect_of_digest_revoke()- Sets a write protection of the Secure Boot public key digest revocation bit.
How to add a new field
Find a free bits for field. Show esp_efuse_table.csv file or run
idf.py show-efuse-tableor the next command:
$ ./efuse_table_gen.py esp32s2/esp_efuse_table.csv --info
Parsing efuse CSV input file $IDF_PATH/components/efuse/esp32s2/esp_efuse_table.csv ...
Verifying efuse table...
Max number of bits in BLK 256
Sorted efuse table:
# field_name efuse_block bit_start bit_count
1 WR_DIS EFUSE_BLK0 0 32
2 WR_DIS.RD_DIS EFUSE_BLK0 0 1
3 WR_DIS.DIS_ICACHE EFUSE_BLK0 2 1
4 WR_DIS.DIS_DCACHE EFUSE_BLK0 2 1
5 WR_DIS.DIS_DOWNLOAD_ICACHE EFUSE_BLK0 2 1
6 WR_DIS.DIS_DOWNLOAD_DCACHE EFUSE_BLK0 2 1
7 WR_DIS.DIS_FORCE_DOWNLOAD EFUSE_BLK0 2 1
8 WR_DIS.DIS_USB EFUSE_BLK0 2 1
9 WR_DIS.DIS_TWAI EFUSE_BLK0 2 1
10 WR_DIS.DIS_BOOT_REMAP EFUSE_BLK0 2 1
11 WR_DIS.SOFT_DIS_JTAG EFUSE_BLK0 2 1
12 WR_DIS.HARD_DIS_JTAG EFUSE_BLK0 2 1
13 WR_DIS.DIS_DOWNLOAD_MANUAL_ENCRYPT EFUSE_BLK0 2 1
14 WR_DIS.VDD_SPI_XPD EFUSE_BLK0 3 1
15 WR_DIS.VDD_SPI_TIEH EFUSE_BLK0 3 1
16 WR_DIS.VDD_SPI_FORCE EFUSE_BLK0 3 1
17 WR_DIS.WDT_DELAY_SEL EFUSE_BLK0 3 1
18 WR_DIS.SPI_BOOT_CRYPT_CNT EFUSE_BLK0 4 1
19 WR_DIS.SECURE_BOOT_KEY_REVOKE0 EFUSE_BLK0 5 1
20 WR_DIS.SECURE_BOOT_KEY_REVOKE1 EFUSE_BLK0 6 1
21 WR_DIS.SECURE_BOOT_KEY_REVOKE2 EFUSE_BLK0 7 1
22 WR_DIS.KEY_PURPOSE_0 EFUSE_BLK0 8 1
23 WR_DIS.KEY_PURPOSE_1 EFUSE_BLK0 9 1
24 WR_DIS.KEY_PURPOSE_2 EFUSE_BLK0 10 1
25 WR_DIS.KEY_PURPOSE_3 EFUSE_BLK0 11 1
26 WR_DIS.KEY_PURPOSE_4 EFUSE_BLK0 12 1
27 WR_DIS.KEY_PURPOSE_5 EFUSE_BLK0 13 1
28 WR_DIS.SECURE_BOOT_EN EFUSE_BLK0 15 1
29 WR_DIS.SECURE_BOOT_AGGRESSIVE_REVOKE EFUSE_BLK0 16 1
30 WR_DIS.FLASH_TPUW EFUSE_BLK0 18 1
31 WR_DIS.DIS_DOWNLOAD_MODE EFUSE_BLK0 18 1
32 WR_DIS.DIS_LEGACY_SPI_BOOT EFUSE_BLK0 18 1
33 WR_DIS.UART_PRINT_CHANNEL EFUSE_BLK0 18 1
34 WR_DIS.DIS_USB_DOWNLOAD_MODE EFUSE_BLK0 18 1
35 WR_DIS.ENABLE_SECURITY_DOWNLOAD EFUSE_BLK0 18 1
36 WR_DIS.UART_PRINT_CONTROL EFUSE_BLK0 18 1
37 WR_DIS.PIN_POWER_SELECTION EFUSE_BLK0 18 1
38 WR_DIS.FLASH_TYPE EFUSE_BLK0 18 1
39 WR_DIS.FORCE_SEND_RESUME EFUSE_BLK0 18 1
40 WR_DIS.SECURE_VERSION EFUSE_BLK0 18 1
41 WR_DIS.BLK1 EFUSE_BLK0 20 1
42 WR_DIS.MAC EFUSE_BLK0 20 1
43 WR_DIS.SPI_PAD_CONFIG_CLK EFUSE_BLK0 20 1
44 WR_DIS.SPI_PAD_CONFIG_Q EFUSE_BLK0 20 1
45 WR_DIS.SPI_PAD_CONFIG_D EFUSE_BLK0 20 1
46 WR_DIS.SPI_PAD_CONFIG_CS EFUSE_BLK0 20 1
47 WR_DIS.SPI_PAD_CONFIG_HD EFUSE_BLK0 20 1
48 WR_DIS.SPI_PAD_CONFIG_WP EFUSE_BLK0 20 1
49 WR_DIS.SPI_PAD_CONFIG_DQS EFUSE_BLK0 20 1
50 WR_DIS.SPI_PAD_CONFIG_D4 EFUSE_BLK0 20 1
51 WR_DIS.SPI_PAD_CONFIG_D5 EFUSE_BLK0 20 1
52 WR_DIS.SPI_PAD_CONFIG_D6 EFUSE_BLK0 20 1
53 WR_DIS.SPI_PAD_CONFIG_D7 EFUSE_BLK0 20 1
54 WR_DIS.WAFER_VERSION_MAJOR EFUSE_BLK0 20 1
55 WR_DIS.WAFER_VERSION_MINOR_HI EFUSE_BLK0 20 1
56 WR_DIS.FLASH_VERSION EFUSE_BLK0 20 1
57 WR_DIS.BLK_VERSION_MAJOR EFUSE_BLK0 20 1
58 WR_DIS.PSRAM_VERSION EFUSE_BLK0 20 1
59 WR_DIS.PKG_VERSION EFUSE_BLK0 20 1
60 WR_DIS.WAFER_VERSION_MINOR_LO EFUSE_BLK0 20 1
61 WR_DIS.SYS_DATA_PART1 EFUSE_BLK0 21 1
62 WR_DIS.OPTIONAL_UNIQUE_ID EFUSE_BLK0 21 1
63 WR_DIS.ADC_CALIB EFUSE_BLK0 21 1
64 WR_DIS.BLK_VERSION_MINOR EFUSE_BLK0 21 1
65 WR_DIS.TEMP_CALIB EFUSE_BLK0 21 1
66 WR_DIS.RTCCALIB_V1IDX_A10H EFUSE_BLK0 21 1
67 WR_DIS.RTCCALIB_V1IDX_A11H EFUSE_BLK0 21 1
68 WR_DIS.RTCCALIB_V1IDX_A12H EFUSE_BLK0 21 1
69 WR_DIS.RTCCALIB_V1IDX_A13H EFUSE_BLK0 21 1
70 WR_DIS.RTCCALIB_V1IDX_A20H EFUSE_BLK0 21 1
71 WR_DIS.RTCCALIB_V1IDX_A21H EFUSE_BLK0 21 1
72 WR_DIS.RTCCALIB_V1IDX_A22H EFUSE_BLK0 21 1
73 WR_DIS.RTCCALIB_V1IDX_A23H EFUSE_BLK0 21 1
74 WR_DIS.RTCCALIB_V1IDX_A10L EFUSE_BLK0 21 1
75 WR_DIS.RTCCALIB_V1IDX_A11L EFUSE_BLK0 21 1
76 WR_DIS.RTCCALIB_V1IDX_A12L EFUSE_BLK0 21 1
77 WR_DIS.RTCCALIB_V1IDX_A13L EFUSE_BLK0 21 1
78 WR_DIS.RTCCALIB_V1IDX_A20L EFUSE_BLK0 21 1
79 WR_DIS.RTCCALIB_V1IDX_A21L EFUSE_BLK0 21 1
80 WR_DIS.RTCCALIB_V1IDX_A22L EFUSE_BLK0 21 1
81 WR_DIS.RTCCALIB_V1IDX_A23L EFUSE_BLK0 21 1
82 WR_DIS.BLOCK_USR_DATA EFUSE_BLK0 22 1
83 WR_DIS.CUSTOM_MAC EFUSE_BLK0 22 1
84 WR_DIS.BLOCK_KEY0 EFUSE_BLK0 23 1
85 WR_DIS.BLOCK_KEY1 EFUSE_BLK0 24 1
86 WR_DIS.BLOCK_KEY2 EFUSE_BLK0 25 1
87 WR_DIS.BLOCK_KEY3 EFUSE_BLK0 26 1
88 WR_DIS.BLOCK_KEY4 EFUSE_BLK0 27 1
89 WR_DIS.BLOCK_KEY5 EFUSE_BLK0 28 1
90 WR_DIS.BLOCK_SYS_DATA2 EFUSE_BLK0 29 1
91 WR_DIS.USB_EXCHG_PINS EFUSE_BLK0 30 1
92 WR_DIS.USB_EXT_PHY_ENABLE EFUSE_BLK0 30 1
93 WR_DIS.USB_FORCE_NOPERSIST EFUSE_BLK0 30 1
94 WR_DIS.BLOCK0_VERSION EFUSE_BLK0 30 1
95 RD_DIS EFUSE_BLK0 32 7
96 RD_DIS.BLOCK_KEY0 EFUSE_BLK0 32 1
97 RD_DIS.BLOCK_KEY1 EFUSE_BLK0 33 1
98 RD_DIS.BLOCK_KEY2 EFUSE_BLK0 34 1
99 RD_DIS.BLOCK_KEY3 EFUSE_BLK0 35 1
100 RD_DIS.BLOCK_KEY4 EFUSE_BLK0 36 1
101 RD_DIS.BLOCK_KEY5 EFUSE_BLK0 37 1
102 RD_DIS.BLOCK_SYS_DATA2 EFUSE_BLK0 38 1
103 DIS_ICACHE EFUSE_BLK0 40 1
104 DIS_DCACHE EFUSE_BLK0 41 1
105 DIS_DOWNLOAD_ICACHE EFUSE_BLK0 42 1
106 DIS_DOWNLOAD_DCACHE EFUSE_BLK0 43 1
107 DIS_FORCE_DOWNLOAD EFUSE_BLK0 44 1
108 DIS_USB EFUSE_BLK0 45 1
109 DIS_TWAI EFUSE_BLK0 46 1
110 DIS_BOOT_REMAP EFUSE_BLK0 47 1
111 SOFT_DIS_JTAG EFUSE_BLK0 49 1
112 HARD_DIS_JTAG EFUSE_BLK0 50 1
113 DIS_DOWNLOAD_MANUAL_ENCRYPT EFUSE_BLK0 51 1
114 USB_EXCHG_PINS EFUSE_BLK0 56 1
115 USB_EXT_PHY_ENABLE EFUSE_BLK0 57 1
116 USB_FORCE_NOPERSIST EFUSE_BLK0 58 1
117 BLOCK0_VERSION EFUSE_BLK0 59 2
118 VDD_SPI_XPD EFUSE_BLK0 68 1
119 VDD_SPI_TIEH EFUSE_BLK0 69 1
120 VDD_SPI_FORCE EFUSE_BLK0 70 1
121 WDT_DELAY_SEL EFUSE_BLK0 80 2
122 SPI_BOOT_CRYPT_CNT EFUSE_BLK0 82 3
123 SECURE_BOOT_KEY_REVOKE0 EFUSE_BLK0 85 1
124 SECURE_BOOT_KEY_REVOKE1 EFUSE_BLK0 86 1
125 SECURE_BOOT_KEY_REVOKE2 EFUSE_BLK0 87 1
126 KEY_PURPOSE_0 EFUSE_BLK0 88 4
127 KEY_PURPOSE_1 EFUSE_BLK0 92 4
128 KEY_PURPOSE_2 EFUSE_BLK0 96 4
129 KEY_PURPOSE_3 EFUSE_BLK0 100 4
130 KEY_PURPOSE_4 EFUSE_BLK0 104 4
131 KEY_PURPOSE_5 EFUSE_BLK0 108 4
132 SECURE_BOOT_EN EFUSE_BLK0 116 1
133 SECURE_BOOT_AGGRESSIVE_REVOKE EFUSE_BLK0 117 1
134 FLASH_TPUW EFUSE_BLK0 124 4
135 DIS_DOWNLOAD_MODE EFUSE_BLK0 128 1
136 DIS_LEGACY_SPI_BOOT EFUSE_BLK0 129 1
137 UART_PRINT_CHANNEL EFUSE_BLK0 130 1
138 DIS_USB_DOWNLOAD_MODE EFUSE_BLK0 132 1
139 ENABLE_SECURITY_DOWNLOAD EFUSE_BLK0 133 1
140 UART_PRINT_CONTROL EFUSE_BLK0 134 2
141 PIN_POWER_SELECTION EFUSE_BLK0 136 1
142 FLASH_TYPE EFUSE_BLK0 137 1
143 FORCE_SEND_RESUME EFUSE_BLK0 138 1
144 SECURE_VERSION EFUSE_BLK0 139 16
145 DISABLE_WAFER_VERSION_MAJOR EFUSE_BLK0 160 1
146 DISABLE_BLK_VERSION_MAJOR EFUSE_BLK0 161 1
147 MAC EFUSE_BLK1 0 8
148 MAC EFUSE_BLK1 8 8
149 MAC EFUSE_BLK1 16 8
150 MAC EFUSE_BLK1 24 8
151 MAC EFUSE_BLK1 32 8
152 MAC EFUSE_BLK1 40 8
153 SPI_PAD_CONFIG_CLK EFUSE_BLK1 48 6
154 SPI_PAD_CONFIG_Q EFUSE_BLK1 54 6
155 SPI_PAD_CONFIG_D EFUSE_BLK1 60 6
156 SPI_PAD_CONFIG_CS EFUSE_BLK1 66 6
157 SPI_PAD_CONFIG_HD EFUSE_BLK1 72 6
158 SPI_PAD_CONFIG_WP EFUSE_BLK1 78 6
159 SPI_PAD_CONFIG_DQS EFUSE_BLK1 84 6
160 SPI_PAD_CONFIG_D4 EFUSE_BLK1 90 6
161 SPI_PAD_CONFIG_D5 EFUSE_BLK1 96 6
162 SPI_PAD_CONFIG_D6 EFUSE_BLK1 102 6
163 SPI_PAD_CONFIG_D7 EFUSE_BLK1 108 6
164 WAFER_VERSION_MAJOR EFUSE_BLK1 114 2
165 WAFER_VERSION_MINOR_HI EFUSE_BLK1 116 1
166 FLASH_VERSION EFUSE_BLK1 117 4
167 BLK_VERSION_MAJOR EFUSE_BLK1 121 2
168 PSRAM_VERSION EFUSE_BLK1 124 4
169 PKG_VERSION EFUSE_BLK1 128 4
170 WAFER_VERSION_MINOR_LO EFUSE_BLK1 132 3
171 SYS_DATA_PART2 EFUSE_BLK10 0 256
172 OPTIONAL_UNIQUE_ID EFUSE_BLK2 0 128
173 ADC_CALIB EFUSE_BLK2 128 4
174 BLK_VERSION_MINOR EFUSE_BLK2 132 3
175 TEMP_CALIB EFUSE_BLK2 135 9
176 RTCCALIB_V1IDX_A10H EFUSE_BLK2 144 8
177 RTCCALIB_V1IDX_A11H EFUSE_BLK2 152 8
178 RTCCALIB_V1IDX_A12H EFUSE_BLK2 160 8
179 RTCCALIB_V1IDX_A13H EFUSE_BLK2 168 8
180 RTCCALIB_V1IDX_A20H EFUSE_BLK2 176 8
181 RTCCALIB_V1IDX_A21H EFUSE_BLK2 184 8
182 RTCCALIB_V1IDX_A22H EFUSE_BLK2 192 8
183 RTCCALIB_V1IDX_A23H EFUSE_BLK2 200 8
184 RTCCALIB_V1IDX_A10L EFUSE_BLK2 208 6
185 RTCCALIB_V1IDX_A11L EFUSE_BLK2 214 6
186 RTCCALIB_V1IDX_A12L EFUSE_BLK2 220 6
187 RTCCALIB_V1IDX_A13L EFUSE_BLK2 226 6
188 RTCCALIB_V1IDX_A20L EFUSE_BLK2 232 6
189 RTCCALIB_V1IDX_A21L EFUSE_BLK2 238 6
190 RTCCALIB_V1IDX_A22L EFUSE_BLK2 244 6
191 RTCCALIB_V1IDX_A23L EFUSE_BLK2 250 6
192 USER_DATA EFUSE_BLK3 0 256
193 USER_DATA.MAC_CUSTOM EFUSE_BLK3 200 48
194 KEY0 EFUSE_BLK4 0 256
195 KEY1 EFUSE_BLK5 0 256
196 KEY2 EFUSE_BLK6 0 256
197 KEY3 EFUSE_BLK7 0 256
198 KEY4 EFUSE_BLK8 0 256
199 KEY5 EFUSE_BLK9 0 256
Used bits in efuse table:
EFUSE_BLK0
[0 31] [0 0] [2 2] ... [32 38] [40 47] [49 51] [56 60] [68 70] [80 111] [116 117] [124 130] [132 154] [160 161]
EFUSE_BLK1
[0 122] [124 134]
EFUSE_BLK10
[0 255]
EFUSE_BLK2
[0 255]
EFUSE_BLK3
[0 255] [200 247]
EFUSE_BLK4
[0 255]
EFUSE_BLK5
[0 255]
EFUSE_BLK6
[0 255]
EFUSE_BLK7
[0 255]
EFUSE_BLK8
[0 255]
EFUSE_BLK9
[0 255]
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_tablecommand to check eFuse table. To generate source files runefuse_common_tableorefuse_custom_tablecommand.
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
Get eFuses During Build
There is a way to get the state of eFuses at the build stage of the project. There are two cmake functions for this:
espefuse_get_json_summary()- It calls theespefuse.py summary --format jsoncommand and returns a json string (it is not stored in a file).espefuse_get_efuse()- It finds a given eFuse name in the json string and returns its property.
The json string has the following properties:
{
"MAC": {
"bit_len": 48,
"block": 0,
"category": "identity",
"description": "Factory MAC Address",
"efuse_type": "bytes:6",
"name": "MAC",
"pos": 0,
"readable": true,
"value": "94:b9:7e:5a:6e:58 (CRC 0xe2 OK)",
"word": 1,
"writeable": true
},
}
These functions can be used from a top-level project CMakeLists.txt (get-started/hello_world/CMakeLists.txt):
# ...
project(hello_world)
espefuse_get_json_summary(efuse_json)
espefuse_get_efuse(ret_data ${efuse_json} "MAC" "value")
message("MAC:" ${ret_data})
The format of the value property is the same as shown in espefuse.py summary.
MAC:94:b9:7e:5a:6e:58 (CRC 0xe2 OK)
There is an example test system/efuse/CMakeLists.txt which adds a custom target efuse-summary. This allows you to run the idf.py efuse-summary command to read the required eFuses (specified in the efuse_names list) at any time, not just at project build time.
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).
Flash Encryption Testing
Flash Encryption (FE) is a hardware feature that requires the physical burning of eFuses: key and FLASH_CRYPT_CNT. If FE is not actually enabled then enabling the CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH option just gives testing possibilities and does not encrypt anything in the flash, even though the logs say encryption happens. The bootloader_flash_write() is adapted for this purpose. But if FE is already enabled on the chip and you run an application or bootloader created with the CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH option then the flash encryption/decryption operations will work properly (data are encrypted as it is written into an encrypted flash partition and decrypted when they are read from an encrypted partition).
espefuse.py
esptool includes a useful tool for reading/writing ESP32-S2 eFuse bits - espefuse.py.
espefuse.py -p PORT summary
espefuse.py v4.6-dev
Connecting....
Detecting chip type... Unsupported detection protocol, switching and trying again...
Detecting chip type... ESP32-S2
=== Run "summary" command ===
EFUSE_NAME (Block) Description = [Meaningful Value] [Readable/Writeable] (Hex Value)
----------------------------------------------------------------------------------------
Config fuses:
WR_DIS (BLOCK0) Disable programming of individual eFuses = 0 R/W (0x00000000)
RD_DIS (BLOCK0) Disable reading from BlOCK4-10 = 0 R/W (0b0000000)
DIS_ICACHE (BLOCK0) Set this bit to disable Icache = False R/W (0b0)
DIS_DCACHE (BLOCK0) Set this bit to disable Dcache = False R/W (0b0)
DIS_TWAI (BLOCK0) Set this bit to disable the TWAI Controller functi = False R/W (0b0)
on
DIS_BOOT_REMAP (BLOCK0) Disables capability to Remap RAM to ROM address sp = False R/W (0b0)
ace
DIS_LEGACY_SPI_BOOT (BLOCK0) Set this bit to disable Legacy SPI boot mode = False R/W (0b0)
UART_PRINT_CHANNEL (BLOCK0) Selects the default UART for printing boot message = UART0 R/W (0b0)
s
UART_PRINT_CONTROL (BLOCK0) Set the default UART boot message output mode = Enable R/W (0b00)
PIN_POWER_SELECTION (BLOCK0) Set default power supply for GPIO33-GPIO37; set wh = VDD3P3_CPU R/W (0b0)
en SPI flash is initialized
BLOCK_USR_DATA (BLOCK3) User data
= 00 00 00 00 00 00 00 00 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
BLOCK_SYS_DATA2 (BLOCK10) System data part 2 (reserved)
= 00 00 00 00 00 00 00 00 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
Flash fuses:
FLASH_TPUW (BLOCK0) Configures flash startup delay after SoC power-up; = 0 R/W (0x0)
in unit of (ms/2). When the value is 15; delay is
7.5 ms
FLASH_TYPE (BLOCK0) SPI flash type = 4 data lines R/W (0b0)
FORCE_SEND_RESUME (BLOCK0) If set; forces ROM code to send an SPI flash resum = False R/W (0b0)
e command during SPI boot
FLASH_VERSION (BLOCK1) Flash version = 2 R/W (0x2)
Identity fuses:
BLOCK0_VERSION (BLOCK0) BLOCK0 efuse version = 0 R/W (0b00)
DISABLE_WAFER_VERSION_MAJOR (BLOCK0) Disables check of wafer version major = False R/W (0b0)
DISABLE_BLK_VERSION_MAJOR (BLOCK0) Disables check of blk version major = False R/W (0b0)
WAFER_VERSION_MAJOR (BLOCK1) WAFER_VERSION_MAJOR = 1 R/W (0b01)
WAFER_VERSION_MINOR_HI (BLOCK1) WAFER_VERSION_MINOR most significant bit = False R/W (0b0)
BLK_VERSION_MAJOR (BLOCK1) BLK_VERSION_MAJOR = 0 R/W (0b00)
PSRAM_VERSION (BLOCK1) PSRAM version = 1 R/W (0x1)
PKG_VERSION (BLOCK1) Package version = 0 R/W (0x0)
WAFER_VERSION_MINOR_LO (BLOCK1) WAFER_VERSION_MINOR least significant bits = 0 R/W (0b000)
OPTIONAL_UNIQUE_ID (BLOCK2) Optional unique 128-bit ID
= ea 0e c6 f1 01 f2 38 82 e9 98 5b 59 81 fe 00 02 R/W
BLK_VERSION_MINOR (BLOCK2) BLK_VERSION_MINOR of BLOCK2 = ADC calib V2 R/W (0b010)
WAFER_VERSION_MINOR (BLOCK0) calc WAFER VERSION MINOR = WAFER_VERSION_MINOR_HI = 0 R/W (0x0)
<< 3 + WAFER_VERSION_MINOR_LO (read only)
Jtag fuses:
SOFT_DIS_JTAG (BLOCK0) Software disables JTAG. When software disabled; JT = False R/W (0b0)
AG can be activated temporarily by HMAC peripheral
HARD_DIS_JTAG (BLOCK0) Hardware disables JTAG permanently = False R/W (0b0)
Mac fuses:
MAC (BLOCK1) MAC address
= 58:cf:79:b3:b9:54 (OK) R/W
CUSTOM_MAC (BLOCK3) Custom MAC
= 00:00:00:00:00:00 (OK) R/W
Security fuses:
DIS_DOWNLOAD_ICACHE (BLOCK0) Disables Icache when SoC is in Download mode = False R/W (0b0)
DIS_DOWNLOAD_DCACHE (BLOCK0) Disables Dcache when SoC is in Download mode = False R/W (0b0)
DIS_FORCE_DOWNLOAD (BLOCK0) Set this bit to disable the function that forces c = False R/W (0b0)
hip into download mode
DIS_DOWNLOAD_MANUAL_ENCRYPT (BLOCK0) Disables flash encryption when in download boot mo = False R/W (0b0)
des
SPI_BOOT_CRYPT_CNT (BLOCK0) Enables flash encryption when 1 or 3 bits are set = Disable R/W (0b000)
and disabled otherwise
SECURE_BOOT_KEY_REVOKE0 (BLOCK0) Revoke 1st secure boot key = False R/W (0b0)
SECURE_BOOT_KEY_REVOKE1 (BLOCK0) Revoke 2nd secure boot key = False R/W (0b0)
SECURE_BOOT_KEY_REVOKE2 (BLOCK0) Revoke 3rd secure boot key = False R/W (0b0)
KEY_PURPOSE_0 (BLOCK0) Purpose of KEY0 = USER R/W (0x0)
KEY_PURPOSE_1 (BLOCK0) Purpose of KEY1 = USER R/W (0x0)
KEY_PURPOSE_2 (BLOCK0) Purpose of KEY2 = USER R/W (0x0)
KEY_PURPOSE_3 (BLOCK0) Purpose of KEY3 = USER R/W (0x0)
KEY_PURPOSE_4 (BLOCK0) Purpose of KEY4 = USER R/W (0x0)
KEY_PURPOSE_5 (BLOCK0) Purpose of KEY5 = USER R/W (0x0)
SECURE_BOOT_EN (BLOCK0) Set this bit to enable secure boot = False R/W (0b0)
SECURE_BOOT_AGGRESSIVE_REVOKE (BLOCK0) Set this bit to enable aggressive secure boot key = False R/W (0b0)
revocation mode
DIS_DOWNLOAD_MODE (BLOCK0) Set this bit to disable all download boot modes = False R/W (0b0)
ENABLE_SECURITY_DOWNLOAD (BLOCK0) Set this bit to enable secure UART download mode ( = False R/W (0b0)
read/write flash only)
SECURE_VERSION (BLOCK0) Secure version (used by ESP-IDF anti-rollback feat = 0 R/W (0x0000)
ure)
BLOCK_KEY0 (BLOCK4)
Purpose: USER
Key0 or user data
= 00 00 00 00 00 00 00 00 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
BLOCK_KEY1 (BLOCK5)
Purpose: USER
Key1 or user data
= 00 00 00 00 00 00 00 00 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
BLOCK_KEY2 (BLOCK6)
Purpose: USER
Key2 or user data
= 00 00 00 00 00 00 00 00 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
BLOCK_KEY3 (BLOCK7)
Purpose: USER
Key3 or user data
= 00 00 00 00 00 00 00 00 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
BLOCK_KEY4 (BLOCK8)
Purpose: USER
Key4 or user data
= 00 00 00 00 00 00 00 00 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
BLOCK_KEY5 (BLOCK9)
Purpose: USER
Key5 or user data
= 00 00 00 00 00 00 00 00 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
Spi Pad fuses:
SPI_PAD_CONFIG_CLK (BLOCK1) SPI_PAD_configure CLK = 0 R/W (0b000000)
SPI_PAD_CONFIG_Q (BLOCK1) SPI_PAD_configure Q(D1) = 0 R/W (0b000000)
SPI_PAD_CONFIG_D (BLOCK1) SPI_PAD_configure D(D0) = 0 R/W (0b000000)
SPI_PAD_CONFIG_CS (BLOCK1) SPI_PAD_configure CS = 0 R/W (0b000000)
SPI_PAD_CONFIG_HD (BLOCK1) SPI_PAD_configure HD(D3) = 0 R/W (0b000000)
SPI_PAD_CONFIG_WP (BLOCK1) SPI_PAD_configure WP(D2) = 0 R/W (0b000000)
SPI_PAD_CONFIG_DQS (BLOCK1) SPI_PAD_configure DQS = 0 R/W (0b000000)
SPI_PAD_CONFIG_D4 (BLOCK1) SPI_PAD_configure D4 = 0 R/W (0b000000)
SPI_PAD_CONFIG_D5 (BLOCK1) SPI_PAD_configure D5 = 0 R/W (0b000000)
SPI_PAD_CONFIG_D6 (BLOCK1) SPI_PAD_configure D6 = 0 R/W (0b000000)
SPI_PAD_CONFIG_D7 (BLOCK1) SPI_PAD_configure D7 = 0 R/W (0b000000)
Usb fuses:
DIS_USB (BLOCK0) Set this bit to disable USB OTG function = False R/W (0b0)
USB_EXCHG_PINS (BLOCK0) Set this bit to exchange USB D+ and D- pins = False R/W (0b0)
USB_EXT_PHY_ENABLE (BLOCK0) Set this bit to enable external USB PHY = False R/W (0b0)
USB_FORCE_NOPERSIST (BLOCK0) If set; forces USB BVALID to 1 = False R/W (0b0)
DIS_USB_DOWNLOAD_MODE (BLOCK0) Set this bit to disable use of USB OTG in UART dow = False R/W (0b0)
nload boot mode
Vdd fuses:
VDD_SPI_XPD (BLOCK0) If VDD_SPI_FORCE is 1; this value determines if th = False R/W (0b0)
e VDD_SPI regulator is powered on
VDD_SPI_TIEH (BLOCK0) If VDD_SPI_FORCE is 1; determines VDD_SPI voltage
= VDD_SPI connects to 1.8 V LDO R/W (0b0)
VDD_SPI_FORCE (BLOCK0) Set this bit to use XPD_VDD_PSI_REG and VDD_SPI_TI = False R/W (0b0)
EH to configure VDD_SPI LDO
Wdt fuses:
WDT_DELAY_SEL (BLOCK0) RTC watchdog timeout threshold; in unit of slow cl = 40000 R/W (0b00)
ock cycle
Flash voltage (VDD_SPI) determined by GPIO45 on reset (GPIO45=High: VDD_SPI pin is powered from internal 1.8V LDO
GPIO45=Low or NC: VDD_SPI pin is powered directly from VDD3P3_RTC_IO via resistor Rspi. Typically this voltage is 3.3 V).
To get a dump for all eFuse registers.
espefuse.py -p PORT dump
espefuse.py v4.6-dev
Connecting....
Detecting chip type... Unsupported detection protocol, switching and trying again...
Detecting chip type... ESP32-S2
BLOCK0 ( ) [0 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000
MAC_SPI_8M_0 (BLOCK1 ) [1 ] read_regs: 79b3b954 000058cf 00000000 10440000 00000000 00000000
BLOCK_SYS_DATA (BLOCK2 ) [2 ] read_regs: f1c60eea 8238f201 595b98e9 0200fe81 1c549f24 88491102 06461421 070c2083
BLOCK_USR_DATA (BLOCK3 ) [3 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK_KEY0 (BLOCK4 ) [4 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK_KEY1 (BLOCK5 ) [5 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK_KEY2 (BLOCK6 ) [6 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK_KEY3 (BLOCK7 ) [7 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK_KEY4 (BLOCK8 ) [8 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK_KEY5 (BLOCK9 ) [9 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK_SYS_DATA2 (BLOCK10 ) [10] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK0 ( ) [0 ] err__regs: 00000000 00000000 00000000 00000000 00000000 00000000
EFUSE_RD_RS_ERR0_REG 0x00000000
EFUSE_RD_RS_ERR1_REG 0x00000000
=== Run "dump" command ===
Header File
Enumerations
-
enum esp_efuse_block_t
Type of eFuse blocks ESP32S2.
Values:
-
enumerator EFUSE_BLK0
Number of eFuse BLOCK0. REPEAT_DATA
-
enumerator EFUSE_BLK1
Number of eFuse BLOCK1. MAC_SPI_8M_SYS
-
enumerator EFUSE_BLK2
Number of eFuse BLOCK2. SYS_DATA_PART1
-
enumerator EFUSE_BLK_SYS_DATA_PART1
Number of eFuse BLOCK2. SYS_DATA_PART1
-
enumerator EFUSE_BLK3
Number of eFuse BLOCK3. USER_DATA
-
enumerator EFUSE_BLK_USER_DATA
Number of eFuse BLOCK3. USER_DATA
-
enumerator EFUSE_BLK4
Number of eFuse BLOCK4. KEY0
-
enumerator EFUSE_BLK_KEY0
Number of eFuse BLOCK4. KEY0
-
enumerator EFUSE_BLK5
Number of eFuse BLOCK5. KEY1
-
enumerator EFUSE_BLK_KEY1
Number of eFuse BLOCK5. KEY1
-
enumerator EFUSE_BLK6
Number of eFuse BLOCK6. KEY2
-
enumerator EFUSE_BLK_KEY2
Number of eFuse BLOCK6. KEY2
-
enumerator EFUSE_BLK7
Number of eFuse BLOCK7. KEY3
-
enumerator EFUSE_BLK_KEY3
Number of eFuse BLOCK7. KEY3
-
enumerator EFUSE_BLK8
Number of eFuse BLOCK8. KEY4
-
enumerator EFUSE_BLK_KEY4
Number of eFuse BLOCK8. KEY4
-
enumerator EFUSE_BLK9
Number of eFuse BLOCK9. KEY5
-
enumerator EFUSE_BLK_KEY5
Number of eFuse BLOCK9. KEY5
-
enumerator EFUSE_BLK_KEY_MAX
-
enumerator EFUSE_BLK10
Number of eFuse BLOCK10. SYS_DATA_PART2
-
enumerator EFUSE_BLK_SYS_DATA_PART2
Number of eFuse BLOCK10. SYS_DATA_PART2
-
enumerator EFUSE_BLK_MAX
-
enumerator EFUSE_BLK0
-
enum esp_efuse_coding_scheme_t
Type of coding scheme.
Values:
-
enumerator EFUSE_CODING_SCHEME_NONE
None
-
enumerator EFUSE_CODING_SCHEME_RS
Reed-Solomon coding
-
enumerator EFUSE_CODING_SCHEME_NONE
-
enum esp_efuse_purpose_t
Type of key purpose.
Values:
-
enumerator ESP_EFUSE_KEY_PURPOSE_USER
User purposes (software-only use)
-
enumerator ESP_EFUSE_KEY_PURPOSE_RESERVED
Reserved
-
enumerator ESP_EFUSE_KEY_PURPOSE_XTS_AES_256_KEY_1
XTS_AES_256_KEY_1 (flash/PSRAM encryption)
-
enumerator ESP_EFUSE_KEY_PURPOSE_XTS_AES_256_KEY_2
XTS_AES_256_KEY_2 (flash/PSRAM encryption)
-
enumerator ESP_EFUSE_KEY_PURPOSE_XTS_AES_128_KEY
XTS_AES_128_KEY (flash/PSRAM encryption)
-
enumerator ESP_EFUSE_KEY_PURPOSE_HMAC_DOWN_ALL
HMAC Downstream mode
-
enumerator ESP_EFUSE_KEY_PURPOSE_HMAC_DOWN_JTAG
JTAG soft enable key (uses HMAC Downstream mode)
-
enumerator ESP_EFUSE_KEY_PURPOSE_HMAC_DOWN_DIGITAL_SIGNATURE
Digital Signature peripheral key (uses HMAC Downstream mode)
-
enumerator ESP_EFUSE_KEY_PURPOSE_HMAC_UP
HMAC Upstream mode
-
enumerator ESP_EFUSE_KEY_PURPOSE_SECURE_BOOT_DIGEST0
SECURE_BOOT_DIGEST0 (Secure Boot key digest)
-
enumerator ESP_EFUSE_KEY_PURPOSE_SECURE_BOOT_DIGEST1
SECURE_BOOT_DIGEST1 (Secure Boot key digest)
-
enumerator ESP_EFUSE_KEY_PURPOSE_SECURE_BOOT_DIGEST2
SECURE_BOOT_DIGEST2 (Secure Boot key digest)
-
enumerator ESP_EFUSE_KEY_PURPOSE_MAX
MAX PURPOSE
-
enumerator ESP_EFUSE_KEY_PURPOSE_USER
Header File
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.
备注
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.
-
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
-
esp_err_t esp_efuse_enable_rom_secure_download_mode(void)
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.
备注
If Secure Download mode is already enabled, this function does nothing and returns success.
备注
Disabling the ROM Download Mode also disables Secure Download Mode.
- 返回
ESP_OK If the eFuse was successfully burned, or had already been burned.
ESP_ERR_INVALID_STATE ROM Download Mode has been disabled via eFuse, so Secure Download mode is unavailable.
-
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.
-
const esp_efuse_desc_t **esp_efuse_get_purpose_field(esp_efuse_block_t block)
Returns a pointer to a key purpose for an efuse key block.
To get the value of this field use esp_efuse_read_field_blob() or esp_efuse_get_key_purpose().
- 参数
block -- [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
- 返回
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)
Returns a pointer to a key block.
- 参数
block -- [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
- 返回
Pointer: If Successful returns a pointer to the corresponding efuse field otherwise NULL.
-
esp_err_t esp_efuse_set_key_purpose(esp_efuse_block_t block, esp_efuse_purpose_t purpose)
Sets a key purpose for an efuse key block.
- 参数
block -- [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
purpose -- [in] Key purpose.
- 返回
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_keypurpose_dis_write(esp_efuse_block_t block)
Sets a write protection of the key purpose field for an efuse 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.
-
esp_efuse_block_t esp_efuse_find_unused_key_block(void)
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.
- 返回
First unused key block, or EFUSE_BLK_KEY_MAX if no unused key block is found.
-
unsigned esp_efuse_count_unused_key_blocks(void)
Return the number of unused efuse key blocks in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX.
-
bool esp_efuse_get_digest_revoke(unsigned num_digest)
Returns the status of the Secure Boot public key digest revocation bit.
- 参数
num_digest -- [in] The number of digest in range 0..2
- 返回
True: If key digest is revoked,
False; If key digest is not revoked.
-
esp_err_t esp_efuse_set_digest_revoke(unsigned num_digest)
Sets the Secure Boot public key digest revocation bit.
- 参数
num_digest -- [in] The number of digest in range 0..2
- 返回
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_write_protect_of_digest_revoke(unsigned num_digest)
Returns a write protection of the Secure Boot public key digest revocation bit.
- 参数
num_digest -- [in] The number of digest in range 0..2
- 返回
True: The revocation bit is write protected. False: The revocation bit is writeable.
-
esp_err_t esp_efuse_set_write_protect_of_digest_revoke(unsigned num_digest)
Sets a write protection of the Secure Boot public key digest revocation bit.
- 参数
num_digest -- [in] The number of digest in range 0..2
- 返回
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_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.
备注
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.
备注
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.- 参数
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.
备注
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.
备注
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.- 参数
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_secure_boot_read_key_digests(esp_secure_boot_key_digests_t *trusted_key_digests)
Read key digests from efuse. Any revoked/missing digests will be marked as NULL.
- 参数
trusted_key_digests -- [out] Trusted keys digests, stored in this parameter after successfully completing this function. The number of digests depends on the SOC's capabilities.
- 返回
ESP_OK: Successful.
ESP_FAIL: If trusted_keys is NULL or there is no valid digest.
-
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..-]
-
esp_efuse_block_t efuse_block
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
-
enumerator ESP_EFUSE_ROM_LOG_ALWAYS_ON