libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

[components][drivers][wlan] 功能可裁剪 

- WLAN 连接信息保存功能可裁剪
- WIFI MSH 命令功能可裁剪
- WLAN 管理功能可裁剪
- WLAN 自动连接功能可裁剪
- WLAN 自动连接时使用最新热点信息
- WLAN 用户事件回调由独立线程调用
- WLAN 独立线程可裁剪
- WLAN 协议管理功能可裁剪
- LWIP 协议层可裁剪
- SCAN 结果支持过滤
- WIFI 阻塞式连接支持多次扫描
- WLAN 新增网卡对象指针
- WLAN 获取信息时更新信号强度
- 其他优化性质改动
This commit is contained in:
tangyuxin 2019-07-15 18:17:53 +08:00
parent 3d022a6816
commit 46498d5d1e
12 changed files with 480 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
components/drivers/Kconfig
View File

@ -254,9 +254,8 @@ config RT_USING_TOUCH
bool "Using Touch device drivers"
default n
menu "Using Hardware Crypto drivers"
config RT_USING_HWCRYPTO
bool "Using Hardware Crypto"
menuconfig RT_USING_HWCRYPTO
bool "Using Hardware Crypto drivers"
default n
if RT_USING_HWCRYPTO
@ -420,69 +419,120 @@ menu "Using Hardware Crypto drivers"
default n
endif
endif
endmenu
menu "Using WiFi"
config RT_USING_WIFI
bool "Using Wi-Fi framework"
default n
menuconfig RT_USING_WIFI
bool "Using Wi-Fi framework"
default n
if RT_USING_WIFI
config RT_WLAN_DEVICE_STA_NAME
string "The WiFi device name for station"
string "The device name for station"
default "wlan0"
config RT_WLAN_DEVICE_AP_NAME
string "The WiFi device name for ap"
string "The device name for ap"
default "wlan1"
config RT_WLAN_DEFAULT_PROT
string "Default transport protocol"
default "lwip"
config RT_WLAN_SCAN_WAIT_MS
int "Set scan timeout time(ms)"
default 10000
config RT_WLAN_CONNECT_WAIT_MS
int "Set connect timeout time(ms)"
default 10000
config RT_WLAN_SSID_MAX_LENGTH
int "SSID name maximum length"
int "SSID maximum length"
default 32
config RT_WLAN_PASSWORD_MAX_LENGTH
int "Maximum password length"
int "Password maximum length"
default 32
config RT_WLAN_SCAN_SORT
bool "Automatic sorting of scan results"
default y
config RT_WLAN_CFG_INFO_MAX
int "Maximum number of WiFi information automatically saved"
default 3
config RT_WLAN_WORKQUEUE_THREAD_NAME
string "WiFi work queue thread name"
default "wlan_job"
config RT_WLAN_WORKQUEUE_THREAD_SIZE
int "wifi work queue thread size"
default 2048
config RT_WLAN_WORKQUEUE_THREAD_PRIO
int "WiFi work queue thread priority"
default 22
config RT_WLAN_DEV_EVENT_NUM
int "Maximum number of driver events"
int "Driver events maxcount"
default 2
config RT_WLAN_PROT_LWIP_PBUF_FORCE
bool "Forced use of PBUF transmission"
default n
config RT_WLAN_MANAGE_ENABLE
bool "Connection management Enable"
default y
if RT_WLAN_MANAGE_ENABLE
config RT_WLAN_SCAN_WAIT_MS
int "Set scan timeout time(ms)"
default 10000
config RT_WLAN_CONNECT_WAIT_MS
int "Set connect timeout time(ms)"
default 10000
config RT_WLAN_SCAN_SORT
bool "Automatic sorting of scan results"
default y
config RT_WLAN_MSH_CMD_ENABLE
bool "MSH command Enable"
default y
config RT_WLAN_AUTO_CONNECT_ENABLE
bool "Auto connect Enable"
select RT_WLAN_CFG_ENABLE
select RT_WLAN_WORK_THREAD_ENABLE
default y
endif
config RT_WLAN_CFG_ENABLE
bool "WiFi information automatically saved Enable"
default y
if RT_WLAN_CFG_ENABLE
config RT_WLAN_CFG_INFO_MAX
int "Maximum number of WiFi information automatically saved"
default 3
endif
config RT_WLAN_PROT_ENABLE
bool "Transport protocol manage Enable"
default y
if RT_WLAN_PROT_ENABLE
config RT_WLAN_PROT_NAME_LEN
int "Transport protocol name length"
default 8
config RT_WLAN_PROT_MAX
int "Transport protocol maxcount"
default 2
config RT_WLAN_DEFAULT_PROT
string "Default transport protocol"
default "lwip"
config RT_WLAN_PROT_LWIP_ENABLE
bool "LWIP transport protocol Enable"
select RT_USING_LWIP
default y
if RT_WLAN_PROT_LWIP_ENABLE
config RT_WLAN_PROT_LWIP_NAME
string "LWIP transport protocol name"
default "lwip"
config RT_WLAN_PROT_LWIP_PBUF_FORCE
bool "Forced use of PBUF transmission"
default n
endif
endif
config RT_WLAN_WORK_THREAD_ENABLE
bool "WLAN work queue thread Enable"
default y
if RT_WLAN_WORK_THREAD_ENABLE
config RT_WLAN_WORKQUEUE_THREAD_NAME
string "WLAN work queue thread name"
default "wlan"
config RT_WLAN_WORKQUEUE_THREAD_SIZE
int "WLAN work queue thread size"
default 2048
config RT_WLAN_WORKQUEUE_THREAD_PRIO
int "WLAN work queue thread priority"
default 15
endif
menuconfig RT_WLAN_DEBUG
bool "Enable WLAN Debugging Options"
@ -514,7 +564,6 @@ menu "Using WiFi"
default n
endif
endif
endmenu
menu "Using USB"
config RT_USING_USB_HOST

