mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
[esp_rom]: Partially buildable for linux
The following files have been ported: * esp_rom_crc.h * esp_rom_sys.h * esp_rom_efuse.h (mostly no-ops) * esp_rom_md5.h Integrated Linux-based rom implementation into log and NVS component. Added brief host tests for ROM to ensure basic consistency on Linux. Added ROM printf host unit tests. Temporarily added reset reason for Linux in ROM.
This commit is contained in:
Jakob Hasse
parent
b8c2825b21
commit
4dd88329c1
@ -355,3 +355,10 @@ test_eh_frame_parser:
|
||||
- cd ${IDF_PATH}/components/esp_system/test_eh_frame_parser
|
||||
- make
|
||||
- ./eh_frame_test
|
||||
|
||||
test_rom_on_linux_works:
|
||||
extends: .host_test_template
|
||||
script:
|
||||
- cd ${IDF_PATH}/components/esp_rom/host_test/rom_test
|
||||
- idf.py build
|
||||
- build/test_rom_host.elf
|
||||
|
||||
@ -1,16 +1,31 @@
|
||||
idf_build_get_property(target IDF_TARGET)
|
||||
|
||||
set(sources "patches/esp_rom_crc.c"
|
||||
"patches/esp_rom_sys.c"
|
||||
"patches/esp_rom_uart.c")
|
||||
set(include_dirs "include" "include/${target}")
|
||||
|
||||
set(private_required_comp "")
|
||||
|
||||
set(sources "")
|
||||
|
||||
if(target STREQUAL "linux")
|
||||
list(APPEND sources "${target}/esp_rom_sys.c"
|
||||
"${target}/esp_rom_crc.c"
|
||||
"${target}/esp_rom_md5.c"
|
||||
"${target}/esp_rom_efuse.c")
|
||||
else()
|
||||
list(APPEND include_dirs "${target}")
|
||||
list(APPEND sources "patches/esp_rom_crc.c"
|
||||
"patches/esp_rom_sys.c"
|
||||
"patches/esp_rom_uart.c")
|
||||
list(APPEND private_required_comp soc hal)
|
||||
endif()
|
||||
|
||||
if(CONFIG_IDF_TARGET_ARCH_XTENSA)
|
||||
list(APPEND sources "patches/esp_rom_longjmp.S")
|
||||
endif()
|
||||
|
||||
idf_component_register(SRCS ${sources}
|
||||
INCLUDE_DIRS include "${target}" "include/${target}"
|
||||
PRIV_REQUIRES soc hal)
|
||||
INCLUDE_DIRS ${include_dirs}
|
||||
PRIV_REQUIRES ${private_required_comp})
|
||||
|
||||
# Append a target linker script at the target-specific path,
|
||||
# only the 'name' part is different for each script
|
||||
@ -18,9 +33,16 @@ function(rom_linker_script name)
|
||||
target_linker_script(${COMPONENT_LIB} INTERFACE "${target}/ld/${target}.rom.${name}.ld")
|
||||
endfunction()
|
||||
|
||||
target_linker_script(${COMPONENT_LIB} INTERFACE "${target}/ld/${target}.rom.ld")
|
||||
rom_linker_script("api")
|
||||
rom_linker_script("libgcc")
|
||||
if(target STREQUAL "linux")
|
||||
# We need to disable some warnings due to the ROM code's printf implementation
|
||||
if(${CMAKE_CXX_COMPILER_VERSION} GREATER "7.0.0") # TODO: clang compatibility
|
||||
target_compile_options(${COMPONENT_LIB} PUBLIC -Wimplicit-fallthrough=0 -Wno-shift-count-overflow)
|
||||
endif()
|
||||
else()
|
||||
target_linker_script(${COMPONENT_LIB} INTERFACE "${target}/ld/${target}.rom.ld")
|
||||
rom_linker_script("api")
|
||||
rom_linker_script("libgcc")
|
||||
endif()
|
||||
|
||||
if(BOOTLOADER_BUILD)
|
||||
if(target STREQUAL "esp32")
|
||||
|
||||
5
components/esp_rom/host_test/rom_test/CMakeLists.txt
Normal file
5
components/esp_rom/host_test/rom_test/CMakeLists.txt
Normal file
@ -0,0 +1,5 @@
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
set(COMPONENTS main)
|
||||
project(test_rom_host)
|
||||
37
components/esp_rom/host_test/rom_test/README.md
Normal file
37
components/esp_rom/host_test/rom_test/README.md
Normal file
@ -0,0 +1,37 @@
|
||||
| Supported Targets | Linux |
|
||||
| ----------------- | ----- |
|
||||
|
||||
# Simplest rom test on Linux target
|
||||
|
||||
This unit test tests only if some of the supplied Linux functions seem to work correctly. The test framework is CATCH.
|
||||
|
||||
## Requirements
|
||||
|
||||
* A Linux system
|
||||
* The usual IDF requirements for Linux system, as described in the [Getting Started Guides](../../../../docs/en/get-started/index.rst).
|
||||
* The host's gcc/g++
|
||||
|
||||
This application has been tested on Ubuntu 20.04 with `gcc` version *9.3.0*.
|
||||
|
||||
## Build
|
||||
|
||||
First, make sure that the target is set to Linux. Run `idf.py --preview set-target linux` if you are not sure. Then do a normal IDF build: `idf.py build`.
|
||||
|
||||
## Run
|
||||
|
||||
IDF monitor doesn't work yet for Linux. You have to run the app manually:
|
||||
|
||||
```bash
|
||||
./build/test_rom_host.elf
|
||||
```
|
||||
|
||||
## Example Output
|
||||
|
||||
Ideally, all tests pass, which is indicated by "All tests passed" in the last line:
|
||||
|
||||
```bash
|
||||
$ ./build/test_rom_host.elf
|
||||
test
|
||||
===============================================================================
|
||||
All tests passed (8 assertions in 6 test cases)
|
||||
```
|
||||
@ -0,0 +1,5 @@
|
||||
idf_component_register(SRCS "rom_test.cpp"
|
||||
INCLUDE_DIRS
|
||||
"."
|
||||
$ENV{IDF_PATH}/tools/catch
|
||||
REQUIRES esp_rom)
|
||||
95
components/esp_rom/host_test/rom_test/main/rom_test.cpp
Normal file
95
components/esp_rom/host_test/rom_test/main/rom_test.cpp
Normal file
@ -0,0 +1,95 @@
|
||||
/* LOG unit tests
|
||||
|
||||
This example code is in the Public Domain (or CC0 licensed, at your option.)
|
||||
|
||||
Unless required by applicable law or agreed to in writing, this
|
||||
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
||||
CONDITIONS OF ANY KIND, either express or implied.
|
||||
|
||||
This is a very basic test to see whether the supplied linux functions appear to work correctly.
|
||||
|
||||
Note that the printf function is roughly tested in the log host test.
|
||||
*/
|
||||
#define CATCH_CONFIG_MAIN
|
||||
#include <cstdio>
|
||||
#include <regex>
|
||||
#include <cstring>
|
||||
#include "esp_rom_sys.h"
|
||||
#include "esp_rom_efuse.h"
|
||||
#include "esp_rom_crc.h"
|
||||
#include "esp_rom_md5.h"
|
||||
|
||||
#include "catch.hpp"
|
||||
|
||||
using namespace std;
|
||||
|
||||
static const char *TEST_TAG = "test";
|
||||
|
||||
// ESP_LOG_EARLY functions are tested in the log host tests and also test rom printf.
|
||||
TEST_CASE("esp_rom printf returns correct char num")
|
||||
{
|
||||
CHECK(esp_rom_printf("test\n") == 5);
|
||||
}
|
||||
|
||||
TEST_CASE("delay works")
|
||||
{
|
||||
const uint64_t DELAY = 100u;
|
||||
struct timespec current_time;
|
||||
CHECK(clock_gettime(CLOCK_MONOTONIC, ¤t_time) == 0);
|
||||
uint64_t start_us = current_time.tv_sec * 1000000 + current_time.tv_nsec / 1000;
|
||||
|
||||
esp_rom_delay_us(DELAY);
|
||||
|
||||
CHECK(clock_gettime(CLOCK_MONOTONIC, ¤t_time) == 0);
|
||||
uint64_t end_us = current_time.tv_sec * 1000000 + current_time.tv_nsec / 1000;
|
||||
|
||||
CHECK(start_us + DELAY <= end_us);
|
||||
}
|
||||
|
||||
TEST_CASE("crc quick check")
|
||||
{
|
||||
uint32_t expected_result = 0xd4dc5010;
|
||||
uint32_t result;
|
||||
const uint8_t original [] = {0x01, 0x21, 0x09, 0xff, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74,
|
||||
0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe5, 0x00, 0xff, 0xff, 0x06, 0xba, 0xe7, 0xa1};
|
||||
|
||||
result = esp_rom_crc32_le(0xffffffff, original, sizeof(original));
|
||||
|
||||
CHECK(result == expected_result);
|
||||
}
|
||||
|
||||
TEST_CASE("reset reason basic check")
|
||||
{
|
||||
CHECK(esp_rom_get_reset_reason(0) == RESET_REASON_CHIP_POWER_ON);
|
||||
}
|
||||
|
||||
TEST_CASE("flash gpio info")
|
||||
{
|
||||
CHECK(esp_rom_efuse_get_flash_gpio_info() == 0);
|
||||
}
|
||||
|
||||
TEST_CASE("get flash wp gpio")
|
||||
{
|
||||
CHECK(esp_rom_efuse_get_flash_wp_gpio() == 0);
|
||||
}
|
||||
|
||||
TEST_CASE("secure boot always disabled on Linux")
|
||||
{
|
||||
CHECK(esp_rom_efuse_is_secure_boot_enabled() == false);
|
||||
}
|
||||
|
||||
TEST_CASE("md5")
|
||||
{
|
||||
md5_context_t context;
|
||||
const uint8_t expected_result [16] = {0x00, 0x2e, 0x17, 0x69, 0x17, 0x24, 0x32, 0x78, 0x72, 0xf1, 0xaf, 0x42, 0x9f, 0x1c, 0xe4, 0xd9};
|
||||
uint8_t result [16] = {};
|
||||
const std::string MD5_TEST_STRING("This is an MD5 test");
|
||||
|
||||
esp_rom_md5_init(&context);
|
||||
esp_rom_md5_update(&context, MD5_TEST_STRING.c_str(), MD5_TEST_STRING.size());
|
||||
esp_rom_md5_final(result, &context);
|
||||
|
||||
for (int i = 0; i < 16; i++) {
|
||||
CHECK(result[i] == expected_result[i]);
|
||||
}
|
||||
}
|
||||
2
components/esp_rom/host_test/rom_test/sdkconfig.defaults
Normal file
2
components/esp_rom/host_test/rom_test/sdkconfig.defaults
Normal file
@ -0,0 +1,2 @@
|
||||
CONFIG_IDF_TARGET="linux"
|
||||
CONFIG_COMPILER_CXX_EXCEPTIONS=y
|
||||
@ -13,7 +13,7 @@
|
||||
// limitations under the License.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "sdkconfig.h"
|
||||
#include <stdint.h>
|
||||
#include "soc/reset_reasons.h"
|
||||
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
|
||||
// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
@ -11,24 +11,21 @@
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
#ifndef crc_h
|
||||
#define crc_h
|
||||
|
||||
#include <stdint.h>
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Mock function to replace ESP ROM function used in IDF with a Linux implementation.
|
||||
* Note: the name MUST have the prefix esp_rom_* since tools/ci/check_api_violation.sh checks and complains otherwise.
|
||||
* @brief Dummy to satisfy the requirement for this type on Linux targets.
|
||||
* Look at other reset_reasons.h files in IDF.
|
||||
*/
|
||||
uint32_t esp_rom_crc32_le(uint32_t crc, const uint8_t* buf, size_t len);
|
||||
typedef enum {
|
||||
RESET_REASON_CHIP_POWER_ON = 0x01, // Power on reset
|
||||
} soc_reset_reason_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* crc_h */
|
||||
226
components/esp_rom/linux/esp_rom_crc.c
Normal file
226
components/esp_rom/linux/esp_rom_crc.c
Normal file
@ -0,0 +1,226 @@
|
||||
// Copyright 2021 Espressif Systems (Shanghai) CO LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "esp_rom_crc.h"
|
||||
|
||||
static const uint32_t crc32_le_table[256] = {
|
||||
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,
|
||||
0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,
|
||||
0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,
|
||||
0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,
|
||||
0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
|
||||
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,
|
||||
0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,
|
||||
0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,
|
||||
0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,
|
||||
0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
|
||||
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,
|
||||
0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,
|
||||
0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,
|
||||
0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,
|
||||
0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
|
||||
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL,
|
||||
|
||||
0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L,
|
||||
0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L,
|
||||
0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L,
|
||||
0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
|
||||
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL,
|
||||
0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L,
|
||||
0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL,
|
||||
0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL,
|
||||
0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
|
||||
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L,
|
||||
0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L,
|
||||
0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L,
|
||||
0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL,
|
||||
0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
|
||||
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,
|
||||
0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL
|
||||
};
|
||||
|
||||
static uint32_t crc32_be_table[256] = {
|
||||
0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L, 0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
|
||||
0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L, 0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
|
||||
0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L, 0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
|
||||
0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L, 0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
|
||||
0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L, 0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
|
||||
0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L, 0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
|
||||
0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L, 0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
|
||||
0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L, 0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
|
||||
0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL, 0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
|
||||
0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L, 0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
|
||||
0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL, 0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
|
||||
0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L, 0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
|
||||
0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL, 0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
|
||||
0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L, 0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
|
||||
0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL, 0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
|
||||
0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L, 0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
|
||||
0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L, 0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
|
||||
0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL, 0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
|
||||
0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L, 0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
|
||||
0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL, 0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
|
||||
0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L, 0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
|
||||
0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL, 0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
|
||||
0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L, 0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
|
||||
0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL, 0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
|
||||
0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L, 0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
|
||||
0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L, 0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
|
||||
0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L, 0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
|
||||
0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L, 0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
|
||||
0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L, 0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
|
||||
0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L, 0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
|
||||
0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L, 0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
|
||||
0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L, 0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
|
||||
};
|
||||
|
||||
static uint16_t crc16_le_table[256] = {
|
||||
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 0x8c48, 0x9dc1,0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
|
||||
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 0x9cc9, 0x8d40,0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
|
||||
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 0xad4a, 0xbcc3,0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
|
||||
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 0xbdcb, 0xac42,0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
|
||||
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 0xce4c, 0xdfc5,0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
|
||||
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 0xdecd, 0xcf44,0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
|
||||
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 0xef4e, 0xfec7,0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
|
||||
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 0xffcf, 0xee46,0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
|
||||
|
||||
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 0x0840, 0x19c9,0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
|
||||
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 0x18c1, 0x0948,0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
|
||||
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 0x2942, 0x38cb,0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
|
||||
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 0x39c3, 0x284a,0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
|
||||
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 0x4a44, 0x5bcd,0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
|
||||
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 0x5ac5, 0x4b4c,0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
|
||||
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 0x6b46, 0x7acf,0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
|
||||
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 0x7bc7, 0x6a4e,0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
|
||||
};
|
||||
|
||||
static uint16_t crc16_be_table[256] = {
|
||||
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129,0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
|
||||
0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318,0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
|
||||
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b,0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
|
||||
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a,0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
|
||||
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed,0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
|
||||
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc,0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
|
||||
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f,0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
|
||||
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe,0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
|
||||
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1,0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
|
||||
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290,0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
|
||||
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3,0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
|
||||
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2,0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
|
||||
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865,0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
|
||||
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54,0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
|
||||
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07,0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
|
||||
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36,0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
|
||||
};
|
||||
|
||||
static uint8_t crc8_le_table[256] = {
|
||||
0x00, 0x91, 0xe3, 0x72, 0x07, 0x96, 0xe4, 0x75, 0x0e, 0x9f, 0xed, 0x7c, 0x09, 0x98, 0xea, 0x7b,
|
||||
0x1c, 0x8d, 0xff, 0x6e, 0x1b, 0x8a, 0xf8, 0x69, 0x12, 0x83, 0xf1, 0x60, 0x15, 0x84, 0xf6, 0x67,
|
||||
0x38, 0xa9, 0xdb, 0x4a, 0x3f, 0xae, 0xdc, 0x4d, 0x36, 0xa7, 0xd5, 0x44, 0x31, 0xa0, 0xd2, 0x43,
|
||||
0x24, 0xb5, 0xc7, 0x56, 0x23, 0xb2, 0xc0, 0x51, 0x2a, 0xbb, 0xc9, 0x58, 0x2d, 0xbc, 0xce, 0x5f,
|
||||
0x70, 0xe1, 0x93, 0x02, 0x77, 0xe6, 0x94, 0x05, 0x7e, 0xef, 0x9d, 0x0c, 0x79, 0xe8, 0x9a, 0x0b,
|
||||
0x6c, 0xfd, 0x8f, 0x1e, 0x6b, 0xfa, 0x88, 0x19, 0x62, 0xf3, 0x81, 0x10, 0x65, 0xf4, 0x86, 0x17,
|
||||
0x48, 0xd9, 0xab, 0x3a, 0x4f, 0xde, 0xac, 0x3d, 0x46, 0xd7, 0xa5, 0x34, 0x41, 0xd0, 0xa2, 0x33,
|
||||
0x54, 0xc5, 0xb7, 0x26, 0x53, 0xc2, 0xb0, 0x21, 0x5a, 0xcb, 0xb9, 0x28, 0x5d, 0xcc, 0xbe, 0x2f,
|
||||
|
||||
0xe0, 0x71, 0x03, 0x92, 0xe7, 0x76, 0x04, 0x95, 0xee, 0x7f, 0x0d, 0x9c, 0xe9, 0x78, 0x0a, 0x9b,
|
||||
0xfc, 0x6d, 0x1f, 0x8e, 0xfb, 0x6a, 0x18, 0x89, 0xf2, 0x63, 0x11, 0x80, 0xf5, 0x64, 0x16, 0x87,
|
||||
0xd8, 0x49, 0x3b, 0xaa, 0xdf, 0x4e, 0x3c, 0xad, 0xd6, 0x47, 0x35, 0xa4, 0xd1, 0x40, 0x32, 0xa3,
|
||||
0xc4, 0x55, 0x27, 0xb6, 0xc3, 0x52, 0x20, 0xb1, 0xca, 0x5b, 0x29, 0xb8, 0xcd, 0x5c, 0x2e, 0xbf,
|
||||
0x90, 0x01, 0x73, 0xe2, 0x97, 0x06, 0x74, 0xe5, 0x9e, 0x0f, 0x7d, 0xec, 0x99, 0x08, 0x7a, 0xeb,
|
||||
0x8c, 0x1d, 0x6f, 0xfe, 0x8b, 0x1a, 0x68, 0xf9, 0x82, 0x13, 0x61, 0xf0, 0x85, 0x14, 0x66, 0xf7,
|
||||
0xa8, 0x39, 0x4b, 0xda, 0xaf, 0x3e, 0x4c, 0xdd, 0xa6, 0x37, 0x45, 0xd4, 0xa1, 0x30, 0x42, 0xd3,
|
||||
0xb4, 0x25, 0x57, 0xc6, 0xb3, 0x22, 0x50, 0xc1, 0xba, 0x2b, 0x59, 0xc8, 0xbd, 0x2c, 0x5e, 0xcf
|
||||
};
|
||||
|
||||
static uint8_t crc8_be_table[256] = {
|
||||
0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15, 0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
|
||||
0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65, 0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
|
||||
0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5, 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
|
||||
0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85, 0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
|
||||
0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2, 0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
|
||||
0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2, 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
|
||||
0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32, 0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
|
||||
0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42, 0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
|
||||
0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c, 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
|
||||
0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec, 0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
|
||||
0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c, 0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
|
||||
0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c, 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
|
||||
0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b, 0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
|
||||
0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b, 0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
|
||||
0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb, 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
|
||||
0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb, 0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
|
||||
};
|
||||
|
||||
uint32_t esp_rom_crc32_le(uint32_t crc, uint8_t const * buf,uint32_t len)
|
||||
{
|
||||
uint32_t i;
|
||||
crc = ~crc;
|
||||
for(i=0;i<len;i++){
|
||||
crc = crc32_le_table[(crc^buf[i])&0xff]^(crc>>8);
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
|
||||
uint32_t esp_rom_crc32_be(uint32_t crc, uint8_t const * buf,uint32_t len)
|
||||
{
|
||||
uint32_t i;
|
||||
crc = ~crc;
|
||||
for(i=0;i<len;i++){
|
||||
crc = crc32_be_table[(crc>>24)^buf[i]]^(crc<<8);
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
|
||||
uint16_t esp_rom_crc16_le(uint16_t crc, uint8_t const * buf, uint32_t len)
|
||||
{
|
||||
uint32_t i;
|
||||
crc = ~crc;
|
||||
for(i = 0; i < len; i++)
|
||||
{
|
||||
crc = crc16_le_table[(crc^buf[i])&0xff]^(crc>>8);
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
|
||||
uint16_t esp_rom_crc16_be(uint16_t crc, uint8_t const * buf,uint32_t len)
|
||||
{
|
||||
uint32_t i;
|
||||
crc = ~crc;
|
||||
for(i=0;i<len;i++){
|
||||
crc = crc16_be_table[(crc>>8)^buf[i]]^(crc<<8);
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
|
||||
uint8_t esp_rom_crc8_le(uint8_t crc, uint8_t const * buf, uint32_t len)
|
||||
{
|
||||
uint32_t i;
|
||||
crc = ~crc;
|
||||
for(i = 0; i < len; i++)
|
||||
{
|
||||
crc = crc8_le_table[crc^buf[i]];
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
|
||||
uint8_t esp_rom_crc8_be(uint8_t crc, uint8_t const * buf,uint32_t len)
|
||||
{
|
||||
uint32_t i;
|
||||
crc = ~crc;
|
||||
for(i=0;i<len;i++){
|
||||
crc = crc8_be_table[crc^buf[i]];
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
55
components/esp_rom/linux/esp_rom_efuse.c
Normal file
55
components/esp_rom/linux/esp_rom_efuse.c
Normal file
@ -0,0 +1,55 @@
|
||||
// Copyright 2021 Espressif Systems (Shanghai) CO LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "esp_rom_efuse.h"
|
||||
|
||||
static uint8_t esp_crc8(uint8_t const * p, uint32_t len)
|
||||
{
|
||||
unsigned char i = 0;
|
||||
unsigned char crc = 0;
|
||||
|
||||
while (len--) {
|
||||
crc = crc ^ (*p++);
|
||||
|
||||
for (i = 0; i < 8; i++) {
|
||||
if ((crc) & 0x01) {
|
||||
crc = (crc >> 1) ^ (0x8c) ;
|
||||
} else {
|
||||
crc = crc >> 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (crc);
|
||||
}
|
||||
|
||||
uint8_t esp_rom_efuse_mac_address_crc8(const uint8_t *data, uint32_t len)
|
||||
{
|
||||
return esp_crc8(data, len);
|
||||
}
|
||||
|
||||
uint32_t esp_rom_efuse_get_flash_gpio_info(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t esp_rom_efuse_get_flash_wp_gpio(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool esp_rom_efuse_is_secure_boot_enabled(void)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
246
components/esp_rom/linux/esp_rom_md5.c
Normal file
246
components/esp_rom/linux/esp_rom_md5.c
Normal file
@ -0,0 +1,246 @@
|
||||
/*
|
||||
* MD5 hash implementation and interface functions
|
||||
* Copyright (c) 2003-2005, Jouni Malinen <j@w1.fi>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* Alternatively, this software may be distributed under the terms of BSD
|
||||
* license.
|
||||
*
|
||||
* See README and COPYING for more details.
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include "esp_rom_md5.h"
|
||||
|
||||
static void byteReverse(unsigned char *buf, unsigned longs);
|
||||
static void MD5Transform(uint32_t buf[4], uint32_t const in[16]);
|
||||
|
||||
/* ===== start - public domain MD5 implementation ===== */
|
||||
/*
|
||||
* This code implements the MD5 message-digest algorithm.
|
||||
* The algorithm is due to Ron Rivest. This code was
|
||||
* written by Colin Plumb in 1993, no copyright is claimed.
|
||||
* This code is in the public domain; do with it what you wish.
|
||||
*
|
||||
* Equivalent code is available from RSA Data Security, Inc.
|
||||
* This code has been tested against that, and is equivalent,
|
||||
* except that you don't need to include two pages of legalese
|
||||
* with every copy.
|
||||
*
|
||||
* To compute the message digest of a chunk of bytes, declare an
|
||||
* MD5Context structure, pass it to MD5Init, call MD5Update as
|
||||
* needed on buffers full of bytes, and then call MD5Final, which
|
||||
* will fill a supplied 16-byte array with the digest.
|
||||
*/
|
||||
|
||||
void esp_rom_md5_init(md5_context_t *context)
|
||||
{
|
||||
context->buf[0] = 0x67452301;
|
||||
context->buf[1] = 0xefcdab89;
|
||||
context->buf[2] = 0x98badcfe;
|
||||
context->buf[3] = 0x10325476;
|
||||
|
||||
context->bits[0] = 0;
|
||||
context->bits[1] = 0;
|
||||
}
|
||||
|
||||
void esp_rom_md5_update(md5_context_t *context, const void *buf, uint32_t len)
|
||||
{
|
||||
uint32_t t;
|
||||
|
||||
/* Update bitcount */
|
||||
|
||||
t = context->bits[0];
|
||||
if ((context->bits[0] = t + ((uint32_t) len << 3)) < t)
|
||||
context->bits[1]++; /* Carry from low to high */
|
||||
context->bits[1] += len >> 29;
|
||||
|
||||
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
|
||||
|
||||
/* Handle any leading odd-sized chunks */
|
||||
|
||||
if (t) {
|
||||
unsigned char *p = (unsigned char *) context->in + t;
|
||||
|
||||
t = 64 - t;
|
||||
if (len < t) {
|
||||
memcpy(p, buf, len);
|
||||
return;
|
||||
}
|
||||
memcpy(p, buf, t);
|
||||
byteReverse(context->in, 16);
|
||||
MD5Transform(context->buf, (uint32_t *) context->in);
|
||||
buf += t;
|
||||
len -= t;
|
||||
}
|
||||
/* Process data in 64-byte chunks */
|
||||
|
||||
while (len >= 64) {
|
||||
memcpy(context->in, buf, 64);
|
||||
byteReverse(context->in, 16);
|
||||
MD5Transform(context->buf, (uint32_t *) context->in);
|
||||
buf += 64;
|
||||
len -= 64;
|
||||
}
|
||||
|
||||
/* Handle any remaining bytes of data. */
|
||||
|
||||
memcpy(context->in, buf, len);
|
||||
}
|
||||
|
||||
void esp_rom_md5_final(uint8_t *digest, md5_context_t *context)
|
||||
{
|
||||
unsigned count;
|
||||
unsigned char *p;
|
||||
|
||||
/* Compute number of bytes mod 64 */
|
||||
count = (context->bits[0] >> 3) & 0x3F;
|
||||
|
||||
/* Set the first char of padding to 0x80. This is safe since there is
|
||||
always at least one byte free */
|
||||
p = context->in + count;
|
||||
*p++ = 0x80;
|
||||
|
||||
/* Bytes of padding needed to make 64 bytes */
|
||||
count = 64 - 1 - count;
|
||||
|
||||
/* Pad out to 56 mod 64 */
|
||||
if (count < 8) {
|
||||
/* Two lots of padding: Pad the first block to 64 bytes */
|
||||
memset(p, 0, count);
|
||||
byteReverse(context->in, 16);
|
||||
MD5Transform(context->buf, (uint32_t *) context->in);
|
||||
|
||||
/* Now fill the next block with 56 bytes */
|
||||
memset(context->in, 0, 56);
|
||||
} else {
|
||||
/* Pad block to 56 bytes */
|
||||
memset(p, 0, count - 8);
|
||||
}
|
||||
byteReverse(context->in, 14);
|
||||
|
||||
/* Append length in bits and transform */
|
||||
((uint32_t *) context->in)[14] = context->bits[0];
|
||||
((uint32_t *) context->in)[15] = context->bits[1];
|
||||
|
||||
MD5Transform(context->buf, (uint32_t *) context->in);
|
||||
byteReverse((unsigned char *) context->buf, 4);
|
||||
memcpy(digest, context->buf, 16);
|
||||
memset(context, 0, sizeof(*context)); /* In case it's sensitive */
|
||||
}
|
||||
|
||||
static void byteReverse(unsigned char *buf, unsigned longs)
|
||||
{
|
||||
uint32_t t;
|
||||
do {
|
||||
t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
|
||||
((unsigned) buf[1] << 8 | buf[0]);
|
||||
*(uint32_t *) buf = t;
|
||||
buf += 4;
|
||||
} while (--longs);
|
||||
}
|
||||
|
||||
/* The four core functions - F1 is optimized somewhat */
|
||||
|
||||
/* #define F1(x, y, z) (x & y | ~x & z) */
|
||||
#define F1(x, y, z) (z ^ (x & (y ^ z)))
|
||||
#define F2(x, y, z) F1(z, x, y)
|
||||
#define F3(x, y, z) (x ^ y ^ z)
|
||||
#define F4(x, y, z) (y ^ (x | ~z))
|
||||
|
||||
/* This is the central step in the MD5 algorithm. */
|
||||
#define MD5STEP(f, w, x, y, z, data, s) \
|
||||
( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
|
||||
|
||||
/*
|
||||
* The core of the MD5 algorithm, this alters an existing MD5 hash to
|
||||
* reflect the addition of 16 longwords of new data. MD5Update blocks
|
||||
* the data and converts bytes into longwords for this routine.
|
||||
*/
|
||||
static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
|
||||
{
|
||||
register uint32_t a, b, c, d;
|
||||
|
||||
a = buf[0];
|
||||
b = buf[1];
|
||||
c = buf[2];
|
||||
d = buf[3];
|
||||
|
||||
MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
|
||||
MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
|
||||
MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
|
||||
MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
|
||||
MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
|
||||
|
||||
MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
|
||||
MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
|
||||
MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
|
||||
MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
|
||||
MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
|
||||
|
||||
MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
|
||||
MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
|
||||
MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
|
||||
MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
|
||||
MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
|
||||
|
||||
MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
|
||||
MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
|
||||
MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
|
||||
MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
|
||||
MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
|
||||
|
||||
buf[0] += a;
|
||||
buf[1] += b;
|
||||
buf[2] += c;
|
||||
buf[3] += d;
|
||||
}
|
||||
/* ===== end - public domain MD5 implementation ===== */
|
||||
295
components/esp_rom/linux/esp_rom_sys.c
Normal file
295
components/esp_rom/linux/esp_rom_sys.c
Normal file
@ -0,0 +1,295 @@
|
||||
// Copyright 2021 Espressif Systems (Shanghai) CO LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdarg.h>
|
||||
#include <assert.h>
|
||||
#include <unistd.h>
|
||||
#include "esp_rom_sys.h"
|
||||
|
||||
static void call_linux_putc(char c);
|
||||
|
||||
static void (*s_esp_rom_putc)(char c) = call_linux_putc;
|
||||
|
||||
static void call_linux_putc(char c) {
|
||||
putc(c, stdout);
|
||||
}
|
||||
|
||||
#define is_digit(c) ((c >= '0') && (c <= '9'))
|
||||
|
||||
static int _cvt(unsigned long long val, char *buf, long radix, char *digits)
|
||||
{
|
||||
#ifdef SUPPORT_LITTLE_RADIX
|
||||
char temp[64];
|
||||
#else
|
||||
char temp[32];
|
||||
#endif
|
||||
char *cp = temp;
|
||||
int length = 0;
|
||||
|
||||
if (val == 0) {
|
||||
/* Special case */
|
||||
*cp++ = '0';
|
||||
} else {
|
||||
while (val) {
|
||||
*cp++ = digits[val % radix];
|
||||
val /= radix;
|
||||
}
|
||||
}
|
||||
while (cp != temp) {
|
||||
*buf++ = *--cp;
|
||||
length++;
|
||||
}
|
||||
*buf = '\0';
|
||||
return (length);
|
||||
}
|
||||
|
||||
static int esp_rom_vprintf(void (*putc)(char c), const char *fmt, va_list ap)
|
||||
{
|
||||
#ifdef BINARY_SUPPORT
|
||||
char buf[sizeof(long long)*8];
|
||||
int i;
|
||||
#else
|
||||
char buf[32];
|
||||
#endif
|
||||
char c, sign, *cp=buf;
|
||||
int left_prec, right_prec, zero_fill, pad, pad_on_right,
|
||||
islong, islonglong;
|
||||
long long val = 0;
|
||||
int res = 0, length = 0;
|
||||
|
||||
while ((c = *fmt++) != '\0') {
|
||||
if (c == '%') {
|
||||
c = *fmt++;
|
||||
left_prec = right_prec = pad_on_right = islong = islonglong = 0;
|
||||
if (c == '-') {
|
||||
c = *fmt++;
|
||||
pad_on_right++;
|
||||
}
|
||||
if (c == '0') {
|
||||
zero_fill = true;
|
||||
c = *fmt++;
|
||||
} else {
|
||||
zero_fill = false;
|
||||
}
|
||||
while (is_digit(c)) {
|
||||
left_prec = (left_prec * 10) + (c - '0');
|
||||
c = *fmt++;
|
||||
}
|
||||
if (c == '.') {
|
||||
c = *fmt++;
|
||||
zero_fill++;
|
||||
while (is_digit(c)) {
|
||||
right_prec = (right_prec * 10) + (c - '0');
|
||||
c = *fmt++;
|
||||
}
|
||||
} else {
|
||||
right_prec = left_prec;
|
||||
}
|
||||
sign = '\0';
|
||||
if (c == 'l') {
|
||||
c = *fmt++;
|
||||
islong = 1;
|
||||
if (c == 'l') {
|
||||
c = *fmt++;
|
||||
islonglong = 1;
|
||||
}
|
||||
}
|
||||
switch (c) {
|
||||
case 'p':
|
||||
islong = 1;
|
||||
case 'd':
|
||||
case 'D':
|
||||
case 'x':
|
||||
case 'X':
|
||||
case 'u':
|
||||
case 'U':
|
||||
#ifdef BINARY_SUPPORT
|
||||
case 'b':
|
||||
case 'B':
|
||||
#endif
|
||||
if (islonglong) {
|
||||
val = va_arg(ap, long long);
|
||||
} else if (islong) {
|
||||
val = (long long)va_arg(ap, long);
|
||||
} else{
|
||||
val = (long long)va_arg(ap, int);
|
||||
}
|
||||
if ((c == 'd') || (c == 'D')) {
|
||||
if (val < 0) {
|
||||
sign = '-';
|
||||
val = -val;
|
||||
}
|
||||
} else {
|
||||
if (islong) {
|
||||
val &= (((long long)1) << (sizeof(long) * 8)) - 1;
|
||||
} else{
|
||||
val &= (((long long)1) << (sizeof(int) * 8)) - 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (c) {
|
||||
case 'p':
|
||||
(*putc)('0');
|
||||
(*putc)('x');
|
||||
zero_fill = true;
|
||||
left_prec = sizeof(unsigned long)*2;
|
||||
case 'd':
|
||||
case 'D':
|
||||
case 'u':
|
||||
case 'U':
|
||||
case 'x':
|
||||
case 'X':
|
||||
switch (c) {
|
||||
case 'd':
|
||||
case 'D':
|
||||
case 'u':
|
||||
case 'U':
|
||||
length = _cvt(val, buf, 10, "0123456789");
|
||||
break;
|
||||
case 'p':
|
||||
case 'x':
|
||||
length = _cvt(val, buf, 16, "0123456789abcdef");
|
||||
break;
|
||||
case 'X':
|
||||
length = _cvt(val, buf, 16, "0123456789ABCDEF");
|
||||
break;
|
||||
}
|
||||
cp = buf;
|
||||
break;
|
||||
case 's':
|
||||
case 'S':
|
||||
cp = va_arg(ap, char *);
|
||||
if (cp == NULL) {
|
||||
cp = "<null>";
|
||||
}
|
||||
length = 0;
|
||||
while (cp[length] != '\0') length++;
|
||||
break;
|
||||
case 'c':
|
||||
case 'C':
|
||||
c = va_arg(ap, int /*char*/);
|
||||
(*putc)(c);
|
||||
res++;
|
||||
continue;
|
||||
#ifdef BINARY_SUPPORT
|
||||
case 'b':
|
||||
case 'B':
|
||||
length = left_prec;
|
||||
if (left_prec == 0) {
|
||||
if (islonglong)
|
||||
length = sizeof(long long)*8;
|
||||
else if (islong)
|
||||
length = sizeof(long)*8;
|
||||
else
|
||||
length = sizeof(int)*8;
|
||||
}
|
||||
for (i = 0; i < length-1; i++) {
|
||||
buf[i] = ((val & ((long long)1<<i)) ? '1' : '.');
|
||||
}
|
||||
cp = buf;
|
||||
break;
|
||||
#endif
|
||||
case '%':
|
||||
(*putc)('%');
|
||||
break;
|
||||
default:
|
||||
(*putc)('%');
|
||||
(*putc)(c);
|
||||
res += 2;
|
||||
}
|
||||
pad = left_prec - length;
|
||||
if (sign != '\0') {
|
||||
pad--;
|
||||
}
|
||||
if (zero_fill) {
|
||||
c = '0';
|
||||
if (sign != '\0') {
|
||||
(*putc)(sign);
|
||||
res++;
|
||||
sign = '\0';
|
||||
}
|
||||
} else {
|
||||
c = ' ';
|
||||
}
|
||||
if (!pad_on_right) {
|
||||
while (pad-- > 0) {
|
||||
(*putc)(c);
|
||||
res++;
|
||||
}
|
||||
}
|
||||
if (sign != '\0') {
|
||||
(*putc)(sign);
|
||||
res++;
|
||||
}
|
||||
while (length-- > 0) {
|
||||
c = *cp++;
|
||||
(*putc)(c);
|
||||
res++;
|
||||
}
|
||||
if (pad_on_right) {
|
||||
while (pad-- > 0) {
|
||||
(*putc)(' ');
|
||||
res++;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
(*putc)(c);
|
||||
res++;
|
||||
}
|
||||
}
|
||||
return (res);
|
||||
}
|
||||
|
||||
int esp_rom_printf(const char *fmt, ...)
|
||||
{
|
||||
|
||||
va_list list;
|
||||
va_start(list, fmt);
|
||||
int result = esp_rom_vprintf(s_esp_rom_putc, fmt, list);
|
||||
va_end(list);
|
||||
return result;
|
||||
}
|
||||
|
||||
void esp_rom_delay_us(uint32_t us)
|
||||
{
|
||||
int sleep_result = usleep(us);
|
||||
assert(sleep_result == 0);
|
||||
(void)sleep_result; // Prevents compiler from optimizing out usleep() due to unused result. Also prevents warning.
|
||||
}
|
||||
|
||||
void esp_rom_install_channel_putc(int channel, void (*putc)(char c))
|
||||
{
|
||||
if (putc != NULL) {
|
||||
s_esp_rom_putc = putc;
|
||||
}
|
||||
}
|
||||
|
||||
void esp_rom_install_uart_printf(void)
|
||||
{
|
||||
// Since this is the linux implementation, we don't set any "UART" putc function, but the one which delegates to
|
||||
// the Linux libc version of putc.
|
||||
s_esp_rom_putc = call_linux_putc;
|
||||
}
|
||||
|
||||
soc_reset_reason_t esp_rom_get_reset_reason(int cpu_no)
|
||||
{
|
||||
return RESET_REASON_CHIP_POWER_ON;
|
||||
}
|
||||
@ -1,8 +1,12 @@
|
||||
idf_build_get_property(target IDF_TARGET)
|
||||
set(srcs "log.c")
|
||||
set(priv_requires "")
|
||||
set(requires "")
|
||||
if(${target} STREQUAL "linux")
|
||||
# We leave log buffers out for now on Linux since it's rarely used
|
||||
# We leave log buffers out for now on Linux since it's rarely used. Excplicitely add esp_rom to Linux target
|
||||
# since we don't have the common components there yet.
|
||||
list(APPEND srcs "log_linux.c")
|
||||
list(APPEND requires esp_rom)
|
||||
else()
|
||||
list(APPEND srcs "log_buffers.c")
|
||||
list(APPEND priv_requires soc)
|
||||
@ -11,6 +15,7 @@ endif()
|
||||
idf_component_register(SRCS ${srcs}
|
||||
INCLUDE_DIRS "include"
|
||||
LDFRAGMENTS linker.lf
|
||||
REQUIRES ${requires}
|
||||
PRIV_REQUIRES ${priv_requires})
|
||||
|
||||
if(NOT ${target} STREQUAL "linux")
|
||||
|
||||
@ -3,9 +3,7 @@
|
||||
|
||||
# Simple log test on Linux target
|
||||
|
||||
This unit test tests basic functionality of the log component. The test does not use mocks. Instead, it runs the whole implementation of the component on the Linux host. The test framework is CATCH.
|
||||
|
||||
*Note that the early log (ESP_EARLY_LOG<X>) functionality has not been ported to Linux since it depends on the ROM component.*
|
||||
This unit test tests basic functionality of the log component. The test does not use mocks. Instead, it runs the whole implementation of the component on the Linux host. The test framework is CATCH. For early log, we only perform a compile time test since there's nothing to test on Linux except for the log macros themselves (all the implementation will be in chip ROM).
|
||||
|
||||
## Requirements
|
||||
|
||||
|
||||
@ -18,29 +18,19 @@ using namespace std;
|
||||
|
||||
static const char *TEST_TAG = "test";
|
||||
|
||||
struct PrintFixture {
|
||||
class BasicLogFixture {
|
||||
public:
|
||||
static const size_t BUFFER_SIZE = 4096;
|
||||
|
||||
PrintFixture(esp_log_level_t log_level = ESP_LOG_VERBOSE)
|
||||
BasicLogFixture(esp_log_level_t log_level = ESP_LOG_VERBOSE)
|
||||
{
|
||||
if (instance != nullptr) {
|
||||
throw exception();
|
||||
}
|
||||
|
||||
std::memset(print_buffer, 0, BUFFER_SIZE);
|
||||
|
||||
instance = this;
|
||||
|
||||
old_vprintf = esp_log_set_vprintf(print_callback);
|
||||
|
||||
esp_log_level_set(TEST_TAG, log_level);
|
||||
esp_log_level_set("*", log_level);
|
||||
}
|
||||
|
||||
~PrintFixture()
|
||||
virtual ~BasicLogFixture()
|
||||
{
|
||||
esp_log_level_set(TEST_TAG, ESP_LOG_INFO);
|
||||
esp_log_set_vprintf(old_vprintf);
|
||||
instance = nullptr;
|
||||
esp_log_level_set("*", ESP_LOG_INFO);
|
||||
}
|
||||
|
||||
string get_print_buffer_string() const
|
||||
@ -51,10 +41,33 @@ struct PrintFixture {
|
||||
void reset_buffer()
|
||||
{
|
||||
std::memset(print_buffer, 0, BUFFER_SIZE);
|
||||
additional_reset();
|
||||
}
|
||||
|
||||
protected:
|
||||
char print_buffer [BUFFER_SIZE];
|
||||
|
||||
virtual void additional_reset() { }
|
||||
};
|
||||
|
||||
struct PrintFixture : BasicLogFixture {
|
||||
PrintFixture(esp_log_level_t log_level = ESP_LOG_VERBOSE) : BasicLogFixture(log_level)
|
||||
{
|
||||
if (instance != nullptr) {
|
||||
throw exception();
|
||||
}
|
||||
|
||||
instance = this;
|
||||
|
||||
old_vprintf = esp_log_set_vprintf(print_callback);
|
||||
}
|
||||
|
||||
virtual ~PrintFixture()
|
||||
{
|
||||
esp_log_set_vprintf(old_vprintf);
|
||||
instance = nullptr;
|
||||
}
|
||||
|
||||
private:
|
||||
static int print_callback(const char *format, va_list args)
|
||||
{
|
||||
@ -72,7 +85,47 @@ private:
|
||||
vprintf_like_t old_vprintf;
|
||||
};
|
||||
|
||||
struct PutcFixture : BasicLogFixture {
|
||||
PutcFixture(esp_log_level_t log_level = ESP_LOG_VERBOSE) : BasicLogFixture(log_level), counter(0)
|
||||
{
|
||||
if (instance != nullptr) {
|
||||
throw exception();
|
||||
}
|
||||
|
||||
esp_rom_install_channel_putc(0, putc_callback);
|
||||
|
||||
instance = this;
|
||||
}
|
||||
|
||||
~PutcFixture()
|
||||
{
|
||||
esp_rom_install_uart_printf();
|
||||
instance = nullptr;
|
||||
}
|
||||
|
||||
void additional_reset() override
|
||||
{
|
||||
counter = 0;
|
||||
}
|
||||
|
||||
size_t counter;
|
||||
|
||||
private:
|
||||
static void putc_callback(char c)
|
||||
{
|
||||
return instance->putc_to_buffer(c);
|
||||
}
|
||||
|
||||
void putc_to_buffer(char c)
|
||||
{
|
||||
print_buffer[counter++] = c;
|
||||
}
|
||||
|
||||
static PutcFixture *instance;
|
||||
};
|
||||
|
||||
PrintFixture *PrintFixture::instance = nullptr;
|
||||
PutcFixture *PutcFixture::instance = nullptr;
|
||||
|
||||
TEST_CASE("verbose log level")
|
||||
{
|
||||
@ -139,3 +192,78 @@ TEST_CASE("changing log level")
|
||||
ESP_LOGI(TEST_TAG, "must indeed be printed");
|
||||
CHECK(regex_search(fix.get_print_buffer_string(), test_print) == true);
|
||||
}
|
||||
|
||||
TEST_CASE("rom printf")
|
||||
{
|
||||
PutcFixture fix;
|
||||
int printed_chars = esp_rom_printf("info");
|
||||
|
||||
CHECK(printed_chars == 4);
|
||||
CHECK(fix.get_print_buffer_string() == "info");
|
||||
}
|
||||
|
||||
TEST_CASE("early verbose log level")
|
||||
{
|
||||
PutcFixture fix;
|
||||
const std::regex test_print("V \\([0-9]*\\) test: verbose", std::regex::ECMAScript);
|
||||
|
||||
ESP_EARLY_LOGV(TEST_TAG, "verbose");
|
||||
CHECK(regex_search(fix.get_print_buffer_string(), test_print) == true);
|
||||
}
|
||||
|
||||
TEST_CASE("early debug log level")
|
||||
{
|
||||
PutcFixture fix;
|
||||
const std::regex test_print("D \\([0-9]*\\) test: debug", std::regex::ECMAScript);
|
||||
|
||||
ESP_EARLY_LOGD(TEST_TAG, "debug");
|
||||
CHECK(regex_search(fix.get_print_buffer_string(), test_print) == true);
|
||||
}
|
||||
|
||||
TEST_CASE("early info log level")
|
||||
{
|
||||
PutcFixture fix;
|
||||
const std::regex test_print("I \\([0-9]*\\) test: info", std::regex::ECMAScript);
|
||||
|
||||
ESP_EARLY_LOGI(TEST_TAG, "info");
|
||||
CHECK(regex_search(fix.get_print_buffer_string(), test_print) == true);
|
||||
}
|
||||
|
||||
TEST_CASE("early warn log level")
|
||||
{
|
||||
PutcFixture fix;
|
||||
const std::regex test_print("W \\([0-9]*\\) test: warn", std::regex::ECMAScript);
|
||||
|
||||
ESP_EARLY_LOGW(TEST_TAG, "warn");
|
||||
CHECK(regex_search(fix.get_print_buffer_string(), test_print) == true);
|
||||
}
|
||||
|
||||
TEST_CASE("early error log level")
|
||||
{
|
||||
PutcFixture fix;
|
||||
const std::regex test_print("E \\([0-9]*\\) test: error", std::regex::ECMAScript);
|
||||
|
||||
ESP_EARLY_LOGE(TEST_TAG, "error");
|
||||
CHECK(regex_search(fix.get_print_buffer_string(), test_print) == true);
|
||||
}
|
||||
|
||||
TEST_CASE("changing early log level")
|
||||
{
|
||||
PutcFixture fix(ESP_LOG_INFO);
|
||||
const std::regex test_print("I \\([0-9]*\\) test: must indeed be printed", std::regex::ECMAScript);
|
||||
|
||||
ESP_EARLY_LOGI(TEST_TAG, "must indeed be printed");
|
||||
CHECK(regex_search(fix.get_print_buffer_string(), test_print) == true);
|
||||
|
||||
fix.reset_buffer();
|
||||
esp_log_level_set("*", ESP_LOG_WARN);
|
||||
|
||||
ESP_EARLY_LOGI(TEST_TAG, "must not be printed");
|
||||
CHECK(fix.get_print_buffer_string().size() == 0);
|
||||
|
||||
fix.reset_buffer();
|
||||
esp_log_level_set("*", ESP_LOG_INFO);
|
||||
|
||||
ESP_EARLY_LOGI(TEST_TAG, "must indeed be printed");
|
||||
CHECK(regex_search(fix.get_print_buffer_string(), test_print) == true);
|
||||
}
|
||||
|
||||
@ -10,9 +10,7 @@
|
||||
#include <stdint.h>
|
||||
#include <stdarg.h>
|
||||
#include "sdkconfig.h"
|
||||
#if !defined(CONFIG_IDF_TARGET_LINUX)
|
||||
#include "esp_rom_sys.h"
|
||||
#endif // !CONFIG_IDF_TARGET_LINUX
|
||||
#if CONFIG_IDF_TARGET_ESP32
|
||||
#include "esp32/rom/ets_sys.h" // will be removed in idf v5.0
|
||||
#elif CONFIG_IDF_TARGET_ESP32S2
|
||||
|
||||
@ -41,6 +41,6 @@ uint32_t esp_log_timestamp(void)
|
||||
struct timespec current_time;
|
||||
int result = clock_gettime(CLOCK_MONOTONIC, ¤t_time);
|
||||
assert(result == 0);
|
||||
uint32_t seconds = current_time.tv_sec * 1000 + current_time.tv_nsec / 1000000;
|
||||
return seconds;
|
||||
uint32_t milliseconds = current_time.tv_sec * 1000 + current_time.tv_nsec / 1000000;
|
||||
return milliseconds;
|
||||
}
|
||||
|
||||
@ -15,6 +15,12 @@ set(srcs "src/nvs_api.cpp"
|
||||
|
||||
set(public_req spi_flash)
|
||||
|
||||
# Current linux-based builds don't have common components.
|
||||
# Add the necessary ones manually:
|
||||
if(${target} STREQUAL "linux")
|
||||
list(APPEND public_req "esp_rom" "log")
|
||||
endif()
|
||||
|
||||
set(include_dirs "include")
|
||||
|
||||
idf_component_register(SRCS "${srcs}"
|
||||
@ -29,9 +35,7 @@ if(${target} STREQUAL "linux")
|
||||
endif()
|
||||
idf_component_get_property(spi_flash_dir spi_flash COMPONENT_DIR)
|
||||
target_include_directories(${COMPONENT_LIB} PUBLIC
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/mock/int"
|
||||
"${spi_flash_dir}/sim/stubs/freertos/include")
|
||||
target_sources(${COMPONENT_LIB} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/mock/int/crc.cpp")
|
||||
target_compile_options(${COMPONENT_LIB} PUBLIC "-DLINUX_TARGET")
|
||||
else()
|
||||
# TODO: this is a workaround until IDF-2085 is fixed
|
||||
|
||||
@ -1,63 +0,0 @@
|
||||
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
static const unsigned int crc32_le_table[256] = {
|
||||
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,
|
||||
0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,
|
||||
0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,
|
||||
0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,
|
||||
0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
|
||||
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,
|
||||
0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,
|
||||
0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,
|
||||
0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,
|
||||
0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
|
||||
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,
|
||||
0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,
|
||||
0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,
|
||||
0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,
|
||||
0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
|
||||
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL,
|
||||
|
||||
0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L,
|
||||
0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L,
|
||||
0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L,
|
||||
0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
|
||||
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL,
|
||||
0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L,
|
||||
0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL,
|
||||
0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL,
|
||||
0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
|
||||
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L,
|
||||
0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L,
|
||||
0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L,
|
||||
0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL,
|
||||
0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
|
||||
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,
|
||||
0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL
|
||||
};
|
||||
|
||||
|
||||
|
||||
extern "C" uint32_t esp_rom_crc32_le(unsigned int crc, unsigned char const * buf,unsigned int len)
|
||||
{
|
||||
unsigned int i;
|
||||
crc = ~crc;
|
||||
for(i=0;i<len;i++){
|
||||
crc = crc32_le_table[(crc^buf[i])&0xff]^(crc>>8);
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
@ -22,18 +22,12 @@
|
||||
#include <functional>
|
||||
#include "nvs_handle_simple.hpp"
|
||||
#include "esp_err.h"
|
||||
|
||||
#ifdef LINUX_TARGET
|
||||
#include "crc.h"
|
||||
#define ESP_LOGD(...)
|
||||
#else // LINUX_TARGET
|
||||
#include <esp32/rom/crc.h>
|
||||
#include <esp_rom_crc.h>
|
||||
|
||||
// Uncomment this line to force output from this module
|
||||
// #define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
|
||||
#include "esp_log.h"
|
||||
static const char* TAG = "nvs";
|
||||
#endif // ! LINUX_TARGET
|
||||
|
||||
class NVSHandleEntry : public intrusive_list_node<NVSHandleEntry> {
|
||||
public:
|
||||
@ -311,7 +305,7 @@ extern "C" esp_err_t nvs_open(const char* name, nvs_open_mode_t open_mode, nvs_h
|
||||
extern "C" void nvs_close(nvs_handle_t handle)
|
||||
{
|
||||
Lock lock;
|
||||
ESP_LOGD(TAG, "%s %d", __func__, handle);
|
||||
ESP_LOGD(TAG, "%s %d", __func__, static_cast<int>(handle));
|
||||
auto it = find_if(begin(s_nvs_handles), end(s_nvs_handles), [=](NVSHandleEntry& e) -> bool {
|
||||
return e.mHandle == handle;
|
||||
});
|
||||
@ -352,7 +346,7 @@ template<typename T>
|
||||
static esp_err_t nvs_set(nvs_handle_t c_handle, const char* key, T value)
|
||||
{
|
||||
Lock lock;
|
||||
ESP_LOGD(TAG, "%s %s %d %d", __func__, key, sizeof(T), (uint32_t) value);
|
||||
ESP_LOGD(TAG, "%s %s %d %ld", __func__, key, static_cast<int>(sizeof(T)), static_cast<long int>(value));
|
||||
NVSHandleSimple *handle;
|
||||
auto err = nvs_find_ns_handle(c_handle, &handle);
|
||||
if (err != ESP_OK) {
|
||||
@ -429,7 +423,7 @@ extern "C" esp_err_t nvs_set_str(nvs_handle_t c_handle, const char* key, const c
|
||||
extern "C" esp_err_t nvs_set_blob(nvs_handle_t c_handle, const char* key, const void* value, size_t length)
|
||||
{
|
||||
Lock lock;
|
||||
ESP_LOGD(TAG, "%s %s %d", __func__, key, length);
|
||||
ESP_LOGD(TAG, "%s %s %d", __func__, key, static_cast<int>(length));
|
||||
NVSHandleSimple *handle;
|
||||
auto err = nvs_find_ns_handle(c_handle, &handle);
|
||||
if (err != ESP_OK) {
|
||||
@ -443,7 +437,7 @@ template<typename T>
|
||||
static esp_err_t nvs_get(nvs_handle_t c_handle, const char* key, T* out_value)
|
||||
{
|
||||
Lock lock;
|
||||
ESP_LOGD(TAG, "%s %s %d", __func__, key, sizeof(T));
|
||||
ESP_LOGD(TAG, "%s %s %ld", __func__, key, static_cast<long int>(sizeof(T)));
|
||||
NVSHandleSimple *handle;
|
||||
auto err = nvs_find_ns_handle(c_handle, &handle);
|
||||
if (err != ESP_OK) {
|
||||
@ -629,8 +623,8 @@ extern "C" esp_err_t nvs_flash_generate_keys(const esp_partition_t* partition, n
|
||||
return err;
|
||||
}
|
||||
|
||||
uint32_t crc_calc = crc32_le(0xffffffff, cfg->eky, NVS_KEY_SIZE);
|
||||
crc_calc = crc32_le(crc_calc, cfg->tky, NVS_KEY_SIZE);
|
||||
uint32_t crc_calc = esp_rom_crc32_le(0xffffffff, cfg->eky, NVS_KEY_SIZE);
|
||||
crc_calc = esp_rom_crc32_le(crc_calc, cfg->tky, NVS_KEY_SIZE);
|
||||
|
||||
uint8_t crc_wr[16];
|
||||
memset(crc_wr, 0xff, sizeof(crc_wr));
|
||||
@ -702,8 +696,8 @@ extern "C" esp_err_t nvs_flash_read_security_cfg(const esp_partition_t* partitio
|
||||
return err;
|
||||
}
|
||||
|
||||
crc_calc = crc32_le(0xffffffff, cfg->eky, NVS_KEY_SIZE);
|
||||
crc_calc = crc32_le(crc_calc, cfg->tky, NVS_KEY_SIZE);
|
||||
crc_calc = esp_rom_crc32_le(0xffffffff, cfg->eky, NVS_KEY_SIZE);
|
||||
crc_calc = esp_rom_crc32_le(crc_calc, cfg->tky, NVS_KEY_SIZE);
|
||||
|
||||
if(crc_calc != crc_read) {
|
||||
if(!check_if_initialized(cfg->eky, cfg->tky, crc_read)) {
|
||||
|
||||
@ -12,11 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
#include "nvs_page.hpp"
|
||||
#if defined(LINUX_TARGET)
|
||||
#include "crc.h"
|
||||
#else
|
||||
#include <esp_rom_crc.h>
|
||||
#endif
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
|
||||
|
||||
@ -13,11 +13,7 @@
|
||||
// limitations under the License.
|
||||
#include "nvs_types.hpp"
|
||||
|
||||
#if defined(LINUX_TARGET)
|
||||
#include "crc.h"
|
||||
#else
|
||||
#include <esp_rom_crc.h>
|
||||
#endif
|
||||
#include "esp_rom_crc.h"
|
||||
|
||||
namespace nvs
|
||||
{
|
||||
|
||||
@ -3,7 +3,6 @@ all: $(TEST_PROGRAM)
|
||||
|
||||
SOURCE_FILES = \
|
||||
esp_error_check_stub.cpp \
|
||||
../mock/int/crc.cpp \
|
||||
$(addprefix ../src/, \
|
||||
nvs_types.cpp \
|
||||
nvs_api.cpp \
|
||||
@ -31,13 +30,15 @@ SOURCE_FILES = \
|
||||
test_nvs_initialization.cpp \
|
||||
main.cpp
|
||||
|
||||
SOURCE_FILES_C = ../../esp_rom/linux/esp_rom_crc.c
|
||||
|
||||
ifeq ($(shell $(CC) -v 2>&1 | grep -c "clang version"), 1)
|
||||
COMPILER := clang
|
||||
else
|
||||
COMPILER := gcc
|
||||
endif
|
||||
|
||||
CPPFLAGS += -I../include -I../src -I../mock/int -I./ -I../../esp_common/include -I../../esp32/include -I ../../mbedtls/mbedtls/include -I ../../spi_flash/include -I ../../hal/include -I ../../xtensa/include -I ../../../tools/catch -fprofile-arcs -ftest-coverage -g2 -ggdb
|
||||
CPPFLAGS += -I../include -I../src -I../../esp_rom/include -I../../esp_rom/include/linux -I../../log/include -I./ -I../../esp_common/include -I../../esp32/include -I ../../mbedtls/mbedtls/include -I ../../spi_flash/include -I ../../hal/include -I ../../xtensa/include -I ../../../tools/catch -fprofile-arcs -ftest-coverage -g2 -ggdb
|
||||
CFLAGS += -fprofile-arcs -ftest-coverage -DLINUX_TARGET
|
||||
CXXFLAGS += -std=c++11 -Wall -Werror -DLINUX_TARGET
|
||||
LDFLAGS += -lstdc++ -Wall -fprofile-arcs -ftest-coverage
|
||||
@ -49,14 +50,16 @@ LDFLAGS += -fsanitize=address
|
||||
endif
|
||||
|
||||
OBJ_FILES = $(SOURCE_FILES:.cpp=.o)
|
||||
OBJ_FILES_C = $(SOURCE_FILES_C:.c=.o)
|
||||
|
||||
COVERAGE_FILES = $(OBJ_FILES:.o=.gc*)
|
||||
|
||||
$(OBJ_FILES): %.o: %.cpp
|
||||
$(OBJ_FILES_C): %.c: %.c
|
||||
|
||||
$(TEST_PROGRAM): clean-coverage $(OBJ_FILES)
|
||||
$(TEST_PROGRAM): clean-coverage $(OBJ_FILES) $(OBJ_FILES_C)
|
||||
$(MAKE) -C ../../mbedtls/mbedtls/ lib
|
||||
g++ $(LDFLAGS) -o $(TEST_PROGRAM) $(OBJ_FILES) ../../mbedtls/mbedtls/library/libmbedcrypto.a
|
||||
g++ $(LDFLAGS) -o $(TEST_PROGRAM) $(OBJ_FILES) $(OBJ_FILES_C) ../../mbedtls/mbedtls/library/libmbedcrypto.a
|
||||
|
||||
$(OUTPUT_DIR):
|
||||
mkdir -p $(OUTPUT_DIR)
|
||||
@ -84,7 +87,7 @@ clean-coverage:
|
||||
|
||||
clean: clean-coverage
|
||||
$(MAKE) -C ../../mbedtls/mbedtls/ clean
|
||||
rm -f $(OBJ_FILES) $(TEST_PROGRAM)
|
||||
rm -f $(OBJ_FILES) $(OBJ_FILES_C) $(TEST_PROGRAM)
|
||||
rm -f ../nvs_partition_generator/partition_single_page.bin
|
||||
rm -f ../nvs_partition_generator/partition_multipage_blob.bin
|
||||
rm -f ../nvs_partition_generator/partition_encrypted.bin
|
||||
|
||||
@ -1,3 +1,6 @@
|
||||
#define CONFIG_NVS_ENCRYPTION 1
|
||||
//currently use the legacy implementation, since the stubs for new HAL are not done yet
|
||||
#define CONFIG_SPI_FLASH_USE_LEGACY_IMPL 1
|
||||
#define CONFIG_LOG_MAXIMUM_LEVEL 3
|
||||
#define CONFIG_LOG_TIMESTAMP_SOURCE_RTOS 1
|
||||
#define CONFIG_IDF_TARGET_LINUX 1
|
||||
|
||||
Loading…
Reference in New Issue
Block a user