efuse: Validates data after burning and re-burnes it if necessary

components/efuse/esp32/esp_efuse_utility.c

@@ -27,15 +27,27 @@ const esp_efuse_range_addr_t range_read_addr_blocks[] = {
     {EFUSE_BLK3_RDATA0_REG, EFUSE_BLK3_RDATA7_REG}     // range address of EFUSE_BLK3
 };
 
-/*Range addresses to write blocks*/
+static uint32_t write_mass_blocks[EFUSE_BLK_MAX][COUNT_EFUSE_REG_PER_BLOCK] = { 0 };
+
+/*Range addresses to write blocks (it is not real regs, it is a buffer) */
 const esp_efuse_range_addr_t range_write_addr_blocks[] = {
-    {EFUSE_BLK0_WDATA0_REG, EFUSE_BLK0_WDATA6_REG},    // range address of EFUSE_BLK0
-    {EFUSE_BLK1_WDATA0_REG, EFUSE_BLK1_WDATA7_REG},    // range address of EFUSE_BLK1
-    {EFUSE_BLK2_WDATA0_REG, EFUSE_BLK2_WDATA7_REG},    // range address of EFUSE_BLK2
-    {EFUSE_BLK3_WDATA0_REG, EFUSE_BLK3_WDATA7_REG}     // range address of EFUSE_BLK3
+    {(uint32_t) &write_mass_blocks[EFUSE_BLK0][0],  (uint32_t) &write_mass_blocks[EFUSE_BLK0][6]},
+    {(uint32_t) &write_mass_blocks[EFUSE_BLK1][0],  (uint32_t) &write_mass_blocks[EFUSE_BLK1][7]},
+    {(uint32_t) &write_mass_blocks[EFUSE_BLK2][0],  (uint32_t) &write_mass_blocks[EFUSE_BLK2][7]},
+    {(uint32_t) &write_mass_blocks[EFUSE_BLK3][0],  (uint32_t) &write_mass_blocks[EFUSE_BLK3][7]},
 };
 
 #ifndef CONFIG_EFUSE_VIRTUAL
+/* Addresses to write blocks*/
+const uint32_t start_write_addr[] = {
+    EFUSE_BLK0_WDATA0_REG,
+    EFUSE_BLK1_WDATA0_REG,
+    EFUSE_BLK2_WDATA0_REG,
+    EFUSE_BLK3_WDATA0_REG,
+};
+
+static void apply_repeat_encoding(const uint8_t *in_bytes, uint32_t *out_words, size_t in_bytes_len);
+
 // Update Efuse timing configuration
 static esp_err_t esp_efuse_set_timing(void)
 {
@@ -52,27 +64,12 @@ void esp_efuse_utility_clear_program_registers(void)
 }
 
 // Burn values written to the efuse write registers
-void esp_efuse_utility_burn_chip(void)
+esp_err_t esp_efuse_utility_burn_chip(void)
 {
+    esp_err_t error = ESP_OK;
 #ifdef CONFIG_EFUSE_VIRTUAL
     ESP_LOGW(TAG, "Virtual efuses enabled: Not really burning eFuses");
-    for (int num_block = EFUSE_BLK0; num_block < EFUSE_BLK_MAX; num_block++) {
-        esp_efuse_coding_scheme_t scheme = esp_efuse_get_coding_scheme(num_block);
-        if (scheme == EFUSE_CODING_SCHEME_3_4) {
-            uint8_t buf[COUNT_EFUSE_REG_PER_BLOCK * 4] = { 0 };
-            int i = 0;
-            for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4, ++i) {
-                *((uint32_t*)buf + i) = REG_READ(addr_wr_block);
-            }
-            int j = 0;
-            uint32_t out_buf[COUNT_EFUSE_REG_PER_BLOCK] = { 0 };
-            for (int k = 0; k < 4; ++k, ++j) {
-                memcpy((uint8_t*)out_buf + j * 6, &buf[k * 8], 6);
-            }
-            for (int k = 0; k < COUNT_EFUSE_REG_PER_BLOCK; ++k) {
-                REG_WRITE(range_write_addr_blocks[num_block].start + k * 4,  out_buf[k]);
-            }
-        }
+    for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
         int subblock = 0;
         for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4) {
             virt_blocks[num_block][subblock++] |= REG_READ(addr_wr_block);
@@ -81,12 +78,87 @@ void esp_efuse_utility_burn_chip(void)
 #ifdef CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH
     esp_efuse_utility_write_efuses_to_flash();
 #endif
-#else
-    esp_efuse_set_timing();
-    // Permanently update values written to the efuse write registers
-    efuse_hal_program(0);
+#else // CONFIG_EFUSE_VIRTUAL
+    if (esp_efuse_set_timing() != ESP_OK) {
+        ESP_LOGE(TAG, "Efuse fields are not burnt");
+    } else {
+        // Permanently update values written to the efuse write registers
+        // It is necessary to process blocks in the order from MAX-> EFUSE_BLK0, because EFUSE_BLK0 has protection bits for other blocks.
+        for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
+            esp_efuse_coding_scheme_t scheme = esp_efuse_get_coding_scheme(num_block);
+            bool need_burn_block = false;
+            for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4) {
+                if (REG_READ(addr_wr_block) != 0) {
+                    need_burn_block = true;
+                    break;
+                }
+            }
+            if (!need_burn_block) {
+                continue;
+            }
+            if (error) {
+                // It is done for a use case: BLOCK2 (Flash encryption key) could have an error (incorrect written data)
+                // in this case we can not burn any data into BLOCK0 because it might set read/write protections of BLOCK2.
+                ESP_LOGE(TAG, "BLOCK%d can not be burned because a previous block got an error, skipped.", num_block);
+                continue;
+            }
+            efuse_hal_clear_program_registers();
+            unsigned w_data_len;
+            unsigned r_data_len;
+            if (scheme == EFUSE_CODING_SCHEME_3_4) {
+                esp_efuse_utility_apply_34_encoding((void *)range_write_addr_blocks[num_block].start, (uint32_t *)start_write_addr[num_block], ESP_EFUSE_LEN_OF_3_4_SCHEME_BLOCK_IN_BYTES);
+                r_data_len = ESP_EFUSE_LEN_OF_3_4_SCHEME_BLOCK_IN_BYTES;
+                w_data_len = 32;
+            } else if (scheme == EFUSE_CODING_SCHEME_REPEAT) {
+                apply_repeat_encoding((void *)range_write_addr_blocks[num_block].start, (uint32_t *)start_write_addr[num_block], 16);
+                r_data_len = ESP_EFUSE_LEN_OF_REPEAT_BLOCK_IN_BYTES;
+                w_data_len = 32;
+            } else {
+                r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
+                w_data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
+                memcpy((void *)start_write_addr[num_block], (void *)range_write_addr_blocks[num_block].start, w_data_len);
+            }
+
+            uint32_t backup_write_data[8];
+            memcpy(backup_write_data, (void *)start_write_addr[num_block], w_data_len);
+            int repeat_burn_op = 1;
+            bool correct_written_data;
+            bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
+            if (coding_error_before) {
+                ESP_LOGW(TAG, "BLOCK%d already has a coding error", num_block);
+            }
+            bool coding_error_occurred;
+
+            do {
+                ESP_LOGI(TAG, "BURN BLOCK%d", num_block);
+                efuse_hal_program(0); // BURN a block
+
+                bool coding_error_after = efuse_hal_is_coding_error_in_block(num_block);
+                coding_error_occurred = (coding_error_before != coding_error_after) && coding_error_before == false;
+                if (coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d got a coding error", num_block);
+                }
+
+                correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
+                if (!correct_written_data || coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
+                    memcpy((void *)start_write_addr[num_block], (void *)backup_write_data, w_data_len);
+                }
+
+            } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);
+
+            if (coding_error_occurred) {
+                ESP_LOGW(TAG, "Coding error was not fixed");
+            }
+            if (!correct_written_data) {
+                ESP_LOGE(TAG, "Written data are incorrect");
+                error = ESP_FAIL;
+            }
+        }
+    }
 #endif // CONFIG_EFUSE_VIRTUAL
     esp_efuse_utility_reset();
