bool ESP32_Get_NVS_Status(esp_hardware_esp32_t hardware){
esp_err_t err;nvs_handle hardwareHandle; uint32_t status;
nvs_open("nvs",NVS_READWRITE,&hardwareHandle);
err = nvs_get_u32(hardwareHandle,ESP32_hardwareName(hardware),&status);
if(err) {
status = ESP32HARDWAREDEFAULT;
nvs_set_u32(hardwareHandle,ESP32_hardwareName(hardware),ESP32HARDWAREDEFAULT);
}
nvs_close(hardwareHandle);
return (bool) status;
}
/**
* Retrieve the connection info. A rc==0 means ok.
*/
static int getConnectionInfo(connection_info_t *pConnectionInfo) {
nvs_handle handle;
size_t size;
esp_err_t err;
uint32_t version;
err = nvs_open(BOOTWIFI_NAMESPACE, NVS_READWRITE, &handle);
if (err != 0) {
ESP_LOGE(tag, "nvs_open: %x", err);
return -1;
}
// Get the version that the data was saved against.
err = nvs_get_u32(handle, KEY_VERSION, &version);
if (err != ESP_OK) {
ESP_LOGD(tag, "No version record found (%d).", err);
nvs_close(handle);
return -1;
}
// Check the versions match
if ((version & 0xff00) != (g_version & 0xff00)) {
ESP_LOGD(tag, "Incompatible versions ... current is %x, found is %x", version, g_version);
nvs_close(handle);
return -1;
}
size = sizeof(connection_info_t);
err = nvs_get_blob(handle, KEY_CONNECTION_INFO, pConnectionInfo, &size);
if (err != ESP_OK) {
ESP_LOGD(tag, "No connection record found (%d).", err);
nvs_close(handle);
return -1;
}
if (err != ESP_OK) {
ESP_LOGE(tag, "nvs_open: %x", err);
nvs_close(handle);
return -1;
}
// Cleanup
nvs_close(handle);
// Do a sanity check on the SSID
if (strlen(pConnectionInfo->ssid) == 0) {
ESP_LOGD(tag, "NULL ssid detected");
return -1;
}
return 0;
} // getConnectionInfo
static esp_err_t load_cal_data_from_nvs_handle(nvs_handle handle,
esp_phy_calibration_data_t* out_cal_data)
{
esp_err_t err;
uint32_t cal_data_version;
err = nvs_get_u32(handle, PHY_CAL_VERSION_KEY, &cal_data_version);
if (err != ESP_OK) {
ESP_LOGD(TAG, "%s: failed to get cal_version (0x%x)", __func__, err);
return err;
}
uint32_t cal_format_version = phy_get_rf_cal_version() & (~BIT(16));
ESP_LOGV(TAG, "phy_get_rf_cal_version: %d\n", cal_format_version);
if (cal_data_version != cal_format_version) {
ESP_LOGD(TAG, "%s: expected calibration data format %d, found %d",
__func__, cal_format_version, cal_data_version);
return ESP_FAIL;
}
uint8_t cal_data_mac[6];
size_t length = sizeof(cal_data_mac);
err = nvs_get_blob(handle, PHY_CAL_MAC_KEY, cal_data_mac, &length);
if (err != ESP_OK) {
ESP_LOGD(TAG, "%s: failed to get cal_mac (0x%x)", __func__, err);
return err;
}
if (length != sizeof(cal_data_mac)) {
ESP_LOGD(TAG, "%s: invalid length of cal_mac (%d)", __func__, length);
return ESP_ERR_INVALID_SIZE;
}
uint8_t sta_mac[6];
esp_efuse_mac_get_default(sta_mac);
if (memcmp(sta_mac, cal_data_mac, sizeof(sta_mac)) != 0) {
ESP_LOGE(TAG, "%s: calibration data MAC check failed: expected " \
MACSTR ", found " MACSTR,
__func__, MAC2STR(sta_mac), MAC2STR(cal_data_mac));
return ESP_FAIL;
}
length = sizeof(*out_cal_data);
err = nvs_get_blob(handle, PHY_CAL_DATA_KEY, out_cal_data, &length);
if (err != ESP_OK) {
ESP_LOGE(TAG, "%s: failed to get cal_data(0x%x)", __func__, err);
return err;
}
if (length != sizeof(*out_cal_data)) {
ESP_LOGD(TAG, "%s: invalid length of cal_data (%d)", __func__, length);
return ESP_ERR_INVALID_SIZE;
}
return ESP_OK;
}
bool dhcp_ip_addr_restore(void *netif)
{
nvs_handle nvs;
bool err = false;
struct netif *net = (struct netif *)netif;
struct dhcp *dhcp = netif_dhcp_data(net);
esp_interface_t netif_id = tcpip_adapter_get_esp_if(net);
if(VALID_NETIF_ID(netif_id)) {
uint32_t *ip_addr = &dhcp->offered_ip_addr.addr;
if (nvs_open(DHCP_NAMESPACE, NVS_READONLY, &nvs) == ESP_OK) {
if (nvs_get_u32(nvs, interface_key[netif_id], ip_addr) == ESP_OK) {
restored_ip_addr[netif_id] = *ip_addr;
err = true;
}
nvs_close(nvs);
}
}
return err;
}