24
components/drivers/wlan/SConscript
View File

@ -1,8 +1,30 @@
from building import *
cwd = GetCurrentDir()
src = Glob('*.c')
CPPPATH = [cwd]
src = Split('''
wlan_dev.c
''')
if GetDepend(['RT_WLAN_MANAGE_ENABLE']):
src += ['wlan_mgnt.c']
if GetDepend(['RT_WLAN_MSH_CMD_ENABLE']):
src += ['wlan_cmd.c']
if GetDepend(['RT_WLAN_PROT_ENABLE']):
src += ['wlan_prot.c']
if GetDepend(['RT_WLAN_PROT_LWIP_ENABLE']):
src += ['wlan_lwip.c']
if GetDepend(['RT_WLAN_CFG_ENABLE']):
src += ['wlan_cfg.c']
if GetDepend(['RT_WLAN_WORK_THREAD_ENABLE']):
src += ['wlan_workqueue.c']
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_WIFI'], CPPPATH = CPPPATH)
Return('group')

4
components/drivers/wlan/wlan_cfg.c
View File

@ -19,6 +19,8 @@
#endif /* RT_WLAN_CFG_DEBUG */
#include <rtdbg.h>
#ifdef RT_WLAN_CFG_ENABLE
#define WLAN_CFG_LOCK() (rt_mutex_take(&cfg_mutex, RT_WAITING_FOREVER))
#define WLAN_CFG_UNLOCK() (rt_mutex_release(&cfg_mutex))
@ -462,3 +464,5 @@ void rt_wlan_cfg_dump(void)
rt_kprintf("%3d \n", info->channel);
}
}
#endif

33
components/drivers/wlan/wlan_cmd.c
View File