+    return error;
 }
 
 esp_err_t esp_efuse_utility_apply_34_encoding(const uint8_t *in_bytes, uint32_t *out_words, size_t in_bytes_len)
@@ -118,19 +190,15 @@ esp_err_t esp_efuse_utility_apply_34_encoding(const uint8_t *in_bytes, uint32_t
     return ESP_OK;
 }
 
-static bool read_w_data_and_check_fill(esp_efuse_block_t num_block, uint32_t *buf_w_data)
+#ifndef CONFIG_EFUSE_VIRTUAL
+
+static void apply_repeat_encoding(const uint8_t *in_bytes, uint32_t *out_words, size_t in_bytes_len)
 {
-    bool blk_is_filled = false;
-    int i = 0;
-    for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4, ++i) {
-        buf_w_data[i] = REG_READ(addr_wr_block);
-        if (buf_w_data[i] != 0) {
-            REG_WRITE(addr_wr_block, 0);
-            blk_is_filled = true;
-        }
+    for (unsigned i = 0; i < 2; i++) {
+        memcpy(&out_words[i * 4], (uint32_t *)in_bytes, in_bytes_len);
     }
-    return blk_is_filled;
 }
+#endif // CONFIG_EFUSE_VIRTUAL
 
 static void read_r_data(esp_efuse_block_t num_block, uint32_t* buf_r_data)
 {
@@ -140,27 +208,30 @@ static void read_r_data(esp_efuse_block_t num_block, uint32_t* buf_r_data)
     }
 }
 
