添加rtthread相关代码
This commit is contained in:
30
riscv/rtthread/components/drivers/wlan/SConscript
Executable file
30
riscv/rtthread/components/drivers/wlan/SConscript
Executable file
@@ -0,0 +1,30 @@
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
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')
|
||||
468
riscv/rtthread/components/drivers/wlan/wlan_cfg.c
Executable file
468
riscv/rtthread/components/drivers/wlan/wlan_cfg.c
Executable file
@@ -0,0 +1,468 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-06 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <wlan_cfg.h>
|
||||
|
||||
#define DBG_TAG "WLAN.cfg"
|
||||
#ifdef RT_WLAN_CFG_DEBUG
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#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))
|
||||
|
||||
#if RT_WLAN_CFG_INFO_MAX < 1
|
||||
#error "The minimum configuration is 1"
|
||||
#endif
|
||||
|
||||
struct cfg_save_info_head
|
||||
{
|
||||
rt_uint32_t magic;
|
||||
rt_uint32_t len;
|
||||
rt_uint32_t num;
|
||||
rt_uint32_t crc;
|
||||
};
|
||||
|
||||
struct rt_wlan_cfg_des
|
||||
{
|
||||
rt_uint32_t num;
|
||||
struct rt_wlan_cfg_info *cfg_info;
|
||||
};
|
||||
|
||||
static struct rt_wlan_cfg_des *cfg_cache;
|
||||
static const struct rt_wlan_cfg_ops *cfg_ops;
|
||||
static struct rt_mutex cfg_mutex;
|
||||
|
||||
/*
|
||||
* CRC16_CCITT
|
||||
*/
|
||||
static rt_uint16_t rt_wlan_cal_crc(rt_uint8_t *buff, int len)
|
||||
{
|
||||
rt_uint16_t wCRCin = 0x0000;
|
||||
rt_uint16_t wCPoly = 0x1021;
|
||||
rt_uint8_t wChar = 0;
|
||||
|
||||
while (len--)
|
||||
{
|
||||
int i;
|
||||
|
||||
wChar = *(buff++);
|
||||
wCRCin ^= (wChar << 8);
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
if (wCRCin & 0x8000)
|
||||
wCRCin = (wCRCin << 1) ^ wCPoly;
|
||||
else
|
||||
wCRCin = wCRCin << 1;
|
||||
}
|
||||
}
|
||||
return wCRCin;
|
||||
}
|
||||
|
||||
void rt_wlan_cfg_init(void)
|
||||
{
|
||||
/* init cache memory */
|
||||
if (cfg_cache == RT_NULL)
|
||||
{
|
||||
cfg_cache = rt_malloc(sizeof(struct rt_wlan_cfg_des));
|
||||
if (cfg_cache != RT_NULL)
|
||||
{
|
||||
rt_memset(cfg_cache, 0, sizeof(struct rt_wlan_cfg_des));
|
||||
}
|
||||
/* init mutex lock */
|
||||
rt_mutex_init(&cfg_mutex, "wlan_cfg", RT_IPC_FLAG_PRIO);
|
||||
}
|
||||
}
|
||||
|
||||
void rt_wlan_cfg_set_ops(const struct rt_wlan_cfg_ops *ops)
|
||||
{
|
||||
rt_wlan_cfg_init();
|
||||
|
||||
WLAN_CFG_LOCK();
|
||||
/* save ops pointer */
|
||||
cfg_ops = ops;
|
||||
WLAN_CFG_UNLOCK();
|
||||
}
|
||||
|
||||
/* save config data */
|
||||
rt_err_t rt_wlan_cfg_cache_save(void)
|
||||
{
|
||||
rt_err_t err = RT_EOK;
|
||||
struct cfg_save_info_head *info_pkg;
|
||||
int len = 0;
|
||||
|
||||
if ((cfg_ops == RT_NULL) || (cfg_ops->write_cfg == RT_NULL))
|
||||
return RT_EOK;
|
||||
|
||||
WLAN_CFG_LOCK();
|
||||
len = sizeof(struct cfg_save_info_head) + sizeof(struct rt_wlan_cfg_info) * cfg_cache->num;
|
||||
info_pkg = rt_malloc(len);
|
||||
if (info_pkg == RT_NULL)
|
||||
{
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -RT_ENOMEM;
|
||||
}
|
||||
info_pkg->magic = RT_WLAN_CFG_MAGIC;
|
||||
info_pkg->len = len;
|
||||
info_pkg->num = cfg_cache->num;
|
||||
/* CRC */
|
||||
info_pkg->crc = rt_wlan_cal_crc((rt_uint8_t *)cfg_cache->cfg_info, sizeof(struct rt_wlan_cfg_info) * cfg_cache->num);
|
||||
rt_memcpy(((rt_uint8_t *)info_pkg) + sizeof(struct cfg_save_info_head),
|
||||
cfg_cache->cfg_info, sizeof(struct rt_wlan_cfg_info) * cfg_cache->num);
|
||||
if (cfg_ops->write_cfg(info_pkg, len) != len)
|
||||
err = -RT_ERROR;
|
||||
rt_free(info_pkg);
|
||||
WLAN_CFG_UNLOCK();
|
||||
return err;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_cfg_cache_refresh(void)
|
||||
{
|
||||
int len = 0, i, j;
|
||||
struct cfg_save_info_head *head;
|
||||
void *data;
|
||||
struct rt_wlan_cfg_info *t_info, *cfg_info;
|
||||
rt_uint32_t crc;
|
||||
rt_bool_t equal_flag;
|
||||
|
||||
/* cache is full! exit */
|
||||
if (cfg_cache == RT_NULL || cfg_cache->num >= RT_WLAN_CFG_INFO_MAX)
|
||||
return -RT_ERROR;
|
||||
|
||||
/* check callback */
|
||||
if ((cfg_ops == RT_NULL) ||
|
||||
(cfg_ops->get_len == RT_NULL) ||
|
||||
(cfg_ops->read_cfg == RT_NULL))
|
||||
return -RT_ERROR;
|
||||
|
||||
WLAN_CFG_LOCK();
|
||||
/* get data len */
|
||||
if ((len = cfg_ops->get_len()) <= 0)
|
||||
{
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
head = rt_malloc(len);
|
||||
if (head == RT_NULL)
|
||||
{
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -RT_ERROR;
|
||||
}
|
||||
/* get data */
|
||||
if (cfg_ops->read_cfg(head, len) != len)
|
||||
{
|
||||
rt_free(head);
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -RT_ERROR;
|
||||
}
|
||||
/* get config */
|
||||
data = ((rt_uint8_t *)head) + sizeof(struct cfg_save_info_head);
|
||||
crc = rt_wlan_cal_crc((rt_uint8_t *)data, len - sizeof(struct cfg_save_info_head));
|
||||
LOG_D("head->magic:0x%08x RT_WLAN_CFG_MAGIC:0x%08x", head->magic, RT_WLAN_CFG_MAGIC);
|
||||
LOG_D("head->len:%d len:%d", head->len, len);
|
||||
LOG_D("head->num:%d num:%d", head->num, (len - sizeof(struct cfg_save_info_head)) / sizeof(struct rt_wlan_cfg_info));
|
||||
LOG_D("hred->crc:0x%04x crc:0x%04x", head->crc, crc);
|
||||
/* check */
|
||||
if ((head->magic != RT_WLAN_CFG_MAGIC) ||
|
||||
(head->len != len) ||
|
||||
(head->num != (len - sizeof(struct cfg_save_info_head)) / sizeof(struct rt_wlan_cfg_info)) ||
|
||||
(head->crc != crc))
|
||||
{
|
||||
rt_free(head);
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
/* remove duplicate config */
|
||||
cfg_info = (struct rt_wlan_cfg_info *)data;
|
||||
for (i = 0; i < head->num; i++)
|
||||
{
|
||||
equal_flag = RT_FALSE;
|
||||
for (j = 0; j < cfg_cache->num; j++)
|
||||
{
|
||||
if ((cfg_cache->cfg_info[j].info.ssid.len == cfg_info[i].info.ssid.len) &&
|
||||
(rt_memcmp(&cfg_cache->cfg_info[j].info.ssid.val[0], &cfg_info[i].info.ssid.val[0],
|
||||
cfg_cache->cfg_info[j].info.ssid.len) == 0) &&
|
||||
(rt_memcmp(&cfg_cache->cfg_info[j].info.bssid[0], &cfg_info[i].info.bssid[0], RT_WLAN_BSSID_MAX_LENGTH) == 0))
|
||||
{
|
||||
equal_flag = RT_TRUE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (cfg_cache->num >= RT_WLAN_CFG_INFO_MAX)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if (equal_flag == RT_FALSE)
|
||||
{
|
||||
t_info = rt_realloc(cfg_cache->cfg_info, sizeof(struct rt_wlan_cfg_info) * (cfg_cache->num + 1));
|
||||
if (t_info == RT_NULL)
|
||||
{
|
||||
rt_free(head);
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -RT_ERROR;
|
||||
}
|
||||
cfg_cache->cfg_info = t_info;
|
||||
cfg_cache->cfg_info[cfg_cache->num] = cfg_info[i];
|
||||
cfg_cache->num ++;
|
||||
}
|
||||
}
|
||||
|
||||
rt_free(head);
|
||||
WLAN_CFG_UNLOCK();
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int rt_wlan_cfg_get_num(void)
|
||||
{
|
||||
rt_wlan_cfg_init();
|
||||
|
||||
return cfg_cache->num;
|
||||
}
|
||||
|
||||
int rt_wlan_cfg_read(struct rt_wlan_cfg_info *cfg_info, int num)
|
||||
{
|
||||
rt_wlan_cfg_init();
|
||||
|
||||
if ((cfg_info == RT_NULL) || (num <= 0))
|
||||
return 0;
|
||||
/* copy data */
|
||||
WLAN_CFG_LOCK();
|
||||
num = cfg_cache->num > num ? num : cfg_cache->num;
|
||||
rt_memcpy(&cfg_cache->cfg_info[0], cfg_info, sizeof(struct rt_wlan_cfg_info) * num);
|
||||
WLAN_CFG_UNLOCK();
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_cfg_save(struct rt_wlan_cfg_info *cfg_info)
|
||||
{
|
||||
rt_err_t err = RT_EOK;
|
||||
struct rt_wlan_cfg_info *t_info;
|
||||
int idx = -1, i = 0;
|
||||
|
||||
rt_wlan_cfg_init();
|
||||
|
||||
/* parameter check */
|
||||
if ((cfg_info == RT_NULL) || (cfg_info->info.ssid.len == 0))
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
/* if (iteam == cache) exit */
|
||||
WLAN_CFG_LOCK();
|
||||
for (i = 0; i < cfg_cache->num; i++)
|
||||
{
|
||||
if ((cfg_cache->cfg_info[i].info.ssid.len == cfg_info->info.ssid.len) &&
|
||||
(rt_memcmp(&cfg_cache->cfg_info[i].info.ssid.val[0], &cfg_info->info.ssid.val[0],
|
||||
cfg_cache->cfg_info[i].info.ssid.len) == 0) &&
|
||||
(rt_memcmp(&cfg_cache->cfg_info[i].info.bssid[0], &cfg_info->info.bssid[0], RT_WLAN_BSSID_MAX_LENGTH) == 0))
|
||||
{
|
||||
idx = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ((idx == 0) && (cfg_cache->cfg_info[i].key.len == cfg_info->key.len) &&
|
||||
(rt_memcmp(&cfg_cache->cfg_info[i].key.val[0], &cfg_info->key.val[0], cfg_info->key.len) == 0))
|
||||
{
|
||||
WLAN_CFG_UNLOCK();
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
/* not find iteam with cache, Add iteam to the head */
|
||||
if ((idx == -1) && (cfg_cache->num < RT_WLAN_CFG_INFO_MAX))
|
||||
{
|
||||
t_info = rt_realloc(cfg_cache->cfg_info, sizeof(struct rt_wlan_cfg_info) * (cfg_cache->num + 1));
|
||||
if (t_info == RT_NULL)
|
||||
{
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -RT_ENOMEM;
|
||||
}
|
||||
cfg_cache->cfg_info = t_info;
|
||||
cfg_cache->num ++;
|
||||
}
|
||||
|
||||
/* move cache info */
|
||||
i = (i >= RT_WLAN_CFG_INFO_MAX ? RT_WLAN_CFG_INFO_MAX - 1 : i);
|
||||
for (; i; i--)
|
||||
{
|
||||
cfg_cache->cfg_info[i] = cfg_cache->cfg_info[i - 1];
|
||||
}
|
||||
/* add iteam to head */
|
||||
cfg_cache->cfg_info[i] = *cfg_info;
|
||||
WLAN_CFG_UNLOCK();
|
||||
|
||||
/* save info to flash */
|
||||
err = rt_wlan_cfg_cache_save();
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int rt_wlan_cfg_read_index(struct rt_wlan_cfg_info *cfg_info, int index)
|
||||
{
|
||||
rt_wlan_cfg_init();
|
||||
|
||||
if ((cfg_info == RT_NULL) || (index < 0))
|
||||
return 0;
|
||||
|
||||
WLAN_CFG_LOCK();
|
||||
if (index >= cfg_cache->num)
|
||||
{
|
||||
WLAN_CFG_UNLOCK();
|
||||
return 0;
|
||||
}
|
||||
/* copy data */
|
||||
*cfg_info = cfg_cache->cfg_info[index];
|
||||
WLAN_CFG_UNLOCK();
|
||||
return 1;
|
||||
}
|
||||
|
||||
int rt_wlan_cfg_delete_index(int index)
|
||||
{
|
||||
struct rt_wlan_cfg_info *cfg_info;
|
||||
int i;
|
||||
|
||||
rt_wlan_cfg_init();
|
||||
|
||||
if (index < 0)
|
||||
return -1;
|
||||
|
||||
WLAN_CFG_LOCK();
|
||||
if (index >= cfg_cache->num)
|
||||
{
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* malloc new mem */
|
||||
cfg_info = rt_malloc(sizeof(struct rt_wlan_cfg_info) * (cfg_cache->num - 1));
|
||||
if (cfg_info == RT_NULL)
|
||||
{
|
||||
WLAN_CFG_UNLOCK();
|
||||
return -1;
|
||||
}
|
||||
/* copy data to new mem */
|
||||
for (i = 0; i < cfg_cache->num; i++)
|
||||
{
|
||||
if (i < index)
|
||||
{
|
||||
cfg_info[i] = cfg_cache->cfg_info[i];
|
||||
}
|
||||
else if (i > index)
|
||||
{
|
||||
cfg_info[i - 1] = cfg_cache->cfg_info[i];
|
||||
}
|
||||
}
|
||||
rt_free(cfg_cache->cfg_info);
|
||||
cfg_cache->cfg_info = cfg_info;
|
||||
cfg_cache->num --;
|
||||
WLAN_CFG_UNLOCK();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void rt_wlan_cfg_delete_all(void)
|
||||
{
|
||||
rt_wlan_cfg_init();
|
||||
|
||||
/* delete all iteam */
|
||||
WLAN_CFG_LOCK();
|
||||
cfg_cache->num = 0;
|
||||
rt_free(cfg_cache->cfg_info);
|
||||
cfg_cache->cfg_info = RT_NULL;
|
||||
WLAN_CFG_UNLOCK();
|
||||
}
|
||||
|
||||
void rt_wlan_cfg_dump(void)
|
||||
{
|
||||
int index = 0;
|
||||
struct rt_wlan_info *info;
|
||||
struct rt_wlan_key *key;
|
||||
char *security;
|
||||
|
||||
rt_wlan_cfg_init();
|
||||
|
||||
rt_kprintf(" SSID PASSWORD MAC security chn\n");
|
||||
rt_kprintf("------------------------------- ------------------------------- ----------------- -------------- ---\n");
|
||||
for (index = 0; index < cfg_cache->num; index ++)
|
||||
{
|
||||
info = &cfg_cache->cfg_info[index].info;
|
||||
key = &cfg_cache->cfg_info[index].key;
|
||||
|
||||
if (info->ssid.len)
|
||||
rt_kprintf("%-32.32s", &info->ssid.val[0]);
|
||||
else
|
||||
rt_kprintf("%-32.32s", " ");
|
||||
|
||||
if (key->len)
|
||||
rt_kprintf("%-32.32s", &key->val[0]);
|
||||
else
|
||||
rt_kprintf("%-32.32s", " ");
|
||||
|
||||
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("%3d \n", info->channel);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
67
riscv/rtthread/components/drivers/wlan/wlan_cfg.h
Executable file
67
riscv/rtthread/components/drivers/wlan/wlan_cfg.h
Executable file
@@ -0,0 +1,67 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-06 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __WLAN_CFG_H__
|
||||
#define __WLAN_CFG_H__
|
||||
|
||||
#include <wlan_dev.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_CFG_INFO_MAX
|
||||
#define RT_WLAN_CFG_INFO_MAX (3) /* min is 1 */
|
||||
#endif
|
||||
|
||||
#define RT_WLAN_CFG_MAGIC (0x426f6d62)
|
||||
|
||||
struct rt_wlan_cfg_info
|
||||
{
|
||||
struct rt_wlan_info info;
|
||||
struct rt_wlan_key key;
|
||||
};
|
||||
|
||||
typedef int (*rt_wlan_wr)(void *buff, int len);
|
||||
|
||||
struct rt_wlan_cfg_ops
|
||||
{
|
||||
int (*read_cfg)(void *buff, int len);
|
||||
int (*get_len)(void);
|
||||
int (*write_cfg)(void *buff, int len);
|
||||
};
|
||||
|
||||
void rt_wlan_cfg_init(void);
|
||||
|
||||
void rt_wlan_cfg_set_ops(const struct rt_wlan_cfg_ops *ops);
|
||||
|
||||
int rt_wlan_cfg_get_num(void);
|
||||
|
||||
int rt_wlan_cfg_read(struct rt_wlan_cfg_info *cfg_info, int num);
|
||||
|
||||
int rt_wlan_cfg_read_index(struct rt_wlan_cfg_info *cfg_info, int index);
|
||||
|
||||
rt_err_t rt_wlan_cfg_save(struct rt_wlan_cfg_info *cfg_info);
|
||||
|
||||
rt_err_t rt_wlan_cfg_cache_refresh(void);
|
||||
|
||||
rt_err_t rt_wlan_cfg_cache_save(void);
|
||||
|
||||
int rt_wlan_cfg_delete_index(int index);
|
||||
|
||||
void rt_wlan_cfg_delete_all(void);
|
||||
|
||||
void rt_wlan_cfg_dump(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
827
riscv/rtthread/components/drivers/wlan/wlan_cmd.c
Executable file
827
riscv/rtthread/components/drivers/wlan/wlan_cmd.c
Executable file
@@ -0,0 +1,827 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-13 tyx the first version
|
||||
* 2024-03-24 Evlers fixed a duplicate issue with the wifi scan command
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rthw.h>
|
||||
#include <wlan_mgnt.h>
|
||||
#include <wlan_cfg.h>
|
||||
#include <wlan_prot.h>
|
||||
|
||||
#define DBG_TAG "WLAN.cmd"
|
||||
#ifdef RT_WLAN_MGNT_DEBUG
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#endif /* RT_WLAN_MGNT_DEBUG */
|
||||
#include <rtdbg.h>
|
||||
|
||||
static struct rt_wlan_scan_result scan_result;
|
||||
static struct rt_wlan_info *scan_filter = RT_NULL;
|
||||
|
||||
#if defined(RT_WLAN_MANAGE_ENABLE) && defined(RT_WLAN_MSH_CMD_ENABLE)
|
||||
|
||||
struct wifi_cmd_des
|
||||
{
|
||||
const char *cmd;
|
||||
int (*fun)(int argc, char *argv[]);
|
||||
};
|
||||
|
||||
static int wifi_help(int argc, char *argv[]);
|
||||
static int wifi_scan(int argc, char *argv[]);
|
||||
static int wifi_status(int argc, char *argv[]);
|
||||
static int wifi_join(int argc, char *argv[]);
|
||||
static int wifi_ap(int argc, char *argv[]);
|
||||
static int wifi_list_sta(int argc, char *argv[]);
|
||||
static int wifi_disconnect(int argc, char *argv[]);
|
||||
static int wifi_ap_stop(int argc, char *argv[]);
|
||||
|
||||
#ifdef RT_WLAN_CMD_DEBUG
|
||||
/* just for debug */
|
||||
static int wifi_debug(int argc, char *argv[]);
|
||||
static int wifi_debug_save_cfg(int argc, char *argv[]);
|
||||
static int wifi_debug_dump_cfg(int argc, char *argv[]);
|
||||
static int wifi_debug_clear_cfg(int argc, char *argv[]);
|
||||
static int wifi_debug_dump_prot(int argc, char *argv[]);
|
||||
static int wifi_debug_set_mode(int argc, char *argv[]);
|
||||
static int wifi_debug_set_prot(int argc, char *argv[]);
|
||||
static int wifi_debug_set_autoconnect(int argc, char *argv[]);
|
||||
#endif
|
||||
|
||||
/* cmd table */
|
||||
static const struct wifi_cmd_des cmd_tab[] =
|
||||
{
|
||||
{"scan", wifi_scan},
|
||||
{"help", wifi_help},
|
||||
{"status", wifi_status},
|
||||
{"join", wifi_join},
|
||||
{"ap", wifi_ap},
|
||||
{"list_sta", wifi_list_sta},
|
||||
{"disc", wifi_disconnect},
|
||||
{"ap_stop", wifi_ap_stop},
|
||||
{"smartconfig", RT_NULL},
|
||||
#ifdef RT_WLAN_CMD_DEBUG
|
||||
{"-d", wifi_debug},
|
||||
#endif
|
||||
};
|
||||
|
||||
#ifdef RT_WLAN_CMD_DEBUG
|
||||
/* debug cmd table */
|
||||
static const struct wifi_cmd_des debug_tab[] =
|
||||
{
|
||||
{"save_cfg", wifi_debug_save_cfg},
|
||||
{"dump_cfg", wifi_debug_dump_cfg},
|
||||
{"clear_cfg", wifi_debug_clear_cfg},
|
||||
{"dump_prot", wifi_debug_dump_prot},
|
||||
{"mode", wifi_debug_set_mode},
|
||||
{"prot", wifi_debug_set_prot},
|
||||
{"auto", wifi_debug_set_autoconnect},
|
||||
};
|
||||
#endif
|
||||
|
||||
static int wifi_help(int argc, char *argv[])
|
||||
{
|
||||
rt_kprintf("wifi\n");
|
||||
rt_kprintf("wifi help\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");
|
||||
rt_kprintf("wifi ap_stop\n");
|
||||
rt_kprintf("wifi status\n");
|
||||
rt_kprintf("wifi smartconfig\n");
|
||||
#ifdef RT_WLAN_CMD_DEBUG
|
||||
rt_kprintf("wifi -d debug command\n");
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_status(int argc, char *argv[])
|
||||
{
|
||||
int rssi;
|
||||
struct rt_wlan_info info;
|
||||
|
||||
if (argc > 2)
|
||||
return -1;
|
||||
|
||||
if (rt_wlan_is_connected() == 1)
|
||||
{
|
||||
rssi = rt_wlan_get_rssi();
|
||||
rt_wlan_get_info(&info);
|
||||
rt_kprintf("Wi-Fi STA Info\n");
|
||||
rt_kprintf("SSID : %-.32s\n", &info.ssid.val[0]);
|
||||
rt_kprintf("MAC Addr: %02x:%02x:%02x:%02x:%02x:%02x\n", info.bssid[0],
|
||||
info.bssid[1],
|
||||
info.bssid[2],
|
||||
info.bssid[3],
|
||||
info.bssid[4],
|
||||
info.bssid[5]);
|
||||
rt_kprintf("Channel: %d\n", info.channel);
|
||||
rt_kprintf("DataRate: %dMbps\n", info.datarate / 1000000);
|
||||
rt_kprintf("RSSI: %d\n", rssi);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("wifi disconnected!\n");
|
||||
}
|
||||
|
||||
if (rt_wlan_ap_is_active() == 1)
|
||||
{
|
||||
rt_wlan_ap_get_info(&info);
|
||||
rt_kprintf("Wi-Fi AP Info\n");
|
||||
rt_kprintf("SSID : %-.32s\n", &info.ssid.val[0]);
|
||||
rt_kprintf("MAC Addr: %02x:%02x:%02x:%02x:%02x:%02x\n", info.bssid[0],
|
||||
info.bssid[1],
|
||||
info.bssid[2],
|
||||
info.bssid[3],
|
||||
info.bssid[4],
|
||||
info.bssid[5]);
|
||||
rt_kprintf("Channel: %d\n", info.channel);
|
||||
rt_kprintf("DataRate: %dMbps\n", info.datarate / 1000000);
|
||||
rt_kprintf("hidden: %s\n", info.hidden ? "Enable" : "Disable");
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("wifi ap not start!\n");
|
||||
}
|
||||
rt_kprintf("Auto Connect status:%s!\n", (rt_wlan_get_autoreconnect_mode() ? "Enable" : "Disable"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static rt_bool_t 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 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;
|
||||
|
||||
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]);
|
||||
|
||||
/* 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 (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)
|
||||
{
|
||||
LOG_E("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 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 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 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_uint32_t last_num = scan_result.num;
|
||||
|
||||
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 = 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 &&
|
||||
rt_memcmp(&scan_filter->ssid.val[0], &info->ssid.val[0], scan_filter->ssid.len) == 0))
|
||||
{
|
||||
/*Check whether a new ap is added*/
|
||||
if (last_num < scan_result.num)
|
||||
{
|
||||
/*Print the info*/
|
||||
print_ap_info(info,index);
|
||||
}
|
||||
|
||||
index++;
|
||||
*((int *)(parameter)) = index;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
static int wifi_scan(int argc, char *argv[])
|
||||
{
|
||||
struct rt_wlan_info *info = RT_NULL;
|
||||
struct rt_wlan_info filter;
|
||||
int ret = 0;
|
||||
int i = 0;
|
||||
|
||||
if (argc > 3)
|
||||
return -1;
|
||||
|
||||
if (argc == 3)
|
||||
{
|
||||
INVALID_INFO(&filter);
|
||||
SSID_SET(&filter, argv[2]);
|
||||
info = &filter;
|
||||
}
|
||||
|
||||
ret = rt_wlan_register_event_handler(RT_WLAN_EVT_SCAN_REPORT,user_ap_info_callback,&i);
|
||||
if(ret != RT_EOK)
|
||||
{
|
||||
LOG_E("Scan register user callback error:%d!\n",ret);
|
||||
return 0;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
LOG_E("Scan with info error:%d!\n",ret);
|
||||
}
|
||||
|
||||
/* clean scan result */
|
||||
wifi_scan_result_clean();
|
||||
if(info)
|
||||
{
|
||||
scan_filter = RT_NULL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_join(int argc, char *argv[])
|
||||
{
|
||||
const char *ssid = RT_NULL;
|
||||
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)
|
||||
{
|
||||
ssid = (char *)(&cfg_info.info.ssid.val[0]);
|
||||
if (cfg_info.key.len)
|
||||
key = (char *)(&cfg_info.key.val[0]);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
rt_kprintf("not find connect info\n");
|
||||
}
|
||||
}
|
||||
else if (argc == 3)
|
||||
{
|
||||
/* ssid */
|
||||
ssid = argv[2];
|
||||
}
|
||||
else if (argc == 4)
|
||||
{
|
||||
ssid = argv[2];
|
||||
/* password */
|
||||
key = argv[3];
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
rt_wlan_connect(ssid, key);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_ap(int argc, char *argv[])
|
||||
{
|
||||
const char *ssid = RT_NULL;
|
||||
const char *key = RT_NULL;
|
||||
|
||||
if (argc == 3)
|
||||
{
|
||||
ssid = argv[2];
|
||||
}
|
||||
else if (argc == 4)
|
||||
{
|
||||
ssid = argv[2];
|
||||
key = argv[3];
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
rt_wlan_start_ap(ssid, key);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_list_sta(int argc, char *argv[])
|
||||
{
|
||||
struct rt_wlan_info *sta_info;
|
||||
int num, i;
|
||||
|
||||
if (argc > 2)
|
||||
return -1;
|
||||
num = rt_wlan_ap_get_sta_num();
|
||||
sta_info = rt_malloc(sizeof(struct rt_wlan_info) * num);
|
||||
if (sta_info == RT_NULL)
|
||||
{
|
||||
rt_kprintf("num:%d\n", num);
|
||||
return 0;
|
||||
}
|
||||
rt_wlan_ap_get_sta_info(sta_info, num);
|
||||
rt_kprintf("num:%d\n", num);
|
||||
for (i = 0; i < num; i++)
|
||||
{
|
||||
rt_kprintf("sta mac %02x:%02x:%02x:%02x:%02x:%02x\n",
|
||||
sta_info[i].bssid[0], sta_info[i].bssid[1], sta_info[i].bssid[2],
|
||||
sta_info[i].bssid[3], sta_info[i].bssid[4], sta_info[i].bssid[5]);
|
||||
}
|
||||
rt_free(sta_info);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_disconnect(int argc, char *argv[])
|
||||
{
|
||||
if (argc != 2)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
rt_wlan_disconnect();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_ap_stop(int argc, char *argv[])
|
||||
{
|
||||
if (argc != 2)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
rt_wlan_ap_stop();
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef RT_WLAN_CMD_DEBUG
|
||||
/* just for debug */
|
||||
static int wifi_debug_help(int argc, char *argv[])
|
||||
{
|
||||
rt_kprintf("save_cfg ssid [password]\n");
|
||||
rt_kprintf("dump_cfg\n");
|
||||
rt_kprintf("clear_cfg\n");
|
||||
rt_kprintf("dump_prot\n");
|
||||
rt_kprintf("mode sta/ap dev_name\n");
|
||||
rt_kprintf("prot lwip dev_name\n");
|
||||
rt_kprintf("auto enable/disable\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_debug_save_cfg(int argc, char *argv[])
|
||||
{
|
||||
struct rt_wlan_cfg_info cfg_info;
|
||||
int len;
|
||||
char *ssid = RT_NULL, *password = RT_NULL;
|
||||
|
||||
rt_memset(&cfg_info, 0, sizeof(cfg_info));
|
||||
INVALID_INFO(&cfg_info.info);
|
||||
if (argc == 2)
|
||||
{
|
||||
ssid = argv[1];
|
||||
}
|
||||
else if (argc == 3)
|
||||
{
|
||||
ssid = argv[1];
|
||||
password = argv[2];
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (ssid != RT_NULL)
|
||||
{
|
||||
len = rt_strlen(ssid);
|
||||
if (len > RT_WLAN_SSID_MAX_LENGTH)
|
||||
{
|
||||
rt_kprintf("ssid is to long");
|
||||
return 0;
|
||||
}
|
||||
rt_memcpy(&cfg_info.info.ssid.val[0], ssid, len);
|
||||
cfg_info.info.ssid.len = len;
|
||||
}
|
||||
|
||||
if (password != RT_NULL)
|
||||
{
|
||||
len = rt_strlen(password);
|
||||
if (len > RT_WLAN_PASSWORD_MAX_LENGTH)
|
||||
{
|
||||
rt_kprintf("password is to long");
|
||||
return 0;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
static int wifi_debug_dump_cfg(int argc, char *argv[])
|
||||
{
|
||||
if (argc == 1)
|
||||
{
|
||||
#ifdef RT_WLAN_CFG_ENABLE
|
||||
rt_wlan_cfg_dump();
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
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
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_debug_dump_prot(int argc, char *argv[])
|
||||
{
|
||||
if (argc == 1)
|
||||
{
|
||||
rt_wlan_prot_dump();
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_debug_set_mode(int argc, char *argv[])
|
||||
{
|
||||
rt_wlan_mode_t mode;
|
||||
|
||||
if (argc != 3)
|
||||
return -1;
|
||||
|
||||
if (rt_strcmp("sta", argv[1]) == 0)
|
||||
{
|
||||
mode = RT_WLAN_STATION;
|
||||
}
|
||||
else if (rt_strcmp("ap", argv[1]) == 0)
|
||||
{
|
||||
mode = RT_WLAN_AP;
|
||||
}
|
||||
else if (rt_strcmp("none", argv[1]) == 0)
|
||||
{
|
||||
mode = RT_WLAN_NONE;
|
||||
}
|
||||
else
|
||||
return -1;
|
||||
|
||||
rt_wlan_set_mode(argv[2], mode);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_debug_set_prot(int argc, char *argv[])
|
||||
{
|
||||
if (argc != 3)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
rt_wlan_prot_attach(argv[2], argv[1]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_debug_set_autoconnect(int argc, char *argv[])
|
||||
{
|
||||
if (argc == 2)
|
||||
{
|
||||
if (rt_strcmp(argv[1], "enable") == 0)
|
||||
rt_wlan_config_autoreconnect(RT_TRUE);
|
||||
else if (rt_strcmp(argv[1], "disable") == 0)
|
||||
rt_wlan_config_autoreconnect(RT_FALSE);
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wifi_debug(int argc, char *argv[])
|
||||
{
|
||||
int i, result = 0;
|
||||
const struct wifi_cmd_des *run_cmd = RT_NULL;
|
||||
|
||||
if (argc < 3)
|
||||
{
|
||||
wifi_debug_help(0, RT_NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
for (i = 0; i < sizeof(debug_tab) / sizeof(debug_tab[0]); i++)
|
||||
{
|
||||
if (rt_strcmp(debug_tab[i].cmd, argv[2]) == 0)
|
||||
{
|
||||
run_cmd = &debug_tab[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (run_cmd == RT_NULL)
|
||||
{
|
||||
wifi_debug_help(0, RT_NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (run_cmd->fun != RT_NULL)
|
||||
{
|
||||
result = run_cmd->fun(argc - 2, &argv[2]);
|
||||
}
|
||||
|
||||
if (result)
|
||||
{
|
||||
wifi_debug_help(argc - 2, &argv[2]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int wifi_msh(int argc, char *argv[])
|
||||
{
|
||||
int i, result = 0;
|
||||
const struct wifi_cmd_des *run_cmd = RT_NULL;
|
||||
|
||||
if (argc == 1)
|
||||
{
|
||||
wifi_help(argc, argv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* find fun */
|
||||
for (i = 0; i < sizeof(cmd_tab) / sizeof(cmd_tab[0]); i++)
|
||||
{
|
||||
if (rt_strcmp(cmd_tab[i].cmd, argv[1]) == 0)
|
||||
{
|
||||
run_cmd = &cmd_tab[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* not find fun, print help */
|
||||
if (run_cmd == RT_NULL)
|
||||
{
|
||||
wifi_help(argc, argv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* run fun */
|
||||
if (run_cmd->fun != RT_NULL)
|
||||
{
|
||||
result = run_cmd->fun(argc, argv);
|
||||
}
|
||||
|
||||
if (result)
|
||||
{
|
||||
wifi_help(argc, argv);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if defined(RT_USING_FINSH)
|
||||
MSH_CMD_EXPORT_ALIAS(wifi_msh, wifi, wifi command);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
974
riscv/rtthread/components/drivers/wlan/wlan_dev.c
Executable file
974
riscv/rtthread/components/drivers/wlan/wlan_dev.c
Executable file
@@ -0,0 +1,974 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-03 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rthw.h>
|
||||
#include <rtthread.h>
|
||||
#include <wlan_dev.h>
|
||||
#include <wlan_prot.h>
|
||||
|
||||
#define DBG_TAG "WLAN.dev"
|
||||
#ifdef RT_WLAN_DEV_DEBUG
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#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
|
||||
|
||||
#define WLAN_DEV_LOCK(_wlan) (rt_mutex_take(&(_wlan)->lock, RT_WAITING_FOREVER))
|
||||
#define WLAN_DEV_UNLOCK(_wlan) (rt_mutex_release(&(_wlan)->lock))
|
||||
|
||||
#if RT_WLAN_SSID_MAX_LENGTH < 1
|
||||
#error "SSID length is too short"
|
||||
#endif
|
||||
|
||||
#if RT_WLAN_BSSID_MAX_LENGTH < 1
|
||||
#error "BSSID length is too short"
|
||||
#endif
|
||||
|
||||
#if RT_WLAN_PASSWORD_MAX_LENGTH < 1
|
||||
#error "password length is too short"
|
||||
#endif
|
||||
|
||||
#if RT_WLAN_DEV_EVENT_NUM < 2
|
||||
#error "dev num Too little"
|
||||
#endif
|
||||
|
||||
rt_err_t rt_wlan_dev_init(struct rt_wlan_device *device, rt_wlan_mode_t mode)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
/* init wlan device */
|
||||
LOG_D("F:%s L:%d is run device:0x%08x mode:%d", __FUNCTION__, __LINE__, device, mode);
|
||||
if ((device == RT_NULL) || (mode >= RT_WLAN_MODE_MAX))
|
||||
{
|
||||
LOG_E("F:%s L:%d Parameter Wrongful device:0x%08x mode:%d", __FUNCTION__, __LINE__, device, 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)
|
||||
{
|
||||
LOG_E("L:%d wlan init failed", __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_MODE, (void *)&mode);
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
LOG_E("L:%d wlan config mode failed", __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
device->mode = mode;
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_connect(struct rt_wlan_device *device, struct rt_wlan_info *info, const char *password, int password_len)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
struct rt_sta_info sta_info;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
if (info == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
if ((password_len > RT_WLAN_PASSWORD_MAX_LENGTH) ||
|
||||
(info->ssid.len > RT_WLAN_SSID_MAX_LENGTH))
|
||||
{
|
||||
LOG_E("L:%d password or ssid is too long", __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
rt_memset(&sta_info, 0, sizeof(struct rt_sta_info));
|
||||
rt_memcpy(&sta_info.ssid, &info->ssid, sizeof(rt_wlan_ssid_t));
|
||||
rt_memcpy(sta_info.bssid, info->bssid, RT_WLAN_BSSID_MAX_LENGTH);
|
||||
if (password != RT_NULL)
|
||||
{
|
||||
rt_memcpy(sta_info.key.val, password, password_len);
|
||||
sta_info.key.len = password_len;
|
||||
}
|
||||
sta_info.channel = info->channel;
|
||||
sta_info.security = info->security;
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_JOIN, &sta_info);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_fast_connect(struct rt_wlan_device *device, struct rt_wlan_info *info, const char *password, int password_len)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
struct rt_wlan_buff buff = {0};
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
if (info == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
if ((password_len > RT_WLAN_PASSWORD_MAX_LENGTH) ||
|
||||
(info->ssid.len > RT_WLAN_SSID_MAX_LENGTH))
|
||||
{
|
||||
LOG_E("L:%d password or ssid is too long", __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
buff.len = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_FAST_CONNECT_INFO, buff.data);
|
||||
if(buff.len < 0)
|
||||
{
|
||||
LOG_D("L:%d Can't get fast connect info", __LINE__);
|
||||
return buff.len;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_FAST_CONNECT, &buff);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_disconnect(struct rt_wlan_device *device)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_DISCONNECT, RT_NULL);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_ap_start(struct rt_wlan_device *device, struct rt_wlan_info *info, const char *password, int password_len)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
struct rt_ap_info ap_info;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
if (info == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
if ((password_len > RT_WLAN_PASSWORD_MAX_LENGTH) ||
|
||||
(info->ssid.len > RT_WLAN_SSID_MAX_LENGTH))
|
||||
{
|
||||
LOG_E("L:%d password or ssid is too long", __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
rt_memset(&ap_info, 0, sizeof(struct rt_ap_info));
|
||||
rt_memcpy(&ap_info.ssid, &info->ssid, sizeof(rt_wlan_ssid_t));
|
||||
if (password != RT_NULL)
|
||||
{
|
||||
rt_memcpy(ap_info.key.val, password, password_len);
|
||||
}
|
||||
ap_info.key.len = password_len;
|
||||
ap_info.hidden = info->hidden;
|
||||
ap_info.channel = info->channel;
|
||||
ap_info.security = info->security;
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SOFTAP, &ap_info);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_ap_stop(struct rt_wlan_device *device)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_AP_STOP, RT_NULL);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_ap_deauth(struct rt_wlan_device *device, rt_uint8_t mac[6])
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_AP_DEAUTH, mac);
|
||||
return result;
|
||||
}
|
||||
|
||||
int rt_wlan_dev_get_rssi(struct rt_wlan_device *device)
|
||||
{
|
||||
int rssi = 0;
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
rt_set_errno(-RT_EIO);
|
||||
return 0;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_RSSI, &rssi);
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return rssi;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_get_mac(struct rt_wlan_device *device, rt_uint8_t mac[6])
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_MAC, &mac[0]);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_set_mac(struct rt_wlan_device *device, rt_uint8_t mac[6])
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SET_MAC, &mac[0]);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_set_powersave(struct rt_wlan_device *device, int level)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SET_POWERSAVE, &level);
|
||||
return result;
|
||||
}
|
||||
|
||||
int rt_wlan_dev_get_powersave(struct rt_wlan_device *device)
|
||||
{
|
||||
int level = -1;
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
rt_set_errno(-RT_EIO);
|
||||
return -1;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_POWERSAVE, &level);
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
}
|
||||
|
||||
return level;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_register_event_handler(struct rt_wlan_device *device, rt_wlan_dev_event_t event, rt_wlan_dev_event_handler handler, void *parameter)
|
||||
{
|
||||
int i = 0;
|
||||
rt_base_t level;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
if (event >= RT_WLAN_DEV_EVT_MAX)
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
for (i = 0; i < RT_WLAN_DEV_EVENT_NUM; i++)
|
||||
{
|
||||
if (device->handler_table[event][i].handler == RT_NULL)
|
||||
{
|
||||
device->handler_table[event][i].handler = handler;
|
||||
device->handler_table[event][i].parameter = parameter;
|
||||
rt_hw_interrupt_enable(level);
|
||||
return RT_EOK;
|
||||
}
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
/* No space found */
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_unregister_event_handler(struct rt_wlan_device *device, rt_wlan_dev_event_t event, rt_wlan_dev_event_handler handler)
|
||||
{
|
||||
int i = 0;
|
||||
rt_base_t level;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
if (event >= RT_WLAN_DEV_EVT_MAX)
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
for (i = 0; i < RT_WLAN_DEV_EVENT_NUM; i++)
|
||||
{
|
||||
if (device->handler_table[event][i].handler == handler)
|
||||
{
|
||||
rt_memset(&device->handler_table[event][i], 0, sizeof(struct rt_wlan_dev_event_desc));
|
||||
rt_hw_interrupt_enable(level);
|
||||
return RT_EOK;
|
||||
}
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
/* not find iteam */
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
void rt_wlan_dev_indicate_event_handle(struct rt_wlan_device *device, rt_wlan_dev_event_t event, struct rt_wlan_buff *buff)
|
||||
{
|
||||
void *parameter[RT_WLAN_DEV_EVENT_NUM] = {0};
|
||||
rt_wlan_dev_event_handler handler[RT_WLAN_DEV_EVENT_NUM] = {0};
|
||||
int i;
|
||||
rt_base_t level;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (event >= RT_WLAN_DEV_EVT_MAX)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/* get callback handle */
|
||||
level = rt_hw_interrupt_disable();
|
||||
for (i = 0; i < RT_WLAN_DEV_EVENT_NUM; i++)
|
||||
{
|
||||
handler[i] = device->handler_table[event][i].handler;
|
||||
parameter[i] = device->handler_table[event][i].parameter;
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
/* run callback */
|
||||
for (i = 0; i < RT_WLAN_DEV_EVENT_NUM; i++)
|
||||
{
|
||||
if (handler[i] != RT_NULL)
|
||||
{
|
||||
handler[i](device, event, buff, parameter[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_enter_promisc(struct rt_wlan_device *device)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
int enable = 1;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_CFG_PROMISC, &enable);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_exit_promisc(struct rt_wlan_device *device)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
int enable = 0;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_CFG_PROMISC, &enable);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_set_promisc_callback(struct rt_wlan_device *device, rt_wlan_pormisc_callback_t callback)
|
||||
{
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
device->pormisc_callback = callback;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
void rt_wlan_dev_promisc_handler(struct rt_wlan_device *device, void *data, int len)
|
||||
{
|
||||
rt_wlan_pormisc_callback_t callback;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
callback = device->pormisc_callback;
|
||||
|
||||
if (callback != RT_NULL)
|
||||
{
|
||||
callback(device, data, len);
|
||||
}
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_cfg_filter(struct rt_wlan_device *device, struct rt_wlan_filter *filter)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
if (filter == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_CFG_FILTER, filter);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_set_channel(struct rt_wlan_device *device, int channel)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
if (channel < 0)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SET_CHANNEL, &channel);
|
||||
return result;
|
||||
}
|
||||
|
||||
int rt_wlan_dev_get_channel(struct rt_wlan_device *device)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
int channel = -1;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
rt_set_errno(-RT_EIO);
|
||||
return -1;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_CHANNEL, &channel);
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return channel;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_set_country(struct rt_wlan_device *device, rt_country_code_t country_code)
|
||||
{
|
||||
int result = RT_EOK;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SET_COUNTRY, &country_code);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_country_code_t rt_wlan_dev_get_country(struct rt_wlan_device *device)
|
||||
{
|
||||
int result = RT_EOK;
|
||||
rt_country_code_t country_code = RT_COUNTRY_UNKNOWN;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
rt_set_errno(-RT_EIO);
|
||||
return RT_COUNTRY_UNKNOWN;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_GET_COUNTRY, &country_code);
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
return RT_COUNTRY_UNKNOWN;
|
||||
}
|
||||
|
||||
return country_code;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_scan(struct rt_wlan_device *device, struct rt_wlan_info *info)
|
||||
{
|
||||
struct rt_scan_info scan_info = { 0 };
|
||||
struct rt_scan_info *p_scan_info = RT_NULL;
|
||||
rt_err_t result = 0;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
if (info != RT_NULL)
|
||||
{
|
||||
if (info->ssid.len > RT_WLAN_SSID_MAX_LENGTH)
|
||||
{
|
||||
LOG_E("L:%d ssid is too long", __LINE__);
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
rt_memcpy(&scan_info.ssid, &info->ssid, sizeof(rt_wlan_ssid_t));
|
||||
rt_memcpy(scan_info.bssid, info->bssid, RT_WLAN_BSSID_MAX_LENGTH);
|
||||
if (info->channel > 0)
|
||||
{
|
||||
scan_info.channel_min = info->channel;
|
||||
scan_info.channel_max = info->channel;
|
||||
}
|
||||
else
|
||||
{
|
||||
scan_info.channel_min = -1;
|
||||
scan_info.channel_max = -1;
|
||||
}
|
||||
scan_info.passive = info->hidden ? RT_TRUE : RT_FALSE;
|
||||
p_scan_info = &scan_info;
|
||||
}
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SCAN, p_scan_info);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_scan_stop(struct rt_wlan_device *device)
|
||||
{
|
||||
rt_err_t result = 0;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_SCAN_STOP, RT_NULL);
|
||||
return result;
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_enter_mgnt_filter(struct rt_wlan_device *device)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
int enable = 1;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_CFG_MGNT_FILTER, &enable);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_exit_mgnt_filter(struct rt_wlan_device *device)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
int enable = 0;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
result = rt_device_control(RT_DEVICE(device), RT_WLAN_CMD_CFG_MGNT_FILTER, &enable);
|
||||
return result;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_set_mgnt_filter_callback(struct rt_wlan_device *device, rt_wlan_mgnt_filter_callback_t callback)
|
||||
{
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
device->mgnt_filter_callback = callback;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
void rt_wlan_dev_mgnt_filter_handler(struct rt_wlan_device *device, void *data, int len)
|
||||
{
|
||||
rt_wlan_mgnt_filter_callback_t callback;
|
||||
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
callback = device->mgnt_filter_callback;
|
||||
|
||||
if (callback != RT_NULL)
|
||||
{
|
||||
callback(device, data, len);
|
||||
}
|
||||
}
|
||||
|
||||
int rt_wlan_dev_send_raw_frame(struct rt_wlan_device *device, void *buff, int len)
|
||||
{
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
if (device->ops->wlan_send_raw_frame)
|
||||
{
|
||||
return device->ops->wlan_send_raw_frame(device, buff, len);
|
||||
}
|
||||
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
static rt_err_t _rt_wlan_dev_init(rt_device_t dev)
|
||||
{
|
||||
struct rt_wlan_device *wlan = (struct rt_wlan_device *)dev;
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
rt_mutex_init(&wlan->lock, "wlan_dev", RT_IPC_FLAG_PRIO);
|
||||
|
||||
if (wlan->ops->wlan_init)
|
||||
result = wlan->ops->wlan_init(wlan);
|
||||
|
||||
if (result == RT_EOK)
|
||||
{
|
||||
LOG_I("wlan init success");
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_I("wlan init failed");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t _rt_wlan_dev_control(rt_device_t dev, int cmd, void *args)
|
||||
{
|
||||
struct rt_wlan_device *wlan = (struct rt_wlan_device *)dev;
|
||||
rt_err_t err = RT_EOK;
|
||||
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
|
||||
WLAN_DEV_LOCK(wlan);
|
||||
|
||||
switch (cmd)
|
||||
{
|
||||
case RT_WLAN_CMD_MODE:
|
||||
{
|
||||
rt_wlan_mode_t mode = *((rt_wlan_mode_t *)args);
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_MODE, "RT_WLAN_CMD_MODE");
|
||||
if (wlan->ops->wlan_mode)
|
||||
err = wlan->ops->wlan_mode(wlan, mode);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_SCAN:
|
||||
{
|
||||
struct rt_scan_info *scan_info = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SCAN, "RT_WLAN_CMD_SCAN");
|
||||
if (wlan->ops->wlan_scan)
|
||||
err = wlan->ops->wlan_scan(wlan, scan_info);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_JOIN:
|
||||
{
|
||||
struct rt_sta_info *sta_info = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_JOIN, "RT_WLAN_CMD_JOIN");
|
||||
if (wlan->ops->wlan_join)
|
||||
err = wlan->ops->wlan_join(wlan, sta_info);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_SOFTAP:
|
||||
{
|
||||
struct rt_ap_info *ap_info = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SOFTAP, "RT_WLAN_CMD_SOFTAP");
|
||||
if (wlan->ops->wlan_softap)
|
||||
err = wlan->ops->wlan_softap(wlan, ap_info);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_DISCONNECT:
|
||||
{
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_DISCONNECT, "RT_WLAN_CMD_DISCONNECT");
|
||||
if (wlan->ops->wlan_disconnect)
|
||||
err = wlan->ops->wlan_disconnect(wlan);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_AP_STOP:
|
||||
{
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_AP_STOP, "RT_WLAN_CMD_AP_STOP");
|
||||
if (wlan->ops->wlan_ap_stop)
|
||||
err = wlan->ops->wlan_ap_stop(wlan);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_AP_DEAUTH:
|
||||
{
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_AP_DEAUTH, "RT_WLAN_CMD_AP_DEAUTH");
|
||||
if (wlan->ops->wlan_ap_deauth)
|
||||
err = wlan->ops->wlan_ap_deauth(wlan, args);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_SCAN_STOP:
|
||||
{
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SCAN_STOP, "RT_WLAN_CMD_SCAN_STOP");
|
||||
if (wlan->ops->wlan_scan_stop)
|
||||
err = wlan->ops->wlan_scan_stop(wlan);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_GET_RSSI:
|
||||
{
|
||||
int *rssi = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_RSSI, "RT_WLAN_CMD_GET_RSSI");
|
||||
if (wlan->ops->wlan_get_rssi)
|
||||
*rssi = wlan->ops->wlan_get_rssi(wlan);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_SET_POWERSAVE:
|
||||
{
|
||||
int level = *((int *)args);
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SET_POWERSAVE, "RT_WLAN_CMD_SET_POWERSAVE");
|
||||
if (wlan->ops->wlan_set_powersave)
|
||||
err = wlan->ops->wlan_set_powersave(wlan, level);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_GET_POWERSAVE:
|
||||
{
|
||||
int *level = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_POWERSAVE, "RT_WLAN_CMD_GET_POWERSAVE");
|
||||
if (wlan->ops->wlan_get_powersave)
|
||||
*level = wlan->ops->wlan_get_powersave(wlan);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_CFG_PROMISC:
|
||||
{
|
||||
rt_bool_t start = *((rt_bool_t *)args);
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_CFG_PROMISC, "RT_WLAN_CMD_CFG_PROMISC");
|
||||
if (wlan->ops->wlan_cfg_promisc)
|
||||
err = wlan->ops->wlan_cfg_promisc(wlan, start);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_CFG_FILTER:
|
||||
{
|
||||
struct rt_wlan_filter *filter = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_CFG_FILTER, "RT_WLAN_CMD_CFG_FILTER");
|
||||
if (wlan->ops->wlan_cfg_filter)
|
||||
err = wlan->ops->wlan_cfg_filter(wlan, filter);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_CFG_MGNT_FILTER:
|
||||
{
|
||||
rt_bool_t start = *((rt_bool_t *)args);
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_CFG_MGNT_FILTER, "RT_WLAN_CMD_CFG_MGNT_FILTER");
|
||||
if (wlan->ops->wlan_cfg_mgnt_filter)
|
||||
err = wlan->ops->wlan_cfg_mgnt_filter(wlan, start);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_SET_CHANNEL:
|
||||
{
|
||||
int channel = *(int *)args;
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SET_CHANNEL, "RT_WLAN_CMD_SET_CHANNEL");
|
||||
if (wlan->ops->wlan_set_channel)
|
||||
err = wlan->ops->wlan_set_channel(wlan, channel);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_GET_CHANNEL:
|
||||
{
|
||||
int *channel = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_CHANNEL, "RT_WLAN_CMD_GET_CHANNEL");
|
||||
if (wlan->ops->wlan_get_channel)
|
||||
*channel = wlan->ops->wlan_get_channel(wlan);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_SET_COUNTRY:
|
||||
{
|
||||
rt_country_code_t country = *(rt_country_code_t *)args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SET_COUNTRY, "RT_WLAN_CMD_SET_COUNTRY");
|
||||
if (wlan->ops->wlan_set_country)
|
||||
err = wlan->ops->wlan_set_country(wlan, country);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_GET_COUNTRY:
|
||||
{
|
||||
rt_country_code_t *country = args;
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_COUNTRY, "RT_WLAN_CMD_GET_COUNTRY");
|
||||
if (wlan->ops->wlan_get_country)
|
||||
*country = wlan->ops->wlan_get_country(wlan);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_SET_MAC:
|
||||
{
|
||||
rt_uint8_t *mac = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_SET_MAC, "RT_WLAN_CMD_SET_MAC");
|
||||
if (wlan->ops->wlan_set_mac)
|
||||
err = wlan->ops->wlan_set_mac(wlan, mac);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_GET_MAC:
|
||||
{
|
||||
rt_uint8_t *mac = args;
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_MAC, "RT_WLAN_CMD_GET_MAC");
|
||||
if (wlan->ops->wlan_get_mac)
|
||||
err = wlan->ops->wlan_get_mac(wlan, mac);
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_GET_FAST_CONNECT_INFO:
|
||||
{
|
||||
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_GET_FAST_INFO, "RT_WLAN_CMD_GET_FAST_INFO");
|
||||
if (wlan->ops->wlan_get_fast_info)
|
||||
{
|
||||
err = wlan->ops->wlan_get_fast_info(args);
|
||||
}
|
||||
else
|
||||
{
|
||||
err = -RT_EEMPTY;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_CMD_FAST_CONNECT:
|
||||
{
|
||||
struct rt_wlan_buff *buff = (struct rt_wlan_buff *)args;
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, RT_WLAN_CMD_FAST_CONNECT, "RT_WLAN_CMD_FAST_CONNECT");
|
||||
if (wlan->ops->wlan_get_fast_info)
|
||||
{
|
||||
err = wlan->ops->wlan_fast_connect(buff->data,buff->len);
|
||||
}
|
||||
else
|
||||
{
|
||||
err = -RT_EEMPTY;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
LOG_D("%s %d cmd[%d]:%s run......", __FUNCTION__, __LINE__, -1, "UNKUOWN");
|
||||
break;
|
||||
}
|
||||
|
||||
WLAN_DEV_UNLOCK(wlan);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops wlan_ops =
|
||||
{
|
||||
_rt_wlan_dev_init,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
_rt_wlan_dev_control
|
||||
};
|
||||
#endif
|
||||
|
||||
rt_err_t rt_wlan_dev_register(struct rt_wlan_device *wlan, const char *name, const struct rt_wlan_dev_ops *ops, rt_uint32_t flag, void *user_data)
|
||||
{
|
||||
rt_err_t err = RT_EOK;
|
||||
|
||||
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
|
||||
wlan->device.init = _rt_wlan_dev_init;
|
||||
wlan->device.open = RT_NULL;
|
||||
wlan->device.close = RT_NULL;
|
||||
wlan->device.read = RT_NULL;
|
||||
wlan->device.write = RT_NULL;
|
||||
wlan->device.control = _rt_wlan_dev_control;
|
||||
#endif
|
||||
|
||||
wlan->device.user_data = RT_NULL;
|
||||
|
||||
wlan->device.type = RT_Device_Class_NetIf;
|
||||
|
||||
wlan->ops = ops;
|
||||
wlan->user_data = user_data;
|
||||
|
||||
wlan->flags = flag;
|
||||
err = rt_device_register(&wlan->device, name, RT_DEVICE_FLAG_RDWR);
|
||||
|
||||
LOG_D("F:%s L:%d run", __FUNCTION__, __LINE__);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
#endif
|
||||
604
riscv/rtthread/components/drivers/wlan/wlan_dev.h
Executable file
604
riscv/rtthread/components/drivers/wlan/wlan_dev.h
Executable file
@@ -0,0 +1,604 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-03 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __WLAN_DEVICE_H__
|
||||
#define __WLAN_DEVICE_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_WLAN_NONE,
|
||||
RT_WLAN_STATION,
|
||||
RT_WLAN_AP,
|
||||
RT_WLAN_MODE_MAX
|
||||
} rt_wlan_mode_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_WLAN_CMD_MODE = 0x10,
|
||||
RT_WLAN_CMD_SCAN, /* trigger scanning (list cells) */
|
||||
RT_WLAN_CMD_JOIN,
|
||||
RT_WLAN_CMD_SOFTAP, /* start soft-AP */
|
||||
RT_WLAN_CMD_DISCONNECT,
|
||||
RT_WLAN_CMD_AP_STOP, /* stop soft-AP */
|
||||
RT_WLAN_CMD_AP_DEAUTH,
|
||||
RT_WLAN_CMD_SCAN_STOP,
|
||||
RT_WLAN_CMD_GET_RSSI, /* get sensitivity (dBm) */
|
||||
RT_WLAN_CMD_SET_POWERSAVE,
|
||||
RT_WLAN_CMD_GET_POWERSAVE,
|
||||
RT_WLAN_CMD_CFG_PROMISC, /* start/stop minitor */
|
||||
RT_WLAN_CMD_CFG_FILTER, /* start/stop frame filter */
|
||||
RT_WLAN_CMD_CFG_MGNT_FILTER, /* start/stop management frame filter */
|
||||
RT_WLAN_CMD_SET_CHANNEL,
|
||||
RT_WLAN_CMD_GET_CHANNEL,
|
||||
RT_WLAN_CMD_SET_COUNTRY,
|
||||
RT_WLAN_CMD_GET_COUNTRY,
|
||||
RT_WLAN_CMD_SET_MAC,
|
||||
RT_WLAN_CMD_GET_MAC,
|
||||
RT_WLAN_CMD_GET_FAST_CONNECT_INFO,
|
||||
RT_WLAN_CMD_FAST_CONNECT,
|
||||
} rt_wlan_cmd_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_WLAN_DEV_EVT_INIT_DONE = 0,
|
||||
RT_WLAN_DEV_EVT_CONNECT,
|
||||
RT_WLAN_DEV_EVT_CONNECT_FAIL,
|
||||
RT_WLAN_DEV_EVT_DISCONNECT,
|
||||
RT_WLAN_DEV_EVT_AP_START,
|
||||
RT_WLAN_DEV_EVT_AP_STOP,
|
||||
RT_WLAN_DEV_EVT_AP_ASSOCIATED,
|
||||
RT_WLAN_DEV_EVT_AP_DISASSOCIATED,
|
||||
RT_WLAN_DEV_EVT_AP_ASSOCIATE_FAILED,
|
||||
RT_WLAN_DEV_EVT_SCAN_REPORT,
|
||||
RT_WLAN_DEV_EVT_SCAN_DONE,
|
||||
RT_WLAN_DEV_EVT_MAX,
|
||||
} rt_wlan_dev_event_t;
|
||||
|
||||
#define SHARED_ENABLED 0x00008000
|
||||
#define WPA_SECURITY 0x00200000
|
||||
#define WPA2_SECURITY 0x00400000
|
||||
#define WPS_ENABLED 0x10000000
|
||||
#define WEP_ENABLED 0x0001
|
||||
#define TKIP_ENABLED 0x0002
|
||||
#define AES_ENABLED 0x0004
|
||||
#define WSEC_SWFLAG 0x0008
|
||||
|
||||
#define RT_WLAN_FLAG_STA_ONLY (0x1 << 0)
|
||||
#define RT_WLAN_FLAG_AP_ONLY (0x1 << 1)
|
||||
|
||||
#ifndef RT_WLAN_SSID_MAX_LENGTH
|
||||
#define RT_WLAN_SSID_MAX_LENGTH (32) /* SSID MAX LEN */
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_BSSID_MAX_LENGTH
|
||||
#define RT_WLAN_BSSID_MAX_LENGTH (6) /* BSSID MAX LEN (default is 6) */
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_PASSWORD_MAX_LENGTH
|
||||
#define RT_WLAN_PASSWORD_MAX_LENGTH (32) /* PASSWORD MAX LEN*/
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_DEV_EVENT_NUM
|
||||
#define RT_WLAN_DEV_EVENT_NUM (2) /* EVENT GROUP MAX NUM */
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Enumeration of Wi-Fi security modes
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
SECURITY_OPEN = 0, /* Open security */
|
||||
SECURITY_WEP_PSK = WEP_ENABLED, /* WEP Security with open authentication */
|
||||
SECURITY_WEP_SHARED = (WEP_ENABLED | SHARED_ENABLED), /* WEP Security with shared authentication */
|
||||
SECURITY_WPA_TKIP_PSK = (WPA_SECURITY | TKIP_ENABLED), /* WPA Security with TKIP */
|
||||
SECURITY_WPA_AES_PSK = (WPA_SECURITY | AES_ENABLED), /* WPA Security with AES */
|
||||
SECURITY_WPA2_AES_PSK = (WPA2_SECURITY | AES_ENABLED), /* WPA2 Security with AES */
|
||||
SECURITY_WPA2_TKIP_PSK = (WPA2_SECURITY | TKIP_ENABLED), /* WPA2 Security with TKIP */
|
||||
SECURITY_WPA2_MIXED_PSK = (WPA2_SECURITY | AES_ENABLED | TKIP_ENABLED), /* WPA2 Security with AES & TKIP */
|
||||
SECURITY_WPS_OPEN = WPS_ENABLED, /* WPS with open security */
|
||||
SECURITY_WPS_SECURE = (WPS_ENABLED | AES_ENABLED), /* WPS with AES security */
|
||||
SECURITY_UNKNOWN = -1, /* May be returned by scan function if security is unknown.
|
||||
Do not pass this to the join function! */
|
||||
} rt_wlan_security_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_802_11_BAND_5GHZ = 0, /* Denotes 5GHz radio band */
|
||||
RT_802_11_BAND_2_4GHZ = 1, /* Denotes 2.4GHz radio band */
|
||||
RT_802_11_BAND_UNKNOWN = 0x7fffffff, /* unknown */
|
||||
} rt_802_11_band_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_COUNTRY_AFGHANISTAN,
|
||||
RT_COUNTRY_ALBANIA,
|
||||
RT_COUNTRY_ALGERIA,
|
||||
RT_COUNTRY_AMERICAN_SAMOA,
|
||||
RT_COUNTRY_ANGOLA,
|
||||
RT_COUNTRY_ANGUILLA,
|
||||
RT_COUNTRY_ANTIGUA_AND_BARBUDA,
|
||||
RT_COUNTRY_ARGENTINA,
|
||||
RT_COUNTRY_ARMENIA,
|
||||
RT_COUNTRY_ARUBA,
|
||||
RT_COUNTRY_AUSTRALIA,
|
||||
RT_COUNTRY_AUSTRIA,
|
||||
RT_COUNTRY_AZERBAIJAN,
|
||||
RT_COUNTRY_BAHAMAS,
|
||||
RT_COUNTRY_BAHRAIN,
|
||||
RT_COUNTRY_BAKER_ISLAND,
|
||||
RT_COUNTRY_BANGLADESH,
|
||||
RT_COUNTRY_BARBADOS,
|
||||
RT_COUNTRY_BELARUS,
|
||||
RT_COUNTRY_BELGIUM,
|
||||
RT_COUNTRY_BELIZE,
|
||||
RT_COUNTRY_BENIN,
|
||||
RT_COUNTRY_BERMUDA,
|
||||
RT_COUNTRY_BHUTAN,
|
||||
RT_COUNTRY_BOLIVIA,
|
||||
RT_COUNTRY_BOSNIA_AND_HERZEGOVINA,
|
||||
RT_COUNTRY_BOTSWANA,
|
||||
RT_COUNTRY_BRAZIL,
|
||||
RT_COUNTRY_BRITISH_INDIAN_OCEAN_TERRITORY,
|
||||
RT_COUNTRY_BRUNEI_DARUSSALAM,
|
||||
RT_COUNTRY_BULGARIA,
|
||||
RT_COUNTRY_BURKINA_FASO,
|
||||
RT_COUNTRY_BURUNDI,
|
||||
RT_COUNTRY_CAMBODIA,
|
||||
RT_COUNTRY_CAMEROON,
|
||||
RT_COUNTRY_CANADA,
|
||||
RT_COUNTRY_CAPE_VERDE,
|
||||
RT_COUNTRY_CAYMAN_ISLANDS,
|
||||
RT_COUNTRY_CENTRAL_AFRICAN_REPUBLIC,
|
||||
RT_COUNTRY_CHAD,
|
||||
RT_COUNTRY_CHILE,
|
||||
RT_COUNTRY_CHINA,
|
||||
RT_COUNTRY_CHRISTMAS_ISLAND,
|
||||
RT_COUNTRY_COLOMBIA,
|
||||
RT_COUNTRY_COMOROS,
|
||||
RT_COUNTRY_CONGO,
|
||||
RT_COUNTRY_CONGO_THE_DEMOCRATIC_REPUBLIC_OF_THE,
|
||||
RT_COUNTRY_COSTA_RICA,
|
||||
RT_COUNTRY_COTE_DIVOIRE,
|
||||
RT_COUNTRY_CROATIA,
|
||||
RT_COUNTRY_CUBA,
|
||||
RT_COUNTRY_CYPRUS,
|
||||
RT_COUNTRY_CZECH_REPUBLIC,
|
||||
RT_COUNTRY_DENMARK,
|
||||
RT_COUNTRY_DJIBOUTI,
|
||||
RT_COUNTRY_DOMINICA,
|
||||
RT_COUNTRY_DOMINICAN_REPUBLIC,
|
||||
RT_COUNTRY_DOWN_UNDER,
|
||||
RT_COUNTRY_ECUADOR,
|
||||
RT_COUNTRY_EGYPT,
|
||||
RT_COUNTRY_EL_SALVADOR,
|
||||
RT_COUNTRY_EQUATORIAL_GUINEA,
|
||||
RT_COUNTRY_ERITREA,
|
||||
RT_COUNTRY_ESTONIA,
|
||||
RT_COUNTRY_ETHIOPIA,
|
||||
RT_COUNTRY_FALKLAND_ISLANDS_MALVINAS,
|
||||
RT_COUNTRY_FAROE_ISLANDS,
|
||||
RT_COUNTRY_FIJI,
|
||||
RT_COUNTRY_FINLAND,
|
||||
RT_COUNTRY_FRANCE,
|
||||
RT_COUNTRY_FRENCH_GUINA,
|
||||
RT_COUNTRY_FRENCH_POLYNESIA,
|
||||
RT_COUNTRY_FRENCH_SOUTHERN_TERRITORIES,
|
||||
RT_COUNTRY_GABON,
|
||||
RT_COUNTRY_GAMBIA,
|
||||
RT_COUNTRY_GEORGIA,
|
||||
RT_COUNTRY_GERMANY,
|
||||
RT_COUNTRY_GHANA,
|
||||
RT_COUNTRY_GIBRALTAR,
|
||||
RT_COUNTRY_GREECE,
|
||||
RT_COUNTRY_GRENADA,
|
||||
RT_COUNTRY_GUADELOUPE,
|
||||
RT_COUNTRY_GUAM,
|
||||
RT_COUNTRY_GUATEMALA,
|
||||
RT_COUNTRY_GUERNSEY,
|
||||
RT_COUNTRY_GUINEA,
|
||||
RT_COUNTRY_GUINEA_BISSAU,
|
||||
RT_COUNTRY_GUYANA,
|
||||
RT_COUNTRY_HAITI,
|
||||
RT_COUNTRY_HOLY_SEE_VATICAN_CITY_STATE,
|
||||
RT_COUNTRY_HONDURAS,
|
||||
RT_COUNTRY_HONG_KONG,
|
||||
RT_COUNTRY_HUNGARY,
|
||||
RT_COUNTRY_ICELAND,
|
||||
RT_COUNTRY_INDIA,
|
||||
RT_COUNTRY_INDONESIA,
|
||||
RT_COUNTRY_IRAN_ISLAMIC_REPUBLIC_OF,
|
||||
RT_COUNTRY_IRAQ,
|
||||
RT_COUNTRY_IRELAND,
|
||||
RT_COUNTRY_ISRAEL,
|
||||
RT_COUNTRY_ITALY,
|
||||
RT_COUNTRY_JAMAICA,
|
||||
RT_COUNTRY_JAPAN,
|
||||
RT_COUNTRY_JERSEY,
|
||||
RT_COUNTRY_JORDAN,
|
||||
RT_COUNTRY_KAZAKHSTAN,
|
||||
RT_COUNTRY_KENYA,
|
||||
RT_COUNTRY_KIRIBATI,
|
||||
RT_COUNTRY_KOREA_REPUBLIC_OF,
|
||||
RT_COUNTRY_KOSOVO,
|
||||
RT_COUNTRY_KUWAIT,
|
||||
RT_COUNTRY_KYRGYZSTAN,
|
||||
RT_COUNTRY_LAO_PEOPLES_DEMOCRATIC_REPUBIC,
|
||||
RT_COUNTRY_LATVIA,
|
||||
RT_COUNTRY_LEBANON,
|
||||
RT_COUNTRY_LESOTHO,
|
||||
RT_COUNTRY_LIBERIA,
|
||||
RT_COUNTRY_LIBYAN_ARAB_JAMAHIRIYA,
|
||||
RT_COUNTRY_LIECHTENSTEIN,
|
||||
RT_COUNTRY_LITHUANIA,
|
||||
RT_COUNTRY_LUXEMBOURG,
|
||||
RT_COUNTRY_MACAO,
|
||||
RT_COUNTRY_MACEDONIA_FORMER_YUGOSLAV_REPUBLIC_OF,
|
||||
RT_COUNTRY_MADAGASCAR,
|
||||
RT_COUNTRY_MALAWI,
|
||||
RT_COUNTRY_MALAYSIA,
|
||||
RT_COUNTRY_MALDIVES,
|
||||
RT_COUNTRY_MALI,
|
||||
RT_COUNTRY_MALTA,
|
||||
RT_COUNTRY_MAN_ISLE_OF,
|
||||
RT_COUNTRY_MARTINIQUE,
|
||||
RT_COUNTRY_MAURITANIA,
|
||||
RT_COUNTRY_MAURITIUS,
|
||||
RT_COUNTRY_MAYOTTE,
|
||||
RT_COUNTRY_MEXICO,
|
||||
RT_COUNTRY_MICRONESIA_FEDERATED_STATES_OF,
|
||||
RT_COUNTRY_MOLDOVA_REPUBLIC_OF,
|
||||
RT_COUNTRY_MONACO,
|
||||
RT_COUNTRY_MONGOLIA,
|
||||
RT_COUNTRY_MONTENEGRO,
|
||||
RT_COUNTRY_MONTSERRAT,
|
||||
RT_COUNTRY_MOROCCO,
|
||||
RT_COUNTRY_MOZAMBIQUE,
|
||||
RT_COUNTRY_MYANMAR,
|
||||
RT_COUNTRY_NAMIBIA,
|
||||
RT_COUNTRY_NAURU,
|
||||
RT_COUNTRY_NEPAL,
|
||||
RT_COUNTRY_NETHERLANDS,
|
||||
RT_COUNTRY_NETHERLANDS_ANTILLES,
|
||||
RT_COUNTRY_NEW_CALEDONIA,
|
||||
RT_COUNTRY_NEW_ZEALAND,
|
||||
RT_COUNTRY_NICARAGUA,
|
||||
RT_COUNTRY_NIGER,
|
||||
RT_COUNTRY_NIGERIA,
|
||||
RT_COUNTRY_NORFOLK_ISLAND,
|
||||
RT_COUNTRY_NORTHERN_MARIANA_ISLANDS,
|
||||
RT_COUNTRY_NORWAY,
|
||||
RT_COUNTRY_OMAN,
|
||||
RT_COUNTRY_PAKISTAN,
|
||||
RT_COUNTRY_PALAU,
|
||||
RT_COUNTRY_PANAMA,
|
||||
RT_COUNTRY_PAPUA_NEW_GUINEA,
|
||||
RT_COUNTRY_PARAGUAY,
|
||||
RT_COUNTRY_PERU,
|
||||
RT_COUNTRY_PHILIPPINES,
|
||||
RT_COUNTRY_POLAND,
|
||||
RT_COUNTRY_PORTUGAL,
|
||||
RT_COUNTRY_PUETO_RICO,
|
||||
RT_COUNTRY_QATAR,
|
||||
RT_COUNTRY_REUNION,
|
||||
RT_COUNTRY_ROMANIA,
|
||||
RT_COUNTRY_RUSSIAN_FEDERATION,
|
||||
RT_COUNTRY_RWANDA,
|
||||
RT_COUNTRY_SAINT_KITTS_AND_NEVIS,
|
||||
RT_COUNTRY_SAINT_LUCIA,
|
||||
RT_COUNTRY_SAINT_PIERRE_AND_MIQUELON,
|
||||
RT_COUNTRY_SAINT_VINCENT_AND_THE_GRENADINES,
|
||||
RT_COUNTRY_SAMOA,
|
||||
RT_COUNTRY_SANIT_MARTIN_SINT_MARTEEN,
|
||||
RT_COUNTRY_SAO_TOME_AND_PRINCIPE,
|
||||
RT_COUNTRY_SAUDI_ARABIA,
|
||||
RT_COUNTRY_SENEGAL,
|
||||
RT_COUNTRY_SERBIA,
|
||||
RT_COUNTRY_SEYCHELLES,
|
||||
RT_COUNTRY_SIERRA_LEONE,
|
||||
RT_COUNTRY_SINGAPORE,
|
||||
RT_COUNTRY_SLOVAKIA,
|
||||
RT_COUNTRY_SLOVENIA,
|
||||
RT_COUNTRY_SOLOMON_ISLANDS,
|
||||
RT_COUNTRY_SOMALIA,
|
||||
RT_COUNTRY_SOUTH_AFRICA,
|
||||
RT_COUNTRY_SPAIN,
|
||||
RT_COUNTRY_SRI_LANKA,
|
||||
RT_COUNTRY_SURINAME,
|
||||
RT_COUNTRY_SWAZILAND,
|
||||
RT_COUNTRY_SWEDEN,
|
||||
RT_COUNTRY_SWITZERLAND,
|
||||
RT_COUNTRY_SYRIAN_ARAB_REPUBLIC,
|
||||
RT_COUNTRY_TAIWAN_PROVINCE_OF_CHINA,
|
||||
RT_COUNTRY_TAJIKISTAN,
|
||||
RT_COUNTRY_TANZANIA_UNITED_REPUBLIC_OF,
|
||||
RT_COUNTRY_THAILAND,
|
||||
RT_COUNTRY_TOGO,
|
||||
RT_COUNTRY_TONGA,
|
||||
RT_COUNTRY_TRINIDAD_AND_TOBAGO,
|
||||
RT_COUNTRY_TUNISIA,
|
||||
RT_COUNTRY_TURKEY,
|
||||
RT_COUNTRY_TURKMENISTAN,
|
||||
RT_COUNTRY_TURKS_AND_CAICOS_ISLANDS,
|
||||
RT_COUNTRY_TUVALU,
|
||||
RT_COUNTRY_UGANDA,
|
||||
RT_COUNTRY_UKRAINE,
|
||||
RT_COUNTRY_UNITED_ARAB_EMIRATES,
|
||||
RT_COUNTRY_UNITED_KINGDOM,
|
||||
RT_COUNTRY_UNITED_STATES,
|
||||
RT_COUNTRY_UNITED_STATES_REV4,
|
||||
RT_COUNTRY_UNITED_STATES_NO_DFS,
|
||||
RT_COUNTRY_UNITED_STATES_MINOR_OUTLYING_ISLANDS,
|
||||
RT_COUNTRY_URUGUAY,
|
||||
RT_COUNTRY_UZBEKISTAN,
|
||||
RT_COUNTRY_VANUATU,
|
||||
RT_COUNTRY_VENEZUELA,
|
||||
RT_COUNTRY_VIET_NAM,
|
||||
RT_COUNTRY_VIRGIN_ISLANDS_BRITISH,
|
||||
RT_COUNTRY_VIRGIN_ISLANDS_US,
|
||||
RT_COUNTRY_WALLIS_AND_FUTUNA,
|
||||
RT_COUNTRY_WEST_BANK,
|
||||
RT_COUNTRY_WESTERN_SAHARA,
|
||||
RT_COUNTRY_WORLD_WIDE_XX,
|
||||
RT_COUNTRY_YEMEN,
|
||||
RT_COUNTRY_ZAMBIA,
|
||||
RT_COUNTRY_ZIMBABWE,
|
||||
RT_COUNTRY_UNKNOWN
|
||||
} rt_country_code_t;
|
||||
|
||||
struct rt_wlan_device;
|
||||
struct rt_wlan_buff;
|
||||
|
||||
typedef void (*rt_wlan_dev_event_handler)(struct rt_wlan_device *device, rt_wlan_dev_event_t event, struct rt_wlan_buff *buff, void *parameter);
|
||||
|
||||
typedef void (*rt_wlan_pormisc_callback_t)(struct rt_wlan_device *device, void *data, int len);
|
||||
|
||||
typedef void (*rt_wlan_mgnt_filter_callback_t)(struct rt_wlan_device *device, void *data, int len);
|
||||
|
||||
struct rt_wlan_ssid
|
||||
{
|
||||
rt_uint8_t len;
|
||||
rt_uint8_t val[RT_WLAN_SSID_MAX_LENGTH + 1];
|
||||
};
|
||||
typedef struct rt_wlan_ssid rt_wlan_ssid_t;
|
||||
|
||||
struct rt_wlan_key
|
||||
{
|
||||
rt_uint8_t len;
|
||||
rt_uint8_t val[RT_WLAN_PASSWORD_MAX_LENGTH + 1];
|
||||
};
|
||||
typedef struct rt_wlan_key rt_wlan_key_t;
|
||||
|
||||
#define INVALID_INFO(_info) do { \
|
||||
rt_memset((_info), 0, sizeof(struct rt_wlan_info)); \
|
||||
(_info)->band = RT_802_11_BAND_UNKNOWN; \
|
||||
(_info)->security = SECURITY_UNKNOWN; \
|
||||
(_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 */
|
||||
rt_wlan_security_t security;
|
||||
/* 2.4G/5G */
|
||||
rt_802_11_band_t band;
|
||||
/* maximal data rate */
|
||||
rt_uint32_t datarate;
|
||||
/* radio channel */
|
||||
rt_int16_t channel;
|
||||
/* signal strength */
|
||||
rt_int16_t rssi;
|
||||
/* ssid */
|
||||
rt_wlan_ssid_t ssid;
|
||||
/* hwaddr */
|
||||
rt_uint8_t bssid[RT_WLAN_BSSID_MAX_LENGTH];
|
||||
rt_uint8_t hidden;
|
||||
};
|
||||
|
||||
struct rt_wlan_buff
|
||||
{
|
||||
void *data;
|
||||
rt_int32_t len;
|
||||
};
|
||||
|
||||
struct rt_filter_pattern
|
||||
{
|
||||
rt_uint16_t offset; /* Offset in bytes to start filtering (referenced to the start of the ethernet packet) */
|
||||
rt_uint16_t mask_size; /* Size of the mask in bytes */
|
||||
rt_uint8_t *mask; /* Pattern mask bytes to be ANDed with the pattern eg. "\xff00" (must be in network byte order) */
|
||||
rt_uint8_t *pattern; /* Pattern bytes used to filter eg. "\x0800" (must be in network byte order) */
|
||||
};
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_POSITIVE_MATCHING = 0, /* Receive the data matching with this pattern and discard the other data */
|
||||
RT_NEGATIVE_MATCHING = 1 /* Discard the data matching with this pattern and receive the other data */
|
||||
} rt_filter_rule_t;
|
||||
|
||||
struct rt_wlan_filter
|
||||
{
|
||||
struct rt_filter_pattern patt;
|
||||
rt_filter_rule_t rule;
|
||||
rt_uint8_t enable;
|
||||
};
|
||||
|
||||
struct rt_wlan_dev_event_desc
|
||||
{
|
||||
rt_wlan_dev_event_handler handler;
|
||||
void *parameter;
|
||||
};
|
||||
|
||||
struct rt_wlan_device
|
||||
{
|
||||
struct rt_device device;
|
||||
rt_wlan_mode_t mode;
|
||||
struct rt_mutex lock;
|
||||
struct rt_wlan_dev_event_desc handler_table[RT_WLAN_DEV_EVT_MAX][RT_WLAN_DEV_EVENT_NUM];
|
||||
rt_wlan_pormisc_callback_t pormisc_callback;
|
||||
rt_wlan_mgnt_filter_callback_t mgnt_filter_callback;
|
||||
const struct rt_wlan_dev_ops *ops;
|
||||
rt_uint32_t flags;
|
||||
struct netdev *netdev;
|
||||
void *prot;
|
||||
void *user_data;
|
||||
};
|
||||
|
||||
struct rt_sta_info
|
||||
{
|
||||
rt_wlan_ssid_t ssid;
|
||||
rt_wlan_key_t key;
|
||||
rt_uint8_t bssid[6];
|
||||
rt_uint16_t channel;
|
||||
rt_wlan_security_t security;
|
||||
};
|
||||
|
||||
struct rt_ap_info
|
||||
{
|
||||
rt_wlan_ssid_t ssid;
|
||||
rt_wlan_key_t key;
|
||||
rt_bool_t hidden;
|
||||
rt_uint16_t channel;
|
||||
rt_wlan_security_t security;
|
||||
};
|
||||
|
||||
struct rt_scan_info
|
||||
{
|
||||
rt_wlan_ssid_t ssid;
|
||||
rt_uint8_t bssid[6];
|
||||
rt_int16_t channel_min;
|
||||
rt_int16_t channel_max;
|
||||
rt_bool_t passive;
|
||||
};
|
||||
|
||||
struct rt_wlan_dev_ops
|
||||
{
|
||||
rt_err_t (*wlan_init)(struct rt_wlan_device *wlan);
|
||||
rt_err_t (*wlan_mode)(struct rt_wlan_device *wlan, rt_wlan_mode_t mode);
|
||||
rt_err_t (*wlan_scan)(struct rt_wlan_device *wlan, struct rt_scan_info *scan_info);
|
||||
rt_err_t (*wlan_join)(struct rt_wlan_device *wlan, struct rt_sta_info *sta_info);
|
||||
rt_err_t (*wlan_softap)(struct rt_wlan_device *wlan, struct rt_ap_info *ap_info);
|
||||
rt_err_t (*wlan_disconnect)(struct rt_wlan_device *wlan);
|
||||
rt_err_t (*wlan_ap_stop)(struct rt_wlan_device *wlan);
|
||||
rt_err_t (*wlan_ap_deauth)(struct rt_wlan_device *wlan, rt_uint8_t mac[]);
|
||||
rt_err_t (*wlan_scan_stop)(struct rt_wlan_device *wlan);
|
||||
int (*wlan_get_rssi)(struct rt_wlan_device *wlan);
|
||||
rt_err_t (*wlan_set_powersave)(struct rt_wlan_device *wlan, int level);
|
||||
int (*wlan_get_powersave)(struct rt_wlan_device *wlan);
|
||||
rt_err_t (*wlan_cfg_promisc)(struct rt_wlan_device *wlan, rt_bool_t start);
|
||||
rt_err_t (*wlan_cfg_filter)(struct rt_wlan_device *wlan, struct rt_wlan_filter *filter);
|
||||
rt_err_t (*wlan_cfg_mgnt_filter)(struct rt_wlan_device *wlan, rt_bool_t start);
|
||||
rt_err_t (*wlan_set_channel)(struct rt_wlan_device *wlan, int channel);
|
||||
int (*wlan_get_channel)(struct rt_wlan_device *wlan);
|
||||
rt_err_t (*wlan_set_country)(struct rt_wlan_device *wlan, rt_country_code_t country_code);
|
||||
rt_country_code_t (*wlan_get_country)(struct rt_wlan_device *wlan);
|
||||
rt_err_t (*wlan_set_mac)(struct rt_wlan_device *wlan, rt_uint8_t mac[]);
|
||||
rt_err_t (*wlan_get_mac)(struct rt_wlan_device *wlan, rt_uint8_t mac[]);
|
||||
int (*wlan_recv)(struct rt_wlan_device *wlan, void *buff, int len);
|
||||
int (*wlan_send)(struct rt_wlan_device *wlan, void *buff, int len);
|
||||
int (*wlan_send_raw_frame)(struct rt_wlan_device *wlan, void *buff, int len);
|
||||
int (*wlan_get_fast_info)(void *data);
|
||||
rt_err_t (*wlan_fast_connect)(void *data,rt_int32_t len);
|
||||
};
|
||||
|
||||
/*
|
||||
* wlan device init
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_init(struct rt_wlan_device *device, rt_wlan_mode_t mode);
|
||||
|
||||
/*
|
||||
* wlan device station interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_connect(struct rt_wlan_device *device, struct rt_wlan_info *info, const char *password, int password_len);
|
||||
rt_err_t rt_wlan_dev_fast_connect(struct rt_wlan_device *device, struct rt_wlan_info *info, const char *password, int password_len);
|
||||
rt_err_t rt_wlan_dev_disconnect(struct rt_wlan_device *device);
|
||||
int rt_wlan_dev_get_rssi(struct rt_wlan_device *device);
|
||||
|
||||
/*
|
||||
* wlan device ap interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_ap_start(struct rt_wlan_device *device, struct rt_wlan_info *info, const char *password, int password_len);
|
||||
rt_err_t rt_wlan_dev_ap_stop(struct rt_wlan_device *device);
|
||||
rt_err_t rt_wlan_dev_ap_deauth(struct rt_wlan_device *device, rt_uint8_t mac[6]);
|
||||
|
||||
/*
|
||||
* wlan device scan interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_scan(struct rt_wlan_device *device, struct rt_wlan_info *info);
|
||||
rt_err_t rt_wlan_dev_scan_stop(struct rt_wlan_device *device);
|
||||
|
||||
/*
|
||||
* wlan device mac interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_get_mac(struct rt_wlan_device *device, rt_uint8_t mac[6]);
|
||||
rt_err_t rt_wlan_dev_set_mac(struct rt_wlan_device *device, rt_uint8_t mac[6]);
|
||||
|
||||
/*
|
||||
* wlan device powersave interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_set_powersave(struct rt_wlan_device *device, int level);
|
||||
int rt_wlan_dev_get_powersave(struct rt_wlan_device *device);
|
||||
|
||||
/*
|
||||
* wlan device event interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_register_event_handler(struct rt_wlan_device *device, rt_wlan_dev_event_t event, rt_wlan_dev_event_handler handler, void *parameter);
|
||||
rt_err_t rt_wlan_dev_unregister_event_handler(struct rt_wlan_device *device, rt_wlan_dev_event_t event, rt_wlan_dev_event_handler handler);
|
||||
void rt_wlan_dev_indicate_event_handle(struct rt_wlan_device *device, rt_wlan_dev_event_t event, struct rt_wlan_buff *buff);
|
||||
|
||||
/*
|
||||
* wlan device promisc interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_enter_promisc(struct rt_wlan_device *device);
|
||||
rt_err_t rt_wlan_dev_exit_promisc(struct rt_wlan_device *device);
|
||||
rt_err_t rt_wlan_dev_set_promisc_callback(struct rt_wlan_device *device, rt_wlan_pormisc_callback_t callback);
|
||||
void rt_wlan_dev_promisc_handler(struct rt_wlan_device *device, void *data, int len);
|
||||
|
||||
/*
|
||||
* wlan device filter interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_cfg_filter(struct rt_wlan_device *device, struct rt_wlan_filter *filter);
|
||||
|
||||
/*
|
||||
* wlan device channel interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_set_channel(struct rt_wlan_device *device, int channel);
|
||||
int rt_wlan_dev_get_channel(struct rt_wlan_device *device);
|
||||
|
||||
/*
|
||||
* wlan device country interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_set_country(struct rt_wlan_device *device, rt_country_code_t country_code);
|
||||
rt_country_code_t rt_wlan_dev_get_country(struct rt_wlan_device *device);
|
||||
|
||||
/*
|
||||
* wlan device datat transfer interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_report_data(struct rt_wlan_device *device, void *buff, int len);
|
||||
// void rt_wlan_dev_data_ready(struct rt_wlan_device *device, int len);
|
||||
|
||||
/*
|
||||
* wlan device register interface
|
||||
*/
|
||||
rt_err_t rt_wlan_dev_register(struct rt_wlan_device *wlan, const char *name,
|
||||
const struct rt_wlan_dev_ops *ops, rt_uint32_t flag, void *user_data);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
558
riscv/rtthread/components/drivers/wlan/wlan_lwip.c
Executable file
558
riscv/rtthread/components/drivers/wlan/wlan_lwip.c
Executable file
@@ -0,0 +1,558 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-14 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rthw.h>
|
||||
#include <rtthread.h>
|
||||
#include <wlan_dev.h>
|
||||
#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
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#endif /* RT_WLAN_LWIP_DEBUG */
|
||||
#include <rtdbg.h>
|
||||
|
||||
#ifndef IPADDR_STRLEN_MAX
|
||||
#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;
|
||||
struct eth_device eth;
|
||||
rt_int8_t connected_flag;
|
||||
struct rt_timer timer;
|
||||
struct rt_work work;
|
||||
};
|
||||
|
||||
static void netif_is_ready(struct rt_work *work, void *parameter)
|
||||
{
|
||||
ip_addr_t ip_addr_zero = { 0 };
|
||||
struct rt_wlan_device *wlan = parameter;
|
||||
struct lwip_prot_des *lwip_prot = (struct lwip_prot_des *)wlan->prot;
|
||||
struct eth_device *eth_dev;
|
||||
rt_base_t level;
|
||||
struct rt_wlan_buff buff;
|
||||
rt_uint32_t ip_addr[4];
|
||||
char str[IPADDR_STRLEN_MAX];
|
||||
|
||||
if (lwip_prot == RT_NULL)
|
||||
return;
|
||||
|
||||
eth_dev = &lwip_prot->eth;
|
||||
rt_timer_stop(&lwip_prot->timer);
|
||||
if (ip_addr_cmp(&(eth_dev->netif->ip_addr), &ip_addr_zero) != 0)
|
||||
{
|
||||
rt_timer_start(&lwip_prot->timer);
|
||||
goto exit;
|
||||
}
|
||||
rt_memset(&ip_addr, 0, sizeof(ip_addr));
|
||||
#if LWIP_IPV4 && LWIP_IPV6
|
||||
if (eth_dev->netif->ip_addr.type == IPADDR_TYPE_V4)
|
||||
{
|
||||
ip_addr[0] = ip4_addr_get_u32(ð_dev->netif->ip_addr.u_addr.ip4);
|
||||
buff.data = &ip_addr[0];
|
||||
buff.len = sizeof(ip_addr[0]);
|
||||
}
|
||||
else if (eth_dev->netif->ip_addr.type == IPADDR_TYPE_V6)
|
||||
{
|
||||
*(ip6_addr_t *)(&ip_addr[0]) = eth_dev->netif->ip_addr.u_addr.ip6;
|
||||
buff.data = ip_addr;
|
||||
buff.len = sizeof(ip_addr);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_W("F:%s L:%d ip addr type not support", __FUNCTION__, __LINE__);
|
||||
}
|
||||
#else
|
||||
#if LWIP_IPV4
|
||||
ip_addr[0] = ip4_addr_get_u32(ð_dev->netif->ip_addr);
|
||||
buff.data = &ip_addr[0];
|
||||
buff.len = sizeof(ip_addr[0]);
|
||||
#else
|
||||
*(ip_addr_t *)(&ip_addr[0]) = eth_dev->netif->ip_addr;
|
||||
buff.data = ip_addr;
|
||||
buff.len = sizeof(ip_addr);
|
||||
#endif
|
||||
#endif
|
||||
if (rt_wlan_prot_ready(wlan, &buff) != 0)
|
||||
{
|
||||
rt_timer_start(&lwip_prot->timer);
|
||||
goto exit;
|
||||
}
|
||||
rt_memset(str, 0, IPADDR_STRLEN_MAX);
|
||||
rt_enter_critical();
|
||||
rt_memcpy(str, ipaddr_ntoa(&(eth_dev->netif->ip_addr)), IPADDR_STRLEN_MAX);
|
||||
rt_exit_critical();
|
||||
LOG_I("Got IP address : %s", str);
|
||||
exit:
|
||||
level = rt_hw_interrupt_disable();
|
||||
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;
|
||||
struct rt_work *work;
|
||||
rt_base_t level;
|
||||
|
||||
if (lwip_prot == RT_NULL)
|
||||
return;
|
||||
|
||||
work = &lwip_prot->work;
|
||||
workqueue = rt_wlan_get_workqueue();
|
||||
if (workqueue != RT_NULL)
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
rt_work_init(work, netif_is_ready, parameter);
|
||||
rt_hw_interrupt_enable(level);
|
||||
if (rt_workqueue_dowork(workqueue, work) != RT_EOK)
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
rt_memset(work, 0, sizeof(struct rt_work));
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
}
|
||||
#else
|
||||
netif_is_ready(RT_NULL, parameter);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
static void netif_set_connected(void *parameter)
|
||||
{
|
||||
struct rt_wlan_device *wlan = parameter;
|
||||
struct lwip_prot_des *lwip_prot = wlan->prot;
|
||||
struct eth_device *eth_dev;
|
||||
|
||||
if (lwip_prot == RT_NULL)
|
||||
return;
|
||||
|
||||
eth_dev = &lwip_prot->eth;
|
||||
|
||||
if (lwip_prot->connected_flag)
|
||||
{
|
||||
if (wlan->mode == RT_WLAN_STATION)
|
||||
{
|
||||
LOG_D("F:%s L:%d dhcp start run", __FUNCTION__, __LINE__);
|
||||
netifapi_netif_common(eth_dev->netif, netif_set_link_up, NULL);
|
||||
#ifdef RT_LWIP_DHCP
|
||||
netifapi_dhcp_start(eth_dev->netif);
|
||||
#endif
|
||||
rt_timer_start(&lwip_prot->timer);
|
||||
}
|
||||
else if (wlan->mode == RT_WLAN_AP)
|
||||
{
|
||||
LOG_D("F:%s L:%d dhcpd start run", __FUNCTION__, __LINE__);
|
||||
|
||||
netifapi_netif_common(eth_dev->netif, netif_set_link_up, NULL);
|
||||
#ifdef LWIP_USING_DHCPD
|
||||
{
|
||||
char netif_name[RT_NAME_MAX];
|
||||
|
||||
rt_memset(netif_name, 0, sizeof(netif_name));
|
||||
rt_memcpy(netif_name, eth_dev->netif->name, sizeof(eth_dev->netif->name));
|
||||
dhcpd_start(netif_name);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_D("F:%s L:%d set linkdown", __FUNCTION__, __LINE__);
|
||||
netifapi_netif_common(eth_dev->netif, netif_set_link_down, NULL);
|
||||
rt_timer_stop(&lwip_prot->timer);
|
||||
#ifdef RT_LWIP_DHCP
|
||||
{
|
||||
ip_addr_t ip_addr = { 0 };
|
||||
netifapi_dhcp_stop(eth_dev->netif);
|
||||
netif_set_addr(eth_dev->netif, &ip_addr, &ip_addr, &ip_addr);
|
||||
}
|
||||
#endif
|
||||
#ifdef LWIP_USING_DHCPD
|
||||
{
|
||||
char netif_name[RT_NAME_MAX];
|
||||
rt_memset(netif_name, 0, sizeof(netif_name));
|
||||
rt_memcpy(netif_name, lwip_prot->eth.netif->name, sizeof(lwip_prot->eth.netif->name));
|
||||
dhcpd_stop(netif_name);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
static void rt_wlan_lwip_event_handle(struct rt_wlan_prot *port, struct rt_wlan_device *wlan, int event)
|
||||
{
|
||||
struct lwip_prot_des *lwip_prot = (struct lwip_prot_des *)wlan->prot;
|
||||
rt_bool_t flag_old;
|
||||
|
||||
if (lwip_prot == RT_NULL)
|
||||
return;
|
||||
|
||||
flag_old = lwip_prot->connected_flag;
|
||||
|
||||
switch (event)
|
||||
{
|
||||
case RT_WLAN_PROT_EVT_CONNECT:
|
||||
{
|
||||
LOG_D("event: CONNECT");
|
||||
lwip_prot->connected_flag = RT_TRUE;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_PROT_EVT_DISCONNECT:
|
||||
{
|
||||
LOG_D("event: DISCONNECT");
|
||||
lwip_prot->connected_flag = RT_FALSE;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_PROT_EVT_AP_START:
|
||||
{
|
||||
LOG_D("event: AP_START");
|
||||
lwip_prot->connected_flag = RT_TRUE;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_PROT_EVT_AP_STOP:
|
||||
{
|
||||
LOG_D("event: AP_STOP");
|
||||
lwip_prot->connected_flag = RT_FALSE;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_PROT_EVT_AP_ASSOCIATED:
|
||||
{
|
||||
LOG_D("event: ASSOCIATED");
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_PROT_EVT_AP_DISASSOCIATED:
|
||||
{
|
||||
LOG_D("event: DISASSOCIATED");
|
||||
break;
|
||||
}
|
||||
default :
|
||||
{
|
||||
LOG_D("event: UNKNOWN");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (flag_old != lwip_prot->connected_flag)
|
||||
{
|
||||
#ifdef RT_WLAN_WORK_THREAD_ENABLE
|
||||
rt_wlan_workqueue_dowork(netif_set_connected, wlan);
|
||||
#else
|
||||
netif_set_connected(wlan);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
static rt_err_t rt_wlan_lwip_protocol_control(rt_device_t device, int cmd, void *args)
|
||||
{
|
||||
struct eth_device *eth_dev = (struct eth_device *)device;
|
||||
struct rt_wlan_device *wlan;
|
||||
rt_err_t err = RT_EOK;
|
||||
|
||||
RT_ASSERT(eth_dev != RT_NULL);
|
||||
|
||||
LOG_D("F:%s L:%d device:0x%08x user_data:0x%08x", __FUNCTION__, __LINE__, eth_dev, eth_dev->parent.user_data);
|
||||
|
||||
switch (cmd)
|
||||
{
|
||||
case NIOCTL_GADDR:
|
||||
/* get MAC address */
|
||||
wlan = eth_dev->parent.user_data;
|
||||
err = rt_device_control((rt_device_t)wlan, RT_WLAN_CMD_GET_MAC, args);
|
||||
break;
|
||||
default :
|
||||
break;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
static rt_err_t rt_wlan_lwip_protocol_recv(struct rt_wlan_device *wlan, void *buff, int len)
|
||||
{
|
||||
struct eth_device *eth_dev = &((struct lwip_prot_des *)wlan->prot)->eth;
|
||||
struct pbuf *p = RT_NULL;
|
||||
|
||||
LOG_D("F:%s L:%d run", __FUNCTION__, __LINE__);
|
||||
|
||||
if (eth_dev == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
#ifdef RT_WLAN_PROT_LWIP_PBUF_FORCE
|
||||
{
|
||||
p = buff;
|
||||
if ((eth_dev->netif->input(p, eth_dev->netif)) != ERR_OK)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
return RT_EOK;
|
||||
}
|
||||
#else
|
||||
{
|
||||
int count = 0;
|
||||
|
||||
while (p == RT_NULL)
|
||||
{
|
||||
p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
|
||||
if (p != RT_NULL)
|
||||
break;
|
||||
|
||||
p = pbuf_alloc(PBUF_RAW, len, PBUF_RAM);
|
||||
if (p != RT_NULL)
|
||||
break;
|
||||
|
||||
LOG_D("F:%s L:%d wait for pbuf_alloc!", __FUNCTION__, __LINE__);
|
||||
rt_thread_delay(1);
|
||||
count++;
|
||||
|
||||
//wait for 10ms or give up!!
|
||||
if (count >= 10)
|
||||
{
|
||||
LOG_W("F:%s L:%d pbuf allocate fail!!!", __FUNCTION__, __LINE__);
|
||||
return -RT_ENOMEM;
|
||||
}
|
||||
}
|
||||
/*copy data dat -> pbuf*/
|
||||
pbuf_take(p, buff, len);
|
||||
if ((eth_dev->netif->input(p, eth_dev->netif)) != ERR_OK)
|
||||
{
|
||||
LOG_D("F:%s L:%d IP input error", __FUNCTION__, __LINE__);
|
||||
pbuf_free(p);
|
||||
p = RT_NULL;
|
||||
}
|
||||
LOG_D("F:%s L:%d netif iput success! len:%d", __FUNCTION__, __LINE__, len);
|
||||
return RT_EOK;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static rt_err_t rt_wlan_lwip_protocol_send(rt_device_t device, struct pbuf *p)
|
||||
{
|
||||
struct rt_wlan_device *wlan = ((struct eth_device *)device)->parent.user_data;
|
||||
|
||||
LOG_D("F:%s L:%d run", __FUNCTION__, __LINE__);
|
||||
|
||||
if (wlan == RT_NULL)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
#ifdef RT_WLAN_PROT_LWIP_PBUF_FORCE
|
||||
{
|
||||
rt_wlan_prot_transfer_dev(wlan, p, p->tot_len);
|
||||
return RT_EOK;
|
||||
}
|
||||
#else
|
||||
{
|
||||
rt_uint8_t *frame;
|
||||
|
||||
/* sending data directly */
|
||||
if (p->len == p->tot_len)
|
||||
{
|
||||
frame = (rt_uint8_t *)p->payload;
|
||||
rt_wlan_prot_transfer_dev(wlan, frame, p->tot_len);
|
||||
LOG_D("F:%s L:%d run len:%d", __FUNCTION__, __LINE__, p->tot_len);
|
||||
return RT_EOK;
|
||||
}
|
||||
frame = rt_malloc(p->tot_len);
|
||||
if (frame == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d malloc out_buf fail\n", __FUNCTION__, __LINE__);
|
||||
return -RT_ENOMEM;
|
||||
}
|
||||
/*copy pbuf -> data dat*/
|
||||
pbuf_copy_partial(p, frame, p->tot_len, 0);
|
||||
/* send data */
|
||||
rt_wlan_prot_transfer_dev(wlan, frame, p->tot_len);
|
||||
LOG_D("F:%s L:%d run len:%d", __FUNCTION__, __LINE__, p->tot_len);
|
||||
rt_free(frame);
|
||||
return RT_EOK;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops wlan_lwip_ops =
|
||||
{
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
rt_wlan_lwip_protocol_control
|
||||
};
|
||||
#endif
|
||||
|
||||
static struct rt_wlan_prot *rt_wlan_lwip_protocol_register(struct rt_wlan_prot *prot, struct rt_wlan_device *wlan)
|
||||
{
|
||||
struct eth_device *eth = RT_NULL;
|
||||
rt_uint8_t id = 0;
|
||||
char eth_name[4], timer_name[16];
|
||||
rt_device_t device = RT_NULL;
|
||||
struct lwip_prot_des *lwip_prot;
|
||||
|
||||
if (wlan == RT_NULL || prot == RT_NULL)
|
||||
return RT_NULL;;
|
||||
|
||||
LOG_D("F:%s L:%d is run wlan:0x%08x", __FUNCTION__, __LINE__, wlan);
|
||||
|
||||
do
|
||||
{
|
||||
/* find ETH device name */
|
||||
eth_name[0] = 'w';
|
||||
eth_name[1] = '0' + id++;
|
||||
eth_name[2] = '\0';
|
||||
device = rt_device_find(eth_name);
|
||||
}
|
||||
while (device);
|
||||
|
||||
if (id > 9)
|
||||
{
|
||||
LOG_E("F:%s L:%d not find Empty name", __FUNCTION__, __LINE__, eth_name);
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
if (rt_device_open((rt_device_t)wlan, RT_DEVICE_OFLAG_RDWR) != RT_EOK)
|
||||
{
|
||||
LOG_E("F:%s L:%d open wlan failed", __FUNCTION__, __LINE__);
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
lwip_prot = rt_malloc(sizeof(struct lwip_prot_des));
|
||||
if (lwip_prot == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d malloc mem failed", __FUNCTION__, __LINE__);
|
||||
rt_device_close((rt_device_t)wlan);
|
||||
return RT_NULL;
|
||||
}
|
||||
rt_memset(lwip_prot, 0, sizeof(struct lwip_prot_des));
|
||||
|
||||
eth = &lwip_prot->eth;
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
eth->parent.ops = &wlan_lwip_ops;
|
||||
#else
|
||||
eth->parent.init = RT_NULL;
|
||||
eth->parent.open = RT_NULL;
|
||||
eth->parent.close = RT_NULL;
|
||||
eth->parent.read = RT_NULL;
|
||||
eth->parent.write = RT_NULL;
|
||||
eth->parent.control = rt_wlan_lwip_protocol_control;
|
||||
#endif
|
||||
|
||||
eth->parent.user_data = wlan;
|
||||
eth->eth_rx = RT_NULL;
|
||||
eth->eth_tx = rt_wlan_lwip_protocol_send;
|
||||
|
||||
/* register ETH device */
|
||||
if (eth_device_init(eth, eth_name) != RT_EOK)
|
||||
{
|
||||
LOG_E("eth device init failed");
|
||||
rt_device_close((rt_device_t)wlan);
|
||||
rt_free(lwip_prot);
|
||||
return RT_NULL;
|
||||
}
|
||||
rt_memcpy(&lwip_prot->prot, prot, sizeof(struct rt_wlan_prot));
|
||||
rt_sprintf(timer_name, "timer_%s", eth_name);
|
||||
rt_timer_init(&lwip_prot->timer, timer_name, timer_callback, wlan, rt_tick_from_millisecond(1000),
|
||||
RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT);
|
||||
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;
|
||||
}
|
||||
|
||||
static void rt_wlan_lwip_protocol_unregister(struct rt_wlan_prot *prot, struct rt_wlan_device *wlan)
|
||||
{
|
||||
struct lwip_prot_des *lwip_prot = (struct lwip_prot_des *)prot;
|
||||
|
||||
LOG_D("F:%s L:%d is run wlan:0x%08x", __FUNCTION__, __LINE__, wlan);
|
||||
#if !defined(RT_USING_LWIP141)
|
||||
wlan->prot = RT_NULL;
|
||||
if (lwip_prot == RT_NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef LWIP_USING_DHCPD
|
||||
{
|
||||
char netif_name[RT_NAME_MAX];
|
||||
rt_memset(netif_name, 0, sizeof(netif_name));
|
||||
rt_memcpy(netif_name, lwip_prot->eth.netif->name, sizeof(lwip_prot->eth.netif->name));
|
||||
dhcpd_stop(netif_name);
|
||||
}
|
||||
#endif
|
||||
eth_device_deinit(&lwip_prot->eth);
|
||||
rt_device_close((rt_device_t)wlan);
|
||||
rt_timer_detach(&lwip_prot->timer);
|
||||
wlan->netdev = RT_NULL;
|
||||
rt_free(lwip_prot);
|
||||
#endif
|
||||
}
|
||||
|
||||
static struct rt_wlan_prot_ops ops =
|
||||
{
|
||||
rt_wlan_lwip_protocol_recv,
|
||||
rt_wlan_lwip_protocol_register,
|
||||
rt_wlan_lwip_protocol_unregister
|
||||
};
|
||||
|
||||
int rt_wlan_lwip_init(void)
|
||||
{
|
||||
static struct rt_wlan_prot prot;
|
||||
rt_wlan_prot_event_t event;
|
||||
|
||||
rt_memset(&prot, 0, sizeof(prot));
|
||||
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)
|
||||
{
|
||||
LOG_E("F:%s L:%d protocol regisetr failed", __FUNCTION__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (event = RT_WLAN_PROT_EVT_INIT_DONE; event < RT_WLAN_PROT_EVT_MAX; event++)
|
||||
{
|
||||
rt_wlan_prot_event_register(&prot, event, rt_wlan_lwip_event_handle);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
INIT_PREV_EXPORT(rt_wlan_lwip_init);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
1775
riscv/rtthread/components/drivers/wlan/wlan_mgnt.c
Executable file
1775
riscv/rtthread/components/drivers/wlan/wlan_mgnt.c
Executable file
File diff suppressed because it is too large
Load Diff
153
riscv/rtthread/components/drivers/wlan/wlan_mgnt.h
Executable file
153
riscv/rtthread/components/drivers/wlan/wlan_mgnt.h
Executable file
@@ -0,0 +1,153 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-06 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __WLAN_MGNT_H__
|
||||
#define __WLAN_MGNT_H__
|
||||
|
||||
#include <wlan_dev.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_SCAN_WAIT_MS
|
||||
#define RT_WLAN_SCAN_WAIT_MS (10 * 1000)
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_SCAN_CACHE_NUM
|
||||
#define RT_WLAN_SCAN_CACHE_NUM (50)
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_CONNECT_WAIT_MS
|
||||
#define RT_WLAN_CONNECT_WAIT_MS (10 * 1000)
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_START_AP_WAIT_MS
|
||||
#define RT_WLAN_START_AP_WAIT_MS (10 * 1000)
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_EBOX_NUM
|
||||
#define RT_WLAN_EBOX_NUM (10)
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_SCAN_RETRY_CNT
|
||||
#define RT_WLAN_SCAN_RETRY_CNT (3)
|
||||
#endif
|
||||
|
||||
#ifndef AUTO_CONNECTION_PERIOD_MS
|
||||
#define AUTO_CONNECTION_PERIOD_MS (2000)
|
||||
#endif
|
||||
|
||||
/*state fot station*/
|
||||
#define RT_WLAN_STATE_CONNECT (1UL << 0)
|
||||
#define RT_WLAN_STATE_CONNECTING (1UL << 1)
|
||||
#define RT_WLAN_STATE_READY (1UL << 2)
|
||||
#define RT_WLAN_STATE_POWERSAVE (1UL << 3)
|
||||
|
||||
/*flags fot station*/
|
||||
#define RT_WLAN_STATE_AUTOEN (1UL << 0)
|
||||
|
||||
/*state fot ap*/
|
||||
#define RT_WLAN_STATE_ACTIVE (1UL << 0)
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_WLAN_EVT_READY = 0, /* connect and prot is ok, You can send data*/
|
||||
RT_WLAN_EVT_SCAN_DONE, /* Scan a info */
|
||||
RT_WLAN_EVT_SCAN_REPORT, /* Scan end */
|
||||
RT_WLAN_EVT_STA_CONNECTED, /* connect success */
|
||||
RT_WLAN_EVT_STA_CONNECTED_FAIL, /* connection failed */
|
||||
RT_WLAN_EVT_STA_DISCONNECTED, /* disconnect */
|
||||
RT_WLAN_EVT_AP_START, /* AP start */
|
||||
RT_WLAN_EVT_AP_STOP, /* AP stop */
|
||||
RT_WLAN_EVT_AP_ASSOCIATED, /* sta associated */
|
||||
RT_WLAN_EVT_AP_DISASSOCIATED, /* sta disassociated */
|
||||
RT_WLAN_EVT_MAX
|
||||
} rt_wlan_event_t;
|
||||
|
||||
typedef void (*rt_wlan_event_handler)(int event, struct rt_wlan_buff *buff, void *parameter);
|
||||
|
||||
struct rt_wlan_scan_result
|
||||
{
|
||||
rt_int32_t num;
|
||||
struct rt_wlan_info *info;
|
||||
};
|
||||
|
||||
/*
|
||||
* wifi init interface
|
||||
*/
|
||||
int rt_wlan_init(void);
|
||||
rt_err_t rt_wlan_set_mode(const char *dev_name, rt_wlan_mode_t mode);
|
||||
rt_wlan_mode_t rt_wlan_get_mode(const char *dev_name);
|
||||
|
||||
/*
|
||||
* wifi station mode interface
|
||||
*/
|
||||
rt_err_t rt_wlan_connect(const char *ssid, const char *password);
|
||||
rt_err_t rt_wlan_connect_adv(struct rt_wlan_info *info, const char *password);
|
||||
rt_err_t rt_wlan_disconnect(void);
|
||||
rt_bool_t rt_wlan_is_connected(void);
|
||||
rt_bool_t rt_wlan_is_ready(void);
|
||||
rt_err_t rt_wlan_set_mac(rt_uint8_t *mac);
|
||||
rt_err_t rt_wlan_get_mac(rt_uint8_t *mac);
|
||||
rt_err_t rt_wlan_get_info(struct rt_wlan_info *info);
|
||||
int rt_wlan_get_rssi(void);
|
||||
|
||||
/*
|
||||
* wifi ap mode interface
|
||||
*/
|
||||
rt_err_t rt_wlan_start_ap(const char *ssid, const char *password);
|
||||
rt_err_t rt_wlan_start_ap_adv(struct rt_wlan_info *info, const char *password);
|
||||
rt_bool_t rt_wlan_ap_is_active(void);
|
||||
rt_err_t rt_wlan_ap_stop(void);
|
||||
rt_err_t rt_wlan_ap_get_info(struct rt_wlan_info *info);
|
||||
int rt_wlan_ap_get_sta_num(void);
|
||||
int rt_wlan_ap_get_sta_info(struct rt_wlan_info *info, int num);
|
||||
rt_err_t rt_wlan_ap_deauth_sta(rt_uint8_t *mac);
|
||||
rt_err_t rt_wlan_ap_set_country(rt_country_code_t country_code);
|
||||
rt_country_code_t rt_wlan_ap_get_country(void);
|
||||
|
||||
/*
|
||||
* wifi scan interface
|
||||
*/
|
||||
rt_err_t rt_wlan_scan(void);
|
||||
struct rt_wlan_scan_result *rt_wlan_scan_sync(void);
|
||||
rt_err_t rt_wlan_scan_with_info(struct rt_wlan_info *info);
|
||||
|
||||
|
||||
/*
|
||||
* wifi auto connect interface
|
||||
*/
|
||||
void rt_wlan_config_autoreconnect(rt_bool_t enable);
|
||||
rt_bool_t rt_wlan_get_autoreconnect_mode(void);
|
||||
|
||||
/*
|
||||
* wifi power management interface
|
||||
*/
|
||||
rt_err_t rt_wlan_set_powersave(int level);
|
||||
int rt_wlan_get_powersave(void);
|
||||
|
||||
/*
|
||||
* wifi event management interface
|
||||
*/
|
||||
rt_err_t rt_wlan_register_event_handler(rt_wlan_event_t event, rt_wlan_event_handler handler, void *parameter);
|
||||
rt_err_t rt_wlan_unregister_event_handler(rt_wlan_event_t event);
|
||||
|
||||
/*
|
||||
* wifi management lock interface
|
||||
*/
|
||||
void rt_wlan_mgnt_lock(void);
|
||||
void rt_wlan_mgnt_unlock(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
364
riscv/rtthread/components/drivers/wlan/wlan_prot.c
Executable file
364
riscv/rtthread/components/drivers/wlan/wlan_prot.c
Executable file
@@ -0,0 +1,364 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-14 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rthw.h>
|
||||
#include <rtthread.h>
|
||||
#include <wlan_dev.h>
|
||||
#include <wlan_prot.h>
|
||||
|
||||
#define DBG_TAG "WLAN.prot"
|
||||
#ifdef RT_WLAN_PROT_DEBUG
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#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
|
||||
|
||||
struct rt_wlan_prot_event_des
|
||||
{
|
||||
rt_wlan_prot_event_handler handler;
|
||||
struct rt_wlan_prot *prot;
|
||||
};
|
||||
|
||||
static struct rt_wlan_prot *_prot[RT_WLAN_PROT_MAX];
|
||||
|
||||
static struct rt_wlan_prot_event_des prot_event_tab[RT_WLAN_PROT_EVT_MAX][RT_WLAN_PROT_MAX];
|
||||
|
||||
static void rt_wlan_prot_event_handle(struct rt_wlan_device *wlan, rt_wlan_dev_event_t event, struct rt_wlan_buff *buff, void *parameter)
|
||||
{
|
||||
int i;
|
||||
struct rt_wlan_prot *wlan_prot;
|
||||
struct rt_wlan_prot *prot;
|
||||
rt_wlan_prot_event_handler handler;
|
||||
rt_wlan_prot_event_t prot_event;
|
||||
|
||||
LOG_D("F:%s L:%d event:%d", __FUNCTION__, __LINE__, event);
|
||||
|
||||
wlan_prot = wlan->prot;
|
||||
handler = RT_NULL;
|
||||
prot = RT_NULL;
|
||||
switch (event)
|
||||
{
|
||||
case RT_WLAN_DEV_EVT_INIT_DONE:
|
||||
{
|
||||
LOG_D("L%d event: INIT_DONE", __LINE__);
|
||||
prot_event = RT_WLAN_PROT_EVT_INIT_DONE;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_DEV_EVT_CONNECT:
|
||||
{
|
||||
LOG_D("L%d event: CONNECT", __LINE__);
|
||||
prot_event = RT_WLAN_PROT_EVT_CONNECT;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_DEV_EVT_DISCONNECT:
|
||||
{
|
||||
LOG_D("L%d event: DISCONNECT", __LINE__);
|
||||
prot_event = RT_WLAN_PROT_EVT_DISCONNECT;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_DEV_EVT_AP_START:
|
||||
{
|
||||
LOG_D("L%d event: AP_START", __LINE__);
|
||||
prot_event = RT_WLAN_PROT_EVT_AP_START;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_DEV_EVT_AP_STOP:
|
||||
{
|
||||
LOG_D("L%d event: AP_STOP", __LINE__);
|
||||
prot_event = RT_WLAN_PROT_EVT_AP_STOP;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_DEV_EVT_AP_ASSOCIATED:
|
||||
{
|
||||
LOG_D("L%d event: AP_ASSOCIATED", __LINE__);
|
||||
prot_event = RT_WLAN_PROT_EVT_AP_ASSOCIATED;
|
||||
break;
|
||||
}
|
||||
case RT_WLAN_DEV_EVT_AP_DISASSOCIATED:
|
||||
{
|
||||
LOG_D("L%d event: AP_DISASSOCIATED", __LINE__);
|
||||
prot_event = RT_WLAN_PROT_EVT_AP_DISASSOCIATED;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < RT_WLAN_PROT_MAX; i++)
|
||||
{
|
||||
if ((prot_event_tab[prot_event][i].handler != RT_NULL) &&
|
||||
(prot_event_tab[prot_event][i].prot->id == wlan_prot->id))
|
||||
{
|
||||
handler = prot_event_tab[prot_event][i].handler;
|
||||
prot = prot_event_tab[prot_event][i].prot;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (handler != RT_NULL)
|
||||
{
|
||||
handler(prot, wlan, prot_event);
|
||||
}
|
||||
}
|
||||
|
||||
static struct rt_wlan_device *rt_wlan_prot_find_by_name(const char *name)
|
||||
{
|
||||
rt_device_t device;
|
||||
|
||||
if (name == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d Parameter Wrongful", __FUNCTION__, __LINE__);
|
||||
return RT_NULL;
|
||||
}
|
||||
device = rt_device_find(name);
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d not find wlan dev!! name:%s", __FUNCTION__, __LINE__, name);
|
||||
return RT_NULL;
|
||||
}
|
||||
return (struct rt_wlan_device *)device;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_prot_attach(const char *dev_name, const char *prot_name)
|
||||
{
|
||||
struct rt_wlan_device *wlan;
|
||||
|
||||
wlan = rt_wlan_prot_find_by_name(dev_name);
|
||||
if (wlan == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
return rt_wlan_prot_attach_dev(wlan, prot_name);
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_prot_detach(const char *name)
|
||||
{
|
||||
struct rt_wlan_device *wlan;
|
||||
|
||||
wlan = rt_wlan_prot_find_by_name(name);
|
||||
if (wlan == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
return rt_wlan_prot_detach_dev(wlan);
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_prot_attach_dev(struct rt_wlan_device *wlan, const char *prot_name)
|
||||
{
|
||||
int i = 0;
|
||||
struct rt_wlan_prot *prot = wlan->prot;
|
||||
rt_wlan_dev_event_handler handler = rt_wlan_prot_event_handle;
|
||||
|
||||
if (wlan == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d wlan is null", __FUNCTION__, __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
if (prot != RT_NULL &&
|
||||
(rt_strcmp(prot->name, prot_name) == 0))
|
||||
{
|
||||
LOG_D("prot is register");
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
/* if prot not NULL */
|
||||
if (prot != RT_NULL)
|
||||
rt_wlan_prot_detach_dev(wlan);
|
||||
|
||||
#ifdef RT_WLAN_PROT_LWIP_PBUF_FORCE
|
||||
if (rt_strcmp(RT_WLAN_PROT_LWIP_NAME, prot_name) != 0)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
#endif
|
||||
/* find prot */
|
||||
for (i = 0; i < RT_WLAN_PROT_MAX; i++)
|
||||
{
|
||||
if ((_prot[i] != RT_NULL) && (rt_strcmp(_prot[i]->name, prot_name) == 0))
|
||||
{
|
||||
/* attach prot */
|
||||
wlan->prot = _prot[i]->ops->dev_reg_callback(_prot[i], wlan);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (i >= RT_WLAN_PROT_MAX)
|
||||
{
|
||||
LOG_E("F:%s L:%d not find wlan protocol", __FUNCTION__, __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_prot_detach_dev(struct rt_wlan_device *wlan)
|
||||
{
|
||||
struct rt_wlan_prot *prot = wlan->prot;
|
||||
rt_wlan_dev_event_t event;
|
||||
|
||||
if (prot == RT_NULL)
|
||||
return RT_EOK;
|
||||
|
||||
for (event = RT_WLAN_DEV_EVT_INIT_DONE; event < RT_WLAN_DEV_EVT_MAX; event ++)
|
||||
{
|
||||
rt_wlan_dev_unregister_event_handler(wlan, event, rt_wlan_prot_event_handle);
|
||||
}
|
||||
|
||||
/* detach prot */
|
||||
prot->ops->dev_unreg_callback(prot, wlan);
|
||||
wlan->prot = RT_NULL;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_prot_regisetr(struct rt_wlan_prot *prot)
|
||||
{
|
||||
int i;
|
||||
rt_uint32_t id;
|
||||
static rt_uint8_t num;
|
||||
|
||||
/* Parameter checking */
|
||||
if ((prot == RT_NULL) ||
|
||||
(prot->ops->prot_recv == RT_NULL) ||
|
||||
(prot->ops->dev_reg_callback == RT_NULL))
|
||||
{
|
||||
LOG_E("F:%s L:%d Parameter Wrongful", __FUNCTION__, __LINE__);
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/* save prot */
|
||||
for (i = 0; i < RT_WLAN_PROT_MAX; i++)
|
||||
{
|
||||
if (_prot[i] == RT_NULL)
|
||||
{
|
||||
id = (RT_LWAN_ID_PREFIX << 16) | num;
|
||||
prot->id = id;
|
||||
_prot[i] = prot;
|
||||
num ++;
|
||||
break;
|
||||
}
|
||||
else if (rt_strcmp(_prot[i]->name, prot->name) == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* is full */
|
||||
if (i >= RT_WLAN_PROT_MAX)
|
||||
{
|
||||
LOG_E("F:%s L:%d Space full", __FUNCTION__, __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_prot_event_register(struct rt_wlan_prot *prot, rt_wlan_prot_event_t event, rt_wlan_prot_event_handler handler)
|
||||
{
|
||||
int i;
|
||||
|
||||
if ((prot == RT_NULL) || (handler == RT_NULL))
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
for (i = 0; i < RT_WLAN_PROT_MAX; i++)
|
||||
{
|
||||
if (prot_event_tab[event][i].handler == RT_NULL)
|
||||
{
|
||||
prot_event_tab[event][i].handler = handler;
|
||||
prot_event_tab[event][i].prot = prot;
|
||||
return RT_EOK;
|
||||
}
|
||||
}
|
||||
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_prot_event_unregister(struct rt_wlan_prot *prot, rt_wlan_prot_event_t event)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (prot == RT_NULL)
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
for (i = 0; i < RT_WLAN_PROT_MAX; i++)
|
||||
{
|
||||
if ((prot_event_tab[event][i].handler != RT_NULL) &&
|
||||
(prot_event_tab[event][i].prot == prot))
|
||||
{
|
||||
rt_memset(&prot_event_tab[event][i], 0, sizeof(struct rt_wlan_prot_event_des));
|
||||
return RT_EOK;
|
||||
}
|
||||
}
|
||||
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_prot_transfer_dev(struct rt_wlan_device *wlan, void *buff, int len)
|
||||
{
|
||||
if (wlan->ops->wlan_send != RT_NULL)
|
||||
{
|
||||
return wlan->ops->wlan_send(wlan, buff, len);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_dev_transfer_prot(struct rt_wlan_device *wlan, void *buff, int len)
|
||||
{
|
||||
struct rt_wlan_prot *prot = wlan->prot;
|
||||
|
||||
if (prot != RT_NULL)
|
||||
{
|
||||
return prot->ops->prot_recv(wlan, buff, len);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
extern int rt_wlan_prot_ready_event(struct rt_wlan_device *wlan, struct rt_wlan_buff *buff);
|
||||
int rt_wlan_prot_ready(struct rt_wlan_device *wlan, struct rt_wlan_buff *buff)
|
||||
{
|
||||
return rt_wlan_prot_ready_event(wlan, buff);
|
||||
}
|
||||
|
||||
void rt_wlan_prot_dump(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
rt_kprintf(" name id \n");
|
||||
rt_kprintf("-------- --------\n");
|
||||
for (i = 0; i < RT_WLAN_PROT_MAX; i++)
|
||||
{
|
||||
if (_prot[i] != RT_NULL)
|
||||
{
|
||||
rt_kprintf("%-8.8s ", _prot[i]->name);
|
||||
rt_kprintf("%08x\n", _prot[i]->id);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
83
riscv/rtthread/components/drivers/wlan/wlan_prot.h
Executable file
83
riscv/rtthread/components/drivers/wlan/wlan_prot.h
Executable file
@@ -0,0 +1,83 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-14 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __WLAN_PROT_H__
|
||||
#define __WLAN_PROT_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_PROT_NAME_LEN
|
||||
#define RT_WLAN_PROT_NAME_LEN (8)
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_PROT_MAX
|
||||
#define RT_WLAN_PROT_MAX (1)
|
||||
#endif
|
||||
|
||||
#define RT_LWAN_ID_PREFIX (0x5054)
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_WLAN_PROT_EVT_INIT_DONE = 0,
|
||||
RT_WLAN_PROT_EVT_CONNECT,
|
||||
RT_WLAN_PROT_EVT_DISCONNECT,
|
||||
RT_WLAN_PROT_EVT_AP_START,
|
||||
RT_WLAN_PROT_EVT_AP_STOP,
|
||||
RT_WLAN_PROT_EVT_AP_ASSOCIATED,
|
||||
RT_WLAN_PROT_EVT_AP_DISASSOCIATED,
|
||||
RT_WLAN_PROT_EVT_MAX,
|
||||
} rt_wlan_prot_event_t;
|
||||
|
||||
struct rt_wlan_prot;
|
||||
struct rt_wlan_prot_ops
|
||||
{
|
||||
rt_err_t (*prot_recv)(struct rt_wlan_device *wlan, void *buff, int len);
|
||||
struct rt_wlan_prot *(*dev_reg_callback)(struct rt_wlan_prot *prot, struct rt_wlan_device *wlan);
|
||||
void (*dev_unreg_callback)(struct rt_wlan_prot *prot, struct rt_wlan_device *wlan);
|
||||
};
|
||||
|
||||
struct rt_wlan_prot
|
||||
{
|
||||
char name[RT_WLAN_PROT_NAME_LEN];
|
||||
rt_uint32_t id;
|
||||
const struct rt_wlan_prot_ops *ops;
|
||||
};
|
||||
|
||||
typedef void (*rt_wlan_prot_event_handler)(struct rt_wlan_prot *port, struct rt_wlan_device *wlan, int event);
|
||||
|
||||
rt_err_t rt_wlan_prot_attach(const char *dev_name, const char *prot_name);
|
||||
|
||||
rt_err_t rt_wlan_prot_attach_dev(struct rt_wlan_device *wlan, const char *prot_name);
|
||||
|
||||
rt_err_t rt_wlan_prot_detach(const char *dev_name);
|
||||
|
||||
rt_err_t rt_wlan_prot_detach_dev(struct rt_wlan_device *wlan);
|
||||
|
||||
rt_err_t rt_wlan_prot_regisetr(struct rt_wlan_prot *prot);
|
||||
|
||||
rt_err_t rt_wlan_prot_transfer_dev(struct rt_wlan_device *wlan, void *buff, int len);
|
||||
|
||||
rt_err_t rt_wlan_dev_transfer_prot(struct rt_wlan_device *wlan, void *buff, int len);
|
||||
|
||||
rt_err_t rt_wlan_prot_event_register(struct rt_wlan_prot *prot, rt_wlan_prot_event_t event, rt_wlan_prot_event_handler handler);
|
||||
|
||||
rt_err_t rt_wlan_prot_event_unregister(struct rt_wlan_prot *prot, rt_wlan_prot_event_t event);
|
||||
|
||||
int rt_wlan_prot_ready(struct rt_wlan_device *wlan, struct rt_wlan_buff *buff);
|
||||
|
||||
void rt_wlan_prot_dump(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
101
riscv/rtthread/components/drivers/wlan/wlan_workqueue.c
Executable file
101
riscv/rtthread/components/drivers/wlan/wlan_workqueue.c
Executable file
@@ -0,0 +1,101 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-19 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rthw.h>
|
||||
#include <rtthread.h>
|
||||
#include <wlan_workqueue.h>
|
||||
#include <ipc/workqueue.h>
|
||||
|
||||
#define DBG_TAG "WLAN.work"
|
||||
#define DBG_LVL DBG_INFO
|
||||
#include <rtdbg.h>
|
||||
|
||||
#ifdef RT_WLAN_WORK_THREAD_ENABLE
|
||||
|
||||
struct rt_wlan_work
|
||||
{
|
||||
struct rt_work work;
|
||||
void (*fun)(void *parameter);
|
||||
void *parameter;
|
||||
};
|
||||
|
||||
static struct rt_workqueue *wlan_workqueue;
|
||||
|
||||
static void rt_wlan_workqueue_fun(struct rt_work *work, void *work_data)
|
||||
{
|
||||
struct rt_wlan_work *wlan_work = work_data;
|
||||
|
||||
wlan_work->fun(wlan_work->parameter);
|
||||
rt_free(wlan_work);
|
||||
}
|
||||
|
||||
struct rt_workqueue *rt_wlan_get_workqueue(void)
|
||||
{
|
||||
return wlan_workqueue;
|
||||
}
|
||||
|
||||
rt_err_t rt_wlan_workqueue_dowork(void (*func)(void *parameter), void *parameter)
|
||||
{
|
||||
struct rt_wlan_work *wlan_work;
|
||||
rt_err_t err = RT_EOK;
|
||||
|
||||
LOG_D("F:%s is run", __FUNCTION__);
|
||||
if (func == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d func is null", __FUNCTION__, __LINE__);
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
if (wlan_workqueue == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d not init wlan work queue", __FUNCTION__, __LINE__);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
wlan_work = rt_malloc(sizeof(struct rt_wlan_work));
|
||||
if (wlan_work == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d create work failed", __FUNCTION__, __LINE__);
|
||||
return -RT_ENOMEM;
|
||||
}
|
||||
wlan_work->fun = func;
|
||||
wlan_work->parameter = parameter;
|
||||
rt_work_init(&wlan_work->work, rt_wlan_workqueue_fun, wlan_work);
|
||||
err = rt_workqueue_dowork(wlan_workqueue, &wlan_work->work);
|
||||
if (err != RT_EOK)
|
||||
{
|
||||
LOG_E("F:%s L:%d do work failed", __FUNCTION__, __LINE__);
|
||||
rt_free(wlan_work);
|
||||
return err;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
int rt_wlan_workqueue_init(void)
|
||||
{
|
||||
static rt_int8_t _init_flag = 0;
|
||||
|
||||
if (_init_flag == 0)
|
||||
{
|
||||
wlan_workqueue = rt_workqueue_create(RT_WLAN_WORKQUEUE_THREAD_NAME, RT_WLAN_WORKQUEUE_THREAD_SIZE,
|
||||
RT_WLAN_WORKQUEUE_THREAD_PRIO);
|
||||
if (wlan_workqueue == RT_NULL)
|
||||
{
|
||||
LOG_E("F:%s L:%d wlan work queue create failed", __FUNCTION__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
_init_flag = 1;
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
INIT_PREV_EXPORT(rt_wlan_workqueue_init);
|
||||
|
||||
#endif
|
||||
42
riscv/rtthread/components/drivers/wlan/wlan_workqueue.h
Executable file
42
riscv/rtthread/components/drivers/wlan/wlan_workqueue.h
Executable file
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2023, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-08-19 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __WLAN_WORKQUEUE_H__
|
||||
#define __WLAN_WORKQUEUE_H__
|
||||
|
||||
#include <ipc/workqueue.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_WORKQUEUE_THREAD_NAME
|
||||
#define RT_WLAN_WORKQUEUE_THREAD_NAME ("wlan_job")
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_WORKQUEUE_THREAD_SIZE
|
||||
#define RT_WLAN_WORKQUEUE_THREAD_SIZE (2048)
|
||||
#endif
|
||||
|
||||
#ifndef RT_WLAN_WORKQUEUE_THREAD_PRIO
|
||||
#define RT_WLAN_WORKQUEUE_THREAD_PRIO (20)
|
||||
#endif
|
||||
|
||||
int rt_wlan_workqueue_init(void);
|
||||
|
||||
rt_err_t rt_wlan_workqueue_dowork(void (*func)(void *parameter), void *parameter);
|
||||
|
||||
struct rt_workqueue *rt_wlan_get_workqueue(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user