wen/luban-lite
1
0
Fork 0
mirror of https://gitee.com/Vancouver2017/luban-lite.git synced 2025-12-16 00:58:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
luban-lite/bsp/examples/test-wifi/test_wifi.c
刘可亮 3e10f578d3 v1.2.2
2025-10-21 13:59:50 +08:00

783 lines
22 KiB
C
Raw Permalink Blame History

/*
* Copyright (c) 2025, ArtInChip Technology Co., Ltd
*
* SPDX-License-Identifier: Apache-2.0
*
* Authors: zrq <ruiqi.zheng@artinchip.com>
*/
#include <rtthread.h>
#include <rtconfig.h>
#include <getopt.h>
#include <sys/socket.h>
#include <netdev.h>
#include <math.h>
#include "aic_core.h"
typedef enum {
ERR_NONE = 0,
ERR_WIFI_INIT,
ERR_WIFI_SCAN,
ERR_WIFI_SCAN_NUM,
ERR_WIFI_JOIN,
ERR_WIFI_DISC,
ERR_WIFI_START_AP,
ERR_WIFI_STOP_AP,
ERR_UNKNOWN
} WifiErrorCode;
extern rt_err_t ping(char* target_name, rt_uint32_t times, rt_size_t size);
static const char sopts[] = "s::a::p::t::b::c::xdlkh";
static const struct option lopts[] = {
{"sta_test", optional_argument, NULL, 's'},
{"ap_test", optional_argument, NULL, 'a'},
{"ap_tcp", optional_argument, NULL, 'p'},
{"sta_tcp", optional_argument, NULL, 't'},
{"ap_udp", optional_argument, NULL, 'b'},
{"sta_udp", optional_argument, NULL, 'c'},
{"stress", no_argument, NULL, 'x'},
{"delete", no_argument, NULL, 'd'},
{"load", no_argument, NULL, 'l'},
{"del_load", no_argument, NULL, 'k'},
{"usage", no_argument, NULL, 'h'},
{0, 0, 0, 0}
};
static void usage(char *program)
{
rt_kprintf("Usage: %s [options]: \n", program);
rt_kprintf("\t -s, --sta_test\t\tSTA mode basic function test.if not set, use RT_WLAN_DEVICE_STA_NAME.\n");
rt_kprintf("\t -a, --ap_test\t\tAP mode basic function test.if not set, use RT_WLAN_DEVICE_AP_NAME.\n");
rt_kprintf("\t -p, --ap_tcp\t\tDevice set to AP mode,and set to iperf server for tcp.\n");
rt_kprintf("\t -t, --sta_tcp\t\tDevice set to STA mode,and set to iperf server/client for tcp.\n");
rt_kprintf("\t -b, --ap_udp\t\tDevice set to AP mode,and set to iperf server for udp.\n");
rt_kprintf("\t -c, --sta_udp\t\tDevice set to STA mode,and set to iperf server/client for udp.\n");
rt_kprintf("\t -x, --stress\t\tSwitching between AP and STA modes for infinite loop testing.\n");
rt_kprintf("\t -d, --del_stress\t\tDelete the stress test thread.\n");
rt_kprintf("\t -l, --load\t\tCreating load thread increases CPU burden.\n");
rt_kprintf("\t -k, --del_load\t\tDeleet the load thread.\n");
rt_kprintf("\t -h, --usage \n");
rt_kprintf("\n");
rt_kprintf("Example: %s -s / %s -swlan0\n", program, program);
rt_kprintf("Example: %s -a / %s -awlan0\n", program, program);
rt_kprintf("Example: %s -p\n", program);
rt_kprintf("Example: %s -t / %s -tserver\n", program, program);
}
static struct rt_wlan_scan_result scan_result;
static struct rt_wlan_info *scan_filter = RT_NULL;
static rt_int32_t record_scan_num = 0;
static bool g_sta_test_flag = 0;
static bool g_ap_test_flag = 0;
static u32 g_stress_cnt = 0;
static u32 g_wifi_errcode[ERR_UNKNOWN] = {0};
static rt_thread_t wifi_stress_thread = RT_NULL;
static rt_sem_t wifi_stress_exit_sem = RT_NULL;
static volatile rt_bool_t wifi_stress_exit_flag = RT_FALSE;
static rt_thread_t load_thread;
static rt_bool_t aic_wifi_info_isequ(struct rt_wlan_info *info1, struct rt_wlan_info *info2)
{
rt_bool_t is_equ = 1;
rt_uint8_t bssid_zero[RT_WLAN_BSSID_MAX_LENGTH] = { 0 };
if (is_equ && (info1->security != SECURITY_UNKNOWN) && (info2->security != SECURITY_UNKNOWN)) {
is_equ &= info2->security == info1->security;
}
if (is_equ && ((info1->ssid.len > 0) && (info2->ssid.len > 0))) {
is_equ &= info1->ssid.len == info2->ssid.len;
is_equ &= rt_memcmp(&info2->ssid.val[0], &info1->ssid.val[0], info1->ssid.len) == 0;
}
if (is_equ && (rt_memcmp(&info1->bssid[0], bssid_zero, RT_WLAN_BSSID_MAX_LENGTH)) &&
(rt_memcmp(&info2->bssid[0], bssid_zero, RT_WLAN_BSSID_MAX_LENGTH))) {
is_equ &= rt_memcmp(&info1->bssid[0], &info2->bssid[0], RT_WLAN_BSSID_MAX_LENGTH) == 0;
}
if (is_equ && info1->datarate && info2->datarate) {
is_equ &= info1->datarate == info2->datarate;
}
if (is_equ && (info1->channel >= 0) && (info2->channel >= 0)) {
is_equ &= info1->channel == info2->channel;
}
if (is_equ && (info1->rssi < 0) && (info2->rssi < 0)) {
is_equ &= info1->rssi == info2->rssi;
}
return is_equ;
}
static rt_err_t aic_wifi_scan_result_cache(struct rt_wlan_info *info)
{
struct rt_wlan_info *ptable;
rt_err_t err = RT_EOK;
int i, insert = -1;
rt_base_t level;
if ((info == RT_NULL) || (info->ssid.len == 0)) return -RT_EINVAL;
pr_debug("ssid:%s len:%d mac:%02x:%02x:%02x:%02x:%02x:%02x", info->ssid.val, info->ssid.len,
info->bssid[0], info->bssid[1], info->bssid[2], info->bssid[3], info->bssid[4], info->bssid[5]);
/* scanning result filtering */
level = rt_hw_interrupt_disable();
if (scan_filter) {
struct rt_wlan_info _tmp_info = *scan_filter;
rt_hw_interrupt_enable(level);
if (aic_wifi_info_isequ(&_tmp_info, info) != RT_TRUE) {
return RT_EOK;
}
} else {
rt_hw_interrupt_enable(level);
}
/* de-duplicatio */
for (i = 0; i < scan_result.num; i++) {
if ((info->ssid.len == scan_result.info[i].ssid.len) &&
(rt_memcmp(&info->bssid[0], &scan_result.info[i].bssid[0], RT_WLAN_BSSID_MAX_LENGTH) == 0))
return RT_EOK;
#ifdef RT_WLAN_SCAN_SORT
if (insert >= 0)
continue;
/* Signal intensity comparison */
if ((info->rssi < 0) && (scan_result.info[i].rssi < 0)) {
if (info->rssi > scan_result.info[i].rssi) {
insert = i;
continue;
} else if (info->rssi < scan_result.info[i].rssi) {
continue;
}
}
/* Channel comparison */
if (info->channel < scan_result.info[i].channel) {
insert = i;
continue;
} else if (info->channel > scan_result.info[i].channel) {
continue;
}
/* data rate comparison */
if ((info->datarate > scan_result.info[i].datarate)) {
insert = i;
continue;
} else if (info->datarate < scan_result.info[i].datarate) {
continue;
}
#endif
}
/* Insert the end */
if (insert == -1)
insert = scan_result.num;
if (scan_result.num >= RT_WLAN_SCAN_CACHE_NUM)
return RT_EOK;
/* malloc memory */
ptable = rt_malloc(sizeof(struct rt_wlan_info) * (scan_result.num + 1));
if (ptable == RT_NULL) {
pr_err("wlan info malloc failed!");
return -RT_ENOMEM;
}
scan_result.num ++;
/* copy info */
for (i = 0; i < scan_result.num; i++) {
if (i < insert)
ptable[i] = scan_result.info[i];
else if (i > insert)
ptable[i] = scan_result.info[i - 1];
else if (i == insert)
ptable[i] = *info;
}
rt_free(scan_result.info);
scan_result.info = ptable;
return err;
}
static void aic_wifi_scan_result_clean(void)
{
/* If there is data */
if (scan_result.num) {
scan_result.num = 0;
rt_free(scan_result.info);
scan_result.info = RT_NULL;
}
}
static void aic_print_ap_info(struct rt_wlan_info *info,int index)
{
char *security;
if(index == 0) {
rt_kprintf(" SSID MAC security rssi chn Mbps\n");
rt_kprintf("------------------------------- ----------------- -------------- ---- --- ----\n");
}
{
rt_kprintf("%-32.32s", &(info->ssid.val[0]));
rt_kprintf("%02x:%02x:%02x:%02x:%02x:%02x ",
info->bssid[0],
info->bssid[1],
info->bssid[2],
info->bssid[3],
info->bssid[4],
info->bssid[5]
);
switch (info->security) {
case SECURITY_OPEN:
security = "OPEN";
break;
case SECURITY_WEP_PSK:
security = "WEP_PSK";
break;
case SECURITY_WEP_SHARED:
security = "WEP_SHARED";
break;
case SECURITY_WPA_TKIP_PSK:
security = "WPA_TKIP_PSK";
break;
case SECURITY_WPA_AES_PSK:
security = "WPA_AES_PSK";
break;
case SECURITY_WPA2_AES_PSK:
security = "WPA2_AES_PSK";
break;
case SECURITY_WPA2_TKIP_PSK:
security = "WPA2_TKIP_PSK";
break;
case SECURITY_WPA2_MIXED_PSK:
security = "WPA2_MIXED_PSK";
break;
case SECURITY_WPS_OPEN:
security = "WPS_OPEN";
break;
case SECURITY_WPS_SECURE:
security = "WPS_SECURE";
break;
default:
security = "UNKNOWN";
break;
}
rt_kprintf("%-14.14s ", security);
rt_kprintf("%-4d ", info->rssi);
rt_kprintf("%3d ", info->channel);
rt_kprintf("%4d\n", info->datarate / 1000000);
}
}
static void aic_user_ap_info_callback(int event, struct rt_wlan_buff *buff, void *parameter)
{
struct rt_wlan_info *info = RT_NULL;
int index = 0;
int ret = RT_EOK;
RT_ASSERT(event == RT_WLAN_EVT_SCAN_REPORT);
RT_ASSERT(buff != RT_NULL);
RT_ASSERT(parameter != RT_NULL);
info = (struct rt_wlan_info *)buff->data;
index = *((int *)(parameter));
ret = aic_wifi_scan_result_cache(info);
if(ret == RT_EOK) {
if(scan_filter == RT_NULL ||
(scan_filter != RT_NULL &&
scan_filter->ssid.len == info->ssid.len &&
memcmp(&scan_filter->ssid.val[0], &info->ssid.val[0], scan_filter->ssid.len) == 0)) {
/*Print the info*/
aic_print_ap_info(info,index);
index++;
*((int *)(parameter)) = index;
}
}
}
static void aic_scan_done_callback(int event, struct rt_wlan_buff *buff, void *parameter)
{
RT_ASSERT(event == RT_WLAN_EVT_SCAN_DONE);
RT_ASSERT(parameter != RT_NULL);
record_scan_num = scan_result.num;
}
static int aic_wifi_scan(char *ssid)
{
struct rt_wlan_info *info = RT_NULL;
struct rt_wlan_info filter;
int ret = 0;
int i = 0;
if (ssid) {
INVALID_INFO(&filter);
SSID_SET(&filter, ssid);
info = &filter;
}
ret = rt_wlan_register_event_handler(RT_WLAN_EVT_SCAN_REPORT, aic_user_ap_info_callback, &i);
if(ret != RT_EOK) {
pr_err("Scan register user callback error:%d!\n", ret);
return -1;
}
ret = rt_wlan_register_event_handler(RT_WLAN_EVT_SCAN_DONE, aic_scan_done_callback, &i);
if(ret != RT_EOK) {
pr_err("Scan register user callback error:%d!\n", ret);
return -1;
}
if(info)
scan_filter = info;
/*Todo: what can i do for it return val */
ret = rt_wlan_scan_with_info(info);
if(ret != RT_EOK) {
pr_err("Scan with info error:%d!\n", ret);
}
/* clean scan result */
aic_wifi_scan_result_clean();
if(info)
scan_filter = RT_NULL;
return 0;
}
static int aic_wifi_init(char *dev_name, char *set_mode)
{
rt_err_t err = RT_EOK;
rt_wlan_mode_t mode;
char device[16] = {0};
if (strncmp("sta", set_mode, 3) == 0) {
mode = RT_WLAN_STATION;
} else if (strncmp("ap", set_mode, 2) == 0) {
mode = RT_WLAN_AP;
} else if (strncmp("none", set_mode, 4) == 0) {
mode = RT_WLAN_NONE;
} else {
return -1;
}
// if the device name is not set, set the default value.
if (dev_name == NULL) {
if (mode == RT_WLAN_STATION)
snprintf(device, sizeof(device), "%s", RT_WLAN_DEVICE_STA_NAME);
else if (mode == RT_WLAN_AP)
snprintf(device, sizeof(device), "%s", RT_WLAN_DEVICE_AP_NAME);
} else {
snprintf(device, sizeof(device), "%s", dev_name);
}
err = rt_wlan_set_mode((const char*)device, mode);
if (err != RT_EOK) {
pr_err("wifi init err! errcode:%d\n", err);
return -1;
}
return 0;
}
extern int netdev_cmd_ping(char* target_name, char *netdev_name, rt_uint32_t times, rt_size_t size);
static int aic_wifi_connect(char *ssid, char *password)
{
int try_cnt = 0;
rt_err_t err = RT_EOK;
struct netdev *dev = netdev_get_by_name("w0");
if (dev == NULL) {
pr_err("get the netdev failed!\n");
return -RT_EINVAL;
}
err = rt_wlan_connect(ssid, password);
if (err < 0) {
pr_err("WiFi connect failed!\n");
return err;
}
while (dev->ip_addr.addr == 0) {
rt_thread_mdelay(500);
try_cnt++;
if (try_cnt >= 10) {
pr_err("WiFi dhcpc timeout, get ip err!\n");
return -RT_EINVAL;
}
}
rt_kprintf("IP ADDR:%s GW ADDR: %s\n", inet_ntoa(dev->ip_addr.addr), inet_ntoa(dev->gw));
err = netdev_cmd_ping(inet_ntoa(dev->gw), RT_NULL, 4, 0);
if (err < 0) {
pr_err("WiFi ping gate way failed!\n");
return err;
}
return 0;
}
static int aic_wifi_sta_basic_test(char *dev_name)
{
int ret = 0;
g_sta_test_flag = 0;
//1.init the wifi to sta mode
ret = aic_wifi_init(dev_name , "sta");
if (ret < 0) {
pr_err("WiFi initialization failed!\n");
g_wifi_errcode[ERR_WIFI_INIT]++;
return ERR_WIFI_INIT;
}
//2.wifi scan
record_scan_num = 0;
ret = aic_wifi_scan(NULL);
if (ret < 0) {
pr_err("WiFi scan start failed!\n");
g_wifi_errcode[ERR_WIFI_SCAN]++;
return ERR_WIFI_SCAN;
}
rt_kprintf("%s:get the scan result nums:%d\n", __func__, record_scan_num);
if (record_scan_num <= 0) {
pr_err("WiFi scan result empty, please check the RF\n");
g_wifi_errcode[ERR_WIFI_SCAN_NUM]++;
return ERR_WIFI_SCAN_NUM;
}
//3.open network test
ret = aic_wifi_connect(OPEN_NETWORK_SSID, NULL);
if (ret < 0) {
pr_err("WiFi connect failed!\n");
g_wifi_errcode[ERR_WIFI_JOIN]++;
ret= ERR_WIFI_JOIN;
goto err_join;
}
//4.WPA2_AES_PSK network test
ret = aic_wifi_connect(WPA2_AES_PSK_NETWORK_SSID, WPA2_AES_PSK_NETWORK_PASSWORD);
if (ret < 0) {
pr_err("WiFi connect failed!\n");
g_wifi_errcode[ERR_WIFI_JOIN]++;
ret= ERR_WIFI_JOIN;
goto err_join;
}
g_sta_test_flag = 1;
err_join:
//5.disconnect
ret = rt_wlan_disconnect();
if (ret < 0) {
pr_err("WiFi disconnet failed!\n");
g_wifi_errcode[ERR_WIFI_DISC]++;
return ERR_WIFI_DISC;
}
return ret;
}
static int aic_wifi_ap_basic_test(char *dev_name)
{
int ret = 0;
g_ap_test_flag = 0;
//1.init the wifi to ap mode
ret = aic_wifi_init(dev_name , "ap");
if (ret < 0) {
pr_err("WiFi initialization failed!\n");
g_wifi_errcode[ERR_WIFI_INIT]++;
return ERR_WIFI_INIT;
}
//2.gen the ap for test
ret = rt_wlan_start_ap(AP_TEST_SSID, AP_TEST_PASSWORD);
if (ret < 0) {
pr_err("WiFi start ap failed!\n");
g_wifi_errcode[ERR_WIFI_START_AP]++;
return ERR_WIFI_START_AP;
}
rt_thread_mdelay(200);
//3.stop the ap
ret = rt_wlan_ap_stop();
if (ret < 0) {
pr_err("WiFi stop ap failed!\n");
g_wifi_errcode[ERR_WIFI_STOP_AP]++;
return ERR_WIFI_STOP_AP;
}
g_ap_test_flag = 1;
return ret;
}
static void aic_wifi_report_err(void)
{
rt_kprintf("\n=== WiFi Test Status ===\n");
rt_kprintf("Error Counts:\n");
rt_kprintf(" Init Failures: %d\n", g_wifi_errcode[ERR_WIFI_INIT]);
rt_kprintf(" Scan Failures: %d\n", g_wifi_errcode[ERR_WIFI_SCAN]);
rt_kprintf(" Scan NULL Failures: %d\n", g_wifi_errcode[ERR_WIFI_SCAN_NUM]);
rt_kprintf(" Join Failures: %d\n", g_wifi_errcode[ERR_WIFI_JOIN]);
rt_kprintf(" Disc Failures: %d\n", g_wifi_errcode[ERR_WIFI_DISC]);
rt_kprintf(" StartAP Failures: %d\n", g_wifi_errcode[ERR_WIFI_START_AP]);
rt_kprintf(" StopAP Failures: %d\n", g_wifi_errcode[ERR_WIFI_STOP_AP]);
rt_kprintf("=======================\n");
if (g_sta_test_flag && g_ap_test_flag)
rt_kprintf("wifi stress test success %d times.\n", ++g_stress_cnt);
}
static void aic_wifi_stress_test()
{
// basic test device name use RT_WLAN_DEVICE
while (1) {
aic_wifi_sta_basic_test(NULL);
rt_thread_mdelay(200);
aic_wifi_ap_basic_test(NULL);
rt_thread_mdelay(200);
/* check the heap */
system("free");
#ifdef RT_MEMTRACE_BRIEF_DUMP
system("memheaptrace");
#endif
aic_wifi_report_err();
if (wifi_stress_exit_flag) {
rt_kprintf("wifi stress thread exit.\n");
break;
}
}
rt_sem_release(wifi_stress_exit_sem);
}
static int create_stress_test_thread(void)
{
wifi_stress_exit_sem = rt_sem_create("exit_sem", 0, RT_IPC_FLAG_FIFO);
if (wifi_stress_exit_sem == NULL) {
rt_kprintf("wifi stress thread sem create failed.\n");
return -1;
}
wifi_stress_thread = rt_thread_create("wifi_stress", aic_wifi_stress_test, RT_NULL, 10240, 19, 20);
if (wifi_stress_thread != RT_NULL) {
rt_thread_startup(wifi_stress_thread);
return 0;
}
rt_sem_delete(wifi_stress_exit_sem);
rt_kprintf("%s err return.\n", __FUNCTION__);
return -1;
}
static void delete_stress_test_thread(void)
{
if (!wifi_stress_thread) {
rt_kprintf("wifi stress thread already exited.\n");
return;
}
wifi_stress_exit_flag = RT_TRUE;
if (rt_sem_take(wifi_stress_exit_sem, RT_WAITING_FOREVER) == RT_EOK) {
rt_kprintf("delete the wifi stress thread.\n");
rt_thread_delete(wifi_stress_thread);
wifi_stress_thread = RT_NULL;
rt_sem_delete(wifi_stress_exit_sem);
wifi_stress_exit_flag = RT_FALSE;
}
}
static int aic_wifi_iperf_sta(char *para, u8 mode)
{
int ret = 0;
char iperf_cmd[64] = {0};
//1.stop the primary mode
rt_wlan_ap_stop();
rt_wlan_disconnect();
snprintf(iperf_cmd, sizeof(iperf_cmd), "iperf --stop");
system(iperf_cmd);
memset(iperf_cmd, 0, sizeof(iperf_cmd));
//2.init the wifi to sta mode
ret = aic_wifi_init(NULL , "sta");
if (ret < 0) {
pr_err("WiFi initialization failed!\n");
return ERR_WIFI_INIT;
}
//3.WPA2_AES_PSK network
ret = aic_wifi_connect(AP_TEST_SSID, AP_TEST_PASSWORD);
if (ret < 0) {
pr_err("WiFi connect failed!\n");
return ERR_WIFI_JOIN;
}
struct netdev *dev = netdev_get_by_name("w0");
if (dev == NULL) {
pr_err("get the netdev failed!\n");
return -RT_EINVAL;
}
//0 is tcp, 1 is udp
if (mode == 0) {
if (para && strncmp(para, "server", 6) == 0)
snprintf(iperf_cmd, sizeof(iperf_cmd), "iperf -s");
else
snprintf(iperf_cmd, sizeof(iperf_cmd), "iperf -c %s", inet_ntoa(dev->gw));
} else {
if (para && strncmp(para, "server", 6) == 0)
snprintf(iperf_cmd, sizeof(iperf_cmd), "iperf -u -s");
else
snprintf(iperf_cmd, sizeof(iperf_cmd), "iperf -u -c %s", inet_ntoa(dev->gw));
}
system(iperf_cmd);
return 0;
}
static int aic_wifi_iperf_ap(char *para, u8 mode)
{
int ret = 0;
char iperf_cmd[64] = {0};
//1.stop the primary mode
rt_wlan_ap_stop();
rt_wlan_disconnect();
snprintf(iperf_cmd, sizeof(iperf_cmd), "iperf --stop");
system(iperf_cmd);
memset(iperf_cmd, 0, sizeof(iperf_cmd));
//2.init the wifi to ap mode
ret = aic_wifi_init(NULL , "ap");
if (ret < 0) {
pr_err("WiFi initialization failed!\n");
return ERR_WIFI_INIT;
}
//3.gen the ap for test
ret = rt_wlan_start_ap(AP_TEST_SSID, AP_TEST_PASSWORD);
if (ret < 0) {
pr_err("WiFi start ap failed!\n");
return ERR_WIFI_START_AP;
}
//0 is tcp, 1 is udp
if (mode == 0) {
if (para == NULL)
snprintf(iperf_cmd, sizeof(iperf_cmd), "iperf -s");
} else {
if (para == NULL)
snprintf(iperf_cmd, sizeof(iperf_cmd), "iperf -u -s");
}
system(iperf_cmd);
return 0;
}
static void load_thread_entry(void * parameter)
{
while (1) {
volatile float value = 100.0f;
for (int i = 0; i < 100000; i++) {
value = sqrtf(value);
}
rt_thread_delay(1);
}
}
static int create_load_thread(void)
{
load_thread = rt_thread_create("load_thread", load_thread_entry, RT_NULL, 2048, 19, 10);
if (load_thread != RT_NULL) {
rt_thread_startup(load_thread);
return 0;
}
return -1;
}
static void delete_load_thread(void)
{
if (load_thread) {
rt_thread_delete(load_thread);
load_thread = RT_NULL;
}
}
static int cmd_test_wifi(int argc, char *argv[])
{
rt_err_t ret = RT_EOK;
int option = 0;
if (argc == 1) {
usage(argv[0]);
return 0;
}
optind = 0;
while ((option = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) {
switch (option) {
case 's':
ret = aic_wifi_sta_basic_test(optarg);
if (ret != 0)
ret = -RT_ERROR;
break;
case 'a':
ret = aic_wifi_ap_basic_test(optarg);
if (ret != 0)
ret = -RT_ERROR;
break;
case 'p':
ret = aic_wifi_iperf_ap(optarg, 0);
if (ret != 0)
ret = -RT_ERROR;
break;
case 't':
ret = aic_wifi_iperf_sta(optarg, 0);
if (ret != 0)
ret = -RT_ERROR;
break;
case 'b':
ret = aic_wifi_iperf_ap(optarg, 1);
if (ret != 0)
ret = -RT_ERROR;
break;
case 'c':
ret = aic_wifi_iperf_sta(optarg, 1);
if (ret != 0)
ret = -RT_ERROR;
break;
case 'x':
ret = create_stress_test_thread();
if (ret != 0)
ret = -RT_ERROR;
break;
case 'd':
delete_stress_test_thread();
break;
case 'l':
ret = create_load_thread();
if (ret != 0)
ret = -RT_ERROR;
break;
case 'k':
delete_load_thread();
break;
case 'h':
usage(argv[0]);
break;
default:
pr_err("Invalid argument\n");
ret = -RT_ERROR;
usage(argv[0]);
break;
}
}
return ret;
}
MSH_CMD_EXPORT_ALIAS(cmd_test_wifi, test_wifi, wifi test demo);
Reference in New Issue View Git Blame Copy Permalink