-// After esp_efuse_write.. functions EFUSE_BLKx_WDATAx_REG were filled is not coded values.
-// This function reads EFUSE_BLKx_WDATAx_REG registers, applies coding scheme and writes encoded values back to EFUSE_BLKx_WDATAx_REG.
+// This function just checkes that given data for blocks will not rise a coding issue during the burn operation.
+// Encoded data will be set during the burn operation.
 esp_err_t esp_efuse_utility_apply_new_coding_scheme()
 {
-    uint8_t buf_w_data[COUNT_EFUSE_REG_PER_BLOCK * 4];
     uint8_t buf_r_data[COUNT_EFUSE_REG_PER_BLOCK * 4];
-    uint32_t reg[COUNT_EFUSE_REG_PER_BLOCK];
     // start with EFUSE_BLK1. EFUSE_BLK0 - always uses EFUSE_CODING_SCHEME_NONE.
     for (int num_block = EFUSE_BLK1; num_block < EFUSE_BLK_MAX; num_block++) {
         esp_efuse_coding_scheme_t scheme = esp_efuse_get_coding_scheme(num_block);
-        // check and apply a new coding scheme.
         if (scheme != EFUSE_CODING_SCHEME_NONE) {
-            memset(buf_w_data, 0, sizeof(buf_w_data));
-            memset((uint8_t*)reg, 0, sizeof(reg));
-            if (read_w_data_and_check_fill(num_block, (uint32_t*)buf_w_data) == true) {
+            bool is_write_data = false;
+            for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4) {
+                if (REG_READ(addr_wr_block)) {
+                    is_write_data = true;
+                    break;
+                }
+            }
+            if (is_write_data) {
                 read_r_data(num_block, (uint32_t*)buf_r_data);
+                uint8_t* buf_w_data = (uint8_t*)range_write_addr_blocks[num_block].start;
                 if (scheme == EFUSE_CODING_SCHEME_3_4) {
                     if (*((uint32_t*)buf_w_data + 6) != 0 || *((uint32_t*)buf_w_data + 7) != 0) {
                         return ESP_ERR_CODING;
                     }
-                    for (int i = 0; i < 24; ++i) {
+                    for (int i = 0; i < ESP_EFUSE_LEN_OF_3_4_SCHEME_BLOCK_IN_BYTES; ++i) {
                         if (buf_w_data[i] != 0) {
                             int st_offset_buf = (i / 6) * 6;
                             // check that place is free.
@@ -170,32 +241,14 @@ esp_err_t esp_efuse_utility_apply_new_coding_scheme()
                                     return ESP_ERR_CODING;
                                 }
                             }
-
-                            esp_err_t err = esp_efuse_utility_apply_34_encoding(&buf_w_data[st_offset_buf], reg, 6);
-                            if (err != ESP_OK) {
-                                return err;
-                            }
-
-                            int num_reg = (st_offset_buf / 6) * 2;
-                            for (int r = 0; r < 2; r++) {
-                                REG_WRITE(range_write_addr_blocks[num_block].start + (num_reg + r) * 4, reg[r]);
-                            }
-                            i = st_offset_buf + 5;
                         }
                     }
                 } else if (scheme == EFUSE_CODING_SCHEME_REPEAT) {
-                    uint32_t* buf_32 = (uint32_t*)buf_w_data;
                     for (int i = 4; i < 8; ++i) {
-                        if (*(buf_32 + i) != 0) {
+                        if (*((uint32_t*)buf_w_data + i) != 0) {
                             return ESP_ERR_CODING;
                         }
                     }
-                    for (int i = 0; i < 4; ++i) {
-                        if (buf_32[i] != 0) {
-                            REG_WRITE(range_write_addr_blocks[num_block].start + i * 4, buf_32[i]);
-                            REG_WRITE(range_write_addr_blocks[num_block].start + (i + 4) * 4, buf_32[i]);
-                        }
-                    }
                 }
             }
         }

components/efuse/esp32/private_include/esp_efuse_utility.h

@@ -10,6 +10,9 @@
 extern "C" {
 #endif
 
+#define ESP_EFUSE_LEN_OF_3_4_SCHEME_BLOCK_IN_BYTES (24)
+#define ESP_EFUSE_LEN_OF_REPEAT_BLOCK_IN_BYTES (16)
+
 #define COUNT_EFUSE_REG_PER_BLOCK 8      /* The number of registers per block. */
 
 #define ESP_EFUSE_SECURE_VERSION_NUM_BLOCK EFUSE_BLK3

components/efuse/esp32c2/esp_efuse_utility.c

@@ -12,6 +12,7 @@
 #include "soc/efuse_periph.h"
 #include "esp_private/esp_clk.h"
 #include "esp32c2/rom/efuse.h"
+#include "hal/efuse_hal.h"
 
 static const char *TAG = "efuse";
 
@@ -54,8 +55,9 @@ void esp_efuse_utility_clear_program_registers(void)
 }
 
 // Burn values written to the efuse write registers
-void esp_efuse_utility_burn_chip(void)
+esp_err_t esp_efuse_utility_burn_chip(void)
 {
+    esp_err_t error = ESP_OK;
 #ifdef CONFIG_EFUSE_VIRTUAL
     ESP_LOGW(TAG, "Virtual efuses enabled: Not really burning eFuses");
     for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
@@ -67,30 +69,90 @@ void esp_efuse_utility_burn_chip(void)
 #ifdef CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH
     esp_efuse_utility_write_efuses_to_flash();
 #endif
-#else
+#else // CONFIG_EFUSE_VIRTUAL
     if (esp_efuse_set_timing() != ESP_OK) {
         ESP_LOGE(TAG, "Efuse fields are not burnt");
     } else {
         // Permanently update values written to the efuse write registers
         // It is necessary to process blocks in the order from MAX-> EFUSE_BLK0, because EFUSE_BLK0 has protection bits for other blocks.
         for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
+            bool need_burn_block = false;
             for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4) {
                 if (REG_READ(addr_wr_block) != 0) {
-                    if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
-                        uint8_t block_rs[12];
-                        ets_efuse_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-                        memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-                    }
-                    int data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
-                    ets_efuse_program(num_block);
+                    need_burn_block = true;
                     break;
                 }
             }
+            if (!need_burn_block) {
+                continue;
+            }
+            if (error) {
+                // It is done for a use case: BLOCK2 (Flash encryption key) could have an error (incorrect written data)
+                // in this case we can not burn any data into BLOCK0 because it might set read/write protections of BLOCK2.
+                ESP_LOGE(TAG, "BLOCK%d can not be burned because a previous block got an error, skipped.", num_block);
+                continue;
+            }
+            efuse_hal_clear_program_registers();
+            if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
+                uint8_t block_rs[12];
+                efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
+                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
+            }
+            unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
+            unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
+            memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
+
+            uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
+            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
+            int repeat_burn_op = 1;
+            bool correct_written_data;
+            bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
+            if (coding_error_before) {
+                ESP_LOGW(TAG, "BLOCK%d already has a coding error", num_block);
+            }
+            bool coding_error_occurred;
+
+            do {
+                ESP_LOGI(TAG, "BURN BLOCK%d", num_block);
+                efuse_hal_program(num_block); // BURN a block
+
+                bool coding_error_after;
+                for (unsigned i = 0; i < 5; i++) {
+                    efuse_hal_read();
+                    coding_error_after = efuse_hal_is_coding_error_in_block(num_block);
+                    if (coding_error_after == true) {
+                        break;
+                    }
+                }
+                coding_error_occurred = (coding_error_before != coding_error_after) && coding_error_before == false;
+                if (coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d got a coding error", num_block);
+                }
+
+                correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
+                if (!correct_written_data || coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
+                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
+                }
+
+            } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);
+
+            if (coding_error_occurred) {
+                ESP_LOGW(TAG, "Coding error was not fixed");
+                if (num_block == 0) {
+                    ESP_LOGE(TAG, "BLOCK0 got a coding error, which might be critical for security");
+                    error = ESP_FAIL;
+                }
+            }
+            if (!correct_written_data) {
+                ESP_LOGE(TAG, "Written data are incorrect");
+                error = ESP_FAIL;
+            }
         }
     }
 #endif // CONFIG_EFUSE_VIRTUAL
     esp_efuse_utility_reset();
+    return error;
 }
 
 // After esp_efuse_write.. functions EFUSE_BLKx_WDATAx_REG were filled is not coded values.

components/efuse/esp32c3/esp_efuse_utility.c

@@ -69,8 +69,9 @@ void esp_efuse_utility_clear_program_registers(void)
 }
 
 // Burn values written to the efuse write registers
-void esp_efuse_utility_burn_chip(void)
+esp_err_t esp_efuse_utility_burn_chip(void)
 {
+    esp_err_t error = ESP_OK;
 #ifdef CONFIG_EFUSE_VIRTUAL
     ESP_LOGW(TAG, "Virtual efuses enabled: Not really burning eFuses");
     for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
@@ -82,30 +83,90 @@ void esp_efuse_utility_burn_chip(void)
 #ifdef CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH
     esp_efuse_utility_write_efuses_to_flash();
 #endif
-#else
+#else // CONFIG_EFUSE_VIRTUAL
     if (esp_efuse_set_timing() != ESP_OK) {
         ESP_LOGE(TAG, "Efuse fields are not burnt");
     } else {
         // Permanently update values written to the efuse write registers
         // It is necessary to process blocks in the order from MAX-> EFUSE_BLK0, because EFUSE_BLK0 has protection bits for other blocks.
         for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
+            bool need_burn_block = false;
             for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4) {
                 if (REG_READ(addr_wr_block) != 0) {
-                    if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
-                        uint8_t block_rs[12];
-                        efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-                        memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-                    }
-                    int data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
-                    efuse_hal_program(num_block);
+                    need_burn_block = true;
                     break;
                 }
             }
