[DeviceDriver][wlan] add new wlan framework

components/drivers/Kconfig

@@ -194,31 +194,73 @@ 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 "Scan timeout time"
+            default 10000;
+
+        config RT_WLAN_CONNECT_WAIT_MS
+            int "connect timeout time"
+            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"
-            default n
+        config RT_WLAN_CFG_INFO_MAX
+            int "Maximum number of WiFi information automatically saved"
+            default 3
 
-        config WIFI_DEVICE_STA_NAME
-            string "the wifi device name for station"
-            default "w0"
+        config RT_WLAN_WORKQUEUE_THREAD_NAME
+            string "WiFi work queue thread name"
+            default "wlan_job"
 
-        config WIFI_DEVICE_AP_NAME
-            string "the wifi device name for ap"
-            default "ap"
-    endif
+        config RT_WLAN_WORKQUEUE_THREAD_SIZE
+            int "wifi work queue thread size"
+            default 2048
 
-config RT_USING_AUDIO
-    bool "Using Audio device drivers"
-    default n
+        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
+    endif
+endmenu
 
 menu "Using USB"
     config RT_USING_USB_HOST

components/drivers/include/drivers/wlan.h

+/*
+ * 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

@@ -117,6 +117,10 @@ extern "C" {
 #include "drivers/rt_drv_pwm.h"
 #endif
 
+#ifdef RT_USING_WIFI
+#include "drivers/wlan.h"
+#endif
+
 #ifdef __cplusplus
 }
 #endif

components/drivers/wlan/wlan_cfg.c

+/*
+ * 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
+#define DBG_LEVEL DBG_INFO
+#define DBG_SECTION_NAME  "WLAN.cfg"
+#define DBG_COLOR
+#include <rtdbg.h>
+
+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;
+};
+
+#define WLAN_CFG_LOCK()      (rt_mutex_take(&cfg_mutex, RT_WAITING_FOREVER))
+#define WLAN_CFG_UNLOCK()    (rt_mutex_release(&cfg_mutex))
+
+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 (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 (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

+/*
+ * 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
+
+#if RT_WLAN_CFG_INFO_MAX < 1
+#error "The minimum configuration 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.h

-/*
- * 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_lwip.c

+/*
+ * 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
+#define DBG_LEVEL DBG_INFO
+#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.h

 /*
- *  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-02-27     EvalZero     the first verion
+ * 2018-08-06     tyx          the first version
  */
 
 #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
+
+#if RT_WLAN_EBOX_NUM < 1
+#error "event box num Too little"
+#endif
+
+/*state fot station*/
+#define RT_WLAN_STATE_CONNECT     (0x1 << 0)
+#define RT_WLAN_STATE_CONNECTING  (0x1 << 1)
+#define RT_WLAN_STATE_READY       (0x1 << 2)
+#define RT_WLAN_STATE_POWERSAVE   (0x1 << 3)
+
+/*flags fot station*/
+#define RT_WLAN_STATE_AUTOEN      (0x1 << 0)
+
+/*state fot ap*/
+#define RT_WLAN_STATE_ACTIVE      (0x1 << 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);
+int rt_wlan_is_connected(void);
+int 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_enable_powersave(void);
+rt_err_t rt_wlan_disable_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

+/*
+ * 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
+#define DBG_LEVEL DBG_INFO
+#define DBG_SECTION_NAME  "WLAN.prot"
+#define DBG_COLOR
+#include <rtdbg.h>
+
+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

+/*
+ * 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)
+
+#if RT_WLAN_PROT_NAME_LEN < 4
+#error "The name is too short"
+#endif
+
+#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

+/*
+ * 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

+/*
+ * 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