From df30b362a84eecd8ee4f1a97d407968fb23267cf Mon Sep 17 00:00:00 2001 From: Konstantin Kondrashov Date: Wed, 27 Apr 2022 01:10:41 +0800 Subject: [PATCH] efuse: Validates data after burning and re-burnes it if necessary --- components/efuse/esp32/esp_efuse_utility.c | 183 +++++++++++------- .../esp32/private_include/esp_efuse_utility.h | 3 + components/efuse/esp32c2/esp_efuse_utility.c | 82 +++++++- components/efuse/esp32c3/esp_efuse_utility.c | 81 +++++++- components/efuse/esp32h2/esp_efuse_utility.c | 81 +++++++- components/efuse/esp32s2/esp_efuse_utility.c | 81 +++++++- components/efuse/esp32s3/esp_efuse_utility.c | 81 +++++++- .../efuse/private_include/esp_efuse_utility.h | 25 ++- components/efuse/src/esp_efuse_api.c | 8 +- components/efuse/src/esp_efuse_utility.c | 31 ++- .../test_efuse_coding_scheme.c | 4 +- .../efuse/test/with_key_purposes/test_efuse.c | 2 +- components/hal/esp32/efuse_hal.c | 20 +- components/hal/esp32/include/hal/efuse_hal.h | 10 + components/hal/esp32/include/hal/efuse_ll.h | 11 ++ components/hal/esp32c2/efuse_hal.c | 17 ++ .../hal/esp32c2/include/hal/efuse_hal.h | 10 + components/hal/esp32c3/efuse_hal.c | 20 ++ .../hal/esp32c3/include/hal/efuse_hal.h | 10 + components/hal/esp32h2/efuse_hal.c | 19 ++ .../hal/esp32h2/include/hal/efuse_hal.h | 10 + components/hal/esp32s2/efuse_hal.c | 19 ++ .../hal/esp32s2/include/hal/efuse_hal.h | 10 + components/hal/esp32s3/efuse_hal.c | 20 ++ .../hal/esp32s3/include/hal/efuse_hal.h | 10 + 25 files changed, 721 insertions(+), 127 deletions(-) diff --git a/components/efuse/esp32/esp_efuse_utility.c b/components/efuse/esp32/esp_efuse_utility.c index 81dadbc92f..c57672ecd3 100644 --- a/components/efuse/esp32/esp_efuse_utility.c +++ b/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]); - } - } } } } diff --git a/components/efuse/esp32/private_include/esp_efuse_utility.h b/components/efuse/esp32/private_include/esp_efuse_utility.h index 7916223843..7b88cf7b94 100644 --- a/components/efuse/esp32/private_include/esp_efuse_utility.h +++ b/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 diff --git a/components/efuse/esp32c2/esp_efuse_utility.c b/components/efuse/esp32c2/esp_efuse_utility.c index cd30697b6e..f322c2a437 100644 --- a/components/efuse/esp32c2/esp_efuse_utility.c +++ b/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. diff --git a/components/efuse/esp32c3/esp_efuse_utility.c b/components/efuse/esp32c3/esp_efuse_utility.c index 43a1084062..b3bb7524f5 100644 --- a/components/efuse/esp32c3/esp_efuse_utility.c +++ b/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. diff --git a/components/efuse/esp32h2/esp_efuse_utility.c b/components/efuse/esp32h2/esp_efuse_utility.c index 43a1084062..b3bb7524f5 100644 --- a/components/efuse/esp32h2/esp_efuse_utility.c +++ b/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. diff --git a/components/efuse/esp32s2/esp_efuse_utility.c b/components/efuse/esp32s2/esp_efuse_utility.c index 89f8439f67..b614fb5cbf 100644 --- a/components/efuse/esp32s2/esp_efuse_utility.c +++ b/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. diff --git a/components/efuse/esp32s3/esp_efuse_utility.c b/components/efuse/esp32s3/esp_efuse_utility.c index 92fc8b2494..8d73bc9d0d 100644 --- a/components/efuse/esp32s3/esp_efuse_utility.c +++ b/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. diff --git a/components/efuse/private_include/esp_efuse_utility.h b/components/efuse/private_include/esp_efuse_utility.h index 3016d55dd2..0fd026e3e7 100644 --- a/components/efuse/private_include/esp_efuse_utility.h +++ b/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 diff --git a/components/efuse/src/esp_efuse_api.c b/components/efuse/src/esp_efuse_api.c index a89205fc82..09c55bb50c 100644 --- a/components/efuse/src/esp_efuse_api.c +++ b/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(); diff --git a/components/efuse/src/esp_efuse_utility.c b/components/efuse/src/esp_efuse_utility.c index 168dc821fb..07798fc5cb 100644 --- a/components/efuse/src/esp_efuse_utility.c +++ b/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; +} diff --git a/components/efuse/test/three_key_blocks/test_efuse_coding_scheme.c b/components/efuse/test/three_key_blocks/test_efuse_coding_scheme.c index fc19720bf4..97cb17a437 100644 --- a/components/efuse/test/three_key_blocks/test_efuse_coding_scheme.c +++ b/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) { diff --git a/components/efuse/test/with_key_purposes/test_efuse.c b/components/efuse/test/with_key_purposes/test_efuse.c index 6b2d53b550..42f1d8a03f 100644 --- a/components/efuse/test/with_key_purposes/test_efuse.c +++ b/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)); diff --git a/components/hal/esp32/efuse_hal.c b/components/hal/esp32/efuse_hal.c index 9a6ed6ab46..87ccafb690 100644 --- a/components/hal/esp32/efuse_hal.c +++ b/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); +} diff --git a/components/hal/esp32/include/hal/efuse_hal.h b/components/hal/esp32/include/hal/efuse_hal.h index 021f510c5f..fd751b0df9 100644 --- a/components/hal/esp32/include/hal/efuse_hal.h +++ b/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 diff --git a/components/hal/esp32/include/hal/efuse_ll.h b/components/hal/esp32/include/hal/efuse_ll.h index 7aa7adcd21..b0004e2742 100644 --- a/components/hal/esp32/include/hal/efuse_ll.h +++ b/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) diff --git a/components/hal/esp32c2/efuse_hal.c b/components/hal/esp32c2/efuse_hal.c index e805cd29ef..91cc452548 100644 --- a/components/hal/esp32c2/efuse_hal.c +++ b/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; +} diff --git a/components/hal/esp32c2/include/hal/efuse_hal.h b/components/hal/esp32c2/include/hal/efuse_hal.h index a6aaae0a18..b9b29a8598 100644 --- a/components/hal/esp32c2/include/hal/efuse_hal.h +++ b/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 diff --git a/components/hal/esp32c3/efuse_hal.c b/components/hal/esp32c3/efuse_hal.c index e805cd29ef..097834a9c7 100644 --- a/components/hal/esp32c3/efuse_hal.c +++ b/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; +} diff --git a/components/hal/esp32c3/include/hal/efuse_hal.h b/components/hal/esp32c3/include/hal/efuse_hal.h index a6aaae0a18..b9b29a8598 100644 --- a/components/hal/esp32c3/include/hal/efuse_hal.h +++ b/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 diff --git a/components/hal/esp32h2/efuse_hal.c b/components/hal/esp32h2/efuse_hal.c index e805cd29ef..edffad6088 100644 --- a/components/hal/esp32h2/efuse_hal.c +++ b/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; +} diff --git a/components/hal/esp32h2/include/hal/efuse_hal.h b/components/hal/esp32h2/include/hal/efuse_hal.h index a6aaae0a18..b9b29a8598 100644 --- a/components/hal/esp32h2/include/hal/efuse_hal.h +++ b/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 diff --git a/components/hal/esp32s2/efuse_hal.c b/components/hal/esp32s2/efuse_hal.c index eb39fff684..4ee41fcdf2 100644 --- a/components/hal/esp32s2/efuse_hal.c +++ b/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; +} diff --git a/components/hal/esp32s2/include/hal/efuse_hal.h b/components/hal/esp32s2/include/hal/efuse_hal.h index d6b09949ee..48d58bb46b 100644 --- a/components/hal/esp32s2/include/hal/efuse_hal.h +++ b/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 diff --git a/components/hal/esp32s3/efuse_hal.c b/components/hal/esp32s3/efuse_hal.c index 5bda5261e0..f855b64ef9 100644 --- a/components/hal/esp32s3/efuse_hal.c +++ b/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; +} diff --git a/components/hal/esp32s3/include/hal/efuse_hal.h b/components/hal/esp32s3/include/hal/efuse_hal.h index a6aaae0a18..b9b29a8598 100644 --- a/components/hal/esp32s3/include/hal/efuse_hal.h +++ b/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