+            if (!need_burn_block) {
+                continue;
+            }
+            if (error) {
+                // It is done for a use case: BLOCK2 (Flash encryption key) could have an error (incorrect written data)
+                // in this case we can not burn any data into BLOCK0 because it might set read/write protections of BLOCK2.
+                ESP_LOGE(TAG, "BLOCK%d can not be burned because a previous block got an error, skipped.", num_block);
+                continue;
+            }
+            efuse_hal_clear_program_registers();
+            if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
+                uint8_t block_rs[12];
+                efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
+                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
+            }
+            unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
+            unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
+            memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
+
+            uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
+            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
+            int repeat_burn_op = 1;
+            bool correct_written_data;
+            bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
+            if (coding_error_before) {
+                ESP_LOGW(TAG, "BLOCK%d already has a coding error", num_block);
+            }
+            bool coding_error_occurred;
+
+            do {
+                ESP_LOGI(TAG, "BURN BLOCK%d", num_block);
+                efuse_hal_program(num_block); // BURN a block
+
+                bool coding_error_after;
+                for (unsigned i = 0; i < 5; i++) {
+                    efuse_hal_read();
+                    coding_error_after = efuse_hal_is_coding_error_in_block(num_block);
+                    if (coding_error_after == true) {
+                        break;
+                    }
+                }
+                coding_error_occurred = (coding_error_before != coding_error_after) && coding_error_before == false;
+                if (coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d got a coding error", num_block);
+                }
+
+                correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
+                if (!correct_written_data || coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
+                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
+                }
+
+            } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);
+
+            if (coding_error_occurred) {
+                ESP_LOGW(TAG, "Coding error was not fixed");
+                if (num_block == 0) {
+                    ESP_LOGE(TAG, "BLOCK0 got a coding error, which might be critical for security");
+                    error = ESP_FAIL;
+                }
+            }
+            if (!correct_written_data) {
+                ESP_LOGE(TAG, "Written data are incorrect");
+                error = ESP_FAIL;
+            }
         }
     }
 #endif // CONFIG_EFUSE_VIRTUAL
     esp_efuse_utility_reset();
+    return error;
 }
 
 // After esp_efuse_write.. functions EFUSE_BLKx_WDATAx_REG were filled is not coded values.

components/efuse/esp32h2/esp_efuse_utility.c

@@ -69,8 +69,9 @@ void esp_efuse_utility_clear_program_registers(void)
 }
 
 // Burn values written to the efuse write registers
-void esp_efuse_utility_burn_chip(void)
+esp_err_t esp_efuse_utility_burn_chip(void)
 {
+    esp_err_t error = ESP_OK;
 #ifdef CONFIG_EFUSE_VIRTUAL
     ESP_LOGW(TAG, "Virtual efuses enabled: Not really burning eFuses");
     for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
@@ -82,30 +83,90 @@ void esp_efuse_utility_burn_chip(void)
 #ifdef CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH
     esp_efuse_utility_write_efuses_to_flash();
 #endif
-#else
+#else // CONFIG_EFUSE_VIRTUAL
     if (esp_efuse_set_timing() != ESP_OK) {
         ESP_LOGE(TAG, "Efuse fields are not burnt");
     } else {
         // Permanently update values written to the efuse write registers
         // It is necessary to process blocks in the order from MAX-> EFUSE_BLK0, because EFUSE_BLK0 has protection bits for other blocks.
         for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
+            bool need_burn_block = false;
             for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4) {
                 if (REG_READ(addr_wr_block) != 0) {
-                    if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
-                        uint8_t block_rs[12];
-                        efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-                        memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-                    }
-                    int data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
-                    efuse_hal_program(num_block);
+                    need_burn_block = true;
                     break;
                 }
             }
+            if (!need_burn_block) {
+                continue;
+            }
+            if (error) {
+                // It is done for a use case: BLOCK2 (Flash encryption key) could have an error (incorrect written data)
+                // in this case we can not burn any data into BLOCK0 because it might set read/write protections of BLOCK2.
+                ESP_LOGE(TAG, "BLOCK%d can not be burned because a previous block got an error, skipped.", num_block);
+                continue;
+            }
+            efuse_hal_clear_program_registers();
+            if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
+                uint8_t block_rs[12];
+                efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
+                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
+            }
+            unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
+            unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
+            memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
+
+            uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
+            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
+            int repeat_burn_op = 1;
+            bool correct_written_data;
+            bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
+            if (coding_error_before) {
+                ESP_LOGW(TAG, "BLOCK%d already has a coding error", num_block);
+            }
+            bool coding_error_occurred;
+
+            do {
+                ESP_LOGI(TAG, "BURN BLOCK%d", num_block);
+                efuse_hal_program(num_block); // BURN a block
+
+                bool coding_error_after;
+                for (unsigned i = 0; i < 5; i++) {
+                    efuse_hal_read();
+                    coding_error_after = efuse_hal_is_coding_error_in_block(num_block);
+                    if (coding_error_after == true) {
+                        break;
+                    }
+                }
+                coding_error_occurred = (coding_error_before != coding_error_after) && coding_error_before == false;
+                if (coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d got a coding error", num_block);
+                }
+
+                correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
+                if (!correct_written_data || coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
+                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
+                }
+
+            } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);
+
+            if (coding_error_occurred) {
+                ESP_LOGW(TAG, "Coding error was not fixed");
+                if (num_block == 0) {
+                    ESP_LOGE(TAG, "BLOCK0 got a coding error, which might be critical for security");
+                    error = ESP_FAIL;
+                }
+            }
+            if (!correct_written_data) {
+                ESP_LOGE(TAG, "Written data are incorrect");
+                error = ESP_FAIL;
+            }
         }
     }
 #endif // CONFIG_EFUSE_VIRTUAL
     esp_efuse_utility_reset();
+    return error;
 }
 
 // After esp_efuse_write.. functions EFUSE_BLKx_WDATAx_REG were filled is not coded values.

components/efuse/esp32s2/esp_efuse_utility.c

@@ -69,8 +69,9 @@ void esp_efuse_utility_clear_program_registers(void)
 }
 
 // Burn values written to the efuse write registers
-void esp_efuse_utility_burn_chip(void)
+esp_err_t esp_efuse_utility_burn_chip(void)
 {
+    esp_err_t error = ESP_OK;
 #ifdef CONFIG_EFUSE_VIRTUAL
     ESP_LOGW(TAG, "Virtual efuses enabled: Not really burning eFuses");
     for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
@@ -82,30 +83,90 @@ void esp_efuse_utility_burn_chip(void)
 #ifdef CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH
     esp_efuse_utility_write_efuses_to_flash();
 #endif
-#else
+#else // CONFIG_EFUSE_VIRTUAL
     if (esp_efuse_set_timing() != ESP_OK) {
         ESP_LOGE(TAG, "Efuse fields are not burnt");
     } else {
         // Permanently update values written to the efuse write registers
         // It is necessary to process blocks in the order from MAX-> EFUSE_BLK0, because EFUSE_BLK0 has protection bits for other blocks.
         for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
+            bool need_burn_block = false;
             for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4) {
                 if (REG_READ(addr_wr_block) != 0) {
-                    if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
-                        uint8_t block_rs[12];
-                        efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-                        memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-                    }
-                    int data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
-                    efuse_hal_program(num_block);
+                    need_burn_block = true;
                     break;
                 }
             }
