318 lines
8.0 KiB
C
Executable File
318 lines
8.0 KiB
C
Executable File
/*
|
|
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the
|
|
* distribution.
|
|
* 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of
|
|
* its contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "image/fdcm.h"
|
|
#include "image/image.h"
|
|
#if PRJCONF_NET_EN
|
|
#include "lwip/inet.h"
|
|
#include "lwip/ip_addr.h"
|
|
#include "driver/chip/hal_crypto.h"
|
|
#include "efpg/efpg.h"
|
|
#endif /* PRJCONF_NET_EN */
|
|
#include "sysinfo.h"
|
|
#include "sysinfo_debug.h"
|
|
|
|
static struct sysinfo g_sysinfo;
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
static fdcm_handle_t *g_fdcm_hdl;
|
|
#endif
|
|
|
|
#if PRJCONF_NET_EN
|
|
|
|
static uint8_t m_sysinfo_mac_addr[] = { 0x00, 0x80, 0xE1, 0x29, 0xE8, 0xD1 };
|
|
|
|
static void sysinfo_gen_mac_random(uint8_t mac_addr[6])
|
|
{
|
|
#if (PRJCONF_CE_EN && PRJCONF_PRNG_INIT_SEED)
|
|
HAL_PRNG_Generate(mac_addr, 6);
|
|
#else
|
|
int i;
|
|
for (i = 0; i < 6; ++i) {
|
|
mac_addr[i] = (uint8_t)OS_Rand32();
|
|
}
|
|
#endif
|
|
mac_addr[0] &= 0xFC;
|
|
}
|
|
|
|
static void sysinfo_gen_mac_by_chipid(uint8_t mac_addr[6])
|
|
{
|
|
int i;
|
|
uint8_t chipid[16];
|
|
|
|
efpg_read(EFPG_FIELD_CHIPID, chipid);
|
|
|
|
for (i = 0; i < 2; ++i) {
|
|
mac_addr[i] = chipid[i] ^ chipid[i + 6] ^ chipid[i + 12];
|
|
}
|
|
for (i = 2; i < 6; ++i) {
|
|
mac_addr[i] = chipid[i] ^ chipid[i + 6] ^ chipid[i + 10];
|
|
}
|
|
mac_addr[0] &= 0xFC;
|
|
}
|
|
|
|
static void sysinfo_init_mac_addr(void)
|
|
{
|
|
int i;
|
|
|
|
SYSINFO_DBG("mac addr source: %d\n", PRJCONF_MAC_ADDR_SOURCE);
|
|
|
|
switch (PRJCONF_MAC_ADDR_SOURCE) {
|
|
case SYSINFO_MAC_ADDR_CODE:
|
|
memcpy(g_sysinfo.mac_addr, m_sysinfo_mac_addr, SYSINFO_MAC_ADDR_LEN);
|
|
return;
|
|
case SYSINFO_MAC_ADDR_EFUSE:
|
|
if (efpg_read(EFPG_FIELD_MAC_WLAN, g_sysinfo.mac_addr) != 0) {
|
|
SYSINFO_WRN("read mac addr from eFuse fail\n");
|
|
goto random_mac_addr;
|
|
}
|
|
return;
|
|
case SYSINFO_MAC_ADDR_CHIPID:
|
|
sysinfo_gen_mac_by_chipid(g_sysinfo.mac_addr);
|
|
for (i = 0; i < sizeof(g_sysinfo.mac_addr); ++i) {
|
|
if (g_sysinfo.mac_addr[i] != 0)
|
|
return;
|
|
}
|
|
goto random_mac_addr;
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
case SYSINFO_MAC_ADDR_FLASH: {
|
|
struct sysinfo *info = malloc(SYSINFO_SIZE);
|
|
if (info == NULL) {
|
|
SYSINFO_ERR("malloc fail\n");
|
|
goto random_mac_addr;
|
|
}
|
|
if (fdcm_read(g_fdcm_hdl, info, SYSINFO_SIZE) != SYSINFO_SIZE) {
|
|
SYSINFO_WRN("read mac addr from flash fail\n");
|
|
free(info);
|
|
goto random_mac_addr;
|
|
}
|
|
memcpy(g_sysinfo.mac_addr, info->mac_addr, SYSINFO_MAC_ADDR_LEN);
|
|
free(info);
|
|
return;
|
|
}
|
|
#endif
|
|
default:
|
|
SYSINFO_ERR("invalid mac addr source\n");
|
|
goto random_mac_addr;
|
|
}
|
|
|
|
random_mac_addr:
|
|
SYSINFO_DBG("random mac addr\n");
|
|
sysinfo_gen_mac_random(g_sysinfo.mac_addr);
|
|
}
|
|
#endif /* PRJCONF_NET_EN */
|
|
|
|
static void sysinfo_init_value(void)
|
|
{
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
if (sysinfo_load() != 0) {
|
|
sysinfo_default();
|
|
return;
|
|
}
|
|
#if PRJCONF_NET_EN
|
|
if (PRJCONF_MAC_ADDR_SOURCE != SYSINFO_MAC_ADDR_FLASH) {
|
|
sysinfo_init_mac_addr();
|
|
}
|
|
#endif
|
|
#else
|
|
sysinfo_default();
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize the sysinfo module
|
|
* @return 0 on success, -1 on failure
|
|
*/
|
|
int sysinfo_init(void)
|
|
{
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
#ifdef CONFIG_OTA
|
|
#if PRJCONF_SYSINFO_CHECK_OVERLAP
|
|
image_ota_param_t *iop;
|
|
int i;
|
|
uint32_t image_start, image_end;
|
|
|
|
iop = (image_ota_param_t *)image_get_ota_param();
|
|
for (i = 0; i < IMAGE_SEQ_NUM; ++i) {
|
|
image_start = iop->addr[i];
|
|
if (i == 0)
|
|
image_end = iop->addr[i] + IMAGE_AREA_SIZE(iop->img_max_size);
|
|
else
|
|
#if (defined(CONFIG_OTA_POLICY_PINGPONG))
|
|
image_end = iop->addr[i] + IMAGE_AREA_SIZE(iop->img_max_size);
|
|
#elif (defined(CONFIG_OTA_POLICY_IMAGE_COMPRESSION))
|
|
image_end = iop->addr[i] + IMAGE_AREA_SIZE(iop->img_xz_max_size);
|
|
#else
|
|
#error "Invalid OTA policy!"
|
|
#endif
|
|
if (PRJCONF_SYSINFO_ADDR >= image_start && PRJCONF_SYSINFO_ADDR < image_end) {
|
|
SYSINFO_ERR("sysinfo: %#x has overlay image%d: %#x - %#x\n",
|
|
PRJCONF_SYSINFO_ADDR, i, image_start, image_end);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (PRJCONF_SYSINFO_ADDR >= iop->ota_addr &&
|
|
PRJCONF_SYSINFO_ADDR < iop->ota_addr + iop->ota_size) {
|
|
SYSINFO_ERR("sysinfo: %#x has overlay ota area: %#x - %#x\n",
|
|
PRJCONF_SYSINFO_ADDR, iop->ota_addr, iop->ota_addr + iop->ota_size);
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
g_fdcm_hdl = fdcm_open(PRJCONF_SYSINFO_FLASH, PRJCONF_SYSINFO_ADDR, PRJCONF_SYSINFO_SIZE);
|
|
if (g_fdcm_hdl == NULL) {
|
|
SYSINFO_ERR("fdcm open failed, hdl %p\n", g_fdcm_hdl);
|
|
return -1;
|
|
}
|
|
#endif /* PRJCONF_SYSINFO_SAVE_TO_FLASH */
|
|
sysinfo_init_value();
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief DeInitialize the sysinfo module
|
|
* @return None
|
|
*/
|
|
void sysinfo_deinit(void)
|
|
{
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
fdcm_close(g_fdcm_hdl);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @brief Set default value to sysinfo
|
|
* @return 0 on success, -1 on failure
|
|
*/
|
|
int sysinfo_default(void)
|
|
{
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
if (g_fdcm_hdl == NULL) {
|
|
SYSINFO_ERR("uninitialized, hdl %p\n", g_fdcm_hdl);
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
memset(&g_sysinfo, 0, SYSINFO_SIZE);
|
|
|
|
#if PRJCONF_NET_EN
|
|
/* MAC address */
|
|
sysinfo_init_mac_addr();
|
|
|
|
/* wlan mode */
|
|
#ifdef CONFIG_WLAN_STA
|
|
g_sysinfo.wlan_mode = WLAN_MODE_STA;
|
|
#elif defined(CONFIG_WLAN_AP)
|
|
g_sysinfo.wlan_mode = WLAN_MODE_HOSTAP;
|
|
#elif defined(CONFIG_WLAN_MONITOR)
|
|
g_sysinfo.wlan_mode = WLAN_MODE_MONITOR;
|
|
#else
|
|
g_sysinfo.wlan_mode = WLAN_MODE_INVALID;
|
|
#endif
|
|
|
|
/* netif STA */
|
|
g_sysinfo.sta_use_dhcp = 1;
|
|
|
|
/* netif AP */
|
|
IP4_ADDR(&g_sysinfo.netif_ap_param.ip_addr, 192, 168, 51, 1);
|
|
IP4_ADDR(&g_sysinfo.netif_ap_param.net_mask, 255, 255, 255, 0);
|
|
IP4_ADDR(&g_sysinfo.netif_ap_param.gateway, 192, 168, 51, 1);
|
|
#endif
|
|
|
|
SYSINFO_DBG("set default value\n");
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
sysinfo_save();
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
/**
|
|
* @brief Save sysinfo to flash
|
|
* @return 0 on success, -1 on failure
|
|
*/
|
|
int sysinfo_save(void)
|
|
{
|
|
if (g_fdcm_hdl == NULL) {
|
|
SYSINFO_ERR("uninitialized, hdl %p\n", g_fdcm_hdl);
|
|
return -1;
|
|
}
|
|
|
|
if (fdcm_write(g_fdcm_hdl, &g_sysinfo, SYSINFO_SIZE) != SYSINFO_SIZE) {
|
|
SYSINFO_ERR("fdcm write failed\n");
|
|
return -1;
|
|
}
|
|
|
|
SYSINFO_DBG("save sysinfo to flash\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Load sysinfo from flash
|
|
* @return 0 on success, -1 on failure
|
|
*/
|
|
int sysinfo_load(void)
|
|
{
|
|
if (g_fdcm_hdl == NULL) {
|
|
SYSINFO_ERR("uninitialized, hdl %p\n", g_fdcm_hdl);
|
|
return -1;
|
|
}
|
|
|
|
if (fdcm_read(g_fdcm_hdl, &g_sysinfo, SYSINFO_SIZE) != SYSINFO_SIZE) {
|
|
SYSINFO_WRN("fdcm read failed\n");
|
|
return -1;
|
|
}
|
|
|
|
SYSINFO_DBG("load sysinfo from flash\n");
|
|
|
|
return 0;
|
|
}
|
|
#endif /* PRJCONF_SYSINFO_SAVE_TO_FLASH */
|
|
|
|
/**
|
|
* @brief Get the pointer of the sysinfo
|
|
* @return Pointer to the sysinfo, NULL on failure
|
|
*/
|
|
struct sysinfo *sysinfo_get(void)
|
|
{
|
|
#if PRJCONF_SYSINFO_SAVE_TO_FLASH
|
|
if (g_fdcm_hdl == NULL) {
|
|
SYSINFO_ERR("uninitialized, hdl %p\n", g_fdcm_hdl);
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
return &g_sysinfo;
|
|
}
|