@ -13,6 +13,8 @@
#include <wlan_cfg.h>
#include <wlan_prot.h>
#if defined(RT_WLAN_MANAGE_ENABLE) && defined(RT_WLAN_MSH_CMD_ENABLE)
struct wifi_cmd_des
{
const char *cmd;
@ -75,7 +77,7 @@ static int wifi_help(int argc, char *argv[])
{
rt_kprintf("wifi\n");
rt_kprintf("wifi help\n");
rt_kprintf("wifi scan\n");
rt_kprintf("wifi scan [SSID]\n");
rt_kprintf("wifi join [SSID] [PASSWORD]\n");
rt_kprintf("wifi ap SSID [PASSWORD]\n");
rt_kprintf("wifi disc\n");
@ -143,12 +145,23 @@ static int wifi_status(int argc, char *argv[])
static int wifi_scan(int argc, char *argv[])
{
struct rt_wlan_scan_result *scan_result = RT_NULL;
struct rt_wlan_info *info = RT_NULL;
struct rt_wlan_info filter;
if (argc > 2)
if (argc > 3)
return -1;
if (argc == 3)
{
INVALID_INFO(&filter);
SSID_SET(&filter, argv[2]);
info = &filter;
}
/* clean scan result */
rt_wlan_scan_result_clean();
/* scan ap info */
scan_result = rt_wlan_scan_sync();
scan_result = rt_wlan_scan_with_info(info);
if (scan_result)
{
int index, num;
@ -224,8 +237,10 @@ static int wifi_join(int argc, char *argv[])
const char *key = RT_NULL;
struct rt_wlan_cfg_info cfg_info;
rt_memset(&cfg_info, 0, sizeof(cfg_info));
if (argc == 2)
{
#ifdef RT_WLAN_CFG_ENABLE
/* get info to connect */
if (rt_wlan_cfg_read_index(&cfg_info, 0) == 1)
{
@ -234,8 +249,9 @@ static int wifi_join(int argc, char *argv[])
key = (char *)(&cfg_info.key.val[0]);
}
else
#endif
{
rt_kprintf("not find info\n");
rt_kprintf("not find connect info\n");
}
}
else if (argc == 3)
@ -387,8 +403,9 @@ static int wifi_debug_save_cfg(int argc, char *argv[])
rt_memcpy(&cfg_info.key.val[0], password, len);
cfg_info.key.len = len;
}
#ifdef RT_WLAN_CFG_ENABLE
rt_wlan_cfg_save(&cfg_info);
#endif
return 0;
}
@ -396,7 +413,9 @@ static int wifi_debug_dump_cfg(int argc, char *argv[])
{
if (argc == 1)
{
#ifdef RT_WLAN_CFG_ENABLE
rt_wlan_cfg_dump();
#endif
}
else
{
@ -409,8 +428,10 @@ static int wifi_debug_clear_cfg(int argc, char *argv[])
{
if (argc == 1)
{
#ifdef RT_WLAN_CFG_ENABLE
rt_wlan_cfg_delete_all();
rt_wlan_cfg_cache_save();
#endif
}
else
{
@ -564,3 +585,5 @@ static int wifi_msh(int argc, char *argv[])
#if defined(RT_USING_FINSH) && defined(FINSH_USING_MSH)
FINSH_FUNCTION_EXPORT_ALIAS(wifi_msh, __cmd_wifi, wifi command.);
#endif
#endif

24
components/drivers/wlan/wlan_dev.c
View File

@ -21,6 +21,8 @@
#endif /* RT_WLAN_DEV_DEBUG */
#include <rtdbg.h>
#if defined(RT_USING_WIFI) || defined(RT_USING_WLAN)
#ifndef RT_DEVICE
#define RT_DEVICE(__device) ((rt_device_t)__device)
#endif
@ -56,6 +58,17 @@ rt_err_t rt_wlan_dev_init(struct rt_wlan_device *device, rt_wlan_mode_t mode)
return -RT_ERROR;
}
if (mode == RT_WLAN_AP && device->flags & RT_WLAN_FLAG_STA_ONLY)
{
LOG_E("F:%s L:%d This wlan device can only be set to sta mode!", __FUNCTION__, __LINE__);
return -RT_ERROR;
}
else if (mode == RT_WLAN_STATION && device->flags & RT_WLAN_FLAG_AP_ONLY)
{
LOG_E("F:%s L:%d This wlan device can only be set to ap mode!", __FUNCTION__, __LINE__);
return -RT_ERROR;
}
result = rt_device_init(RT_DEVICE(device));
if (result != RT_EOK)
{
@ -545,7 +558,11 @@ rt_err_t rt_wlan_dev_scan_stop(struct rt_wlan_device *device)
rt_err_t rt_wlan_dev_report_data(struct rt_wlan_device *device, void *buff, int len)
{
#ifdef RT_WLAN_PROT_ENABLE
return rt_wlan_dev_transfer_prot(device, buff, len);
#else
return -RT_ERROR;
#endif
}
static rt_err_t _rt_wlan_dev_init(rt_device_t dev)
@ -768,14 +785,15 @@ rt_err_t rt_wlan_dev_register(struct rt_wlan_device *wlan, const char *name, con
{
rt_err_t err = RT_EOK;
if ((wlan == RT_NULL) || (name == RT_NULL) || (ops == RT_NULL))
if ((wlan == RT_NULL) || (name == RT_NULL) || (ops == RT_NULL) ||
(flag & RT_WLAN_FLAG_STA_ONLY && flag & RT_WLAN_FLAG_AP_ONLY))
{
LOG_E("F:%s L:%d parameter Wrongful", __FUNCTION__, __LINE__);
return RT_NULL;
}
rt_memset(wlan, 0, sizeof(struct rt_wlan_device));
#ifdef RT_USING_DEVICE_OPS
wlan->device.ops = &wlan_ops;
#else
@ -801,3 +819,5 @@ rt_err_t rt_wlan_dev_register(struct rt_wlan_device *wlan, const char *name, con
return err;
}
#endif

6
components/drivers/wlan/wlan_dev.h
View File

@ -381,6 +381,11 @@ typedef struct rt_wlan_key rt_wlan_key_t;
(_info)->channel = -1; \
} while(0)
#define SSID_SET(_info, _ssid) do { \
rt_strncpy((char *)(_info)->ssid.val, (_ssid), RT_WLAN_SSID_MAX_LENGTH); \
(_info)->ssid.len = rt_strlen((char *)(_info)->ssid.val); \
} while(0)
struct rt_wlan_info
{
/* security type */
@ -442,6 +447,7 @@ struct rt_wlan_device
rt_wlan_pormisc_callback_t pormisc_callback;
const struct rt_wlan_dev_ops *ops;
rt_uint32_t flags;
struct netdev *netdev;
void *prot;
void *user_data;
};

31
components/drivers/wlan/wlan_lwip.c
View File

@ -14,12 +14,17 @@
#include <wlan_prot.h>
#include <wlan_workqueue.h>
#if defined(RT_WLAN_PROT_ENABLE) && defined(RT_WLAN_PROT_LWIP_ENABLE)
#ifdef RT_USING_LWIP
#include <netif/ethernetif.h>
#include <lwip/netifapi.h>
#ifdef LWIP_USING_DHCPD
#include <dhcp_server.h>
#endif
#ifdef RT_USING_NETDEV
#include <netdev.h>
#endif
#define DBG_TAG "WLAN.lwip"
#ifdef RT_WLAN_LWIP_DEBUG
@ -33,6 +38,10 @@
#define IPADDR_STRLEN_MAX (32)
#endif
#ifndef RT_WLAN_PROT_LWIP_NAME
#define RT_WLAN_PROT_LWIP_NAME ("lwip")
#endif
struct lwip_prot_des
{
struct rt_wlan_prot prot;
@ -100,12 +109,16 @@ static void netif_is_ready(struct rt_work *work, void *parameter)
LOG_I("Got IP address : %s", str);
exit:
level = rt_hw_interrupt_disable();
rt_memset(work, 0, sizeof(struct rt_work));
if (work)
{
rt_memset(work, 0, sizeof(struct rt_work));
}
rt_hw_interrupt_enable(level);
}
static void timer_callback(void *parameter)
{
#ifdef RT_WLAN_WORK_THREAD_ENABLE
struct rt_workqueue *workqueue;
struct rt_wlan_device *wlan = parameter;
struct lwip_prot_des *lwip_prot = (struct lwip_prot_des *)wlan->prot;
@ -125,6 +138,10 @@ static void timer_callback(void *parameter)
rt_hw_interrupt_enable(level);
}
}
#else
netif_is_ready(RT_NULL, parameter);
#endif
}
static void netif_set_connected(void *parameter)
@ -238,8 +255,11 @@ static void rt_wlan_lwip_event_handle(struct rt_wlan_prot *port, struct rt_wlan_
}
if (flag_old != lwip_prot->connected_flag)
{
#ifdef RT_WLAN_WORK_THREAD_ENABLE
rt_wlan_workqueue_dowork(netif_set_connected, wlan);
// netif_set_connected(wlan);
#else
netif_set_connected(wlan);
#endif
}
}
@ -460,7 +480,9 @@ static struct rt_wlan_prot *rt_wlan_lwip_protocol_register(struct rt_wlan_prot *
}
netif_set_up(eth->netif);
LOG_I("eth device init ok name:%s", eth_name);
#ifdef RT_USING_NETDEV
wlan->netdev = netdev_get_by_name(eth_name);
#endif
return &lwip_prot->prot;
}
@ -483,7 +505,7 @@ int rt_wlan_lwip_init(void)
rt_wlan_prot_event_t event;
rt_memset(&prot, 0, sizeof(prot));
rt_strncpy(&prot.name[0], RT_WLAN_PROT_LWIP, RT_WLAN_PROT_NAME_LEN);
rt_strncpy(&prot.name[0], RT_WLAN_PROT_LWIP_NAME, RT_WLAN_PROT_NAME_LEN);
prot.ops = &ops;
if (rt_wlan_prot_regisetr(&prot) != RT_EOK)
@ -502,3 +524,4 @@ int rt_wlan_lwip_init(void)
INIT_PREV_EXPORT(rt_wlan_lwip_init);
#endif
#endif

362
components/drivers/wlan/wlan_mgnt.c
View File

@ -24,6 +24,8 @@
#endif /* RT_WLAN_MGNT_DEBUG */
#include <rtdbg.h>
#ifdef RT_WLAN_MANAGE_ENABLE
#ifndef RT_WLAN_DEVICE
#define RT_WLAN_DEVICE(__device) ((struct rt_wlan_device *)__device)
#endif
@ -48,13 +50,20 @@
#define COMPLETE_LOCK() (rt_mutex_take(&complete_mutex, RT_WAITING_FOREVER))
#define COMPLETE_UNLOCK() (rt_mutex_release(&complete_mutex))
#ifdef RT_WLAN_AUTO_CONNECT_ENABLE
#define TIME_STOP() (rt_timer_stop(&reconnect_time))
#define TIME_START() (rt_timer_start(&reconnect_time))
#else
#define TIME_STOP()
#define TIME_START()
#endif
#define DISCONNECT_RESPONSE_TICK (2000)
#ifndef DISCONNECT_RESPONSE_MS
#define DISCONNECT_RESPONSE_MS (2000)
#endif
#if RT_WLAN_EBOX_NUM < 1
#error "event box num Too little"
#error "event box num Too few"
#endif
struct rt_wlan_mgnt_des
@ -113,8 +122,11 @@ static struct rt_wlan_event_desc event_tab[RT_WLAN_EVT_MAX];
static struct rt_wlan_complete_des *complete_tab[5];
static struct rt_mutex complete_mutex;
static struct rt_wlan_info *scan_filter;
#ifdef RT_WLAN_AUTO_CONNECT_ENABLE
static struct rt_timer reconnect_time;
#endif
rt_inline int _sta_is_null(void)
{
@ -145,9 +157,97 @@ rt_inline rt_bool_t _is_do_connect(void)
return RT_TRUE;
}
static void rt_wlan_mgnt_work(void *parameter);
#ifdef RT_WLAN_WORK_THREAD_ENABLE
static rt_err_t rt_wlan_send_msg(rt_wlan_dev_event_t event, void *buff, int len)
static rt_bool_t rt_wlan_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 void rt_wlan_mgnt_work(void *parameter)
{
struct rt_wlan_msg *msg = parameter;
void *user_parameter;
rt_wlan_event_handler handler = RT_NULL;
struct rt_wlan_buff user_buff = { 0 };
rt_base_t level;
/* Get user callback */
if (msg->event < RT_WLAN_EVT_MAX)
{
level = rt_hw_interrupt_disable();
handler = event_tab[msg->event].handler;
user_parameter = event_tab[msg->event].parameter;
rt_hw_interrupt_enable(level);
}
/* run user callback fun */
if (handler)
{
user_buff.data = msg->buff;
user_buff.len = msg->len;
RT_WLAN_LOG_D("wlan work thread run user callback, event:%d", msg->event);
handler(msg->event, &user_buff, user_parameter);
}
switch (msg->event)
{
case RT_WLAN_EVT_STA_CONNECTED:
{
struct rt_wlan_cfg_info cfg_info;
rt_memset(&cfg_info, 0, sizeof(cfg_info));
/* save config */
if (rt_wlan_is_connected() == RT_TRUE)
{
rt_enter_critical();
cfg_info.info = _sta_mgnt.info;
cfg_info.key = _sta_mgnt.key;
rt_exit_critical();
RT_WLAN_LOG_D("run save config! ssid:%s len%d", _sta_mgnt.info.ssid.val, _sta_mgnt.info.ssid.len);
#ifdef RT_WLAN_CFG_ENABLE
rt_wlan_cfg_save(&cfg_info);
#endif
}
break;
}
default :
break;
}
rt_free(msg);
}
static rt_err_t rt_wlan_send_to_thread(rt_wlan_event_t event, void *buff, int len)
{
struct rt_wlan_msg *msg;
@ -177,14 +277,16 @@ static rt_err_t rt_wlan_send_msg(rt_wlan_dev_event_t event, void *buff, int len)
}
return RT_EOK;
}
#endif
static rt_err_t rt_wlan_scan_result_cache(struct rt_wlan_info *info, int timeout)
{
struct rt_wlan_info *ptable;
rt_err_t err = RT_EOK;
int i, insert = -1;
rt_base_t level;
if (_sta_is_null() || (info == RT_NULL)) return RT_EOK;
if (_sta_is_null() || (info == RT_NULL) || (info->ssid.len == 0)) return RT_EOK;
RT_WLAN_LOG_D("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]);
@ -193,6 +295,23 @@ static rt_err_t rt_wlan_scan_result_cache(struct rt_wlan_info *info, int timeout
if (err != RT_EOK)
return err;
/* 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 (rt_wlan_info_isequ(&_tmp_info, info) != RT_TRUE)
{
rt_mutex_release(&scan_result_mutex);
return RT_EOK;
}
}
else
{
rt_hw_interrupt_enable(level);
}
/* de-duplicatio */
for (i = 0; i < scan_result.num; i++)
{
@ -381,7 +500,7 @@ static rt_err_t rt_wlan_sta_info_del_all(int timeout)
sta_info.node = RT_NULL;
return err;
}
#ifdef RT_WLAN_AUTO_CONNECT_ENABLE
static void rt_wlan_auto_connect_run(struct rt_work *work, void *parameter)
{
static rt_uint32_t id = 0;
@ -418,7 +537,7 @@ static void rt_wlan_auto_connect_run(struct rt_work *work, void *parameter)
cfg_info.key.val[cfg_info.key.len] = '\0';
password = (char *)(&cfg_info.key.val[0]);
}
rt_wlan_connect_adv(&cfg_info.info, password);
rt_wlan_connect((char *)cfg_info.info.ssid.val, password);
exit:
rt_mutex_release(&mgnt_mutex);
level = rt_hw_interrupt_disable();
@ -449,41 +568,10 @@ static void rt_wlan_cyclic_check(void *parameter)
}
}
}
static void rt_wlan_mgnt_work(void *parameter)
{
struct rt_wlan_msg *msg = parameter;
switch (msg->event)
{
case RT_WLAN_DEV_EVT_CONNECT:
{
struct rt_wlan_cfg_info cfg_info;
/* save config */
if (rt_wlan_is_connected() == RT_TRUE)
{
rt_enter_critical();
cfg_info.info = _sta_mgnt.info;
cfg_info.key = _sta_mgnt.key;
rt_exit_critical();
RT_WLAN_LOG_D("run save config! ssid:%s len%d", _sta_mgnt.info.ssid.val, _sta_mgnt.info.ssid.len);
rt_wlan_cfg_save(&cfg_info);
}
break;
}
default :
break;
}
rt_free(msg);
}
#endif
static void rt_wlan_event_dispatch(struct rt_wlan_device *device, rt_wlan_dev_event_t event, struct rt_wlan_buff *buff, void *parameter)
{
rt_base_t level;
void *user_parameter;
rt_wlan_event_handler handler = RT_NULL;
rt_err_t err = RT_NULL;
rt_wlan_event_t user_event = RT_WLAN_EVT_MAX;
int i;
@ -503,7 +591,6 @@ static void rt_wlan_event_dispatch(struct rt_wlan_device *device, rt_wlan_dev_ev
_sta_mgnt.state &= ~RT_WLAN_STATE_CONNECTING;
user_event = RT_WLAN_EVT_STA_CONNECTED;
TIME_STOP();
rt_wlan_send_msg(event, RT_NULL, 0);
user_buff.data = &_sta_mgnt.info;
user_buff.len = sizeof(struct rt_wlan_info);
RT_WLAN_LOG_I("wifi connect success ssid:%s", &_sta_mgnt.info.ssid.val[0]);
@ -518,7 +605,10 @@ static void rt_wlan_event_dispatch(struct rt_wlan_device *device, rt_wlan_dev_ev
user_event = RT_WLAN_EVT_STA_CONNECTED_FAIL;
user_buff.data = &_sta_mgnt.info;
user_buff.len = sizeof(struct rt_wlan_info);
TIME_START();
if (rt_wlan_get_autoreconnect_mode())
{
TIME_START();
}
break;
}
case RT_WLAN_DEV_EVT_DISCONNECT:
@ -529,7 +619,10 @@ static void rt_wlan_event_dispatch(struct rt_wlan_device *device, rt_wlan_dev_ev
user_event = RT_WLAN_EVT_STA_DISCONNECTED;
user_buff.data = &_sta_mgnt.info;
user_buff.len = sizeof(struct rt_wlan_info);
TIME_START();
if (rt_wlan_get_autoreconnect_mode())
{
TIME_START();
}
break;
}
case RT_WLAN_DEV_EVT_AP_START:
@ -622,20 +715,30 @@ static void rt_wlan_event_dispatch(struct rt_wlan_device *device, rt_wlan_dev_ev
}
}
COMPLETE_UNLOCK();
/* Get user callback */
if (user_event < RT_WLAN_EVT_MAX)
#ifdef RT_WLAN_WORK_THREAD_ENABLE
rt_wlan_send_to_thread(user_event, RT_NULL, 0);
#else
{
level = rt_hw_interrupt_disable();
handler = event_tab[user_event].handler;
user_parameter = event_tab[user_event].parameter;
rt_hw_interrupt_enable(level);
}
void *user_parameter;
rt_wlan_event_handler handler = RT_NULL;
rt_base_t level;
/* Get user callback */
if (user_event < RT_WLAN_EVT_MAX)
{
level = rt_hw_interrupt_disable();
handler = event_tab[user_event].handler;
user_parameter = event_tab[user_event].parameter;
rt_hw_interrupt_enable(level);
}
/* run user callback fun */
if (handler)
{
handler(user_event, &user_buff, user_parameter);
/* run user callback fun */
if (handler)
{
RT_WLAN_LOG_D("unknown thread run user callback, event:%d", user_event);
handler(user_event, &user_buff, user_parameter);
}
}
#endif
}
static struct rt_wlan_complete_des *rt_wlan_complete_create(const char *name)
@ -820,14 +923,30 @@ rt_err_t rt_wlan_set_mode(const char *dev_name, rt_wlan_mode_t mode)
/* update dev event handle */
if (up_event_flag == 1)
{
rt_wlan_dev_event_t event;
for (event = RT_WLAN_DEV_EVT_INIT_DONE; event < RT_WLAN_DEV_EVT_MAX; event++)
if (handler)
{
if (handler)
if (mode == RT_WLAN_STATION)
{
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), event, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_CONNECT, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_CONNECT_FAIL, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_DISCONNECT, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_SCAN_REPORT, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_SCAN_DONE, handler, RT_NULL);
}
else
else if (mode == RT_WLAN_AP)
{
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_AP_START, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_AP_STOP, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_AP_ASSOCIATED, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_AP_DISASSOCIATED, handler, RT_NULL);
rt_wlan_dev_register_event_handler(RT_WLAN_DEVICE(device), RT_WLAN_DEV_EVT_AP_ASSOCIATE_FAILED, handler, RT_NULL);
}
}
else
{
rt_wlan_dev_event_t event;
handler = rt_wlan_event_dispatch;
for (event = RT_WLAN_DEV_EVT_INIT_DONE; event < RT_WLAN_DEV_EVT_MAX; event++)
{
rt_wlan_dev_unregister_event_handler(RT_WLAN_DEVICE(device), event, handler);
}
@ -836,8 +955,11 @@ rt_err_t rt_wlan_set_mode(const char *dev_name, rt_wlan_mode_t mode)
MGNT_UNLOCK();
/* Mount protocol */
#ifdef RT_WLAN_DEFAULT_PROT
rt_wlan_prot_attach(dev_name, RT_WLAN_DEFAULT_PROT);
#if defined(RT_WLAN_PROT_ENABLE) && defined(RT_WLAN_DEFAULT_PROT)
if (err == RT_EOK)
{
rt_wlan_prot_attach(dev_name, RT_WLAN_DEFAULT_PROT);
}
#endif
return err;
}
@ -932,6 +1054,7 @@ rt_err_t rt_wlan_connect(const char *ssid, const char *password)
struct rt_wlan_info info;
struct rt_wlan_complete_des *complete;
rt_uint32_t set = 0, recved = 0;
rt_uint32_t scan_retry = RT_WLAN_SCAN_RETRY_CNT;
/* sta dev Can't be NULL */
if (_sta_is_null())
@ -960,12 +1083,11 @@ rt_err_t rt_wlan_connect(const char *ssid, const char *password)
/* get info from cache */
INVALID_INFO(&info);
MGNT_LOCK();
if (rt_wlan_find_best_by_cache(ssid, &info) != RT_TRUE)
while (scan_retry-- && rt_wlan_find_best_by_cache(ssid, &info) != RT_TRUE)
{
rt_wlan_scan_sync();
rt_wlan_find_best_by_cache(ssid, &info);
rt_wlan_scan_result_clean();
}
rt_wlan_scan_result_clean();
if (info.ssid.len <= 0)
{
@ -1216,10 +1338,13 @@ rt_err_t rt_wlan_get_info(struct rt_wlan_info *info)
}
RT_WLAN_LOG_D("%s is run", __FUNCTION__);
rt_enter_critical();
*info = _sta_mgnt.info;
rt_exit_critical();
return RT_EOK;
if (rt_wlan_is_connected() == RT_TRUE)
{
*info = _sta_mgnt.info;
info->rssi = rt_wlan_get_rssi();
return RT_EOK;
}
return -RT_ERROR;
}
int rt_wlan_get_rssi(void)
@ -1268,6 +1393,7 @@ rt_err_t rt_wlan_start_ap(const char *ssid, const char *password)
rt_memcpy(&info.ssid.val, ssid, ssid_len);
info.ssid.len = ssid_len;
info.channel = 6;
info.band = RT_802_11_BAND_2_4GHZ;
/* Initializing events that need to wait */
MGNT_LOCK();
@ -1427,8 +1553,12 @@ rt_err_t rt_wlan_ap_get_info(struct rt_wlan_info *info)
}
RT_WLAN_LOG_D("%s is run", __FUNCTION__);
*info = _ap_mgnt.info;
return RT_EOK;
if (rt_wlan_ap_is_active() == RT_TRUE)
{
*info = _ap_mgnt.info;
return RT_EOK;
}
return -RT_ERROR;
}
/* get sta number */
@ -1555,27 +1685,35 @@ rt_country_code_t rt_wlan_ap_get_country(void)
void rt_wlan_config_autoreconnect(rt_bool_t enable)
{
#ifdef RT_WLAN_AUTO_CONNECT_ENABLE
RT_WLAN_LOG_D("%s is run enable:%d", __FUNCTION__, enable);
MGNT_LOCK();
if (enable)
{
TIME_START();
_sta_mgnt.flags |= RT_WLAN_STATE_AUTOEN;
}
else
{
TIME_STOP();
_sta_mgnt.flags &= ~RT_WLAN_STATE_AUTOEN;
}
MGNT_UNLOCK();
#endif
}
rt_bool_t rt_wlan_get_autoreconnect_mode(void)
{
#ifdef RT_WLAN_AUTO_CONNECT_ENABLE
rt_bool_t enable = 0;
enable = _sta_mgnt.flags & RT_WLAN_STATE_AUTOEN ? 1 : 0;
RT_WLAN_LOG_D("%s is run enable:%d", __FUNCTION__, enable);
return enable;
#else
return RT_FALSE;
#endif
}
/* Call the underlying scan function, which is asynchronous.
@ -1612,6 +1750,9 @@ struct rt_wlan_scan_result *rt_wlan_scan_with_info(struct rt_wlan_info *info)
rt_err_t err = RT_EOK;
struct rt_wlan_complete_des *complete;
rt_uint32_t set = 0, recved = 0;
static struct rt_wlan_info scan_filter_info;
rt_base_t level;
struct rt_wlan_scan_result *result;
if (_sta_is_null())
{
@ -1633,14 +1774,23 @@ struct rt_wlan_scan_result *rt_wlan_scan_with_info(struct rt_wlan_info *info)
return &scan_result;
}
/* add scan info filter */
if (info)
{
scan_filter_info = *info;
level = rt_hw_interrupt_disable();
scan_filter = &scan_filter_info;
rt_hw_interrupt_enable(level);
}
/* run scan */
err = rt_wlan_dev_scan(STA_DEVICE(), info);
if (err != RT_EOK)
{
rt_wlan_complete_delete(complete);
RT_WLAN_LOG_E("scan sync fail");
MGNT_UNLOCK();
return RT_NULL;
result = RT_NULL;
goto scan_exit;
}
/* Initializing events that need to wait */
@ -1653,12 +1803,17 @@ struct rt_wlan_scan_result *rt_wlan_scan_with_info(struct rt_wlan_info *info)
if (!(recved & set))
{
RT_WLAN_LOG_E("scan wait timeout!");
MGNT_UNLOCK();
return &scan_result;
result = &scan_result;
goto scan_exit;
}
scan_exit:
MGNT_UNLOCK();
return &scan_result;
level = rt_hw_interrupt_disable();
scan_filter = RT_NULL;
rt_hw_interrupt_enable(level);
result = &scan_result;
return result;
}
int rt_wlan_scan_get_info_num(void)
@ -1709,8 +1864,7 @@ int rt_wlan_scan_find_cache(struct rt_wlan_info *info, struct rt_wlan_info *out_
{
int i = 0, count = 0;
struct rt_wlan_info *scan_info;
rt_bool_t is_equ = 1;
rt_uint8_t bssid_zero[RT_WLAN_BSSID_MAX_LENGTH] = { 0 };
rt_bool_t is_equ;
if ((out_info == RT_NULL) || (info == RT_NULL) || (num <= 0))
{
@ -1721,31 +1875,7 @@ int rt_wlan_scan_find_cache(struct rt_wlan_info *info, struct rt_wlan_info *out_
for (i = 0; (i < scan_result.num) && (count < num); i++)
{
scan_info = &scan_result.info[i];
if (is_equ && (info->security != SECURITY_UNKNOWN))
{
is_equ &= info->security == scan_info->security;
}
if (is_equ && ((info->ssid.len > 0) && (info->ssid.len == scan_info->ssid.len)))
{
is_equ &= rt_memcmp(&info->ssid.val[0], &scan_info->ssid.val[0], scan_info->ssid.len) == 0;
}
if (is_equ && (rt_memcmp(&info->bssid[0], bssid_zero, RT_WLAN_BSSID_MAX_LENGTH)))
{
is_equ &= rt_memcmp(&info->bssid[0], &scan_info->bssid[0], RT_WLAN_BSSID_MAX_LENGTH) == 0;
}
if (is_equ && info->datarate)
{
is_equ &= info->datarate == scan_info->datarate;
}
if (is_equ && (info->channel >= 0))
{
is_equ &= info->channel == scan_info->channel;
}
if (is_equ && (info->rssi < 0))
{
is_equ &= info->rssi == scan_info->rssi;
}
is_equ = rt_wlan_info_isequ(scan_info, info);
/* Determine whether to find */
if (is_equ)
{
@ -1840,8 +1970,6 @@ void rt_wlan_mgnt_unlock(void)
int rt_wlan_prot_ready_event(struct rt_wlan_device *wlan, struct rt_wlan_buff *buff)
{
rt_base_t level;
void *user_parameter;
rt_wlan_event_handler handler = RT_NULL;
if ((wlan == RT_NULL) || (_sta_mgnt.device != wlan) ||
(!(_sta_mgnt.state & RT_WLAN_STATE_CONNECT)))
@ -1854,13 +1982,24 @@ int rt_wlan_prot_ready_event(struct rt_wlan_device *wlan, struct rt_wlan_buff *b
}
level = rt_hw_interrupt_disable();
_sta_mgnt.state |= RT_WLAN_STATE_READY;
handler = event_tab[RT_WLAN_EVT_READY].handler;
user_parameter = event_tab[RT_WLAN_EVT_READY].parameter;
rt_hw_interrupt_enable(level);
if (handler)
#ifdef RT_WLAN_WORK_THREAD_ENABLE
rt_wlan_send_to_thread(RT_WLAN_EVT_READY, buff->data, buff->len);
#else
{
handler(RT_WLAN_EVT_READY, buff, user_parameter);
void *user_parameter;
rt_wlan_event_handler handler = RT_NULL;
level = rt_hw_interrupt_disable();
handler = event_tab[RT_WLAN_EVT_READY].handler;
user_parameter = event_tab[RT_WLAN_EVT_READY].parameter;
rt_hw_interrupt_enable(level);
if (handler)
{
handler(RT_WLAN_EVT_READY, buff, user_parameter);
}
}
#endif
return 0;
}
@ -1879,10 +2018,15 @@ int rt_wlan_init(void)
rt_mutex_init(&scan_result_mutex, "scan", RT_IPC_FLAG_FIFO);
rt_mutex_init(&sta_info_mutex, "sta", RT_IPC_FLAG_FIFO);
rt_mutex_init(&complete_mutex, "complete", RT_IPC_FLAG_FIFO);
rt_timer_init(&reconnect_time, "wifi_tim", rt_wlan_cyclic_check, RT_NULL, DISCONNECT_RESPONSE_TICK, RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER);
rt_timer_start(&reconnect_time);
#ifdef RT_WLAN_AUTO_CONNECT_ENABLE
rt_timer_init(&reconnect_time, "wifi_tim", rt_wlan_cyclic_check, RT_NULL,
rt_tick_from_millisecond(DISCONNECT_RESPONSE_MS),
RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER);
#endif
_init_flag = 1;
}
return 0;
}
INIT_PREV_EXPORT(rt_wlan_init);
#endif

4
components/drivers/wlan/wlan_mgnt.h
View File

@ -37,6 +37,10 @@ extern "C" {
#define RT_WLAN_EBOX_NUM (10)
#endif
#ifndef RT_WLAN_SCAN_RETRY_CNT
#define RT_WLAN_SCAN_RETRY_CNT (3)
#endif
/*state fot station*/
#define RT_WLAN_STATE_CONNECT (1UL << 0)
#define RT_WLAN_STATE_CONNECTING (1UL << 1)

20
components/drivers/wlan/wlan_prot.c
View File

@ -21,6 +21,8 @@
#endif /* RT_WLAN_PROT_DEBUG */
#include <rtdbg.h>
#ifdef RT_WLAN_PROT_ENABLE
#if RT_WLAN_PROT_NAME_LEN < 4
#error "The name is too short"
#endif
@ -160,7 +162,7 @@ rt_err_t rt_wlan_prot_attach_dev(struct rt_wlan_device *wlan, const char *prot_n
{
int i = 0;
struct rt_wlan_prot *prot = wlan->prot;
rt_wlan_dev_event_t event;
rt_wlan_dev_event_handler handler = rt_wlan_prot_event_handle;
if (wlan == RT_NULL)
{
@ -180,7 +182,7 @@ rt_err_t rt_wlan_prot_attach_dev(struct rt_wlan_device *wlan, const char *prot_n
rt_wlan_prot_detach_dev(wlan);
#ifdef RT_WLAN_PROT_LWIP_PBUF_FORCE
if (rt_strcmp(RT_WLAN_PROT_LWIP, prot_name) != 0)
if (rt_strcmp(RT_WLAN_PROT_LWIP_NAME, prot_name) != 0)
{
return -RT_ERROR;
}
@ -202,13 +204,12 @@ rt_err_t rt_wlan_prot_attach_dev(struct rt_wlan_device *wlan, const char *prot_n
return -RT_ERROR;
}
for (event = RT_WLAN_DEV_EVT_INIT_DONE; event < RT_WLAN_DEV_EVT_MAX; event ++)
{
if (rt_wlan_dev_register_event_handler(wlan, event, rt_wlan_prot_event_handle, RT_NULL) != RT_EOK)
{
LOG_E("prot register event filed:%d", event);
}
}
rt_wlan_dev_register_event_handler(wlan, RT_WLAN_DEV_EVT_CONNECT, handler, RT_NULL);
rt_wlan_dev_register_event_handler(wlan, RT_WLAN_DEV_EVT_DISCONNECT, handler, RT_NULL);
rt_wlan_dev_register_event_handler(wlan, RT_WLAN_DEV_EVT_AP_START, handler, RT_NULL);
rt_wlan_dev_register_event_handler(wlan, RT_WLAN_DEV_EVT_AP_STOP, handler, RT_NULL);
rt_wlan_dev_register_event_handler(wlan, RT_WLAN_DEV_EVT_AP_ASSOCIATED, handler, RT_NULL);
rt_wlan_dev_register_event_handler(wlan, RT_WLAN_DEV_EVT_AP_DISASSOCIATED, handler, RT_NULL);
return RT_EOK;
}
@ -360,3 +361,4 @@ void rt_wlan_prot_dump(void)
}
}
}
#endif

2
components/drivers/wlan/wlan_prot.h
View File

@ -25,8 +25,6 @@ extern "C" {
#define RT_LWAN_ID_PREFIX (0x5054)
#define RT_WLAN_PROT_LWIP ("lwip")
typedef enum
{
RT_WLAN_PROT_EVT_INIT_DONE = 0,

4
components/drivers/wlan/wlan_workqueue.c
View File

@ -17,6 +17,8 @@
#define DBG_LVL DBG_INFO
#include <rtdbg.h>
#ifdef RT_WLAN_WORK_THREAD_ENABLE
struct rt_wlan_work
{
struct rt_work work;
@ -95,3 +97,5 @@ int rt_wlan_workqueue_init(void)
return 0;
}
INIT_PREV_EXPORT(rt_wlan_workqueue_init);
#endif