+            if (!need_burn_block) {
+                continue;
+            }
+            if (error) {
+                // It is done for a use case: BLOCK2 (Flash encryption key) could have an error (incorrect written data)
+                // in this case we can not burn any data into BLOCK0 because it might set read/write protections of BLOCK2.
+                ESP_LOGE(TAG, "BLOCK%d can not be burned because a previous block got an error, skipped.", num_block);
+                continue;
+            }
+            efuse_hal_clear_program_registers();
+            if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
+                uint8_t block_rs[12];
+                efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
+                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
+            }
+            unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
+            unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
+            memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
+
+            uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
+            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
+            int repeat_burn_op = 1;
+            bool correct_written_data;
+            bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
+            if (coding_error_before) {
+                ESP_LOGW(TAG, "BLOCK%d already has a coding error", num_block);
+            }
+            bool coding_error_occurred;
+
+            do {
+                ESP_LOGI(TAG, "BURN BLOCK%d", num_block);
+                efuse_hal_program(num_block); // BURN a block
+
+                bool coding_error_after;
+                for (unsigned i = 0; i < 5; i++) {
+                    efuse_hal_read();
+                    coding_error_after = efuse_hal_is_coding_error_in_block(num_block);
+                    if (coding_error_after == true) {
+                        break;
+                    }
+                }
+                coding_error_occurred = (coding_error_before != coding_error_after) && coding_error_before == false;
+                if (coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d got a coding error", num_block);
+                }
+
+                correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
+                if (!correct_written_data || coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
+                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
+                }
+
+            } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);
+
+            if (coding_error_occurred) {
+                ESP_LOGW(TAG, "Coding error was not fixed");
+                if (num_block == 0) {
+                    ESP_LOGE(TAG, "BLOCK0 got a coding error, which might be critical for security");
+                    error = ESP_FAIL;
+                }
+            }
+            if (!correct_written_data) {
+                ESP_LOGE(TAG, "Written data are incorrect");
+                error = ESP_FAIL;
+            }
         }
     }
 #endif // CONFIG_EFUSE_VIRTUAL
     esp_efuse_utility_reset();
+    return error;
 }
 
 // After esp_efuse_write.. functions EFUSE_BLKx_WDATAx_REG were filled is not coded values.

components/efuse/esp32s3/esp_efuse_utility.c

@@ -69,8 +69,9 @@ void esp_efuse_utility_clear_program_registers(void)
 }
 
 // Burn values written to the efuse write registers
-void esp_efuse_utility_burn_chip(void)
+esp_err_t esp_efuse_utility_burn_chip(void)
 {
+    esp_err_t error = ESP_OK;
 #ifdef CONFIG_EFUSE_VIRTUAL
     ESP_LOGW(TAG, "Virtual efuses enabled: Not really burning eFuses");
     for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
@@ -82,30 +83,90 @@ void esp_efuse_utility_burn_chip(void)
 #ifdef CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH
     esp_efuse_utility_write_efuses_to_flash();
 #endif
-#else
+#else // CONFIG_EFUSE_VIRTUAL
     if (esp_efuse_set_timing() != ESP_OK) {
         ESP_LOGE(TAG, "Efuse fields are not burnt");
     } else {
         // Permanently update values written to the efuse write registers
         // It is necessary to process blocks in the order from MAX-> EFUSE_BLK0, because EFUSE_BLK0 has protection bits for other blocks.
         for (int num_block = EFUSE_BLK_MAX - 1; num_block >= EFUSE_BLK0; num_block--) {
+            bool need_burn_block = false;
             for (uint32_t addr_wr_block = range_write_addr_blocks[num_block].start; addr_wr_block <= range_write_addr_blocks[num_block].end; addr_wr_block += 4) {
                 if (REG_READ(addr_wr_block) != 0) {
-                    if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
-                        uint8_t block_rs[12];
-                        efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
-                        memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
-                    }
-                    int data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
-                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
-                    efuse_hal_program(num_block);
+                    need_burn_block = true;
                     break;
                 }
             }
+            if (!need_burn_block) {
+                continue;
+            }
+            if (error) {
+                // It is done for a use case: BLOCK2 (Flash encryption key) could have an error (incorrect written data)
+                // in this case we can not burn any data into BLOCK0 because it might set read/write protections of BLOCK2.
+                ESP_LOGE(TAG, "BLOCK%d can not be burned because a previous block got an error, skipped.", num_block);
+                continue;
+            }
+            efuse_hal_clear_program_registers();
+            if (esp_efuse_get_coding_scheme(num_block) == EFUSE_CODING_SCHEME_RS) {
+                uint8_t block_rs[12];
+                efuse_hal_rs_calculate((void *)range_write_addr_blocks[num_block].start, block_rs);
+                memcpy((void *)EFUSE_PGM_CHECK_VALUE0_REG, block_rs, sizeof(block_rs));
+            }
+            unsigned r_data_len = (range_read_addr_blocks[num_block].end - range_read_addr_blocks[num_block].start) + sizeof(uint32_t);
+            unsigned data_len = (range_write_addr_blocks[num_block].end - range_write_addr_blocks[num_block].start) + sizeof(uint32_t);
+            memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)range_write_addr_blocks[num_block].start, data_len);
+
+            uint32_t backup_write_data[8 + 3]; // 8 words are data and 3 words are RS coding data
+            memcpy(backup_write_data, (void *)EFUSE_PGM_DATA0_REG, sizeof(backup_write_data));
+            int repeat_burn_op = 1;
+            bool correct_written_data;
+            bool coding_error_before = efuse_hal_is_coding_error_in_block(num_block);
+            if (coding_error_before) {
+                ESP_LOGW(TAG, "BLOCK%d already has a coding error", num_block);
+            }
+            bool coding_error_occurred;
+
+            do {
+                ESP_LOGI(TAG, "BURN BLOCK%d", num_block);
+                efuse_hal_program(num_block); // BURN a block
+
+                bool coding_error_after;
+                for (unsigned i = 0; i < 5; i++) {
+                    efuse_hal_read();
+                    coding_error_after = efuse_hal_is_coding_error_in_block(num_block);
+                    if (coding_error_after == true) {
+                        break;
+                    }
+                }
+                coding_error_occurred = (coding_error_before != coding_error_after) && coding_error_before == false;
+                if (coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d got a coding error", num_block);
+                }
+
+                correct_written_data = esp_efuse_utility_is_correct_written_data(num_block, r_data_len);
+                if (!correct_written_data || coding_error_occurred) {
+                    ESP_LOGW(TAG, "BLOCK%d: next retry to fix an error [%d/3]...", num_block, repeat_burn_op);
+                    memcpy((void *)EFUSE_PGM_DATA0_REG, (void *)backup_write_data, sizeof(backup_write_data));
+                }
+
+            } while ((!correct_written_data || coding_error_occurred) && repeat_burn_op++ < 3);
+
+            if (coding_error_occurred) {
+                ESP_LOGW(TAG, "Coding error was not fixed");
+                if (num_block == 0) {
+                    ESP_LOGE(TAG, "BLOCK0 got a coding error, which might be critical for security");
+                    error = ESP_FAIL;
+                }
+            }
+            if (!correct_written_data) {
+                ESP_LOGE(TAG, "Written data are incorrect");
+                error = ESP_FAIL;
+            }
         }
     }
 #endif // CONFIG_EFUSE_VIRTUAL
     esp_efuse_utility_reset();
