eFuse 管理器
简介
eFuse 是一种微型的一次性可编程保险丝，可以通过“烧录”（即编程）将数据存储到 ESP32 中。eFuse 位组成不同的数据字段，用于系统参数（即 ESP32 的 ESP-IDF 使用的数据参数）或用户自定义参数。
eFuse 管理器组件中集合了多种工具和 API，可帮助定义、烧录和访问 eFuse 参数。常用的工具和 API 包括：
表格格式，用于在 CSV 文件中定义 eFuse 数据字段
efuse_table_gen.py工具，用于生成 CSV 文件指定的 eFuse 数据字段对应的 C 结构体用于读/写 eFuse 数据字段的 C API 集合
eFuse Manager 与 idf.py
idf.py 通过 idf.py efuse-<subcommand> 命令为 eFuse 管理器提供了部分功能。本文档主要使用基于 idf.py 的命令，只有在涉及高级功能或罕见情况时，会使用基于 espefuse.py 的命令。要查看所有可用的命令，请运行 idf.py --help 并搜索以 efuse- 为前缀的命令。
硬件描述
ESP32 有多个 eFuse，可用于存储系统参数和用户参数。每个 eFuse 都是一个一位字段，可以烧写为 1，之后就不能再恢复为 0。eFuse 位被分成了多个 256 位的块，每个块又被分成 8 个 32 位寄存器。部分块保留用于系统参数，其它块可用于用户参数。
如需了解更多内容，请参阅 ESP32 技术参考手册 > eFuse 控制器 (eFuse) [PDF]。
ESP32 有 4 个 eFuse 块，每个块的大小为 256 位（并非所有位都可用于用户参数）：
EFUSE_BLK0 完全用于系统用途；
EFUSE_BLK1 用于 flash 加密密钥。如果不使用 flash 加密功能，此块也可以用于用户参数；
EFUSE_BLK2 用于安全启动密钥。如果不使用安全启动功能，此块也可以用于用户参数；
EFUSE_BLK3 可以部分保留，以存储自定义 MAC 地址，或者完全用于用户参数。请注意，一些位已经用于 ESP-IDF。
定义 eFuse 字段
eFuse 字段通过 CSV 文件中特定格式的表格进行定义。通过这种格式，可定义任意长度和任意位数的 eFuse 字段。
另外，通过这种格式，可以结构化地定义由子字段组成的 eFuse 字段，这意味着一个父 eFuse 字段可能由占用相同 eFuse 位的多个子 eFuse 字段组成。
定义格式
一般情况下，每个记录在定义表格中占据一行，每行包含以下值（也就是列）：
# field_name, efuse_block(EFUSE_BLK0..EFUSE_BLK3), bit_start(0..255), bit_count(1..256), comment
field_nameeFuse 字段的名称。
字段名称前会自动添加
ESP_EFUSE_前缀，在 C 代码中，可通过此名称来访问 eFuse 字段。对于每个 eFuse 字段，
field_name必须唯一。如果此值为空，说明该行与前一行合并。这样就可以定义任意位排序的 eFuse 字段（例如通用表中的
MAC_FACTORY字段）。使用
.来定义一个子 eFuse 字段。详情请参考 结构化 eFuse 字段。
efuse_blockeFuse 字段的块号。例如 EFUSE_BLK0 到 EFUSE_BLK3。
这一字段决定了 eFuse 字段在哪个块中。
bit_starteFuse 字段在块内的位置偏移（0 至 255 位）。
bit_start是可选项，可省略。当省略时，如果上一条记录位于同一个 eFuse 块中，
bit_start会被设置为上一条记录的bit_start + bit_count。如果上一条记录位于不同的 eFuse 块中，则会报错。
bit_counteFuse 字段的大小，以位为单位（1 至 N）。
bit_count不能省略如将其设置为
MAX_BLK_LEN，则此 eFuse 字段为块中允许的最大 eFuse 字段大小。MAX_BLK_LEN考虑了 eFuse 的编码方案。根据 CONFIG_EFUSE_CODE_SCHEME_SELECTOR 选择的编码方案，
MAX_BLK_LEN可能是 256("None")、192 ("3/4") 或 128 ("REPEAT") 位。
comment描述 eFuse 字段的注释。
此注释会逐字复制到 C 头文件中。
如果一个 eFuse 字段需要非顺序位序，那么该 eFuse 字段将占用多行。应在第一行的 field_name 处定该 eFuse 字段的名称，并且将其他行的 field_name 留空。这样就表明这些行属于同一个 eFuse 字段。
以下示例中定义了两个 eFuse 字段。首先定义非连续的 eFuse 字段 MAC_FACTORY，然后定义了常规 eFuse 字段 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
在 C 代码中，可以通过 ESP_EFUSE_MAC_FACTORY 和 ESP_EFUSE_MAC_FACTORY_CRC 使用这两个字段。
结构化 eFuse 字段
通常情况下，一个 eFuse 字段代表一个特定的参数。不过，在某些情况下，一个 eFuse 字段可能由多个子字段组成，因此有必要隔离访问这些子字段。例如，如果一个 eFuse 字段包含一个浮点参数，则可以将浮点的符号、指数和尾数字段作为单独的 eFuse 字段进行访问。
因此，可以在 field_name 中使用 . 操作符，以结构化的方式定义 eFuse 字段。例如，XX.YY.ZZ 定义了一个 eFuse 字段 ZZ，它是 eFuse 字段 YY 的子字段，而 YY 又是 eFuse 字段 XX 的子字段。
以下示例展示了如何以定义结构化 eFuse 字段：
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
在上例中可以看出：
WR_DIS为父 eFuse 字段。其他所有行的field_name都具有WR_DIS.前缀，因此都是WR_DIS的子字段。子字段必须与父字段使用相同的位。注意子字段和父字段的
bit_start和bit_count：子字段的位总是在其父字段范围内。例如，
WR_DIS.RD_DIS和WR_DIS.RD_DIS占用了WR_DIS的第一位和第二位。子字段使用的位不能重叠（子字段有别名时除外）。
可以将别名创建为子字段。例如，
WR_DIS.FIELD_3.ALIAS既是WR_DIS.FIELD_3的子字段，又是别名，因为它们占用的位相同。
所有 eFuse 字段最终都会通过 efuse_table_gen.py 工具转换为 C 结构体。每个 C 结构体从 eFuse 字段的 field_name 中衍生出标识符，并用 _ 替换所有的 . 符号。以 WR_DIS.RD_DIS 和 WR_DIS.FIELD_2.B1 为例，这两个 eFuse 字段用 C 语言分别表示为 ESP_EFUSE_WR_DIS_RD_DIS 和 ESP_EFUSE_WR_DIS_FIELD_2_B1。
efuse_table_gen.py 工具还会检查字段是否相互重叠并在字段范围内。如有违反，会生成以下错误：
Field at USER_DATA, EFUSE_BLK3, 0, 256 intersected with SERIAL_NUMBER, EFUSE_BLK3, 0, 32
要解决此问题，可使用 USER_DATA.SERIAL_NUMBER，让 SERIAL_NUMBER 成为 USER_DATA 的子字段。
Field at FIELD, EFUSE_BLK3, 0, 50 out of range FIELD.MAJOR_NUMBER, EFUSE_BLK3, 60, 32
要解决此问题，可将 FIELD.MAJOR_NUMBER 的 bit_start 从 60 改为 0，使 MAJOR_NUMBER 与 FIELD 重叠。
efuse_table_gen.py 工具
efuse_table_gen.py 工具能够从 CSV 文件生成 C 源文件，其中包含 CSV 文件中定义的 eFuse 字段的对应 C 结构体（类型为 esp_efuse_desc_t）。此外，该工具还会在生成 C 源文件前对 CSV 文件进行检查，以确保：
eFuse 字段的名称唯一
eFuse 字段使用的位不重叠
如前所述，eFuse 字段可用于存储系统参数或用户参数。由于系统参数 eFuse 字段是 ESP-IDF 和 ESP32 的内在要求，这些 eFuse 字段被定义在 通用 CSV 文件中，即 esp_efuse_table.csv 中，是 ESP-IDF 的一部分。对于用户参数 eFuse 字段，用户应在 自定义 CSV 文件（如 esp_efuse_custom_table.csv）中进行定义。
要从 通用 CSV 文件生成 C 源文件，运行 idf.py efuse-common-table 或以下命令：
cd $IDF_PATH/components/efuse/
./efuse_table_gen.py --idf_target esp32 esp32/esp_efuse_table.csv
然后，就会在路径 $IDF_PATH/components/efuse/esp32 中生成以下 C 源文件/头文件：
esp_efuse_table.c文件，包含系统参数 eFuse 字段的 C 结构体。esp_efuse_table.h文件，位于include文件夹。应用程序可包含该头文件，以使用上述 C 结构体。
要使用 自定义 CSV 文件生成 C 源文件，请运行 idf.py efuse-custom-table 或以下命令：
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
然后在 PROJECT_PATH/main 路径下生成 C 源/头文件：
esp_efuse_custom_table.c文件，包含用户参数 eFuse 字段的 C 结构体。esp_efuse_custom_table.h文件，位于include文件夹。应用程序可包含该头文件，以使用上述 C 结构体。
要使用生成的字段，需添加以下头文件：
#include "esp_efuse.h"
#include "esp_efuse_table.h" // 或 "esp_efuse_custom_table.h"
支持的编码方式
eFuse 支持各种编码方式，能够检测或纠正错误，保护 eFuse 数据不受损坏。
ESP32 支持以下 eFuse 编码方式：
非编码方式（值为 0），即不采用编码方式。3/4 编码方式（值为 1）。重复编码方式（值为 2）。不完全受到 IDF 支持，不推荐使用。
以上编码方案对每个 eFuse 块进行单独编码。此外，只有 EFUSE_BLK1、EFUSE_BLK2 和 EFUSE_BLK3 将被编码，这意味着 EUSE_BLK0 始终采用 非编码 方式。
编码方案要求将 eFuse 块中的某些位用作开销。因此，采用编码方案后，每个 eFuse 块的 256 位中只有一部分可用于 eFuse 字段。
非编码：256 位3/4 编码：192 位重复编码：128 位
当使用一种编码方式时，可以写入的有效载荷长度是有限的。如需了解更多内容，请参考 ESP32 技术参考手册 > 章节 20 eFuse 控制器 (eFuse) [PDF] > 章节 20.3.1.3 系统参数 coding_scheme。
通过以下步骤查看芯片的编码方式：
运行
idf.py efuse-summary命令。在烧录期间从
esptool应用程序日志中查看。在应用程序中调用
esp_efuse_get_coding_scheme()函数查看 EFUSE_BLK3 块的编码方式。
CSV 文件中指定的 eFuse 字段必须始终符合芯片使用的 eFuse 编码方案。可以通过 CONFIG_EFUSE_CODE_SCHEME_SELECTOR 选择 CSV 文件使用的编码方案。生成源文件时，如果 CSV 文件中的内容不符合编码方案，则会显示错误信息。在这种情况下，必须调整错误行的 bit_start 和 bit_count，以满足所选编码方案的限制。
备注
更改编码方式后，运行 efuse_common_table 和 efuse_custom_table 命令以查看采用新编码方式的 CSV 表格。
如果程序是用 非编码 方式编译的，而芯片中使用的是 3/4 编码 方式，那么调用 eFuse API 时可能会出现 ESP_ERR_CODING 错误（字段超出块边界）。如果字段符合新的块边界，则 API 会正常运行。
非编码 方式
非编码 方式表示不使用编码方案，因此 eFuse 数据块的 256 位都可以使用。不过，这中方式无法防止 eFuse 位的数据损坏。
3/4 编码 方式
3/4 编码 方式会限制写入一个编码单元的位数。长度为 256 位的块被划分为 4 个编码单元，每个编码单元包含 6 字节的有用数据和 2 字节的服务数据。这 2 字节的服务数据中存储了前 6 个数据字节的校验和。
由于要计算每个编码单元的校验和，写入过程必须根据不同的编码单元进行划分。在这种情况下，通过多个写入操作分别烧录各 eFuse 位（ 非编码 方式的烧录方法）的常规做法将不再适用，必须一次性同时烧写该编码单元的 eFuse 字段数据和校验和。这就是所谓的批量写入模式。
由于采用批量写入模式，一个编码单元只能写入一次，禁止在同一编码单元重复写入。这意味着，在运行时写入的编码单元中只能包含一个 eFuse 字段。但是，如果事先通过 CSV 文件指定了编码单元的 eFuse 字段，或通过 esp_efuse_write_block() 写入编码单元的 eFuse 字段，那么一个编码单元中仍可包含多个 eFuse 字段。
重复编码 方式
重复编码 方式只是简单重复每个 eFuse 位，不会像 3/4 编码 方式那样受到批量写入模式的限制。不过，这样做会产生很大的开销，每个 eFuse 块中只有 128 个位可用。
批量写入模式
如需在运行时写入 eFuse 字段，可能要采用批量写入模式，具体取决于 eFuse 块使用的编码方案。批量写入模式的使用步骤如下：
调用
esp_efuse_batch_write_begin()启用批量写入模式。使用各
esp_efuse_write_...函数，按照常规方法写入 eFuse 字段。完成所有写入后，调用
esp_efuse_batch_write_commit()将准备好的数据烧录到 eFuse 块中。
警告
如果 eFuse 块中已经存在通过 3/4 或 Repeat 编码方案预先写入的数据，则无法在不破坏先前数据校验和/校验符号的情况下，写入额外的内容（即使需要写入的位为空）。
先前的校验和/校验符号会被新的校验和/校验符号覆盖，并完全销毁。（但不会损坏有效负载 eFuse）。
如发现在 CUSTOM_MAC、SPI_PAD_CONFIG_HD、SPI_PAD_CONFIG_CS 等块中存在预写入数据，请联系乐鑫获取所需的预烧录 eFuse。
仅供测试（不推荐）：可以忽略或抑制违反编码方式数据的错误，从而在 eFuse 块中烧录必要的位。
eFuse API
可以通过指向描述结构的指针来访问 eFuse 字段。API 函数可以实现一些基本操作：
esp_efuse_read_field_blob()- 返回读取的 eFuse 位的数组。esp_efuse_read_field_cnt()- 返回烧写为 “1” 的位的数量。esp_efuse_write_field_blob()- 写入一个数组。esp_efuse_write_field_cnt()- 将所需数量的位写为 “1”。esp_efuse_get_field_size()- 返回字段的位数。esp_efuse_read_reg()- 返回 eFuse 寄存器的值。esp_efuse_write_reg()- 将值写入 eFuse 寄存器。esp_efuse_get_coding_scheme()- 返回块的 eFuse 编码方式。esp_efuse_read_block()- 从指定偏移位置开始读取指定大小的 eFuse 块中的密钥。esp_efuse_write_block()- 从指定偏移位置开始将密钥写入指定大小的 eFuse 块中。esp_efuse_batch_write_begin()- 设置字段写入的批处理模式。esp_efuse_batch_write_commit()- 写入所有为批处理写入模式准备的数据，并重置批处理写入模式。esp_efuse_batch_write_cancel()- 重置批处理写入模式和准备的数据。esp_efuse_get_key_dis_read()- 返回密钥块的读保护状态。esp_efuse_set_key_dis_read()- 设置密钥块的读保护状态。esp_efuse_get_key_dis_write()- 返回密钥块的写保护状态。esp_efuse_set_key_dis_write()- 设置密钥块的写保护状态。esp_efuse_get_key_purpose()- 返回 eFuse 密钥块当前设置的用途。esp_efuse_write_key()- 将一块密钥数据烧写到一个 eFuse 块。esp_efuse_write_keys()- 将密钥烧写到未使用的 eFuse 块。esp_efuse_find_purpose()- 查找设置为特定用途的密钥块。esp_efuse_get_keypurpose_dis_write()- 返回 eFuse 密钥块的密钥用途字段的写保护状态（对于 esp32 始终为 true）。esp_efuse_key_block_unused()- 如果密钥块未使用，则返回 true，否则返回 false。esp_efuse_destroy_block()- 销毁此 eFuse 块中的数据。该函数有两个作用：(1) 如果未开启写保护，则将不为 1 的位都烧写为 1；(2) 如果未开启读保护，则开启读保护。
经常使用的字段有专门的函数可供使用，例如 esp_efuse_get_pkg_ver()。
如何添加新字段
为新字段查找空闲位。运行
idf.py show-efuse-table查看esp_efuse_table.csv文件，或运行以下命令：
$ ./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
1 WR_DIS EFUSE_BLK0 0 16
2 WR_DIS.RD_DIS EFUSE_BLK0 0 1
3 WR_DIS.WR_DIS EFUSE_BLK0 1 1
4 WR_DIS.FLASH_CRYPT_CNT EFUSE_BLK0 2 1
5 WR_DIS.UART_DOWNLOAD_DIS EFUSE_BLK0 2 1
6 WR_DIS.MAC EFUSE_BLK0 3 1
7 WR_DIS.MAC_CRC EFUSE_BLK0 3 1
8 WR_DIS.DISABLE_APP_CPU EFUSE_BLK0 3 1
9 WR_DIS.DISABLE_BT EFUSE_BLK0 3 1
10 WR_DIS.DIS_CACHE EFUSE_BLK0 3 1
11 WR_DIS.VOL_LEVEL_HP_INV EFUSE_BLK0 3 1
12 WR_DIS.CLK8M_FREQ EFUSE_BLK0 4 1
13 WR_DIS.ADC_VREF EFUSE_BLK0 4 1
14 WR_DIS.XPD_SDIO_REG EFUSE_BLK0 5 1
15 WR_DIS.XPD_SDIO_TIEH EFUSE_BLK0 5 1
16 WR_DIS.XPD_SDIO_FORCE EFUSE_BLK0 5 1
17 WR_DIS.SPI_PAD_CONFIG_CLK EFUSE_BLK0 6 1
18 WR_DIS.SPI_PAD_CONFIG_Q EFUSE_BLK0 6 1
19 WR_DIS.SPI_PAD_CONFIG_D EFUSE_BLK0 6 1
20 WR_DIS.SPI_PAD_CONFIG_CS0 EFUSE_BLK0 6 1
21 WR_DIS.BLOCK1 EFUSE_BLK0 7 1
22 WR_DIS.BLOCK2 EFUSE_BLK0 8 1
23 WR_DIS.BLOCK3 EFUSE_BLK0 9 1
24 WR_DIS.CUSTOM_MAC_CRC EFUSE_BLK0 9 1
25 WR_DIS.CUSTOM_MAC EFUSE_BLK0 9 1
26 WR_DIS.ADC1_TP_LOW EFUSE_BLK0 9 1
27 WR_DIS.ADC1_TP_HIGH EFUSE_BLK0 9 1
28 WR_DIS.ADC2_TP_LOW EFUSE_BLK0 9 1
29 WR_DIS.ADC2_TP_HIGH EFUSE_BLK0 9 1
30 WR_DIS.SECURE_VERSION EFUSE_BLK0 9 1
31 WR_DIS.MAC_VERSION EFUSE_BLK0 9 1
32 WR_DIS.BLK3_PART_RESERVE EFUSE_BLK0 10 1
33 WR_DIS.FLASH_CRYPT_CONFIG EFUSE_BLK0 10 1
34 WR_DIS.CODING_SCHEME EFUSE_BLK0 10 1
35 WR_DIS.KEY_STATUS EFUSE_BLK0 10 1
36 WR_DIS.ABS_DONE_0 EFUSE_BLK0 12 1
37 WR_DIS.ABS_DONE_1 EFUSE_BLK0 13 1
38 WR_DIS.JTAG_DISABLE EFUSE_BLK0 14 1
39 WR_DIS.CONSOLE_DEBUG_DISABLE EFUSE_BLK0 15 1
40 WR_DIS.DISABLE_DL_ENCRYPT EFUSE_BLK0 15 1
41 WR_DIS.DISABLE_DL_DECRYPT EFUSE_BLK0 15 1
42 WR_DIS.DISABLE_DL_CACHE EFUSE_BLK0 15 1
43 RD_DIS EFUSE_BLK0 16 4
44 RD_DIS.BLOCK1 EFUSE_BLK0 16 1
45 RD_DIS.BLOCK2 EFUSE_BLK0 17 1
46 RD_DIS.BLOCK3 EFUSE_BLK0 18 1
47 RD_DIS.CUSTOM_MAC_CRC EFUSE_BLK0 18 1
48 RD_DIS.CUSTOM_MAC EFUSE_BLK0 18 1
49 RD_DIS.ADC1_TP_LOW EFUSE_BLK0 18 1
50 RD_DIS.ADC1_TP_HIGH EFUSE_BLK0 18 1
51 RD_DIS.ADC2_TP_LOW EFUSE_BLK0 18 1
52 RD_DIS.ADC2_TP_HIGH EFUSE_BLK0 18 1
53 RD_DIS.SECURE_VERSION EFUSE_BLK0 18 1
54 RD_DIS.MAC_VERSION EFUSE_BLK0 18 1
55 RD_DIS.BLK3_PART_RESERVE EFUSE_BLK0 19 1
56 RD_DIS.FLASH_CRYPT_CONFIG EFUSE_BLK0 19 1
57 RD_DIS.CODING_SCHEME EFUSE_BLK0 19 1
58 RD_DIS.KEY_STATUS EFUSE_BLK0 19 1
59 FLASH_CRYPT_CNT EFUSE_BLK0 20 7
60 UART_DOWNLOAD_DIS EFUSE_BLK0 27 1
61 MAC EFUSE_BLK0 32 8
62 MAC EFUSE_BLK0 40 8
63 MAC EFUSE_BLK0 48 8
64 MAC EFUSE_BLK0 56 8
65 MAC EFUSE_BLK0 64 8
66 MAC EFUSE_BLK0 72 8
67 MAC_CRC EFUSE_BLK0 80 8
68 DISABLE_APP_CPU EFUSE_BLK0 96 1
69 DISABLE_BT EFUSE_BLK0 97 1
70 CHIP_PACKAGE_4BIT EFUSE_BLK0 98 1
71 DIS_CACHE EFUSE_BLK0 99 1
72 SPI_PAD_CONFIG_HD EFUSE_BLK0 100 5
73 CHIP_PACKAGE EFUSE_BLK0 105 3
74 CHIP_CPU_FREQ_LOW EFUSE_BLK0 108 1
75 CHIP_CPU_FREQ_RATED EFUSE_BLK0 109 1
76 BLK3_PART_RESERVE EFUSE_BLK0 110 1
77 CHIP_VER_REV1 EFUSE_BLK0 111 1
78 CLK8M_FREQ EFUSE_BLK0 128 8
79 ADC_VREF EFUSE_BLK0 136 5
80 XPD_SDIO_REG EFUSE_BLK0 142 1
81 XPD_SDIO_TIEH EFUSE_BLK0 143 1
82 XPD_SDIO_FORCE EFUSE_BLK0 144 1
83 SPI_PAD_CONFIG_CLK EFUSE_BLK0 160 5
84 SPI_PAD_CONFIG_Q EFUSE_BLK0 165 5
85 SPI_PAD_CONFIG_D EFUSE_BLK0 170 5
86 SPI_PAD_CONFIG_CS0 EFUSE_BLK0 175 5
87 CHIP_VER_REV2 EFUSE_BLK0 180 1
88 VOL_LEVEL_HP_INV EFUSE_BLK0 182 2
89 WAFER_VERSION_MINOR EFUSE_BLK0 184 2
90 FLASH_CRYPT_CONFIG EFUSE_BLK0 188 4
91 CODING_SCHEME EFUSE_BLK0 192 2
92 CONSOLE_DEBUG_DISABLE EFUSE_BLK0 194 1
93 DISABLE_SDIO_HOST EFUSE_BLK0 195 1
94 ABS_DONE_0 EFUSE_BLK0 196 1
95 ABS_DONE_1 EFUSE_BLK0 197 1
96 JTAG_DISABLE EFUSE_BLK0 198 1
97 DISABLE_DL_ENCRYPT EFUSE_BLK0 199 1
98 DISABLE_DL_DECRYPT EFUSE_BLK0 200 1
99 DISABLE_DL_CACHE EFUSE_BLK0 201 1
100 KEY_STATUS EFUSE_BLK0 202 1
101 BLOCK1 EFUSE_BLK1 0 192
102 BLOCK2 EFUSE_BLK2 0 192
103 CUSTOM_MAC_CRC EFUSE_BLK3 0 8
104 MAC_CUSTOM EFUSE_BLK3 8 48
105 ADC1_TP_LOW EFUSE_BLK3 96 7
106 ADC1_TP_HIGH EFUSE_BLK3 103 9
107 ADC2_TP_LOW EFUSE_BLK3 112 7
108 ADC2_TP_HIGH EFUSE_BLK3 119 9
109 SECURE_VERSION EFUSE_BLK3 128 32
110 MAC_VERSION EFUSE_BLK3 184 8
Used bits in efuse table:
EFUSE_BLK0
[0 15] [0 2] [2 3] ... [19 19] [19 27] [32 87] [96 111] [128 140] [142 144] [160 180] [182 185] [188 202]
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)
不包含在方括号中的位是空闲的（一些位是乐鑫的保留位）。已检查所有字段的位重叠情况。
要在现有字段中添加子字段，请参考 结构化 eFuse 字段。例如，可使用 . 操作符将字段 SERIAL_NUMBER、MODEL_NUMBER 和 HARDWARE_REV 添加到现有的 USER_DATA 字段中，如下所示：
USER_DATA.SERIAL_NUMBER, EFUSE_BLK3, 0, 32,
USER_DATA.MODEL_NUMBER, EFUSE_BLK3, 32, 10,
USER_DATA.HARDWARE_REV, EFUSE_BLK3, 42, 10,
通常按照如下步骤添加新的 eFuse 字段：
在 CSV 文件中为每个 eFuse 字段添加一行记录。
运行
show_efuse_table命令检查 eFuse 表。如要生成源文件，运行
efuse_common_table或efuse_custom_table命令。
如果遇到 intersects with 或 out of range 等错误，请参阅 结构化 eFuse 字段 中的解决办法。
位序
eFuse 位序采取小字节序（参见下方示例），这说明 eFuse 位按照从 LSB 到 MSB 的顺序进行读写：
$ idf.py efuse-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
例如，CSV 文件描述了 USER_DATA 字段，该字段占用 256 位，即一个完整的块。
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]
因此，读取如上 eFuse USER_DATA 块会得到以下结果：
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; // 可以用于这种情况，因为它只包含一个条目
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); // 只读取前两位
// field1 = 0x0002
uint8_t id = 0;
size_t id_size = esp_efuse_get_field_size(ESP_EFUSE_ID); // 返回 6
// size_t id_size = ESP_EFUSE_USER_DATA[0]->bit_count; // 不能用于这种情况，因为其中包含 3 个条目，会返回 3 而不是 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
在构建阶段获取 eFuse 状态
要在项目的构建阶段获取 eFuse 状态，可以使用以下两个 CMake 函数：
espefuse_get_json_summary()- 调用espefuse.py summary --format json命令并返回一个 JSON 字符串（该字符串不存储在文件中）。espefuse_get_efuse()- 在此 JSON 字符串中找到给定的 eFuse 名称并返回其属性。
该 JSON 字符串具有以下属性：
{
"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
},
}
可以通过项目顶层目录下的 CMakeLists.txt (system/efuse/CMakeLists.txt) 来使用这些函数：
# ...
project(hello_world)
espefuse_get_json_summary(efuse_json)
espefuse_get_efuse(ret_data ${efuse_json} "MAC" "value")
message("MAC:" ${ret_data})
value 属性的格式与 espefuse.py summary 或 idf.py efuse-summary 中显示的格式相同。
MAC:94:b9:7e:5a:6e:58 (CRC 0xe2 OK)
在示例测试 system/efuse/CMakeLists.txt 中，添加了一个自定义目标 efuse-filter。这样，不仅在项目构建阶段，而在任何时候都可以运行 idf.py efuse-filter 命令读取所需的 eFuse（在 efuse_names 列表中指定）。
调试 eFuse & 单元测试
虚拟 eFuse
Kconfig 选项 CONFIG_EFUSE_VIRTUAL 在 eFuse 管理器中虚拟了 eFuse 值，因此写入操作是仿真操作，不会永久更改 eFuse 值。这对于应用程序调试和单元测试很有用处。
在启动时，eFuses 被复制到 RAM 中。此时，所有的 eFuse 操作（读和写）都是通过 RAM 执行，而不是通过实际的 eFuse 寄存器执行的。
除了 CONFIG_EFUSE_VIRTUAL 选项外，还有 CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH 选项，该选项可将 eFuse 保留在 flash 内存中。要使用此模式，partition_table 在 partition.csv 中包含名为 efuse 的分区：
efuse_em, data, efuse, , 0x2000,
在启动阶段，eFuse 会从 flash 中复制到 RAM 中，在 flash 为空的情况下，则从实际的 eFuse 复制到 RAM 中，然后更新 flash。此选项能够在重启后仍然保留 eFuse，用于测试安全启动和 flash 加密功能。
flash 加密测试
flash 加密是一项硬件功能，需要物理烧录 eFuse key 和 FLASH_CRYPT_CNT。如果 flash 加密实际未启用，那么启用 CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH 选项只是提供了测试的可能性，而不会加密 flash 中的任何内容，即使日志中显示了加密操作。
为此，可使用 bootloader_flash_write() 函数。但是，如果运行应用程序时芯片已启用 flash 加密，或者以 CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH 选项创建了启动加载程序，则 flash 加密/解密操作会正常进行。这意味着数据写入加密 flash 分区时被加密，从加密分区读取时被解密。
espefuse.py
esptool 中包含一个用于读取/写入 ESP32 eFuse 位的有用工具： espefuse.py。
idf.py 命令也可以直接提供上述工具的部分功能。例如，运行 idf.py efuse-summary 命令，效果等同于 espefuse.py summary。
idf.py efuse-summary
Executing action: efuse-summary
(...)
EFUSE_NAME (Block) Description = [Meaningful Value] [Readable/Writeable] (Hex Value)
----------------------------------------------------------------------------------------
Calibration fuses:
ADC_VREF (BLOCK0) True ADC reference voltage = 1121 R/W (0b00011)
Config fuses:
WR_DIS (BLOCK0) Efuse write disable mask = 0 R/W (0x0000)
RD_DIS (BLOCK0) Disable reading from BlOCK1-3 = 0 R/W (0x0)
DISABLE_APP_CPU (BLOCK0) Disables APP CPU = False R/W (0b0)
DISABLE_BT (BLOCK0) Disables Bluetooth = False R/W (0b0)
DIS_CACHE (BLOCK0) Disables cache = False R/W (0b0)
CHIP_CPU_FREQ_LOW (BLOCK0) If set alongside EFUSE_RD_CHIP_CPU_FREQ_RATED; the = False R/W (0b0)
ESP32's max CPU frequency is rated for 160MHz. 24
0MHz otherwise
CHIP_CPU_FREQ_RATED (BLOCK0) If set; the ESP32's maximum CPU frequency has been = True R/W (0b1)
rated
BLK3_PART_RESERVE (BLOCK0) BLOCK3 partially served for ADC calibration data = False R/W (0b0)
CLK8M_FREQ (BLOCK0) 8MHz clock freq override = 51 R/W (0x33)
VOL_LEVEL_HP_INV (BLOCK0) This field stores the voltage level for CPU to run = 0 R/W (0b00)
at 240 MHz; or for flash/PSRAM to run at 80 MHz.0
x0: level 7; 0x1: level 6; 0x2: level 5; 0x3:i
level 4. (RO)
CODING_SCHEME (BLOCK0) Efuse variable block length scheme
= NONE (BLK1-3 len=256 bits) R/W (0b00)
CONSOLE_DEBUG_DISABLE (BLOCK0) Disable ROM BASIC interpreter fallback = True R/W (0b1)
DISABLE_SDIO_HOST (BLOCK0) = False R/W (0b0)
DISABLE_DL_CACHE (BLOCK0) Disable flash cache in UART bootloader = False R/W (0b0)
Flash fuses:
FLASH_CRYPT_CNT (BLOCK0) Flash encryption is enabled if this field has an o = 0 R/W (0b0000000)
dd number of bits set
FLASH_CRYPT_CONFIG (BLOCK0) Flash encryption config (key tweak bits) = 0 R/W (0x0)
Identity fuses:
CHIP_PACKAGE_4BIT (BLOCK0) Chip package identifier #4bit = False R/W (0b0)
CHIP_PACKAGE (BLOCK0) Chip package identifier = 1 R/W (0b001)
CHIP_VER_REV1 (BLOCK0) bit is set to 1 for rev1 silicon = True R/W (0b1)
CHIP_VER_REV2 (BLOCK0) = True R/W (0b1)
WAFER_VERSION_MINOR (BLOCK0) = 0 R/W (0b00)
WAFER_VERSION_MAJOR (BLOCK0) calc WAFER VERSION MAJOR from CHIP_VER_REV1 and CH = 3 R/W (0b011)
IP_VER_REV2 and apb_ctl_date (read only)
PKG_VERSION (BLOCK0) calc Chip package = CHIP_PACKAGE_4BIT << 3 + CHIP_ = 1 R/W (0x1)
PACKAGE (read only)
Jtag fuses:
JTAG_DISABLE (BLOCK0) Disable JTAG = False R/W (0b0)
Mac fuses:
MAC (BLOCK0) MAC address
= 94:b9:7e:5a:6e:58 (CRC 0xe2 OK) R/W
MAC_CRC (BLOCK0) CRC8 for MAC address = 226 R/W (0xe2)
MAC_VERSION (BLOCK3) Version of the MAC field = 0 R/W (0x00)
Security fuses:
UART_DOWNLOAD_DIS (BLOCK0) Disable UART download mode. Valid for ESP32 V3 and = False R/W (0b0)
newer; only
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)
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)
KEY_STATUS (BLOCK0) Usage of efuse block 3 (reserved) = False R/W (0b0)
SECURE_VERSION (BLOCK3) Secure version for anti-rollback = 0 R/W (0x00000000)
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 00 00 00 00 00 00 00 00 R/W
BLOCK2 (BLOCK2) Security 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 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 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_HD (BLOCK0) read for SPI_pad_config_hd = 0 R/W (0b00000)
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_CS0 (BLOCK0) Override SD_CMD pad (GPIO11/SPICS0) = 0 R/W (0b00000)
Vdd fuses:
XPD_SDIO_REG (BLOCK0) read for XPD_SDIO_REG = False R/W (0b0)
XPD_SDIO_TIEH (BLOCK0) If XPD_SDIO_FORCE & XPD_SDIO_REG = 1.8V R/W (0b0)
XPD_SDIO_FORCE (BLOCK0) Ignore MTDI pin (GPIO12) for VDD_SDIO on reset = False R/W (0b0)
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.
idf.py efuse-dump
Executing action: efuse-dump
Running espefuse.py in directory <project-directory>
Executing "espefuse.py dump --chip esp32"...
espefuse.py v4.6-dev
Connecting....
BLOCK0 ( ) [0 ] read_regs: 00000000 7e5a6e58 00e294b9 0000a200 00000333 00100000 00000004
BLOCK1 (flash_encryption) [1 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK2 (secure_boot_v1 s) [2 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
BLOCK3 ( ) [3 ] read_regs: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
EFUSE_REG_DEC_STATUS 0x00000000
=== Run "dump" command ===
Header File
This header file can be included with:
#include "esp_efuse_chip.h"
This header file is a part of the API provided by the
efusecomponent. To declare that your component depends onefuse, add the following to your CMakeLists.txt:REQUIRES efuse
or
PRIV_REQUIRES efuse
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
-
enumerator EFUSE_BLK0
-
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
-
enumerator EFUSE_CODING_SCHEME_NONE
-
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
-
enumerator ESP_EFUSE_KEY_PURPOSE_USER
Header File
This header file can be included with:
#include "esp_efuse.h"
This header file is a part of the API provided by the
efusecomponent. To declare that your component depends onefuse, add the following to your CMakeLists.txt:REQUIRES efuse
or
PRIV_REQUIRES efuse
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.
-
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.
备注
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_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.
-
esp_err_t esp_efuse_destroy_block(esp_efuse_block_t block)
Destroys the data in the given efuse block, if possible.
Data destruction occurs through the following steps: 1) Destroy data in the block:
If write protection is inactive for the block, then unset bits are burned.
If write protection is active, the block remains unaltered. 2) Set read protection for the block if possible (check write-protection for RD_DIS). In this case, data becomes inaccessible, and the software reads it as all zeros. If write protection is enabled and read protection can not be set, data in the block remains readable (returns an error).
Do not use the batch mode with this function as it does the burning itself!
- 参数
block -- [in] A key block in the range EFUSE_BLK_KEY0..EFUSE_BLK_KEY_MAX
- 返回
ESP_OK: Successful.
ESP_FAIL: Data remained readable because the block is write-protected and read protection can not be set.
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