Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
2301_76519099
rt-thread
提交
83d134bc
R
rt-thread
项目概览
2301_76519099
/
rt-thread
与 Fork 源项目一致
Fork自
RT-Thread / rt-thread
通知
3
Star
1
Fork
1
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
rt-thread
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
未验证
提交
83d134bc
编写于
9月 22, 2018
作者:
B
Bernard Xiong
提交者:
GitHub
9月 22, 2018
浏览文件
操作
浏览文件
下载
差异文件
Merge pull request #1810 from enkiller/dev
[DeviceDriver][wlan] add new wlan framework
上级
d675ede8
b5202d17
变更
16
展开全部
隐藏空白更改
内联
并排
Showing
16 changed file
with
5245 addition
and
904 deletion
+5245
-904
components/drivers/Kconfig
components/drivers/Kconfig
+88
-16
components/drivers/include/drivers/wlan.h
components/drivers/include/drivers/wlan.h
+21
-0
components/drivers/include/rtdevice.h
components/drivers/include/rtdevice.h
+6
-16
components/drivers/wlan/wlan_cfg.c
components/drivers/wlan/wlan_cfg.c
+463
-0
components/drivers/wlan/wlan_cfg.h
components/drivers/wlan/wlan_cfg.h
+67
-0
components/drivers/wlan/wlan_cmd.c
components/drivers/wlan/wlan_cmd.c
+428
-389
components/drivers/wlan/wlan_cmd.h
components/drivers/wlan/wlan_cmd.h
+0
-50
components/drivers/wlan/wlan_dev.c
components/drivers/wlan/wlan_dev.c
+627
-182
components/drivers/wlan/wlan_dev.h
components/drivers/wlan/wlan_dev.h
+508
-143
components/drivers/wlan/wlan_lwip.c
components/drivers/wlan/wlan_lwip.c
+483
-0
components/drivers/wlan/wlan_mgnt.c
components/drivers/wlan/wlan_mgnt.c
+1826
-86
components/drivers/wlan/wlan_mgnt.h
components/drivers/wlan/wlan_mgnt.h
+138
-22
components/drivers/wlan/wlan_prot.c
components/drivers/wlan/wlan_prot.c
+364
-0
components/drivers/wlan/wlan_prot.h
components/drivers/wlan/wlan_prot.h
+85
-0
components/drivers/wlan/wlan_workqueue.c
components/drivers/wlan/wlan_workqueue.c
+99
-0
components/drivers/wlan/wlan_workqueue.h
components/drivers/wlan/wlan_workqueue.h
+42
-0
未找到文件。
components/drivers/Kconfig
浏览文件 @
83d134bc
...
...
@@ -207,31 +207,103 @@ config RT_USING_WDT
bool "Using Watch Dog device drivers"
default n
config RT_USING_WIFI
bool "Using Wi-Fi network"
config RT_USING_AUDIO
bool "Using Audio device drivers"
default n
menu "Using WiFi"
config RT_USING_WIFI
bool "Using Wi-Fi framework"
default n
if RT_USING_WIFI
config RT_USING_WLAN_STA
bool "Using station mode"
config RT_WLAN_DEVICE_STA_NAME
string "The WiFi device name for station"
default "wlan0"
config RT_WLAN_DEVICE_AP_NAME
string "The WiFi device name for ap"
default "wlan1"
config RT_WLAN_DEFAULT_PROT
string "Default transport protocol"
default "lwip"
config RT_WLAN_SCAN_WAIT_MS
int "Set scan timeout time(ms)"
default 10000;
config RT_WLAN_CONNECT_WAIT_MS
int "Set connect timeout time(ms)"
default 10000;
config RT_WLAN_SSID_MAX_LENGTH
int "SSID name maximum length"
default 32
config RT_WLAN_PASSWORD_MAX_LENGTH
int "Maximum password length"
default 32
config RT_WLAN_SCAN_SORT
bool "Automatic sorting of scan results"
default y
config RT_USING_WLAN_AP
bool "Using ap mode"
config RT_WLAN_CFG_INFO_MAX
int "Maximum number of WiFi information automatically saved"
default 3
config RT_WLAN_WORKQUEUE_THREAD_NAME
string "WiFi work queue thread name"
default "wlan_job"
config RT_WLAN_WORKQUEUE_THREAD_SIZE
int "wifi work queue thread size"
default 2048
config RT_WLAN_WORKQUEUE_THREAD_PRIO
int "WiFi work queue thread priority"
default 22
config RT_WLAN_DEV_EVENT_NUM
int "Maximum number of driver events"
default 2
config RT_WLAN_PROT_LWIP_PBUF_FORCE
bool "Forced use of PBUF transmission"
default n
config WIFI_DEVICE_STA_NAME
string "the wifi device name for station
"
default
"w0"
menuconfig RT_WLAN_DEBUG
bool "Enable WLAN Debugging Options
"
default
n
config WIFI_DEVICE_AP_NAME
string "the wifi device name for ap"
default "ap
"
endif
if RT_WLAN_DEBUG
config RT_WLAN_CMD_DEBUG
bool "Enable Debugging of wlan_cmd.c
"
default n
config RT_USING_AUDIO
bool "Using Audio device drivers"
default n
config RT_WLAN_MGNT_DEBUG
bool "Enable Debugging of wlan_mgnt.c"
default n
config RT_WLAN_DEV_DEBUG
bool "Enable Debugging of wlan_dev.c"
default n
config RT_WLAN_PROT_DEBUG
bool "Enable Debugging of wlan_prot.c"
default n
config RT_WLAN_CFG_DEBUG
bool "Enable Debugging of wlan_cfg.c"
default n
config RT_WLAN_LWIP_DEBUG
bool "Enable Debugging of wlan_lwip.c"
default n
endif
endif
endmenu
menu "Using USB"
config RT_USING_USB_HOST
...
...
components/drivers/include/drivers/wlan.h
0 → 100644
浏览文件 @
83d134bc
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2018-09-15 tyx the first version
*/
#ifndef __WLAN_H__
#define __WLAN_H__
#include <rtthread.h>
#include <wlan_dev.h>
#include <wlan_cfg.h>
#include <wlan_mgnt.h>
#include <wlan_prot.h>
#include <wlan_workqueue.h>
#endif
components/drivers/include/rtdevice.h
浏览文件 @
83d134bc
/*
* File : rtdevice.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
...
...
@@ -117,6 +103,10 @@ extern "C" {
#include "drivers/rt_drv_pwm.h"
#endif
#ifdef RT_USING_WIFI
#include "drivers/wlan.h"
#endif
#ifdef MTD_USING_NOR
#include "drivers/mtdnor.h"
#endif
...
...
components/drivers/wlan/wlan_cfg.c
0 → 100644
浏览文件 @
83d134bc
/*
* Copyright (c) 2006-2018, 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_ENABLE
#ifdef RT_WLAN_CFG_DEBUG
#define DBG_LEVEL DBG_LOG
#else
#define DBG_LEVEL DBG_INFO
#endif
#define DBG_SECTION_NAME "WLAN.cfg"
#define DBG_COLOR
#include <rtdbg.h>
#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
--
)
{
wChar
=
*
(
buff
++
);
wCRCin
^=
(
wChar
<<
8
);
for
(
int
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_FIFO
);
}
}
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
);
}
}
components/drivers/wlan/wlan_cfg.h
0 → 100644
浏览文件 @
83d134bc
/*
* Copyright (c) 2006-2018, 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
components/drivers/wlan/wlan_cmd.c
浏览文件 @
83d134bc
此差异已折叠。
点击以展开。
components/drivers/wlan/wlan_cmd.h
已删除
100644 → 0
浏览文件 @
d675ede8
/*
* File : wlan_cmd.h
* Wi-Fi common commands
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2018-06-05 RT-Thread first version
*/
#ifndef WLAN_CMD_H__
#define WLAN_CMD_H__
struct
netif
;
int
wifi_get_mode
(
void
);
int
wifi_set_mode
(
int
mode
);
/* do the wifi default action: read wifi setting and then join or start soft-AP */
int
wifi_default
(
void
);
/* setup netif for soft-ap */
int
wifi_softap_setup_netif
(
struct
netif
*
netif
);
int
wifi_set_setting
(
const
char
*
ssid
,
const
char
*
pwd
);
#ifdef PKG_USING_CJSON
int
wifi_read_cfg
(
const
char
*
filename
);
int
wifi_save_cfg
(
const
char
*
filename
);
#endif
/* save wifi setting with default storage file */
int
wifi_save_setting
(
void
);
extern
struct
rt_wlan_info
info
;
#endif
components/drivers/wlan/wlan_dev.c
浏览文件 @
83d134bc
此差异已折叠。
点击以展开。
components/drivers/wlan/wlan_dev.h
浏览文件 @
83d134bc
此差异已折叠。
点击以展开。
components/drivers/wlan/wlan_lwip.c
0 → 100644
浏览文件 @
83d134bc
/*
* Copyright (c) 2006-2018, 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>
#ifdef RT_USING_LWIP
#include <netif/ethernetif.h>
#include <lwip/netifapi.h>
#ifdef LWIP_USING_DHCPD
#include <dhcp_server.h>
#endif
#define DBG_ENABLE
#ifdef RT_WLAN_LWIP_DEBUG
#define DBG_LEVEL DBG_LOG
#else
#define DBG_LEVEL DBG_INFO
#endif
#define DBG_SECTION_NAME "WLAN.lwip"
#define DBG_COLOR
#include <rtdbg.h>
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
=
&
lwip_prot
->
eth
;
char
str
[
IP4ADDR_STRLEN_MAX
];
rt_base_t
level
;
struct
rt_wlan_buff
buff
;
rt_uint32_t
ip_addr
[
4
];
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
(
&
eth_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
(
&
eth_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
,
IP4ADDR_STRLEN_MAX
);
rt_enter_critical
();
rt_memcpy
(
str
,
ipaddr_ntoa
(
&
(
eth_dev
->
netif
->
ip_addr
)),
IP4ADDR_STRLEN_MAX
);
rt_exit_critical
();
LOG_I
(
"Got IP address : %s"
,
str
);
exit:
level
=
rt_hw_interrupt_disable
();
rt_memset
(
work
,
0
,
sizeof
(
struct
rt_work
));
rt_hw_interrupt_enable
(
level
);
}
static
void
timer_callback
(
void
*
parameter
)
{
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
=
&
lwip_prot
->
work
;
rt_base_t
level
;
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
);
}
}
}
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
=
&
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_set_link_up
(
eth_dev
->
netif
);
#ifdef RT_LWIP_DHCP
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_set_link_up
(
eth_dev
->
netif
);
#ifdef LWIP_USING_DHCPD
{
char
netif_name
[
8
];
int
i
;
rt_memset
(
netif_name
,
0
,
sizeof
(
netif_name
));
for
(
i
=
0
;
i
<
sizeof
(
eth_dev
->
netif
->
name
);
i
++
)
{
netif_name
[
i
]
=
eth_dev
->
netif
->
name
[
i
];
}
dhcpd_start
(
netif_name
);
}
#endif
}
}
else
{
if
(
wlan
->
mode
==
RT_WLAN_STATION
)
{
LOG_D
(
"F:%s L:%d dhcp stop run"
,
__FUNCTION__
,
__LINE__
);
netifapi_netif_set_link_down
(
eth_dev
->
netif
);
#ifdef RT_LWIP_DHCP
{
ip4_addr_t
ip_addr
=
{
0
};
dhcp_stop
(
eth_dev
->
netif
);
netif_set_addr
(
eth_dev
->
netif
,
&
ip_addr
,
&
ip_addr
,
&
ip_addr
);
}
#endif
rt_timer_stop
(
&
lwip_prot
->
timer
);
}
else
if
(
wlan
->
mode
==
RT_WLAN_AP
)
{
LOG_D
(
"F:%s L:%d dhcpd stop run"
,
__FUNCTION__
,
__LINE__
);
netifapi_netif_set_link_down
(
eth_dev
->
netif
);
}
}
}
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
;
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
)
{
rt_wlan_workqueue_dowork
(
netif_set_connected
,
wlan
);
// netif_set_connected(wlan);
}
}
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
}
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
;
static
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
;
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
;
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
));
if
(
wlan
->
mode
==
RT_WLAN_STATION
)
{
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
);
}
LOG_I
(
"eth device init ok name:%s"
,
eth_name
);
return
&
lwip_prot
->
prot
;
}
static
void
rt_wlan_lwip_protocol_unregister
(
struct
rt_wlan_prot
*
prot
,
struct
rt_wlan_device
*
wlan
)
{
/*TODO*/
LOG_D
(
"F:%s L:%d is run wlan:0x%08x"
,
__FUNCTION__
,
__LINE__
,
wlan
);
}
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
,
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
components/drivers/wlan/wlan_mgnt.c
浏览文件 @
83d134bc
此差异已折叠。
点击以展开。
components/drivers/wlan/wlan_mgnt.h
浏览文件 @
83d134bc
/*
*
RT-Thread Wi-Fi Device
*
Copyright (c) 2006-2018, RT-Thread Development Team
*
* COPYRIGHT (C) 2014 - 2018, Shanghai Real-Thread Technology Co., Ltd
*
* This file is part of RT-Thread (http://www.rt-thread.org)
*
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2018-0
2-27 EvalZero the first ver
ion
* 2018-0
8-06 tyx the first vers
ion
*/
#ifndef __WLAN_MGNT_H__
#define __WLAN_MGNT_H__
int
rt_wlan_mgnt_attach
(
struct
rt_wlan_device
*
device
,
void
*
user_data
);
#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
/*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
);
int
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
);
struct
rt_wlan_scan_result
*
rt_wlan_scan_with_info
(
struct
rt_wlan_info
*
info
);
int
rt_wlan_scan_get_info_num
(
void
);
int
rt_wlan_scan_get_info
(
struct
rt_wlan_info
*
info
,
int
num
);
struct
rt_wlan_scan_result
*
rt_wlan_scan_get_result
(
void
);
void
rt_wlan_scan_result_clean
(
void
);
int
rt_wlan_scan_find_cache
(
struct
rt_wlan_info
*
info
,
struct
rt_wlan_info
*
out_info
,
int
num
);
rt_bool_t
rt_wlan_find_best_by_cache
(
const
char
*
ssid
,
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
components/drivers/wlan/wlan_prot.c
0 → 100644
浏览文件 @
83d134bc
/*
* Copyright (c) 2006-2018, 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_ENABLE
#ifdef RT_WLAN_PROT_DEBUG
#define DBG_LEVEL DBG_LOG
#else
#define DBG_LEVEL DBG_INFO
#endif
#define DBG_SECTION_NAME "WLAN.prot"
#define DBG_COLOR
#include <rtdbg.h>
#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_t
event
;
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
,
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
;
}
for
(
event
=
RT_WLAN_DEV_EVT_INIT_DONE
;
event
<
RT_WLAN_DEV_EVT_MAX
;
event
++
)
{
if
(
rt_wlan_dev_register_event_handler
(
wlan
,
event
,
rt_wlan_prot_event_handle
,
RT_NULL
)
!=
RT_EOK
)
{
LOG_E
(
"prot register event filed:%d"
,
event
);
}
}
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
);
}
}
}
components/drivers/wlan/wlan_prot.h
0 → 100644
浏览文件 @
83d134bc
/*
* Copyright (c) 2006-2018, 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)
#define RT_WLAN_PROT_LWIP ("lwip")
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
components/drivers/wlan/wlan_workqueue.c
0 → 100644
浏览文件 @
83d134bc
/*
* Copyright (c) 2006-2018, 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_ENABLE
#define DBG_LEVEL DBG_INFO
#define DBG_SECTION_NAME "WLAN.work"
#define DBG_COLOR
#include <rtdbg.h>
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
);
components/drivers/wlan/wlan_workqueue.h
0 → 100644
浏览文件 @
83d134bc
/*
* Copyright (c) 2006-2018, 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
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录