+    return error;
 }
 
 // After esp_efuse_write.. functions EFUSE_BLKx_WDATAx_REG were filled is not coded values.

components/efuse/private_include/esp_efuse_utility.h

@@ -93,8 +93,12 @@ esp_err_t esp_efuse_utility_fill_buff(unsigned int num_reg, esp_efuse_block_t ef
  *
  * If CONFIG_EFUSE_VIRTUAL is set, writing will not be performed.
  * After the function is completed, the writing registers are cleared.
+ *
+ * @return
+ *      - ESP_OK: The operation was successfully completed.
+ *      - ESP_FAIL: The operation was not successfully completed.
  */
-void esp_efuse_utility_burn_efuses(void);
+esp_err_t esp_efuse_utility_burn_efuses(void);
 
 /**
  * @brief Chip specific operations to perform the burn of values written to the efuse write registers.
@@ -103,8 +107,12 @@ void esp_efuse_utility_burn_efuses(void);
  *
  * If CONFIG_EFUSE_VIRTUAL is set, writing will not be performed.
  * After the function is completed, the writing registers are cleared.
+ *
+ * @return
+ *      - ESP_OK: The operation was successfully completed.
+ *      - ESP_FAIL: The operation was not successfully completed.
  */
-void esp_efuse_utility_burn_chip(void);
+esp_err_t esp_efuse_utility_burn_chip(void);
 
 /**
  * @brief Returns the number of array elements for placing these "bits" in an array with the length of each element equal to "size_of_base".
@@ -189,6 +197,19 @@ void esp_efuse_utility_erase_efuses_in_flash(void);
  */
 uint32_t esp_efuse_utility_get_read_register_address(esp_efuse_block_t block);
 
+/**
+ * @brief Checks the correctness of burned data in the given block.
+ *
+ * @note Internal use. Do not call it.
+ *
+ * @param[in] block Index of efuse block.
+ * @param[in] r_data_len Block length for reading data in bytes (multiple of 4).
+ *
+ * @return True  - written data are correct.
+ *         False - written data are incorrect.
+ */
+bool esp_efuse_utility_is_correct_written_data(esp_efuse_block_t block, unsigned r_data_len);
+
 #ifdef __cplusplus
 }
 #endif

components/efuse/src/esp_efuse_api.c

@@ -94,7 +94,7 @@ esp_err_t esp_efuse_write_field_blob(const esp_efuse_desc_t* field[], const void
             if (err == ESP_OK) {
                 err = esp_efuse_utility_apply_new_coding_scheme();
                 if (err == ESP_OK) {
-                    esp_efuse_utility_burn_efuses();
+                    err = esp_efuse_utility_burn_efuses();
                 }
             }
             esp_efuse_utility_reset();
@@ -129,7 +129,7 @@ esp_err_t esp_efuse_write_field_cnt(const esp_efuse_desc_t* field[], size_t cnt)
             if (err == ESP_OK) {
                 err = esp_efuse_utility_apply_new_coding_scheme();
                 if (err == ESP_OK) {
-                    esp_efuse_utility_burn_efuses();
+                    err = esp_efuse_utility_burn_efuses();
                 }
             }
             esp_efuse_utility_reset();
@@ -194,7 +194,7 @@ esp_err_t esp_efuse_write_reg(esp_efuse_block_t blk, unsigned int num_reg, uint3
         if (err == ESP_OK) {
             err = esp_efuse_utility_apply_new_coding_scheme();
             if (err == ESP_OK) {
-                esp_efuse_utility_burn_efuses();
+                err = esp_efuse_utility_burn_efuses();
             }
         }
         esp_efuse_utility_reset();
@@ -277,7 +277,7 @@ esp_err_t esp_efuse_batch_write_commit(void)
     if (--s_batch_writing_mode == 0) {
         esp_err_t err = esp_efuse_utility_apply_new_coding_scheme();
         if (err == ESP_OK) {
-            esp_efuse_utility_burn_efuses();
+            err = esp_efuse_utility_burn_efuses();
             ESP_LOGI(TAG, "Batch mode. Prepared fields are committed");
         } else {
             esp_efuse_utility_reset();

components/efuse/src/esp_efuse_utility.c

@@ -165,11 +165,12 @@ void esp_efuse_utility_reset(void)
 }
 
 // Burn values written to the efuse write registers
-void esp_efuse_utility_burn_efuses(void)
+esp_err_t esp_efuse_utility_burn_efuses(void)
 {
     ++s_burn_counter;
-    esp_efuse_utility_burn_chip();
+    esp_err_t err = esp_efuse_utility_burn_chip();
     ++s_burn_counter;
+    return err;
 }
 
 // Erase the virt_blocks array.
@@ -474,3 +475,29 @@ void esp_efuse_utility_write_efuses_to_flash(void)
     }
 }
 #endif // CONFIG_EFUSE_VIRTUAL_KEEP_IN_FLASH
+
+bool esp_efuse_utility_is_correct_written_data(esp_efuse_block_t block, unsigned r_data_len)
+{
+    uint32_t* w_data = (uint32_t*)range_write_addr_blocks[block].start;
+    uint32_t* r_data = (uint32_t*)range_read_addr_blocks[block].start;
+
+    bool correct_written_data = memcmp(w_data, r_data, r_data_len) == 0;
+    if (correct_written_data) {
+        ESP_LOGI(TAG, "BURN BLOCK%d - OK (write block == read block)", block);
+        return true;
+    }
+
+    correct_written_data = true;
+    for (unsigned i = 0; i < r_data_len / 4; i++) {
+        if ((*(r_data + i) & *(w_data + i)) != *(w_data + i)) {
+            correct_written_data = false;
+            break;
+        }
+    }
+    if (correct_written_data) {
+        ESP_LOGI(TAG, "BURN BLOCK%d - OK (all write block bits are set)", block);
+    } else {
+        ESP_LOGE(TAG, "BURN BLOCK%d - ERROR (written bits != read bits)", block);
+    }
+    return correct_written_data;
+}

components/efuse/test/three_key_blocks/test_efuse_coding_scheme.c

@@ -173,7 +173,7 @@ TEST_CASE("Test Coding Scheme for efuse manager", "[efuse]")
         }
         printf("\n");
 #endif
-        TEST_ASSERT_EQUAL_HEX32_ARRAY(encoded, w_data_after_coding, 8);
+        TEST_ASSERT_EQUAL_HEX32_ARRAY(buf, w_data_after_coding, 8);
     }
     esp_efuse_utility_reset();
     bootloader_random_disable();
