helloyifa/lock_lfvx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
lock_lfvx/bk_idk/components/bk_cli/cli_wifi.c
helloyifa 40580710f2 first commit
2025-10-10 16:07:00 +08:00

2403 lines
60 KiB
C
Raw Blame History

#include <string.h>
#include <common/sys_config.h>
#include "bk_uart.h"
#if CONFIG_LWIP
#include <../../lwip_intf_v2_1/lwip-2.1.2/port/net.h>
#endif
#include "lwip/ip4.h"
#include "bk_private/bk_wifi.h"
#include "bk_wifi_private.h"
#include "bk_cli.h"
#include "cli.h"
#include <components/event.h>
#include <components/netif.h>
#include "bk_wifi.h"
#include "bk_wifi_types.h"
#if CONFIG_WIFI_CLI_RAW_LINK_ENABLE
#include <modules/raw_link.h>
#endif
#if CONFIG_WIFI6_CODE_STACK
#include "bk_wifi.h"
#endif
#if CONFIG_BRIDGE
#include "netif/bridgeif.h"
#include "lwip/netifapi.h"
#include "lwip/inet.h"
#endif
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
#include "driver/flash.h"
#include <driver/flash_partition.h>
#include <lwip/sockets.h>
#include "bk_wifi_private.h"
#include "boot.h"
#endif
#define TAG "wifi_cli"
#define CMD_WLAN_MAX_BSS_CNT 50
beken_semaphore_t wifi_cmd_sema = NULL;
int wifi_cmd_status = 0;
#if (CLI_CFG_WIFI == 1)
int wifi_cli_find_id(int argc, char **argv, char *param)
{
int i;
int index;
index = -1;
if (NULL == param)
goto find_over;
for (i = 1; i < argc; i ++) {
if (os_strcmp(argv[i], param) == 0) {
index = i;
break;
}
}
find_over:
return index;
}
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
typedef struct bk_fast_connect_t
{
uint8_t flag; //to check if ssid/pwd saved in easy flash is valid, default 0x70
//bit[0]:write sta deault info;bit[1]:write ap deault info
uint8_t sta_ssid[33];
uint8_t sta_pwd[65];
uint8_t ap_ssid[33];
uint8_t ap_pwd[65];
uint8_t ap_channel;
}BK_FAST_CONNECT_T;
static BK_FAST_CONNECT_T info_t;
static int fast_connect_cb(void *arg, event_module_t event_module,
int event_id, void *event_data)
{
bk_logic_partition_t *pt = bk_flash_partition_get_info(BK_PARTITION_USR_CONFIG);
BK_FAST_CONNECT_T info_tmp;
CLI_LOGI("%s, flag:%x\r\n", __func__, info_t.flag);
bk_flash_read_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info_tmp, sizeof(BK_FAST_CONNECT_T));
if (info_t.flag == 0x71l) {
if ((info_tmp.flag & 0xf8l) == 0x70l)
info_tmp.flag |= 0x1l;
else
info_tmp.flag = 0x71l;
os_strcpy((char *)info_tmp.sta_ssid, (char *)info_t.sta_ssid);
os_strcpy((char *)info_tmp.sta_pwd, (char *)info_t.sta_pwd);
} else if (info_t.flag == 0x72l) {
if ((info_tmp.flag & 0xf8l) == 0x70l)
info_tmp.flag |= 0x2l;
else
info_tmp.flag = 0x72l;
os_strcpy((char *)info_tmp.ap_ssid, (char *)info_t.ap_ssid);
os_strcpy((char *)info_tmp.ap_pwd, (char *)info_t.ap_pwd);
} else
return -1;
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
bk_flash_erase_sector(pt->partition_start_addr + pt->partition_length -4096);
bk_flash_write_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info_tmp, sizeof(BK_FAST_CONNECT_T));
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
return 0;
}
#if 0
static int demo_tcp_send(void *arg, event_module_t event_module,
int event_id, void *event_data)
{
struct sockaddr_in addr;
int flag = 1, sock, ret = -1, len = 40*1024;
struct timeval tv;
uint8_t *send_buf;
send_buf = (uint8_t *) os_malloc(len);
for (int i = 0; i < len; i++)
send_buf[i] = i & 0xff;
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock < 0) {
CLI_LOGI("create socket failed, err=%d!\n", errno);
return -1;
}
addr.sin_family = PF_INET;
addr.sin_port = htons(5001);
addr.sin_addr.s_addr = inet_addr((char *)"192.168.1.102");
ret = connect(sock, (const struct sockaddr *)&addr, sizeof(addr));
if (ret == -1) {
CLI_LOGI("connect failed, err=%d!\n", errno);
closesocket(sock);
return -1;
}
setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
(void *)&flag, sizeof(int));
tv.tv_sec = 3;
tv.tv_usec = 0;
setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
tv.tv_sec = 3;
tv.tv_usec = 0;
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
ret = send(sock, send_buf, len, 0);
closesocket(sock);
return 0;
}
#endif
void demo_wifi_fast_connect(void)
{
bk_logic_partition_t *pt = bk_flash_partition_get_info(BK_PARTITION_USR_CONFIG);
BK_FAST_CONNECT_T info;
bk_flash_read_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info, sizeof(BK_FAST_CONNECT_T));
CLI_LOGD("%s, flag:%x\r\n", __func__, info.flag);
if (info.flag == 0x71l) {
demo_sta_app_init((char *)info.sta_ssid, (char *)info.sta_pwd);
#if 0
bk_event_register_cb(EVENT_MOD_NETIF, EVENT_NETIF_GOT_IP4,
demo_tcp_send, &info_t);
#endif
} else if (info.flag == 0x72l) {
demo_softap_app_init((char *)info.ap_ssid, (char *)info.ap_pwd, NULL);
} else if (info.flag == 0x73l) {
demo_sta_app_init((char *)info.sta_ssid, (char *)info.sta_pwd);
demo_softap_app_init((char *)info.ap_ssid, (char *)info.ap_pwd, NULL);
}
}
#endif
void cli_wifi_scan_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
int ret = 0;
char *msg = NULL;
if (argc < 2) {
demo_scan_app_init();
} else {
uint8_t *ap_ssid;
ap_ssid = (uint8_t *)argv[1];
demo_scan_adv_app_init(ap_ssid);
}
if(ret == 0)
msg = WIFI_CMD_RSP_SUCCEED;
else
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
}
#include "conv_utf8_pub.h"
void cli_wifi_ap_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
char *ap_ssid = NULL;
char *ap_key = "";
char *ap_channel = NULL;
int ret = 0;
char *msg = NULL;
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
if (wifi_cli_find_id(argc, argv, "-w") > 0 ||
wifi_cli_find_id(argc, argv, "-e") > 0) {
if (argc == 3)
ap_ssid = argv[2];
else if (argc == 4) {
ap_ssid = argv[2];
if (os_strlen(argv[3]) <= 2)
ap_channel = argv[3];
else
ap_key = argv[3];
} else if (argc == 5) {
ap_ssid = argv[2];
ap_key = argv[3];
ap_channel = argv[4];
}
} else {
#endif
if (argc == 2)
ap_ssid = argv[1];
else if (argc == 3) {
ap_ssid = argv[1];
if (os_strlen(argv[2]) <= 2)
ap_channel = argv[2];
else
ap_key = argv[2];
} else if (argc == 4) {
ap_ssid = argv[1];
ap_key = argv[2];
ap_channel = argv[3];
}else{
CLI_LOGI("Invalid parameters\n");
return;
}
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
}
#endif
char *oob_ssid_softap = ap_ssid;
#if CONFIG_USE_CONV_UTF8
oob_ssid_softap = (char *)conv_utf8((uint8_t *)ap_ssid);
#endif
if (oob_ssid_softap) {
ret = demo_softap_app_init((char *)oob_ssid_softap, ap_key, ap_channel);
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
bk_event_unregister_cb(EVENT_MOD_WIFI, EVENT_WIFI_STA_CONNECTED,
fast_connect_cb);
if (wifi_cli_find_id(argc, argv, "-w") > 0) {
bk_logic_partition_t *pt = bk_flash_partition_get_info(BK_PARTITION_USR_CONFIG);
bk_flash_read_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info_t, sizeof(BK_FAST_CONNECT_T));
if ((info_t.flag & 0xf0l) == 0x70l)
info_t.flag |= 0x2l;
else
info_t.flag = 0x72l;
os_strcpy((char *)info_t.ap_ssid, (char *)ap_ssid);
os_strcpy((char *)info_t.ap_pwd, ap_key);
fast_connect_cb(NULL, 0, 0, NULL);
} else if (wifi_cli_find_id(argc, argv, "-e") > 0) {
bk_logic_partition_t *pt = bk_flash_partition_get_info(BK_PARTITION_USR_CONFIG);
bk_flash_read_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info_t, sizeof(BK_FAST_CONNECT_T));
if (info_t.flag == 0x72l || info_t.flag == 0x73l) {
info_t.flag &= ~0x2l;
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
bk_flash_erase_sector(pt->partition_start_addr + pt->partition_length -4096);
bk_flash_write_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info_t, sizeof(BK_FAST_CONNECT_T));
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
}
}
#endif
#if CONFIG_USE_CONV_UTF8
os_free(oob_ssid_softap);
#endif
}
if(ret == 0)
msg = WIFI_CMD_RSP_SUCCEED;
else
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
}
void cli_wifi_hidden_ap_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
wifi_ap_config_t ap_config = WIFI_DEFAULT_AP_CONFIG();
netif_ip4_config_t ip4_config = {0};
int len;
char *ap_ssid = NULL;
char *ap_key = "";
char *ap_channel = NULL;
int ret = 0;
char *msg = NULL;
if (argc == 2)
ap_ssid = argv[1];
else if (argc == 3) {
ap_ssid = argv[1];
if (os_strlen(argv[2]) <= 2)
ap_channel = argv[2];
else
ap_key = argv[2];
} else if (argc == 4) {
ap_ssid = argv[1];
ap_key = argv[2];
ap_channel = argv[3];
}else{
CLI_LOGI("Invalid parameters\n");
return;
}
if (ap_ssid) {
len = os_strlen(ap_ssid);
if (32 < len) {
CLI_LOGE("ssid name more than 32 Bytes\r\n");
return;
}
os_strcpy(ip4_config.ip, WLAN_DEFAULT_IP);
os_strcpy(ip4_config.mask, WLAN_DEFAULT_MASK);
os_strcpy(ip4_config.gateway, WLAN_DEFAULT_GW);
os_strcpy(ip4_config.dns, WLAN_DEFAULT_GW);
ret = bk_netif_set_ip4_config(NETIF_IF_AP, &ip4_config);
os_strcpy(ap_config.ssid, ap_ssid);
os_strcpy(ap_config.password, ap_key);
if (ap_channel) {
int channel;
char *end;
channel = strtol(ap_channel, &end, 0);
if (*end) {
CLI_LOGE("Invalid number '%s'", ap_channel);
return;
}
ap_config.channel = channel;
}
CLI_LOGI("ssid:%s key:%s\r\n", ap_config.ssid, ap_config.password);
ap_config.hidden = true;
ret = bk_wifi_ap_set_config(&ap_config);
ret = bk_wifi_ap_start();
}
if(ret == 0)
msg = WIFI_CMD_RSP_SUCCEED;
else
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
}
void cli_wifi_stop_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
int ret = 0;
char *msg = NULL;
if (argc == 2) {
if (os_strcmp(argv[1], "sta") == 0) {
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
bk_event_unregister_cb(EVENT_MOD_WIFI, EVENT_WIFI_STA_CONNECTED,
fast_connect_cb);
#endif
ret = bk_wifi_sta_stop();
} else if (os_strcmp(argv[1], "ap") == 0)
ret = bk_wifi_ap_stop();
else {
CLI_LOGI("unknown WiFi interface\n");
goto error;
}
} else {
CLI_LOGI("bad parameters\r\n");
goto error;
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_iplog_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
char *iplog_mode = NULL;
char *iplog_type = NULL;
int ret = 0;
char *msg = NULL;
if (argc == 3)
{
iplog_mode = argv[1];
iplog_type = argv[2];
if (iplog_mode && iplog_type)
demo_wifi_iplog_init(iplog_mode, iplog_type);
}
else if (argc == 2)
{
iplog_mode = argv[1];
if (iplog_mode)
demo_wifi_iplog_init(iplog_mode, iplog_type);
}
else
{
CLI_LOGI("cli_wifi_iplog_cmd:invalid argc num\r\n");
goto error;
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_ipdbg_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint32_t func = 0;
uint16_t value = 0;
int ret = 0;
char *msg = NULL;
if (argc == 3)
{
func = (uint32_t)os_strtoul(argv[1], NULL, 16);
value = (uint16_t)os_strtoul(argv[2], NULL, 10);
demo_wifi_ipdbg_init(func, value);
}
else
{
CLI_LOGI("cli_wifi_ipdbg_cmd:invalid argc num\r\n");
goto error;
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_mem_apply_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t value = 0;
uint8_t module = 0;
int ret = 0;
char *msg = NULL;
if (argc < 3)
{
CLI_LOGI("cli_wifi_mem_cmd_cmd:invalid argc num");
goto error;
}
else if(3 == argc)
{
module = (uint8_t)(os_strtoul(argv[1], NULL, 16) & 0xFF);
value = (uint8_t)os_strtoul(argv[2], NULL, 10);
demo_wifi_mem_apply_init(module, value);
}
else
{
CLI_LOGI("cli_wifi_mem_cmd_cmd:invalid argc num\r\n");
goto error;
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
typedef struct {
uint8_t channel;
uint32_t rx_cnt_mgmt;
uint32_t rx_cnt_data;
uint32_t rx_cnt_ctrl;
uint32_t rx_cnt_0_255;
uint32_t rx_cnt_256_511;
uint32_t rx_cnt_512_1023;
uint32_t rx_cnt_1024;
uint32_t rx_cnt_total;
} cli_monitor_result_t;
static cli_monitor_result_t *s_monitor_result = NULL;
bk_err_t cli_monitor_cb(const uint8_t *data, uint32_t len, const wifi_frame_info_t *info)
{
if (s_monitor_result) {
s_monitor_result->rx_cnt_total++;
if (data) {
if ((data[0] & 0xc) == 0x8)
s_monitor_result->rx_cnt_data ++;
else if ((data[0] & 0xc) == 0x0)
s_monitor_result->rx_cnt_mgmt ++;
else
s_monitor_result->rx_cnt_ctrl ++;
}
if (len < 256)
s_monitor_result->rx_cnt_0_255++;
else if (len < 512)
s_monitor_result->rx_cnt_256_511++;
else if (len < 1024)
s_monitor_result->rx_cnt_512_1023++;
else
s_monitor_result->rx_cnt_1024++;
}
return BK_OK;
}
void cli_monitor_show(void)
{
if (s_monitor_result) {
BK_LOG_RAW("total: %u\n", s_monitor_result->rx_cnt_total);
BK_LOG_RAW("mgmt: %u\n", s_monitor_result->rx_cnt_mgmt);
BK_LOG_RAW("data: %u\n", s_monitor_result->rx_cnt_data);
BK_LOG_RAW("ctrl: %u\n", s_monitor_result->rx_cnt_ctrl);
BK_LOG_RAW("0 - 255: %u\n", s_monitor_result->rx_cnt_0_255);
BK_LOG_RAW("256 - 511: %u\n", s_monitor_result->rx_cnt_256_511);
BK_LOG_RAW("512 - 1023: %u\n", s_monitor_result->rx_cnt_512_1023);
BK_LOG_RAW(">=1024: %u\n", s_monitor_result->rx_cnt_1024);
}
}
#if CONFIG_RWNX_PROTO_DEBUG
void cli_wifi_set_proto_debug_flag(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t pd_flag = 0;
int ret = 0;
char *msg = NULL;
if (argc < 2) {
CLI_LOGI("invalid argc num");
goto error;
}
pd_flag = (uint8_t)os_strtoul(argv[1], NULL, 10);
if(pd_flag == 1) {
ret = bk_wifi_enable_proto_debug(pd_flag);
if (!ret) {
CLI_LOGI("enable proto debug ok");
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
CLI_LOGI("enable proto debug failed");
goto error;
}
} else if(pd_flag == 0){
ret = bk_wifi_disable_proto_debug(pd_flag);
if (!ret) {
CLI_LOGI("disable proto debug ok");
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
CLI_LOGI("disable proto debug failed");
goto error;
}
} else {
CLI_LOGI("invalid argv of pd_flag");
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#endif
void cli_wifi_set_arp_rate_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
float arp_tx_rate = 0;
uint16_t set_arp_tx_rate;
int ret = 0;
char *msg = NULL;
if (argc < 2) {
CLI_LOGI("invalid argc num");
goto error;
}
arp_tx_rate = (float)os_strtoul(argv[1], NULL, 10);
set_arp_tx_rate = (uint16_t)(arp_tx_rate * 10);
ret = bk_wifi_send_arp_set_rate_req(set_arp_tx_rate);
if (!ret) {
CLI_LOGI("set_arp_tx_rate ok");
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
CLI_LOGI("set_arp_tx_rate failed");
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_set_interval_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t interval = 0;
int ret = 0;
char *msg = NULL;
if (argc < 2) {
CLI_LOGI("invalid argc num");
goto error;
}
interval = (uint8_t)os_strtoul(argv[1], NULL, 10);
ret = bk_wifi_send_listen_interval_req(interval);
if (!ret) {
CLI_LOGI("set_interval ok");
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
CLI_LOGI("set_interval failed");
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_bcn_loss_intv_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t interval = 0;
uint8_t repeat_num = 0;
int ret = 0;
char *msg = NULL;
if (argc < 3) {
CLI_LOGI("invalid argc num");
goto error;
}
interval = (uint8_t)os_strtoul(argv[1], NULL, 10);
repeat_num = (uint8_t)os_strtoul(argv[2], NULL, 10);
ret = bk_wifi_send_bcn_loss_int_req(interval, repeat_num);
if (!ret) {
CLI_LOGI("set_bcn_loss_int ok");
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
CLI_LOGI("set_bcn_loss_int failed");
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_set_bcn_loss_time_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t wait_cnt = 0;
uint8_t wake_cnt = 0;
int ret = 0;
char *msg = NULL;
if (argc < 3) {
CLI_LOGI("invalid argc num");
goto error;
}
wait_cnt = (uint8_t)os_strtoul(argv[1], NULL, 10);
wake_cnt = (uint8_t)os_strtoul(argv[2], NULL, 10);
ret = bk_wifi_set_bcn_loss_time(wait_cnt, wake_cnt);
if (!ret) {
CLI_LOGI("set_bcn_loss_time ok");
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
CLI_LOGI("set_bcn_loss_time failed");
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_set_bcn_recv_win_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t default_win = 0;
uint8_t max_win = 0;
uint8_t step = 0;
int ret = 0;
char *msg = NULL;
if (argc < 4) {
CLI_LOGI("invalid argc num");
goto error;
}
default_win = (uint8_t)os_strtoul(argv[1], NULL, 10);
max_win = (uint8_t)os_strtoul(argv[2], NULL, 10);
step = (uint8_t)os_strtoul(argv[3], NULL, 10);
ret = bk_wifi_set_bcn_recv_win(default_win, max_win, step);
if (!ret) {
CLI_LOGI("set_bcn_recv_win ok");
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
CLI_LOGI("set_bcn_recv_win failed");
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_set_bcn_miss_time_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t bcnmiss_time = 0;
int ret = 0;
char *msg = NULL;
if (argc < 2) {
CLI_LOGI("invalid argc num");
goto error;
}
bcnmiss_time = (uint8_t)os_strtoul(argv[1], NULL, 10);
ret = bk_wifi_set_bcn_miss_time(bcnmiss_time);
if (!ret) {
CLI_LOGI("set_bcn_miss_time ok");
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
CLI_LOGI("set_bcn_miss_time failed");
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_monitor_stop(void)
{
if (s_monitor_result) {
os_free(s_monitor_result);
s_monitor_result = NULL;
}
BK_LOG_ON_ERR(bk_wifi_monitor_stop());
}
void cli_monitor_start(uint32_t primary_channel)
{
wifi_channel_t chan = {0};
chan.primary = primary_channel;
if (!s_monitor_result) {
s_monitor_result = os_zalloc(sizeof(cli_monitor_result_t));
if (!s_monitor_result)
CLI_LOGI("failed to alloc monitor result\n");
}
BK_LOG_ON_ERR(bk_wifi_monitor_register_cb(cli_monitor_cb));
BK_LOG_ON_ERR(bk_wifi_monitor_start());
BK_LOG_ON_ERR(bk_wifi_monitor_set_channel(&chan));
}
void cli_wifi_monitor_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint32_t primary_channel;
int ret = 0;
char *msg = NULL;
if (argc != 2) {
CLI_LOGI("monitor_parameter invalid\r\n");
goto error;
}
primary_channel = os_strtoul(argv[1], NULL, 10);
if (99 == primary_channel)
cli_monitor_stop();
else if ((primary_channel > 0) && (primary_channel < 15))
cli_monitor_start(primary_channel);
else
cli_monitor_show();
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_sta_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
char *ssid = NULL;
char *password = "";
#ifdef CONFIG_CONNECT_THROUGH_PSK_OR_SAE_PASSWORD
u8 *psk = 0;
#endif
char *msg = NULL;
int ret;
if ((argc < 2) || (argc > 6)) {
CLI_LOGI("invalid argc number\n");
goto error;
}
int err = rtos_init_semaphore(&wifi_cmd_sema, 1);
if (err != kNoErr) {
goto error;
}
#ifdef CONFIG_BSSID_CONNECT
uint8_t bssid[6] = {0};
if (os_strcmp(argv[1], "bssid") == 0) {
if(argc >= 3) {
hexstr2bin_cli(argv[2], bssid, 6);
}
if(argc >= 4) {
password = argv[3];
}
demo_sta_bssid_app_init(bssid, password);
if (wifi_cmd_sema != NULL)
{
err = rtos_get_semaphore(&wifi_cmd_sema, 10000);
if (err != kNoErr)
{
goto error;
}
else
{
if (wifi_cmd_status == 1)
{
msg = WIFI_EVT_GOT_IP;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
rtos_deinit_semaphore(&wifi_cmd_sema);
wifi_cmd_status = 0;
return;
}
else
{
goto error;
}
}
}
}
#endif
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
if (wifi_cli_find_id(argc, argv, "-w") > 0 ||
wifi_cli_find_id(argc, argv, "-e") > 0) {
if (argc >= 2)
ssid = argv[2];
if (argc >= 3)
password = argv[3];
} else {
#endif
if (argc >= 2)
ssid = argv[1];
if (argc >= 3)
password = argv[2];
#ifdef CONFIG_CONNECT_THROUGH_PSK_OR_SAE_PASSWORD
if (argc >= 4) {
psk = (u8 *)argv[2];
password = argv[3];
}
#endif
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
}
#endif
#if 0 //TODO support BSSID/Channel configuration
if (argc >= 4)
bssid = argv[3];
if (argc >= 5)
channel = argv[4];
#endif
char *oob_ssid_tp = ssid;
#if CONFIG_USE_CONV_UTF8
oob_ssid_tp = (char *)conv_utf8((uint8_t *)ssid);
#endif
if (oob_ssid_tp) {
#ifdef CONFIG_CONNECT_THROUGH_PSK_OR_SAE_PASSWORD
ret = demo_sta_app_init((char *)oob_ssid_tp, psk, password);
#else
ret = demo_sta_app_init((char *)oob_ssid_tp, password);
#endif
if (ret == -1)
goto error;
#if CONFIG_ENABLE_WIFI_DEFAULT_CONNECT
if (wifi_cli_find_id(argc, argv, "-w") > 0) {
bk_logic_partition_t *pt = bk_flash_partition_get_info(BK_PARTITION_USR_CONFIG);
bk_flash_read_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info_t, sizeof(BK_FAST_CONNECT_T));
if ((info_t.flag & 0xf0l) == 0x70l)
info_t.flag |= 0x1l;
else
info_t.flag = 0x71l;
os_strcpy((char *)info_t.sta_ssid, (char *)oob_ssid_tp);
os_strcpy((char *)info_t.sta_pwd, password);
bk_event_register_cb(EVENT_MOD_WIFI, EVENT_WIFI_STA_CONNECTED,
fast_connect_cb, &info_t);
} else if (wifi_cli_find_id(argc, argv, "-e") > 0) {
bk_logic_partition_t *pt = bk_flash_partition_get_info(BK_PARTITION_USR_CONFIG);
bk_flash_read_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info_t, sizeof(BK_FAST_CONNECT_T));
if (info_t.flag == 0x71l || info_t.flag == 0x73l) {
info_t.flag &= ~0x1l;
bk_flash_set_protect_type(FLASH_PROTECT_NONE);
bk_flash_write_bytes(pt->partition_start_addr + pt->partition_length -4096,
(uint8_t *)&info_t, sizeof(BK_FAST_CONNECT_T));
bk_flash_set_protect_type(FLASH_UNPROTECT_LAST_BLOCK);
}
}
#endif
#if CONFIG_USE_CONV_UTF8
os_free(oob_ssid_tp);
#endif
#if !CONFIG_SOC_BK7236XX && (!CONFIG_SOC_BK7239XX) && (!CONFIG_SOC_BK7286XX)
if (wifi_cmd_sema != NULL)
{
err = rtos_get_semaphore(&wifi_cmd_sema, 10000);
if (err != kNoErr)
{
goto error;
}
else
{
if (wifi_cmd_status == 1)
{
msg = WIFI_EVT_GOT_IP;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
rtos_deinit_semaphore(&wifi_cmd_sema);
wifi_cmd_status = 0;
return;
}
else
{
goto error;
}
}
}
#endif
} else {
CLI_LOGI("not buf for utf8\r\n");
goto error;
}
goto exit;
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
exit:
if (wifi_cmd_sema != NULL)
rtos_deinit_semaphore(&wifi_cmd_sema);
return;
}
#if CONFIG_AP_STATYPE_LIMIT
void cli_wifi_sta_vsie_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
char *ssid = NULL;
char *password = "";
BK_STA_TYPE sta_type = STA_TYPE1;
wifi_sta_config_t sta_config = {"0"};
if (argc >= 2)
ssid = argv[1];
if (argc == 3 || argc == 4) {
if (os_strlen(argv[2]) <= 1) {
sta_type = *argv[2] - '0';
u8 mac[6];
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ] = (struct bk_vise *)os_zalloc(sizeof(struct bk_vise));
/*set EID*/
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[0] = WLAN_EID_VENDOR_SPECIFIC;
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[1] = 10;
/*set OUI*/
//os_memcpy(sta_config.vsies[sta_type].buf, OUI_BEKEN);
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[2] = (OUI_BEKEN >> 16) & 0xff;
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[3] = (OUI_BEKEN >> 8) & 0xff;
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[4] = OUI_BEKEN & 0xff;
/*set payload*/
bk_wifi_sta_get_mac(mac);
os_memcpy(sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf+5, mac, WIFI_MAC_LEN);
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[11] = sta_type;
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->len = 12;
} else {
password = argv[2];
if (argc == 4)
sta_type = *argv[3] - '0';
else sta_type = 0;
u8 mac[6];
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ] = (struct bk_vise *)os_zalloc(sizeof(struct bk_vise));
/*set EID*/
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[0] = WLAN_EID_VENDOR_SPECIFIC;
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[1] = 10;
/*set OUI*/
//os_memcpy(sta_config.vsies[sta_type].buf, OUI_BEKEN);
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[2] = (OUI_BEKEN >> 16) & 0xff;
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[3] = (OUI_BEKEN >> 8) & 0xff;
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[4] = OUI_BEKEN & 0xff;
/*set payload*/
bk_wifi_sta_get_mac(mac);
os_memcpy(sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf+5, mac, WIFI_MAC_LEN);
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->buf[11] = sta_type;
sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]->len = 12;
}
}
strncpy(sta_config.ssid, ssid, WIFI_SSID_STR_LEN);
strncpy(sta_config.password, password, WIFI_PASSWORD_LEN);
BK_LOGI(TAG, "ssid:%s password:%s\n", sta_config.ssid, sta_config.password);
BK_LOG_ON_ERR(bk_wifi_sta_set_config(&sta_config));
BK_LOG_ON_ERR(bk_wifi_sta_start());
if (sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ])
os_free(sta_config.vsies[WIFI_VENDOR_ELEM_ASSOC_REQ]);
}
void cli_wifi_ap_vsie_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
wifi_ap_config_t ap_config = {"0"};
netif_ip4_config_t ip4_config = {0};
char *ap_ssid = NULL;
char *ap_key = "";
int i;
ap_ssid = argv[1];
if (argc >= 3) {
if (os_strlen(argv[2]) <= 1) {
i = 0;
} else {
i = 1;
ap_key = argv[2];
}
switch (argc - i - 2) {
case 4:
ap_config.max_statype_num[3] = *argv[i+5] - '0';
case 3:
ap_config.max_statype_num[2] = *argv[i+4] - '0';
case 2:
ap_config.max_statype_num[1] = *argv[i+3] - '0';
case 1:
ap_config.max_statype_num[0] = *argv[i+2] - '0';
default:
break;
}
}
strncpy(ip4_config.ip, "192.168.0.1", NETIF_IP4_STR_LEN);
strncpy(ip4_config.mask, "255.255.255.0", NETIF_IP4_STR_LEN);
strncpy(ip4_config.gateway, "192.168.0.1", NETIF_IP4_STR_LEN);
strncpy(ip4_config.dns, "0.0.0.0", NETIF_IP4_STR_LEN);
BK_LOG_ON_ERR(bk_netif_set_ip4_config(NETIF_IF_AP, &ip4_config));
strncpy(ap_config.ssid, ap_ssid, WIFI_SSID_STR_LEN);
strncpy(ap_config.password, ap_key, WIFI_PASSWORD_LEN);
BK_LOGI(TAG, "ssid:%s key:%s\r\n", ap_config.ssid, ap_config.password);
BK_LOG_ON_ERR(bk_wifi_ap_set_config(&ap_config));
BK_LOG_ON_ERR(bk_wifi_ap_start());
}
#endif
#if CONFIG_COMPONENTS_WPA2_ENTERPRISE
/**
* cli command: sta_eap <ssid>, connect to EAP-TLS AP.
*
* restrictions: EAP-TLS is based on PKI, both AP and STA may have certificate. So
* we must install certificate and private key to system. For example, `beken-iot-1.pem'
* is STA's certificate, `beken-iot-1.key' is private key, `rootca.pem' is the RootCA.
* These certificates and private key may be registered to system via `register_xfile'
* function.
*/
void cli_wifi_sta_eap_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
char *ssid = NULL;
char *ca = "cacert.pem";
char *client_cert = "beken-iot-1.pem";
char *private_key = "beken-iot-1.key";
char *private_key_passwd = "12345678";
char *identity = "user";
int ret = 0;
int err = 0;
char *msg = NULL;
if ((argc < 2) || (argc > 5)) {
CLI_LOGI("invalid argc number\n");
goto error;
}
ssid = argv[1];
char *oob_ssid_tp = ssid;
#if CONFIG_USE_CONV_UTF8
oob_ssid_tp = (char *)conv_utf8((uint8_t *)ssid);
#endif
if (oob_ssid_tp) {
int len;
wifi_sta_config_t *sta_config;
len = os_strlen((char *)oob_ssid_tp);
if (WLAN_SSID_MAX_LEN < len) {
CLI_LOGI("ssid name more than 32 Bytes\n");
goto error;
}
sta_config = os_zalloc(sizeof(*sta_config));
if (!sta_config) {
CLI_LOGI("Cannot alloc STA config\n");
goto error;
}
os_strlcpy(sta_config->ssid, oob_ssid_tp, sizeof(sta_config->ssid));
sta_config->password[0] = '\0'; // No passwd needed fo EAP.
os_strlcpy(sta_config->eap, "TLS", sizeof(sta_config->eap));
os_strlcpy(sta_config->identity, identity, sizeof(sta_config->identity));
os_strlcpy(sta_config->ca, ca, sizeof(sta_config->ca));
os_strlcpy(sta_config->client_cert, client_cert, sizeof(sta_config->client_cert));
os_strlcpy(sta_config->private_key, private_key, sizeof(sta_config->private_key));
os_strlcpy(sta_config->private_key_passwd, private_key_passwd, sizeof(sta_config->private_key_passwd));
os_strlcpy(sta_config->phase1, "tls_disable_time_checks=1", sizeof(sta_config->phase1));
CLI_LOGI("ssid:%s key:%s\n", sta_config->ssid, sta_config->password);
CLI_LOGI("eap:%s identity:%s\n", sta_config->eap, sta_config->identity);
CLI_LOGI("ca:%s client_cert:%s\n", sta_config->ca, sta_config->client_cert);
CLI_LOGI("private_key:%s\n", sta_config->private_key);
ret = bk_wifi_sta_set_config(sta_config);
err = bk_wifi_sta_start();
os_free(sta_config);
#if CONFIG_USE_CONV_UTF8
os_free(oob_ssid_tp);
#endif
} else {
CLI_LOGI("not buf for utf8\r\n");
goto error;
}
if (!ret && !err) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#endif
void cli_wifi_state_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
int ret = 0;
char *msg = NULL;
ret = demo_state_app_init();
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
}
#if CONFIG_WIFI_SENSOR
static void cli_wifi_sensor_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
int status;
int ret = 0;
char *msg = NULL;
if (argc != 2) {
bk_printf("param error");
goto error;
}
if (os_strcmp(argv[1], "start") == 0)
bk_wifi_detect_movement_start();
if (os_strcmp(argv[1], "stop") == 0)
bk_wifi_detect_movement_stop();
if (os_strcmp(argv[1], "status") == 0) {
status = bk_get_movement_status();
if (status == 0) {
bk_printf("detect something");
}
else {
bk_printf("detect nothing");
}
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#endif
#if CONFIG_COMPONENTS_WFA_CA
extern void wfa_ca_start();
extern void wfa_ca_stop();
void cli_wifi_wfa_ca_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
int ret = 0;
char *msg = NULL;
if (argc != 2) {
os_printf("param error");
goto error;
}
if (os_strcmp(argv[1], "start") == 0)
wfa_ca_start();
else if (os_strcmp(argv[1], "stop") == 0)
wfa_ca_stop();
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#endif
typedef struct {
uint16_t cnt_probe_req;
uint16_t cnt_probe_rsp;
uint16_t cnt_beacon;
uint16_t cnt_action;
uint16_t cnt_auth;
uint16_t cnt_assoc_req;
uint16_t cnt_assoc_rsp;
uint16_t cnt_others;
uint16_t cnt_total;
} wifi_filter_result_t;
static wifi_filter_result_t *s_filter_result = NULL;
static int wifi_filter_cb(const uint8_t *data, uint32_t len, const wifi_frame_info_t *frame_info)
{
if (!data) {
CLI_LOGE("null data\n");
return BK_OK;
}
if (!s_filter_result)
return BK_OK;
uint16_t framectrl = *(uint16_t*)(data);
uint16_t type_subtype = framectrl & MAC_FCTRL_TYPESUBTYPE_MASK;
if (type_subtype == MAC_FCTRL_BEACON)
s_filter_result->cnt_beacon ++;
else if (type_subtype == MAC_FCTRL_PROBEREQ)
s_filter_result->cnt_probe_req++;
else if (type_subtype == MAC_FCTRL_PROBERSP)
s_filter_result->cnt_probe_rsp++;
else if (type_subtype == MAC_FCTRL_ACTION)
s_filter_result->cnt_action++;
else if (type_subtype == MAC_FCTRL_AUTHENT)
s_filter_result->cnt_auth++;
else if (type_subtype == MAC_FCTRL_ASSOCREQ)
s_filter_result->cnt_assoc_req++;
else if (type_subtype == MAC_FCTRL_ASSOCRSP)
s_filter_result->cnt_assoc_rsp++;
else
s_filter_result->cnt_others++;
s_filter_result->cnt_total++;
return BK_OK;
}
static void wifi_filter_result_dump(void)
{
if (!s_filter_result)
return;
bk_printf("filter result:\n");
bk_printf("total: %u\n", s_filter_result->cnt_total);
bk_printf("beacon: %u\n", s_filter_result->cnt_beacon);
bk_printf("probe req: %u\n", s_filter_result->cnt_probe_req);
bk_printf("probe rsp: %u\n", s_filter_result->cnt_probe_rsp);
bk_printf("auth: %u\n", s_filter_result->cnt_auth);
bk_printf("assoc req: %u\n", s_filter_result->cnt_assoc_req);
bk_printf("assoc rsp: %u\n", s_filter_result->cnt_assoc_rsp);
bk_printf("action: %u\n", s_filter_result->cnt_action);
bk_printf("others: %u\n", s_filter_result->cnt_others);
}
static void wifi_mgmt_filter_help(void)
{
bk_printf("filter {filter_bitmap}\n");
bk_printf(" bit0 - default management\n");
bk_printf(" bit1 - probe req\n");
bk_printf(" bit2 - probe rsp\n");
bk_printf(" bit3 - all beacon\n");
bk_printf(" bit4 - action\n");
bk_printf(" 0 - stop filter\n");
bk_printf(" -1 - display result\n");
}
static void cli_wifi_filter_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
wifi_filter_config_t filter_config = {0};
uint32_t filter = 0;
int ret = 0;
int err = 0;
char *msg = NULL;
if (argc != 2) {
wifi_mgmt_filter_help();
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
filter = os_strtoul(argv[1], NULL, 0);
if (filter == 0) {
if (s_filter_result) {
os_free(s_filter_result);
s_filter_result = NULL;
}
ret = bk_wifi_filter_set_config(&filter_config);
err = bk_wifi_filter_register_cb(NULL);
if (!ret && !err) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
goto error;
}
} else if (filter == -1) {
wifi_filter_result_dump();
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
if (!s_filter_result) {
s_filter_result = (wifi_filter_result_t *)os_zalloc(sizeof(wifi_filter_result_t));
if (!s_filter_result) {
goto error;
}
}
if (filter & (1 << 0))
filter_config.rx_all_default_mgmt = 1;
if (filter & (1 << 1))
filter_config.rx_probe_req = 1;
if (filter & (1 << 2))
filter_config.rx_probe_rsp = 1;
if (filter & (1 << 3))
filter_config.rx_all_beacon = 1;
if (filter & (1 << 4))
filter_config.rx_action = 1;
ret = bk_wifi_filter_set_config(&filter_config);
err = bk_wifi_filter_register_cb(wifi_filter_cb);
if (!ret && !err) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#if CONFIG_WIFI_RAW_TX_TEST
typedef struct {
uint32_t interval;
uint32_t counter;
} wifi_raw_tx_param_t;
static void wifi_raw_tx_thread(void *arg)
{
char frame[] = {
0xB0, //version, type, subtype
0x00, //frame control
0x3A, 0x01, //duration
0xC8, 0x47, 0x8C, 0x42, 0x00, 0x48, //Address1 - destination
0x4C, 0xD1, 0xA1, 0xC5, 0x38, 0xE4, //Address2 - source
0x4C, 0xD1, 0xA1, 0xC5, 0x38, 0xE4, //Address3 - bssid
0x20, 0xC0, //sequence
//Auth Response
0x00, 0x00, //Auth algorithm - open system
0x02, 0x00, //Auth seq num
0x00, 0x00, //Status code
};
wifi_raw_tx_param_t *tx_param;
int ret;
tx_param = (wifi_raw_tx_param_t *)arg;
CLI_LOGI("wifi raw tx begin, interval=%u counter=%d\n", tx_param->interval,
tx_param->counter);
for (uint32_t i = 0; i < tx_param->counter; i++) {
ret = bk_wlan_send_80211_raw_frame((unsigned char *)frame, sizeof(frame));
if (ret != kNoErr)
CLI_LOGI("raw tx error, ret=%d\n", ret);
rtos_delay_milliseconds(tx_param->interval);
}
os_free(arg);
CLI_LOGI("wifi raw tx end\n");
rtos_delete_thread(NULL);
}
static void cli_wifi_raw_tx_cmd(char *pcWriteBuffer, int xWriteBufferLen,
int argc, char **argv)
{
bk_err_t ret;
char *msg = NULL;
if (argc != 3) {
CLI_LOGE("param error");
CLI_LOGI("usage: wifi_raw_tx interval counter");
goto error;
}
wifi_raw_tx_param_t *tx_param;
tx_param = (wifi_raw_tx_param_t *)os_malloc(sizeof(wifi_raw_tx_param_t));
if (!tx_param) {
CLI_LOGE("out of memory\n");
goto error;
}
tx_param->interval = os_strtoul(argv[1], NULL, 10);
tx_param->counter = os_strtoul(argv[2], NULL, 10);
ret = rtos_create_thread(NULL, 2, "raw_tx",
(beken_thread_function_t)wifi_raw_tx_thread,
2048, tx_param);
if (kNoErr != ret) {
os_free(tx_param);
CLI_LOGI("Create raw tx thread failed, ret=%d\r\n", ret);
goto error;
}
else {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#endif
static void cli_wifi_monitor_channel_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
wifi_channel_t chan = {0};
int channel, i = 0;
int ret = 0;
char *msg = NULL;
if (argc == 1) {
CLI_LOGI("Usage: channel [1~13].");
goto error;
}
while (argv[1][i]) {
if ((argv[1][i] < '0') || (argv[1][i] > '9')) {
CLI_LOGE("parameter should be a number\r\n");
goto error ;
}
i++;
}
channel = atoi(argv[1]);
if ((channel < 1) || (channel > 13)) {
CLI_LOGE("Invalid channel number \r\n");
goto error;
}
BK_LOG_RAW("monitor mode, set to channel %d\r\n", channel);
chan.primary = channel;
ret = bk_wifi_monitor_set_channel(&chan);
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
int cli_netif_event_cb(void *arg, event_module_t event_module,
int event_id, void *event_data)
{
netif_event_got_ip4_t *got_ip;
switch (event_id) {
case EVENT_NETIF_GOT_IP4:
if (wifi_cmd_sema != NULL) {
wifi_cmd_status = 1;
rtos_set_semaphore(&wifi_cmd_sema);
}
got_ip = (netif_event_got_ip4_t *)event_data;
CLI_LOGW("%s got ip\n", got_ip->netif_if == NETIF_IF_STA ? "BK STA" : "unknown netif");
break;
default:
CLI_LOGW("rx event <%d %d>\n", event_module, event_id);
break;
}
return BK_OK;
}
int cli_wifi_event_cb(void *arg, event_module_t event_module,
int event_id, void *event_data)
{
wifi_event_sta_disconnected_t *sta_disconnected;
wifi_event_sta_connected_t *sta_connected;
wifi_event_ap_disconnected_t *ap_disconnected;
wifi_event_ap_connected_t *ap_connected;
wifi_event_network_found_t *network_found;
switch (event_id) {
case EVENT_WIFI_STA_CONNECTED:
sta_connected = (wifi_event_sta_connected_t *)event_data;
CLI_LOGW("BK STA connected %s\n", sta_connected->ssid);
break;
case EVENT_WIFI_STA_DISCONNECTED:
sta_disconnected = (wifi_event_sta_disconnected_t *)event_data;
CLI_LOGW("BK STA disconnected, reason(%d)%s\n", sta_disconnected->disconnect_reason,
sta_disconnected->local_generated ? ", local_generated" : "");
break;
case EVENT_WIFI_AP_CONNECTED:
ap_connected = (wifi_event_ap_connected_t *)event_data;
CLI_LOGW(BK_MAC_FORMAT" connected to BK AP\n", BK_MAC_STR(ap_connected->mac));
break;
case EVENT_WIFI_AP_DISCONNECTED:
ap_disconnected = (wifi_event_ap_disconnected_t *)event_data;
CLI_LOGW(BK_MAC_FORMAT" disconnected from BK AP\n", BK_MAC_STR(ap_disconnected->mac));
break;
case EVENT_WIFI_NETWORK_FOUND:
network_found = (wifi_event_network_found_t *)event_data;
CLI_LOGI(" target AP: %s, bssid %pm found\n", network_found->ssid, network_found->bssid);
break;
default:
CLI_LOGW("rx event <%d %d>\n", event_module, event_id);
break;
}
return BK_OK;
}
void cli_wifi_net_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
char buf[128];
int i, left = sizeof(buf) - 1, len = 0;
int ret = 0;
char *msg = NULL;
// net sta xxx
// net ap xxx
if (argc <= 2) {
CLI_LOGI("Usage: net sta/ap <param...>\n");
goto error;
}
buf[0] = 0;
for (i = 2; i < argc; i++) {
len = os_strlen(buf);
snprintf(buf + len, left - len, "%s ", argv[i]);
}
buf[strlen(buf) - 1] = 0;
//CLI_LOGI("CMD: |%s|\n", buf);
#if 1
if (os_strcmp(argv[1], "sta") == 0)
ret = cmd_wlan_sta_exec(buf);
else if (os_strcmp(argv[1], "ap") == 0)
ret = cmd_wlan_ap_exec(buf);
#if CONFIG_P2P
else if (os_strcmp(argv[1], "p2p") == 0)
ret = cmd_wlan_p2p_exec(buf);
#endif
else {
CLI_LOGI("Usage: net sta/ap <param...>\n");
goto error;
}
#endif
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_get_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
int ret = 0;
char *msg = NULL;
// get pm status
// get xx status
if (argc <= 2) {
CLI_LOGI("Usage get xx status\n");
goto error;
}
if(os_strcmp(argv[1], "ps") == 0) {
int state = 0;
if(os_strcmp(argv[2], "status") == 0) {
state = cmd_wlan_get_ps_status();
CLI_LOGI("ps status: %s \n", (state?"sleep":"active"));
} else {
CLI_LOGI("Usage get ps status\n");
goto error;
}
}
else if (os_strcmp(argv[1], "mac_trx") == 0) {
bool reset_status = false;
if ((argc == 4) && (os_strcmp(argv[3], "-r") == 0))
{
reset_status = true;
}
if(os_strcmp(argv[2], "status") == 0) {
bk_wifi_get_mac_trx_status(reset_status);
} else {
CLI_LOGI("Usage get MAC TRX status\n");
goto error;
}
}
else if (os_strcmp(argv[1], "wifi") == 0) {
if(os_strcmp(argv[2], "config") == 0) {
CLI_LOGI("wifi config: \n");
bk_wifi_get_wifi_config();
} else {
CLI_LOGI("Usage get ps status\n");
goto error;
}
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#if CONFIG_WIFI_CLI_RAW_LINK_ENABLE
void cli_rlk_cfg_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint32_t rlk_cfg = 0;
int ret = 0;
char *msg = NULL;
if (argc <= 2) {
CLI_LOGI("invalid RLK command\n");
goto error;
}
if(os_strcmp(argv[1], "rate") == 0) {
rlk_cfg = os_strtoul(argv[2], NULL, 10) & 0xFFFF;
bk_rlk_set_tx_rate(rlk_cfg);
}
else if(os_strcmp(argv[1], "power") == 0) {
rlk_cfg = os_strtoul(argv[2], NULL, 10) & 0xFFFF;
bk_rlk_set_tx_power(rlk_cfg);
}
else if(os_strcmp(argv[1], "ac") == 0) {
rlk_cfg = os_strtoul(argv[2], NULL, 10) & 0xFFFF;
bk_rlk_set_tx_ac(rlk_cfg);
}
else if(os_strcmp(argv[1], "timeout") == 0) {
rlk_cfg = os_strtoul(argv[2], NULL, 10) & 0xFFFF;
bk_rlk_set_tx_timeout_ms(rlk_cfg);
}
else {
CLI_LOGI("invalid RLK paramter\n");
goto error;
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#endif
void cli_wifi_rc_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t sta_idx = 0;
uint16_t rate_cfg = 0;
int ret = 0;
char *msg = NULL;
if (argc <= 2) {
CLI_LOGI("invalid RC command\n");
goto error;
}
if(os_strcmp(argv[1], "set_fixrate") == 0) {
sta_idx = os_strtoul(argv[2], NULL, 10) & 0xFFFF;
rate_cfg = os_strtoul(argv[3], NULL, 10) & 0xFFFF;
bk_wifi_rc_config(sta_idx, rate_cfg);
}
else if (os_strcmp(argv[1], "rssi_offset") == 0) {
CLI_LOGI("rc rssi offset: %d\n",os_strtoul(argv[2], NULL, 10));
bk_wifi_set_rc_rssi_offset(os_strtoul(argv[2], NULL, 10));
}
else {
CLI_LOGI("invalid RC paramter\n");
goto error;
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_ps_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint8_t ps_id = 0;
uint8_t ps_val = 0;
uint8_t ps_val1 = 0;
int ret = 0;
char *msg = NULL;
if (os_strcmp(argv[1], "open") == 0) {
ps_id = 0;
} else if (os_strcmp(argv[1], "close") == 0) {
ps_id = 1;
} else if (os_strcmp(argv[1], "debug") == 0) {
ps_id = 2;
ps_val = os_strtoul(argv[2], NULL, 10) & 0xFFFF;
} else if (os_strcmp(argv[1], "set_td") == 0){
if (argc <= 3) {
CLI_LOGI("error need 2 info\n");
goto error;
}
ps_id = 3;
ps_val = os_strtoul(argv[2], NULL, 10) & 0xFFFF;
ps_val1 = os_strtoul(argv[3], NULL, 10) & 0xFFFF;
} else if (os_strcmp(argv[1], "mask_td") == 0){
ps_id = 4;
} else {
CLI_LOGI("invalid ps paramter\n");
goto error;
}
bk_wifi_ps_config(ps_id, ps_val, ps_val1);
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
CLI_LOGI("ps {open|close|debug [1|...|]|}\n");
CLI_LOGI("ps debug 0 [close ps debug]\r\n");
CLI_LOGI("ps debug 1 [show ps fail reason]\r\n");
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_capa_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint32_t capa_id = 0;
uint32_t capa_val = 0;
int ret = 0;
char *msg = NULL;
if (argc <= 2) {
CLI_LOGI("invalid CAPA command\n");
goto error;
}
if (os_strcmp(argv[1], "erp") == 0) {
capa_id = WIFI_CAPA_ID_ERP_EN;
} else if (os_strcmp(argv[1], "ht") == 0) {
capa_id = WIFI_CAPA_ID_HT_EN;
} else if (os_strcmp(argv[1], "vht") == 0) {
capa_id = WIFI_CAPA_ID_VHT_EN;
} else if (os_strcmp(argv[1], "he") == 0) {
capa_id = WIFI_CAPA_ID_HE_EN;
} else if (os_strcmp(argv[1], "tx_ampdu") == 0) {
capa_id = WIFI_CAPA_ID_TX_AMPDU_EN;
} else if (os_strcmp(argv[1], "rx_ampdu") == 0) {
capa_id = WIFI_CAPA_ID_RX_AMPDU_EN;
} else if (os_strcmp(argv[1], "tx_ampdu_num") == 0) {
capa_id = WIFI_CAPA_ID_TX_AMPDU_NUM;
} else if (os_strcmp(argv[1], "rx_ampdu_num") == 0) {
capa_id = WIFI_CAPA_ID_RX_AMPDU_NUM;
} else if (os_strcmp(argv[1], "vht_mcs") == 0) {
capa_id = WIFI_CAPA_ID_VHT_MCS;
} else if (os_strcmp(argv[1], "he_mcs") == 0) {
capa_id = WIFI_CAPA_ID_HE_MCS;
} else if (os_strcmp(argv[1], "b40") == 0) {
capa_id = WIFI_CAPA_ID_B40_EN;
} else if (os_strcmp(argv[1], "stbc") == 0) {
capa_id = WIFI_CAPA_ID_STBC_EN;
} else if (os_strcmp(argv[1], "sgi") == 0) {
capa_id = WIFI_CAPA_ID_SGI_EN;
} else if (os_strcmp(argv[1], "ldpc") == 0) {
capa_id = WIFI_CAPA_ID_LDPC_EN;
} else if (os_strcmp(argv[1], "bfmee") == 0) {
capa_id = WIFI_CAPA_ID_BEAMFORMEE_EN;
} else if (os_strcmp(argv[1], "11b_only") == 0) {
capa_id = WIFI_CAPA_ID_11B_ONLY_EN;
} else {
CLI_LOGI("invalid CAPA paramter\n");
goto error;
}
capa_val = os_strtoul(argv[2], NULL, 10) & 0xFFFF;
bk_wifi_capa_config(capa_id, capa_val);
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_set_pkt_trx_dbg_cfg(uint32_t cfg_bit)
{
bk_wifi_set_pkt_trx_dbg_cfg(cfg_bit);
#if CONFIG_LWIP_DEBUG_LOG
lwip_set_pkt_trx_dbg_cfg(cfg_bit);
#endif
}
void cli_pkt_debug_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
char *msg = NULL;
uint32_t cfg_bit = 0;
int ret = 0;
if (argc != 2) {
CLI_LOGI("invalid debug command %d\n",argc);
goto error;
}
else if (os_strcmp(argv[1], "help") == 0)
{
CLI_LOGI("WIFI_TX_DBG_LOG_DATA_PKT (1<<0)\r\n");
CLI_LOGI("WIFI_TX_DBG_LOG_MGMT_PKT (1<<1)\r\n");
CLI_LOGI("WIFI_TX_DBG_LOG_PUSH_PKT (1<<2)\r\n");
CLI_LOGI("WIFI_RX_DBG_LOG_DATA_PKT (1<<4)\r\n");
CLI_LOGI("WIFI_RX_DBG_LOG_MGMT_PKT (1<<5)\r\n");
CLI_LOGI("LWIP_TX_DBG_LOG_SOCKET (1<<16)\r\n");
CLI_LOGI("LWIP_TX_DBG_LOG_IP (1<<17)\r\n");
CLI_LOGI("LWIP_TX_DBG_LOG_TCP (1<<18)\r\n");
CLI_LOGI("LWIP_RX_DBG_LOG_SOCKET (1<<20)\r\n");
CLI_LOGI("LWIP_RX_DBG_LOG_IP (1<<21)\r\n");
CLI_LOGI("LWIP_RX_DBG_LOG_TCP (1<<22)\r\n");
CLI_LOGI("LWIP_TX_DBG_LOG_PING (1<<24)\r\n");
CLI_LOGI("LWIP_RX_DBG_LOG_PING (1<<25)\r\n");
}
else
{
cfg_bit = os_strtoul(argv[1], NULL, 0);
cli_set_pkt_trx_dbg_cfg(cfg_bit);
CLI_LOGI("open debug log\n");
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
void cli_wifi_diag_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
char *msg = NULL;
uint8_t diag_type = 0;
uint16_t diag_no = 0;
if (argc > 4) {
CLI_LOGI("invalid debug command %d\n",argc);
goto error;
}
else if (os_strcmp(argv[1], "help") == 0)
{
CLI_LOGI("wifi_diag test \r\n");
CLI_LOGI("--test the connection of GPIO with diagnostics\r\n");
CLI_LOGI("wifi_diag set [diag_type] [diag_no] \r\n");
CLI_LOGI("--diag_type - mac/phy \r\n");
CLI_LOGI("--diag_no - HW diagnostics no \r\n");
}
else if (os_strcmp(argv[1], "test") == 0)
{
bk_wifi_test_hw_diag();
}
else if ((os_strcmp(argv[1], "set") == 0) && (os_strcmp(argv[2], "mac") == 0))
{
diag_type = 4;
diag_no = os_strtoul(argv[3], NULL, 0) & 0xFFFF;
bk_wifi_set_hw_diag(diag_type, diag_no);
}
else if ((os_strcmp(argv[1], "set") == 0) && (os_strcmp(argv[2], "phy") == 0))
{
diag_type = 5;
diag_no = os_strtoul(argv[3], NULL, 0) & 0xFFFF;
bk_wifi_set_hw_diag(diag_type, diag_no);
}
else
{
CLI_LOGI("invalid debug command %d\n",argc);
goto error;
}
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
error:
CLI_LOGI("wifi_diag test \r\n");
CLI_LOGI("--test the connection of GPIO with diagnostics\r\n");
CLI_LOGI("wifi_diag set [diag_type] [diag_no] \r\n");
CLI_LOGI("--diag_type - mac/phy \r\n");
CLI_LOGI("--diag_no - HW diagnostics no \r\n");
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#ifdef CONFIG_WPA_TWT_TEST
void cli_wifi_twt_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
uint16_t mantissa = 0;
uint8_t min_twt = 0;
int ret = 0;
char *msg = NULL;
if(os_strcmp(argv[1], "setup") == 0) {
int setup_command = 0;
if(os_strcmp(argv[2], "suggest") == 0) {
setup_command = 1;
}
else if(os_strcmp(argv[2], "demand") == 0) {
setup_command = 2;
}
else {
CLI_LOGI("Usage: twt setup suggest/demand <param...>\n");
goto error;
}
mantissa = os_strtoul(argv[3], NULL, 10) & 0xFF;
min_twt = os_strtoul(argv[4], NULL, 10) & 0xFF;
ret = bk_wifi_twt_setup(setup_command, mantissa, min_twt);
}
else if (os_strcmp(argv[1], "teardown") == 0)
ret = bk_wifi_twt_teardown();
else {
CLI_LOGI("Usage: twt setup/teardown \n");
goto error;
}
if (!ret) {
msg = WIFI_CMD_RSP_SUCCEED;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
else {
goto error;
}
error:
msg = WIFI_CMD_RSP_ERROR;
os_memcpy(pcWriteBuffer, msg, os_strlen(msg));
return;
}
#endif
void blacklist_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
int blacklist_ena = 0;
if (argc != 2)
{
os_printf("blacklist <0|1>\n");
}
else
{
blacklist_ena = strtoul(argv[1], NULL, 0);
if (blacklist_ena) {
wlan_sta_enable_ssid_blacklist();
}
else {
wlan_sta_disable_ssid_blacklist();
}
os_printf("blacklist %s\n", blacklist_ena ? "enabled" : "disabled");
}
}
#if CONFIG_RTP
#include "RTP.h"
static void rtp_send(void *thread_param)
{
u8 ip[4] = {192, 168, 0, 192};
test_rtp_send(ip, 7180, 7180);
rtos_delete_thread(NULL);
}
static void rtp_recv(void *thread_param)
{
u8 ip[4] = {192, 168, 0, 154};
test_rtp_recv(ip, 7180);
rtos_delete_thread(NULL);
}
void cli_wifi_rtp_cmd(char * pcWriteBuffer, int xWriteBufferLen, int argc, char * * argv)
{
if (wifi_cli_find_id(argc, argv, "-s") > 0) {
rtos_create_thread(NULL, 4, "rtp_send",
rtp_send, 10*1024,
(beken_thread_arg_t) 0);
} else if (wifi_cli_find_id(argc, argv, "-r") > 0) {
rtos_create_thread(NULL, 4, "rtp_recv",
rtp_recv, 10*1024,
(beken_thread_arg_t) 0);
}
}
#endif
void cli_wifi_close_coex_csa_cmd(char * pcWriteBuffer, int xWriteBufferLen, int argc, char * * argv)
{
uint8_t close_csa;
int ret = 0;
if (argc != 2) {
CLI_LOGI("invalid close_coex_csa command %d\n");
return;
}
close_csa = (uint8_t)os_strtoul(argv[1], NULL, 10);
if ((close_csa == 1) || (close_csa == 0))
{
ret = bk_wifi_set_csa_coexist_mode_flag(!!close_csa);
if (ret)
CLI_LOGI("bad state\r\n");
}
else
{
CLI_LOGI("bad parameters\r\n",close_csa);
}
}
#if CONFIG_BRIDGE
extern uint8_t bk_wlan_has_role(uint8_t role);
enum mac_vif_type
{
VIF_STA,
VIF_IBSS,
VIF_AP,
VIF_MESH_POINT,
VIF_MONITOR,
VIF_UNKNOWN
};
extern uint8 bridge_is_enabled;
void bk_bridge_start(char *bridge_ssid, char *ext_ssid, char *key) {
uint8_t mac[6] = {0};
bridgeif_initdata_t mybr_initdata = {0};
wifi_linkstate_reason_t info = {0};
netif_ip4_config_t ip4_config = {0};
ip4_addr_t my_ip, my_gw, my_mask;
bridge_is_enabled = 1;
demo_sta_app_init(ext_ssid, key);
while(1) {
bk_wifi_sta_get_linkstate_with_reason(&info);
if (info.state != WIFI_LINKSTATE_STA_GOT_IP) {
BK_LOGI("br","waiting fot sta getting ip\r\n");
rtos_delay_milliseconds(500);
} else
break;
}
/*confige bridgeif and add sta to bridgeif*/
bk_wifi_sta_get_mac(mac);
os_memcpy(((struct netif *)net_get_br_handle())->hwaddr, mac, 6);
os_memcpy(&mybr_initdata.ethaddr, mac, 6);
mybr_initdata.max_fdb_dynamic_entries = 64;
mybr_initdata.max_fdb_static_entries = 4;
mybr_initdata.max_ports = 16;
bk_netif_get_ip4_config(NETIF_IF_STA, &ip4_config);
inet_aton((char *)&ip4_config.ip, &my_ip);
inet_aton((char *)&ip4_config.gateway, &my_gw);
inet_aton((char *)&ip4_config.mask, &my_mask);
netifapi_netif_add((struct netif *)net_get_br_handle(), &my_ip, &my_mask, &my_gw,
&mybr_initdata, bridgeif_init, netif_input);
bridgeif_add_port((struct netif *)net_get_br_handle(), (struct netif *)net_get_sta_handle());
netif_set_hostname((struct netif *)net_get_sta_handle(), "beken");
/*start softap and add to bridgeif*/
demo_softap_app_init(bridge_ssid, NULL, NULL);
bridgeif_add_port((struct netif *)net_get_br_handle(), (struct netif *)net_get_uap_handle());
netifapi_netif_set_default(net_get_br_handle());
netifapi_netif_set_up((struct netif *)net_get_br_handle());
}
void bk_wifi_bridge_stop() {
bridge_ip_stop();
}
void bk_bridge_stop() {
if(bk_wifi_sta_stop())
bk_printf("bridge stop sta fail\r\n");
if(bk_wifi_ap_stop())
bk_printf("bridge stop ap fail\r\n");
bk_wifi_bridge_stop();
}
void cli_wifi_open_bridge_cmd(char * pcWriteBuffer, int xWriteBufferLen, int argc, char * * argv)
{
char *oob_ssid = NULL;
char *bridge_ssid = NULL;
char *connect_key = NULL;
os_printf("bridge_Command\r\n");
if (argc < 2) {
usage:
bk_printf("Usage: \n");
bk_printf(" %s open bridge_ssid extap_ssid key\n", argv[0]);
bk_printf(" %s close\n", argv[0]);
return;
}
if (!strcmp(argv[1], "open")) {
if (argc < 4)
goto usage;
bridge_ssid = argv[2];
oob_ssid = argv[3];
if(argc == 5)
connect_key = argv[4];
else
connect_key = "";
bk_bridge_start(bridge_ssid, oob_ssid, connect_key);
} else if (!strcmp(argv[1], "close")) {
bk_bridge_stop();
} else {
goto usage;
}
}
#endif
#define WIFI_CMD_CNT (sizeof(s_wifi_commands) / sizeof(struct cli_command))
static const struct cli_command s_wifi_commands[] = {
{"scan", "scan [ssid]", cli_wifi_scan_cmd},
{"ap", "ap ssid [password] [channel[1:14]]", cli_wifi_ap_cmd},
{"start_hidden_softap", "start_hidden_softap ssid [password] [channel[1:14]]", cli_wifi_hidden_ap_cmd},
{"sta", "sta ssid [password][bssid][channel]", cli_wifi_sta_cmd}, //TODO support connect speicific BSSID
#if CONFIG_COMPONENTS_WPA2_ENTERPRISE
{"sta_eap", "sta_eap ssid password [identity] [client_cert] [private_key]", cli_wifi_sta_eap_cmd},
#endif
{"stop", "stop {sta|ap}", cli_wifi_stop_cmd},
#if CONFIG_RWNX_PROTO_DEBUG
{"set_pd_flag", "set proto flag for enable or disable proto debug {1|0}", cli_wifi_set_proto_debug_flag},
#endif
{"set_interval", "set listen interval}", cli_wifi_set_interval_cmd},
{"set_arp_rate", "set arp rate}", cli_wifi_set_arp_rate_cmd},
{"bcn_loss_intv", "bcn_loss_intv interval repeat_num}", cli_wifi_bcn_loss_intv_cmd},
{"bcn_loss_time", "bcn_loss_time wait_cnt wake_cnt}", cli_wifi_set_bcn_loss_time_cmd},
{"bcn_recv_win", "bcn_recv_win default_win max_win step}", cli_wifi_set_bcn_recv_win_cmd},
{"bcn_miss_time", "bcn misstime}", cli_wifi_set_bcn_miss_time_cmd},
{"monitor", "monitor {1~13|15|99}", cli_wifi_monitor_cmd},
{"state", "state - show STA/AP state", cli_wifi_state_cmd},
{"channel", "channel {1~13} - set monitor channel", cli_wifi_monitor_channel_cmd},
{"net", "net {sta/ap} ... - wifi net config", cli_wifi_net_cmd},
{"get", "get wifi status", cli_wifi_get_cmd},
{"iplog", "iplog [modle][type]", cli_wifi_iplog_cmd},
{"ipdbg", "ipdbg [function][value]", cli_wifi_ipdbg_cmd},
{"mem_apply", "mem_apply [module][value]", cli_wifi_mem_apply_cmd},
{"ps","ps enable and debug info config", cli_wifi_ps_cmd},
#ifdef CONFIG_WPA_TWT_TEST
{"twt", "twt {setup|teardown}", cli_wifi_twt_cmd},
#endif
#if CONFIG_COMPONENTS_WFA_CA
{"wfa_ca", "wfa_ca <start|stop>", cli_wifi_wfa_ca_cmd},
#endif
#if CONFIG_WIFI_SENSOR
{"wifisensor", "wifi sensor", cli_wifi_sensor_cmd},
#endif
{"filter", "filter <bits> - bit0/d, 1/preq, 2/prsp, 3/b, 4/a", cli_wifi_filter_cmd},
#if CONFIG_WIFI_RAW_TX_TEST
{"wifi_tx", "wifi_tx - Tx WiFi raw frame", cli_wifi_raw_tx_cmd},
#endif
{"rc", "wifi rate control config", cli_wifi_rc_cmd},
{"capa", "wifi capability config", cli_wifi_capa_cmd},
{"blacklist", "Set ssid blacklist", blacklist_Command},
#if CONFIG_RTP
{"rtp", "rtp -s/c ip", cli_wifi_rtp_cmd},
#endif
#if CONFIG_AP_STATYPE_LIMIT
{"sta_vsie", "sta ssid [password][bssid][sta_type]", cli_wifi_sta_vsie_cmd},
{"ap_vsie", "ap ssid [password][bssid][statype_num]", cli_wifi_ap_vsie_cmd},
#endif
{"pkt_dbg", "packet debug config", cli_pkt_debug_cmd},
{"wifi_diag", "Wi-Fi HW diagnostics config", cli_wifi_diag_cmd},
#if CONFIG_WIFI_CLI_RAW_LINK_ENABLE
{"rlk_cfg", "rlk config", cli_rlk_cfg_cmd},
#endif
{"close_coex_csa","close csa in coexist mode {1|0}", cli_wifi_close_coex_csa_cmd},
#if CONFIG_BRIDGE
{"bridge", "bridge open|close", cli_wifi_open_bridge_cmd},
#endif
};
int cli_wifi_init(void)
{
BK_LOG_ON_ERR(bk_event_register_cb(EVENT_MOD_WIFI, EVENT_ID_ALL, cli_wifi_event_cb, NULL));
BK_LOG_ON_ERR(bk_event_register_cb(EVENT_MOD_NETIF, EVENT_ID_ALL, cli_netif_event_cb, NULL));
return cli_register_commands(s_wifi_commands, WIFI_CMD_CNT);
}
#endif //#if (CLI_CFG_WIFI == 1)
Reference in New Issue View Git Blame Copy Permalink