622 lines
16 KiB
C
622 lines
16 KiB
C
// Copyright 2020-2021 Beken
|
|
//
|
|
// 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 <common/bk_include.h>
|
|
#include <components/log.h>
|
|
#include "bk_drv_model.h"
|
|
#include "bk_uart.h"
|
|
#include "bk_wifi_private.h"
|
|
#include "bk_sys_ctrl.h"
|
|
#include <driver/efuse.h>
|
|
#include <driver/otp.h>
|
|
#include <driver/otp_types.h>
|
|
#include <os/mem.h>
|
|
#include "bk_phy.h"
|
|
#include <components/system.h>
|
|
#include <components/log.h>
|
|
#include "bk_wifi_types.h"
|
|
#include "bk_wifi.h"
|
|
#if (CONFIG_RANDOM_MAC_ADDR)
|
|
#include <driver/trng.h>
|
|
#endif
|
|
#include "driver/flash_partition.h"
|
|
|
|
#define TAG "mac"
|
|
|
|
#if ((CONFIG_SOC_BK7231) && (CONFIG_BASE_MAC_FROM_EFUSE))
|
|
#error "BK7231 not support efuse!"
|
|
#endif
|
|
|
|
#define BASE_MAC_LEN (6)
|
|
#define DEFAULT_MAC_ADDR "\xC8\x47\x8C\x00\x00\x18"
|
|
static uint8_t s_base_mac[] = DEFAULT_MAC_ADDR;
|
|
static bool s_mac_inited = false;
|
|
|
|
#if (CONFIG_BASE_MAC_FROM_EFUSE)
|
|
static int write_base_mac_to_efuse(const uint8_t *mac)
|
|
{
|
|
#if 0
|
|
uint8_t efuse_addr = 0;
|
|
uint8_t efuse_data = 0;
|
|
int i = 0, ret;
|
|
|
|
if (!mac)
|
|
return BK_ERR_PARAM;
|
|
|
|
for (i = 0; i < EFUSE_MAC_LEN; i++) {
|
|
efuse_addr = EFUSE_MAC_START_ADDR + i;
|
|
efuse_data = mac[i];
|
|
|
|
if (i == 0) {
|
|
// ensure mac[0]-bit0 in efuse not '1'
|
|
efuse_data &= ~(0x01);
|
|
}
|
|
|
|
ret = bk_efuse_write_byte(efuse_addr, efuse_data);
|
|
if (ret != BK_OK) {
|
|
BK_LOGI(TAG, "efuse set mac failed(%x)\r\n", ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
BK_LOGI(TAG, "efuse set mac: "BK_MAC_FORMAT"\n", BK_MAC_STR(mac));
|
|
return BK_OK;
|
|
#else
|
|
BK_LOGI(TAG, "write mac to eufse stub");
|
|
return BK_OK;
|
|
#endif
|
|
}
|
|
|
|
static int read_base_mac_from_efuse(uint8_t *mac)
|
|
{
|
|
uint8_t efuse_addr = 0;
|
|
uint8_t efuse_data = 0;
|
|
int i = 0, ret;
|
|
|
|
if (!mac)
|
|
return BK_ERR_PARAM;
|
|
|
|
for (i = 0; i < BK_MAC_ADDR_LEN; i++) {
|
|
efuse_addr = EFUSE_MAC_START_ADDR + i;
|
|
efuse_data = 0;
|
|
|
|
ret = bk_efuse_read_byte(efuse_addr, &efuse_data);
|
|
if (ret == BK_OK)
|
|
mac[i] = efuse_data;
|
|
else {
|
|
os_memset(mac, 0, BK_MAC_ADDR_LEN);
|
|
mac[i] = 0;
|
|
BK_LOGE(TAG, "efuse get mac failed(%x)\n", ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
BK_LOGI(TAG, "efuse get mac: "BK_MAC_FORMAT"\n", BK_MAC_STR(mac));
|
|
|
|
if (BK_IS_ZERO_MAC(mac)) {
|
|
BK_LOGE(TAG, "efuse MAC all zero, see as error\r\n");
|
|
return BK_ERR_ZERO_MAC;
|
|
}
|
|
|
|
return BK_OK;
|
|
}
|
|
#endif
|
|
|
|
#if (CONFIG_BASE_MAC_FROM_RF_OTP_FLASH)
|
|
static int read_base_mac_from_rf_otp_flash(uint8_t *mac)
|
|
{
|
|
#if (CONFIG_SOC_BK7236XX || CONFIG_SOC_BK7239XX || CONFIG_SOC_BK7286XX)
|
|
#if CONFIG_OTP
|
|
uint8_t buf[6];
|
|
bk_err_t result;
|
|
|
|
result = bk_otp_apb_read(OTP_MAC_ADDRESS, buf, sizeof(buf));
|
|
if ((result == BK_OK) && ((buf[0] != 0) || (buf[1] != 0) || (buf[2] != 0) || (buf[3] != 0) || (buf[4] != 0) || (buf[5] != 0)))
|
|
{
|
|
os_memcpy(mac, buf, sizeof(buf));
|
|
return result;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
if (manual_cal_get_macaddr_from_flash((uint8_t *)mac))
|
|
return BK_OK;
|
|
else
|
|
return BK_FAIL;
|
|
}
|
|
|
|
static int write_base_mac_to_rf_otp_flash(const uint8_t *mac)
|
|
{
|
|
if (manual_cal_write_macaddr_to_flash((uint8_t *)s_base_mac))
|
|
return BK_OK;
|
|
else
|
|
return BK_FAIL;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if (CONFIG_BASE_MAC_FROM_OTP1)
|
|
static int write_base_mac_to_otp1(const uint8_t *mac)
|
|
{
|
|
#if CONFIG_OTP
|
|
int ret = BK_FAIL;
|
|
uint8_t mac_r[] = DEFAULT_MAC_ADDR;
|
|
|
|
ret = bk_otp_apb_read(OTP_MAC_ADDRESS, mac_r, BASE_MAC_LEN);
|
|
if(ret == 0)
|
|
{
|
|
for(UINT8 i = 0; i < BASE_MAC_LEN; i++)
|
|
{
|
|
if(mac_r[i] == 0x00)
|
|
{
|
|
ret += 1;
|
|
}
|
|
}
|
|
if(ret == BASE_MAC_LEN)
|
|
{
|
|
ret = bk_otp_apb_update(OTP_MAC_ADDRESS, (uint8_t *)mac, BASE_MAC_LEN);
|
|
if(ret == 0)
|
|
return BK_OK;
|
|
else
|
|
return BK_FAIL;
|
|
}
|
|
else
|
|
{
|
|
return BK_FAIL;
|
|
}
|
|
}
|
|
return BK_FAIL;
|
|
#endif
|
|
}
|
|
|
|
static int read_base_mac_to_otp1(uint8_t *mac)
|
|
{
|
|
#if CONFIG_OTP
|
|
int ret = BK_FAIL;
|
|
uint8_t buf[6];
|
|
ret = bk_otp_apb_read(OTP_MAC_ADDRESS, buf, BASE_MAC_LEN);
|
|
if ((ret == BK_OK) && ((buf[0] != 0) || (buf[1] != 0) || (buf[2] != 0) || (buf[3] != 0) || (buf[4] != 0) || (buf[5] != 0)))
|
|
{
|
|
os_memcpy(mac, buf, sizeof(buf));
|
|
return ret;
|
|
}
|
|
#endif
|
|
if (manual_cal_get_macaddr_from_flash((uint8_t *)mac))
|
|
return BK_OK;
|
|
else
|
|
return BK_FAIL;
|
|
}
|
|
#endif
|
|
|
|
#if (CONFIG_RANDOM_MAC_ADDR)
|
|
static void random_mac_address(u8 *mac)
|
|
{
|
|
int i = 0;
|
|
|
|
mac[3] = bk_rand() & 0xff;
|
|
mac[4] = bk_rand() & 0xff;
|
|
mac[5] = bk_rand() & 0xff;
|
|
|
|
os_printf("mac:");
|
|
for (i = 0; i < 6; i++)
|
|
os_printf("%02X ", mac[i]);
|
|
os_printf("\n");
|
|
}
|
|
|
|
static int bk_check_mac_address(u8 *mac)
|
|
{
|
|
if (mac[0] != 0xc8 || mac[1] != 0x47 || mac[2] != 0x8c) {
|
|
BK_LOGE(TAG, "not a beken mac addr\n");
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#if (CONFIG_NEW_MAC_POLICY)
|
|
/*
|
|
1. BASE MAC stored at flash partison: BK_PARTITION_NET_PARAM as WIFI_MAC_ITEM (0x3ff000: first 6 bytes)
|
|
2. BASE MAC maybe missed while board power down at the time point:
|
|
erase flash partition between BK_PARTITION_NET_PARAM update other netinfo process
|
|
3. Use BK_PARTITION_RF_FIRMWARE last free 512 bytes to backup the BASE MAC
|
|
4. Every backup record of BASE MAC is 10 bytes, just write, no erase. MAX backup 51 times
|
|
*/
|
|
|
|
#define BASE_MAC_MAGIC_TAG (0x4d41)
|
|
#define BASE_MAC_RECORD_COUNT_MAX (51)
|
|
#define BASE_MAC_RECORD_SIZE (512)
|
|
#define BASE_MAC_RECORD_OFFSET (4096 - BASE_MAC_RECORD_SIZE)
|
|
#define BASE_MAC_RECORD_HDR_LEN (3)
|
|
#define BASE_MAC_RECORD_OPT_READ (0)
|
|
#define BASE_MAC_RECORD_OPT_WRITE (1)
|
|
|
|
typedef struct base_mac_record {
|
|
// magic tag of record: 0x4d41
|
|
uint16_t magic_tag;
|
|
// crc of mac[0~5]
|
|
uint8_t crc8_data;
|
|
// crc of magic tag and crc8_data
|
|
uint8_t crc8_hdr;
|
|
// base mac data
|
|
uint8_t mac[BASE_MAC_LEN];
|
|
} base_mac_record_t;
|
|
|
|
/* CRC-8: the poly is 0x31 (x^8 + x^5 + x^4 + 1) */
|
|
static uint8_t utils_crc8(uint8_t *buf, uint16_t length)
|
|
{
|
|
uint8_t crc = 0x00;
|
|
uint8_t i;
|
|
|
|
while (length--) {
|
|
crc ^= *buf++;
|
|
for (i = 8; i > 0; i--) {
|
|
if (crc & 0x80) {
|
|
crc = (crc << 1) ^ 0x31;
|
|
} else {
|
|
crc <<= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return crc;
|
|
}
|
|
|
|
static int is_free_mac_record(base_mac_record_t *mac_rec_p) {
|
|
uint16_t *p = (uint16_t *)mac_rec_p;
|
|
uint16_t *end = p + sizeof(base_mac_record_t)/sizeof(uint16_t);
|
|
while (p < end) {
|
|
if(*p++ != 0xffff) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int get_first_free_mac_record(base_mac_record_t *mac_rec_p, int count) {
|
|
int left = 0, right = count - 1;
|
|
|
|
while (left < right) {
|
|
if(is_free_mac_record(&mac_rec_p[left])) {
|
|
return left;
|
|
}
|
|
left++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
static int is_valid_mac_record(base_mac_record_t *mac_rec_p) {
|
|
if (BASE_MAC_MAGIC_TAG == mac_rec_p->magic_tag) {
|
|
uint8_t crc_hdr = utils_crc8((uint8_t *)mac_rec_p, BASE_MAC_RECORD_HDR_LEN);
|
|
if(crc_hdr == mac_rec_p->crc8_hdr) {
|
|
uint8_t crc_data = utils_crc8(mac_rec_p->mac, BASE_MAC_LEN);
|
|
if(crc_data == mac_rec_p->crc8_data) {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int get_latest_valid_mac_record(base_mac_record_t *mac_rec_p, int count, int free_index) {
|
|
int valid_index = 0;
|
|
|
|
if (free_index == 0) {
|
|
return -1;
|
|
}
|
|
|
|
if(0 < free_index && free_index < BASE_MAC_RECORD_COUNT_MAX) {
|
|
valid_index = free_index - 1;
|
|
} else {
|
|
valid_index = BASE_MAC_RECORD_COUNT_MAX - 1;
|
|
}
|
|
|
|
while (valid_index >= 0) {
|
|
if(is_valid_mac_record(&mac_rec_p[valid_index])) {
|
|
// BK_LOGI(TAG, "get_latest_valid_mac_record: free index(%d), valid index(%d).\n",
|
|
// free_index, valid_index);
|
|
return valid_index;
|
|
}
|
|
valid_index--;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
static void build_base_mac_record(base_mac_record_t *new_mac_p, uint8_t *mac) {
|
|
new_mac_p->magic_tag = BASE_MAC_MAGIC_TAG;
|
|
os_memcpy(new_mac_p->mac, mac, BASE_MAC_LEN);
|
|
new_mac_p->crc8_data = utils_crc8(new_mac_p->mac, BASE_MAC_LEN);
|
|
new_mac_p->crc8_hdr = utils_crc8((uint8_t *)new_mac_p, BASE_MAC_RECORD_HDR_LEN);
|
|
}
|
|
|
|
/*
|
|
sync base mac
|
|
mode: 0 read from rf flash, 1 backup to rf flash
|
|
*/
|
|
static int sync_base_mac_record(uint8_t *mac, int mode)
|
|
{
|
|
int ret = BK_FAIL;
|
|
int valid_index = 0;
|
|
int free_index = 0;
|
|
const int record_len = sizeof(base_mac_record_t);
|
|
|
|
// internal call, need not valid parameter
|
|
// if(NULL == mac) {
|
|
// BK_LOGE(TAG, "get_base_mac_record, para NULL.\n");
|
|
// return BK_FAIL;
|
|
// }
|
|
|
|
if (BASE_MAC_RECORD_OPT_WRITE == mode) {
|
|
BK_LOGI(TAG, "sync_base_mac_record, mac:"BK_MAC_FORMAT"\n", BK_MAC_STR(mac));
|
|
BK_LOGI(TAG, "sync_base_mac_record, mode: %d. \n", mode);
|
|
}
|
|
|
|
base_mac_record_t *mac_rec_p = os_zalloc(BASE_MAC_RECORD_SIZE);
|
|
|
|
if (NULL == mac_rec_p) {
|
|
BK_LOGE(TAG, "get_base_mac_record, memory oom.\n");
|
|
return BK_FAIL;
|
|
}
|
|
|
|
do {
|
|
ret = bk_flash_partition_read(BK_PARTITION_RF_FIRMWARE,
|
|
(uint8_t *)mac_rec_p,
|
|
BASE_MAC_RECORD_OFFSET,
|
|
BASE_MAC_RECORD_SIZE);
|
|
if(BK_OK != ret) {
|
|
BK_LOGE(TAG, "get_base_mac_record, read flash failed.\n");
|
|
break;
|
|
}
|
|
|
|
free_index = get_first_free_mac_record(mac_rec_p, BASE_MAC_RECORD_COUNT_MAX);
|
|
if(free_index < 0 || free_index >= BASE_MAC_RECORD_COUNT_MAX) {
|
|
BK_LOGE(TAG, "sync_base_mac_record, record is full, free space not found.\n");
|
|
if (BASE_MAC_RECORD_OPT_READ != mode) {
|
|
ret = BK_FAIL;
|
|
break;
|
|
}
|
|
} else if(free_index > 1) {
|
|
BK_LOGW(TAG, "sync_base_mac_record, saved records is more than 1, free index(%d).\n", free_index);
|
|
}
|
|
|
|
if (BASE_MAC_RECORD_OPT_READ == mode) {
|
|
valid_index = get_latest_valid_mac_record(mac_rec_p, BASE_MAC_RECORD_COUNT_MAX, free_index);
|
|
if(valid_index < 0 || valid_index >= BASE_MAC_RECORD_COUNT_MAX) {
|
|
BK_LOGE(TAG, "sync_base_mac_record, valid record not found.\n");
|
|
ret = BK_FAIL;
|
|
break;
|
|
}
|
|
os_memcpy(mac, mac_rec_p[valid_index].mac, BASE_MAC_LEN);
|
|
} else if (BASE_MAC_RECORD_OPT_WRITE == mode) {
|
|
build_base_mac_record(&mac_rec_p[free_index], mac);
|
|
bk_flash_partition_write(BK_PARTITION_RF_FIRMWARE,
|
|
(uint8_t *)&mac_rec_p[free_index],
|
|
BASE_MAC_RECORD_OFFSET + record_len*free_index,
|
|
record_len);
|
|
}
|
|
|
|
ret = BK_OK;
|
|
|
|
} while (0);
|
|
|
|
if (NULL != mac_rec_p) {
|
|
os_free(mac_rec_p);
|
|
mac_rec_p = NULL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int is_valid_mac_addr(uint8_t *mac) {
|
|
if(mac[0] == 0xff && mac[1] == 0xff && mac[2] == 0xff
|
|
&& mac[3] == 0xff && mac[4] == 0xff && mac[5] == 0xff) {
|
|
return 0;
|
|
} else if(mac[0] == 0x0 && mac[1] == 0x0 && mac[2] == 0x0
|
|
&& mac[3] == 0x0 && mac[4] == 0x0 && mac[5] == 0x0) {
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int sync_mac_record(void) {
|
|
int ret = BK_OK;
|
|
uint8_t base_mac[BASE_MAC_LEN] = {0};
|
|
|
|
BK_LOGI(TAG, "sync_mac_record, base mac:"BK_MAC_FORMAT"\n", BK_MAC_STR(s_base_mac));
|
|
|
|
ret = sync_base_mac_record(base_mac, BASE_MAC_RECORD_OPT_READ);
|
|
|
|
if (BK_OK == ret) {
|
|
BK_LOGI(TAG, "sync_mac_record, saved base mac:"BK_MAC_FORMAT"\n", BK_MAC_STR(base_mac));
|
|
}
|
|
|
|
if (!is_valid_mac_addr(s_base_mac)) {
|
|
if(BK_OK == ret) {
|
|
// Use saved latest valid mac in last 512 bytes of RF partition
|
|
// Sync the s_base_mac and mac in netinfo partition
|
|
os_memcpy(s_base_mac, base_mac, BASE_MAC_LEN);
|
|
save_net_info(WIFI_MAC_ITEM, s_base_mac, NULL, NULL);
|
|
} else {
|
|
// There isn't valid mac info in Both netinfo partition and RF partition
|
|
BK_LOGE(TAG, "sync_mac_record, NO valid mac be founded.\n");
|
|
return BK_FAIL;
|
|
}
|
|
} else {
|
|
if(BK_OK == ret) {
|
|
if(0 != os_memcmp(s_base_mac, base_mac, BASE_MAC_LEN)) {
|
|
sync_base_mac_record(s_base_mac, BASE_MAC_RECORD_OPT_WRITE);
|
|
}
|
|
} else {
|
|
sync_base_mac_record(s_base_mac, BASE_MAC_RECORD_OPT_WRITE);
|
|
}
|
|
}
|
|
|
|
return BK_OK;
|
|
}
|
|
#endif //#if (CONFIG_NEW_MAC_POLICY)
|
|
|
|
|
|
static int mac_init(void)
|
|
{
|
|
int ret = BK_FAIL;
|
|
|
|
#if (CONFIG_BASE_MAC_FROM_EFUSE)
|
|
ret = read_base_mac_from_efuse(s_base_mac);
|
|
#elif (CONFIG_NEW_MAC_POLICY)
|
|
get_net_info(WIFI_MAC_ITEM, s_base_mac, NULL, NULL);
|
|
ret = sync_mac_record();
|
|
#elif (CONFIG_BASE_MAC_FROM_RF_OTP_FLASH)
|
|
ret = read_base_mac_from_rf_otp_flash(s_base_mac);
|
|
#elif (CONFIG_BASE_MAC_FROM_OTP1)
|
|
ret = read_base_mac_to_otp1(s_base_mac);
|
|
#endif
|
|
|
|
#if (CONFIG_RANDOM_MAC_ADDR)
|
|
if ((BK_OK != ret) || BK_IS_GROUP_MAC(s_base_mac)
|
|
#if CONFIG_BK_MAC_ADDR_CHECK
|
|
|| bk_check_mac_address(s_base_mac)
|
|
#endif
|
|
) {
|
|
os_memcpy(s_base_mac, DEFAULT_MAC_ADDR, BK_MAC_ADDR_LEN);
|
|
random_mac_address(s_base_mac);
|
|
#if (CONFIG_BASE_MAC_FROM_EFUSE)
|
|
ret = write_base_mac_to_efuse(s_base_mac);
|
|
#elif (CONFIG_NEW_MAC_POLICY)
|
|
save_net_info(WIFI_MAC_ITEM, s_base_mac, NULL, NULL);
|
|
ret = sync_mac_record();
|
|
#elif (CONFIG_BASE_MAC_FROM_RF_OTP_FLASH)
|
|
ret = write_base_mac_to_rf_otp_flash(s_base_mac);
|
|
#endif
|
|
BK_LOGI(TAG, "use random mac "BK_MAC_FORMAT" as base mac\n", BK_MAC_STR(s_base_mac));
|
|
}
|
|
#else //#if (CONFIG_RANDOM_MAC_ADDR)
|
|
if (BK_OK != ret) {
|
|
os_memcpy(s_base_mac, DEFAULT_MAC_ADDR, BK_MAC_ADDR_LEN);
|
|
if (BK_IS_GROUP_MAC(s_base_mac)) {
|
|
BK_LOGE(TAG, "base mac is group mac"BK_MAC_FORMAT"\n", BK_MAC_STR(s_base_mac));
|
|
return BK_ERR_GROUP_MAC;
|
|
} else {
|
|
BK_LOGI(TAG, "use default mac "BK_MAC_FORMAT" as base mac\n", BK_MAC_STR(s_base_mac));
|
|
}
|
|
} else {
|
|
BK_LOGI(TAG, "base mac "BK_MAC_FORMAT"\n", BK_MAC_STR(s_base_mac));
|
|
}
|
|
#endif //#if (CONFIG_RANDOM_MAC_ADDR)
|
|
|
|
return BK_OK;
|
|
}
|
|
|
|
|
|
bk_err_t bk_get_mac(uint8_t *mac, mac_type_t type)
|
|
{
|
|
#if !CONFIG_CUS_MAC_MASK
|
|
uint8_t mac_mask = (0xff & (2/*NX_VIRT_DEV_MAX*/ - 1));
|
|
uint8_t mac_low;
|
|
#endif
|
|
|
|
if (s_mac_inited == false) {
|
|
mac_init();
|
|
s_mac_inited = true;
|
|
}
|
|
|
|
switch (type) {
|
|
case MAC_TYPE_BASE:
|
|
os_memcpy(mac, s_base_mac, BK_MAC_ADDR_LEN);
|
|
break;
|
|
|
|
case MAC_TYPE_AP:
|
|
#if CONFIG_CUS_MAC_MASK
|
|
os_memcpy(mac, s_base_mac, BK_MAC_ADDR_LEN);
|
|
for (int i = 0; i < BK_MAC_ADDR_LEN; i++) {
|
|
mac[BK_MAC_ADDR_LEN-i-1] ^= (CONFIG_CUS_MAC_MASK >> (i*8)) & 0xff;
|
|
}
|
|
#else
|
|
mac_mask = (0xff & (2/*NX_VIRT_DEV_MAX*/ - 1));
|
|
|
|
os_memcpy(mac, s_base_mac, BK_MAC_ADDR_LEN);
|
|
mac_low = mac[5];
|
|
|
|
// if NX_VIRT_DEV_MAX == 4.
|
|
// if support AP+STA, mac addr should be equal with each other in byte0-4 & byte5[7:2],
|
|
// byte5[1:0] can be different
|
|
// ie: mac[5]= 0xf7, so mac[5] can be 0xf4, f5, f6. here wre chose 0xf4
|
|
mac[5] &= ~mac_mask;
|
|
mac_low = ((mac_low & mac_mask) ^ mac_mask);
|
|
mac[5] |= mac_low;
|
|
#endif
|
|
break;
|
|
|
|
case MAC_TYPE_STA:
|
|
os_memcpy(mac, s_base_mac, BK_MAC_ADDR_LEN);
|
|
break;
|
|
|
|
case MAC_TYPE_BLUETOOTH:
|
|
os_memcpy(mac, s_base_mac, BK_MAC_ADDR_LEN);
|
|
mac[5] += 1; // add 1, diff from wifi's mac
|
|
break;
|
|
|
|
#ifdef CONFIG_ETH
|
|
case MAC_TYPE_ETH:
|
|
os_memcpy(mac, s_base_mac, BK_MAC_ADDR_LEN);
|
|
mac[5] += 2 /* NX_VIRT_DEV_MAX */ + 1 /* BLUETOOTH */;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
return BK_ERR_INVALID_MAC_TYPE;
|
|
}
|
|
|
|
return BK_OK;
|
|
}
|
|
|
|
bk_err_t bk_set_base_mac(const uint8_t *mac)
|
|
{
|
|
int ret = BK_FAIL;
|
|
|
|
if (!mac)
|
|
return BK_ERR_NULL_PARAM;
|
|
|
|
if (BK_IS_GROUP_MAC(mac)) {
|
|
BK_LOGE(TAG, "set failed, cann't be a bc/mc address\r\n");
|
|
return BK_ERR_GROUP_MAC;
|
|
}
|
|
|
|
os_memcpy(s_base_mac, mac, BK_MAC_ADDR_LEN);
|
|
|
|
#if (CONFIG_BASE_MAC_FROM_EFUSE)
|
|
ret = write_base_mac_to_efuse(mac);
|
|
ret = read_base_mac_from_efuse(s_base_mac);
|
|
#elif (CONFIG_NEW_MAC_POLICY)
|
|
ret = save_net_info(WIFI_MAC_ITEM, s_base_mac, NULL, NULL);
|
|
ret = sync_mac_record();
|
|
ret = get_net_info(WIFI_MAC_ITEM, s_base_mac, NULL, NULL);
|
|
#elif (CONFIG_BASE_MAC_FROM_RF_OTP_FLASH)
|
|
ret = write_base_mac_to_rf_otp_flash(s_base_mac);
|
|
ret = read_base_mac_from_rf_otp_flash(s_base_mac);
|
|
#elif (CONFIG_BASE_MAC_FROM_OTP1)
|
|
ret = write_base_mac_to_otp1(s_base_mac);
|
|
ret = read_base_mac_to_otp1(s_base_mac);
|
|
#endif
|
|
|
|
if (ret != BK_OK)
|
|
BK_LOGE(TAG, "failed to write base mac, ret(%x)\n", ret);
|
|
|
|
return ret;
|
|
}
|
|
|