@@ -197,7 +197,7 @@ TEST_CASE("Test data does not match the coding scheme", "[efuse]")
     esp_efuse_utility_reset();
 
     for (int i = 0; i < count_useful_reg; ++i) {
-        REG_WRITE(EFUSE_BLK2_WDATA0_REG + i * 4, 0xABCDEF01 + i);
+        TEST_ESP_OK(esp_efuse_utility_write_reg(2, i, 0xABCDEF01 + i));
     }
 
     if (coding_scheme == EFUSE_CODING_SCHEME_NONE) {

components/efuse/test/with_key_purposes/test_efuse.c

@@ -105,7 +105,7 @@ TEST_CASE("Test a real write (FPGA)2", "[efuse]")
     esp_efuse_utility_debug_dump_blocks();
 
     ESP_LOGI(TAG, "2. Set a read protection for KEY3");
-    TEST_ESP_OK(esp_efuse_set_read_protect(ESP_EFUSE_KEY3));
+    TEST_ESP_OK(esp_efuse_set_read_protect(EFUSE_BLK_KEY3));
     TEST_ESP_OK(esp_efuse_read_field_blob(ESP_EFUSE_KEY3, &key, 256));
 #ifndef CONFIG_EFUSE_VIRTUAL
     TEST_ASSERT_EACH_EQUAL_HEX8(0, key, sizeof(key));

components/hal/esp32/efuse_hal.c

@@ -88,7 +88,18 @@ void efuse_hal_read(void)
 
 void efuse_hal_clear_program_registers(void)
 {
-    efuse_ll_set_conf_read_op_code();
+    for (uint32_t r = EFUSE_BLK0_WDATA0_REG; r <= EFUSE_BLK0_WDATA6_REG; r += 4) {
+        REG_WRITE(r, 0);
+    }
+    for (uint32_t r = EFUSE_BLK1_WDATA0_REG; r <= EFUSE_BLK1_WDATA7_REG; r += 4) {
+        REG_WRITE(r, 0);
+    }
+    for (uint32_t r = EFUSE_BLK2_WDATA0_REG; r <= EFUSE_BLK2_WDATA7_REG; r += 4) {
+        REG_WRITE(r, 0);
+    }
+    for (uint32_t r = EFUSE_BLK3_WDATA0_REG; r <= EFUSE_BLK3_WDATA7_REG; r += 4) {
+        REG_WRITE(r, 0);
+    }
 }
 
 void efuse_hal_program(uint32_t block)
@@ -103,3 +114,10 @@ void efuse_hal_program(uint32_t block)
 }
 
 /******************* eFuse control functions *************************/
+
+bool efuse_hal_is_coding_error_in_block(unsigned block)
+{
+    return block > 0 &&
+           efuse_ll_get_coding_scheme() == 1 && // 3/4 coding scheme
+           efuse_ll_get_dec_warnings(block);
+}

components/hal/esp32/include/hal/efuse_hal.h

@@ -50,6 +50,16 @@ void efuse_hal_clear_program_registers(void);
  */
 void efuse_hal_program(uint32_t block);
 
+/**
+ * @brief Checks coding error in a block
+ *
+ * @param block Index of efuse block
+ *
+ * @return True  - block has an error.
+ *         False - no error.
+ */
+bool efuse_hal_is_coding_error_in_block(unsigned block);
+
 #ifdef __cplusplus
 }
 #endif

components/hal/esp32/include/hal/efuse_ll.h

@@ -15,6 +15,8 @@
 extern "C" {
 #endif
 
+#define ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block) ((error_reg) & (0x0F << (4 * (block))))
+
 // Always inline these functions even no gcc optimization is applied.
 
 /******************* eFuse fields *************************/
@@ -151,6 +153,15 @@ __attribute__((always_inline)) static inline uint32_t efuse_ll_get_adc2_tp_high(
     return REG_GET_FIELD(EFUSE_BLK3_RDATA3_REG, EFUSE_RD_ADC2_TP_HIGH);
 }
 
+__attribute__((always_inline)) static inline bool efuse_ll_get_dec_warnings(unsigned block)
+{
+    if (block == 0 || block > 4) {
+        return false;
+    }
+    uint32_t error_reg = REG_GET_FIELD(EFUSE_DEC_STATUS_REG, EFUSE_DEC_WARNINGS);
+    return ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block - 1) != 0;
+}
+
 /******************* eFuse control functions *************************/
 
 __attribute__((always_inline)) static inline bool efuse_ll_get_cmd(void)

components/hal/esp32c2/efuse_hal.c

@@ -11,6 +11,7 @@
 #include "hal/efuse_hal.h"
 #include "hal/efuse_ll.h"
 
+#define ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block) ((error_reg) & (0x0F << (4 * (block))))
 
 uint32_t efuse_hal_get_chip_revision(void)
 {
@@ -61,3 +62,19 @@ void efuse_hal_rs_calculate(const void *data, void *rs_values)
 }
 
 /******************* eFuse control functions *************************/
+
+bool efuse_hal_is_coding_error_in_block(unsigned block)
+{
+    if (block == 0) {
+        for (unsigned i = 0; i < 5; i++) {
+            if (REG_READ(EFUSE_RD_REPEAT_ERR_REG + i * 4)) {
+                return true;
+            }
+        }
+    } else if (block <= 3) {
+        // EFUSE_RD_RS_ERR_REG: (hi) ----, ----, ----, ----, ----, BLOCK3, BLOCK2, BLOCK1 (low)
+        uint32_t error_reg = REG_READ(EFUSE_RD_RS_ERR_REG);
+        return ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block - 1) != 0;
+    }
+    return false;
+}

components/hal/esp32c2/include/hal/efuse_hal.h

@@ -54,6 +54,16 @@ void efuse_hal_program(uint32_t block);
  */
 void efuse_hal_rs_calculate(const void *data, void *rs_values);
 
+/**
+ * @brief Checks coding error in a block
+ *
+ * @param block Index of efuse block
+ *
+ * @return True  - block has an error.
+ *         False - no error.
+ */
+bool efuse_hal_is_coding_error_in_block(unsigned block);
+
 #ifdef __cplusplus
 }
 #endif

components/hal/esp32c3/efuse_hal.c

@@ -11,6 +11,7 @@
 #include "hal/efuse_hal.h"
 #include "hal/efuse_ll.h"
 
+#define ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block) ((error_reg) & (0x0F << (4 * (block))))
 
 uint32_t efuse_hal_get_chip_revision(void)
 {
@@ -61,3 +62,22 @@ void efuse_hal_rs_calculate(const void *data, void *rs_values)
 }
 
 /******************* eFuse control functions *************************/
+
+bool efuse_hal_is_coding_error_in_block(unsigned block)
+{
+    if (block == 0) {
+        for (unsigned i = 0; i < 5; i++) {
+            if (REG_READ(EFUSE_RD_REPEAT_ERR0_REG + i * 4)) {
+                return true;
+            }
+        }
+    } else if (block <= 10) {
+        // The order of error in these regs is different only for the C3 chip.
+        // EFUSE_RD_RS_ERR0_REG: (hi) BLOCK7, BLOCK6, BLOCK5, BLOCK4, BLOCK3, BLOCK2, BLOCK1, ------ (low)
+        // EFUSE_RD_RS_ERR1_REG:                                                      BLOCK9, BLOCK8
+        // BLOCK10 is not presented in the error regs.
+        uint32_t error_reg = REG_READ(EFUSE_RD_RS_ERR0_REG + (block / 8) * 4);
+        return ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block % 8) != 0;
+    }
+    return false;
+}

components/hal/esp32c3/include/hal/efuse_hal.h

@@ -54,6 +54,16 @@ void efuse_hal_program(uint32_t block);
  */
 void efuse_hal_rs_calculate(const void *data, void *rs_values);
 
+/**
+ * @brief Checks coding error in a block
+ *
+ * @param block Index of efuse block
+ *
+ * @return True  - block has an error.
+ *         False - no error.
+ */
+bool efuse_hal_is_coding_error_in_block(unsigned block);
+
 #ifdef __cplusplus
 }
 #endif

components/hal/esp32h2/efuse_hal.c

@@ -11,6 +11,7 @@
 #include "hal/efuse_hal.h"
 #include "hal/efuse_ll.h"
 
+#define ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block) ((error_reg) & (0x0F << (4 * (block))))
 
 uint32_t efuse_hal_get_chip_revision(void)
 {
@@ -61,3 +62,21 @@ void efuse_hal_rs_calculate(const void *data, void *rs_values)
 }
 
 /******************* eFuse control functions *************************/
+
+bool efuse_hal_is_coding_error_in_block(unsigned block)
+{
+    if (block == 0) {
+        for (unsigned i = 0; i < 5; i++) {
+            if (REG_READ(EFUSE_RD_REPEAT_ERR0_REG + i * 4)) {
+                return true;
+            }
+        }
+    } else if (block <= 10) {
+        // EFUSE_RD_RS_ERR0_REG: (hi) BLOCK8, BLOCK7, BLOCK6, BLOCK5, BLOCK4, BLOCK3, BLOCK2, BLOCK1 (low)
+        // EFUSE_RD_RS_ERR1_REG:                                                     BLOCK10, BLOCK9
+        block--;
+        uint32_t error_reg = REG_READ(EFUSE_RD_RS_ERR0_REG + (block / 8) * 4);
+        return ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block % 8) != 0;
+    }
+    return false;
+}

components/hal/esp32h2/include/hal/efuse_hal.h

@@ -54,6 +54,16 @@ void efuse_hal_program(uint32_t block);
  */
 void efuse_hal_rs_calculate(const void *data, void *rs_values);
 
+/**
+ * @brief Checks coding error in a block
+ *
+ * @param block Index of efuse block
+ *
+ * @return True  - block has an error.
+ *         False - no error.
+ */
+bool efuse_hal_is_coding_error_in_block(unsigned block);
+
 #ifdef __cplusplus
 }
 #endif

components/hal/esp32s2/efuse_hal.c

@@ -12,6 +12,7 @@
 #include "hal/efuse_ll.h"
 #include "esp32s2/rom/efuse.h"
 
+#define ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block) ((error_reg) & (0x0F << (4 * (block))))
 
 uint32_t efuse_hal_get_chip_revision(void)
 {
@@ -46,3 +47,21 @@ void efuse_hal_rs_calculate(const void *data, void *rs_values)
 }
 
 /******************* eFuse control functions *************************/
+
+bool efuse_hal_is_coding_error_in_block(unsigned block)
+{
+    if (block == 0) {
+        for (unsigned i = 0; i < 5; i++) {
+            if (REG_READ(EFUSE_RD_REPEAT_ERR0_REG + i * 4)) {
+                return true;
+            }
+        }
+    } else if (block <= 10) {
+        // EFUSE_RD_RS_ERR0_REG: (hi) BLOCK8, BLOCK7, BLOCK6, BLOCK5, BLOCK4, BLOCK3, BLOCK2, BLOCK1 (low)
+        // EFUSE_RD_RS_ERR1_REG:                                                     BLOCK10, BLOCK9
+        block--;
+        uint32_t error_reg = REG_READ(EFUSE_RD_RS_ERR0_REG + (block / 8) * 4);
+        return ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block % 8) != 0;
+    }
+    return false;
+}

components/hal/esp32s2/include/hal/efuse_hal.h

@@ -53,6 +53,16 @@ void efuse_hal_program(uint32_t block);
  */
 void efuse_hal_rs_calculate(const void *data, void *rs_values);
 
+/**
+ * @brief Checks coding error in a block
+ *
+ * @param block Index of efuse block
+ *
+ * @return True  - block has an error.
+ *         False - no error.
+ */
+bool efuse_hal_is_coding_error_in_block(unsigned block);
+
 #ifdef __cplusplus
 }
 #endif

components/hal/esp32s3/efuse_hal.c

@@ -12,6 +12,8 @@
 #include "hal/efuse_ll.h"
 #include "esp32s3/rom/efuse.h"
 
+#define ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block) ((error_reg) & (0x0F << (4 * (block))))
+
 uint32_t efuse_hal_get_chip_revision(void)
 {
     return efuse_ll_get_chip_revision();
@@ -61,3 +63,21 @@ void efuse_hal_rs_calculate(const void *data, void *rs_values)
 }
 
 /******************* eFuse control functions *************************/
+
+bool efuse_hal_is_coding_error_in_block(unsigned block)
+{
+    if (block == 0) {
+        for (unsigned i = 0; i < 5; i++) {
+            if (REG_READ(EFUSE_RD_REPEAT_ERR0_REG + i * 4)) {
+                return true;
+            }
+        }
+    } else if (block <= 10) {
+        // EFUSE_RD_RS_ERR0_REG: (hi) BLOCK8, BLOCK7, BLOCK6, BLOCK5, BLOCK4, BLOCK3, BLOCK2, BLOCK1 (low)
+        // EFUSE_RD_RS_ERR1_REG:                                                     BLOCK10, BLOCK9
+        block--;
+        uint32_t error_reg = REG_READ(EFUSE_RD_RS_ERR0_REG + (block / 8) * 4);
+        return ESP_EFUSE_BLOCK_ERROR_BITS(error_reg, block % 8) != 0;
+    }
+    return false;
+}

components/hal/esp32s3/include/hal/efuse_hal.h

@@ -54,6 +54,16 @@ void efuse_hal_program(uint32_t block);
  */
 void efuse_hal_rs_calculate(const void *data, void *rs_values);
 
+/**
+ * @brief Checks coding error in a block
+ *
+ * @param block Index of efuse block
+ *
+ * @return True  - block has an error.
+ *         False - no error.
+ */
+bool efuse_hal_is_coding_error_in_block(unsigned block);
+
 #ifdef __cplusplus
 }
 #endif