| /** |
| * Copyright (C) 2016 CSI Project. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef __CSI_WIFI_H__ |
| #define __CSI_WIFI_H__ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #ifndef bool |
| #define bool int8_t |
| #define false 0 ///< XOS definition of 'false' |
| #define true 1 ///< XOS definition of 'true' |
| #endif |
| |
| typedef enum { |
| WIFI_EVENT_WIFI_READY = 0, /**< WiFi ready */ |
| WIFI_EVENT_SCAN_DONE, /**< finish scanning AP */ |
| WIFI_EVENT_STA_START, /**< station start */ |
| WIFI_EVENT_STA_STOP, /**< station stop */ |
| WIFI_EVENT_STA_CONNECTED, /**< station connected to AP */ |
| WIFI_EVENT_STA_DISCONNECTED, /**< station disconnected from AP */ |
| WIFI_EVENT_STA_AUTHMODE_CHANGE, /**< the auth mode of AP connected by station changed */ |
| WIFI_EVENT_STA_GOT_IP, /**< station got IP from connected AP */ |
| WIFI_EVENT_STA_WPS_ER_SUCCESS, /**< station wps succeeds in enrollee mode */ |
| WIFI_EVENT_STA_WPS_ER_FAILED, /**< station wps fails in enrollee mode */ |
| WIFI_EVENT_STA_WPS_ER_TIMEOUT, /**< station wps timeout in enrollee mode */ |
| WIFI_EVENT_STA_WPS_ER_PIN, /**< station wps pin code in enrollee mode */ |
| WIFI_EVENT_AP_START, /**< soft-AP start */ |
| WIFI_EVENT_AP_STOP, /**< soft-AP stop */ |
| WIFI_EVENT_AP_STACONNECTED, /**< a station connected to soft-AP */ |
| WIFI_EVENT_AP_STADISCONNECTED, /**< a station disconnected from soft-AP */ |
| WIFI_EVENT_AP_PROBEREQRECVED, /**< Receive probe request packet in soft-AP interface */ |
| WIFI_EVENT_AP_STA_GOT_IP6, /**< station or ap interface v6IP addr is preferred */ |
| WIFI_EVENT_ETH_START, /**< ethernet start */ |
| WIFI_EVENT_ETH_STOP, /**< ethernet stop */ |
| WIFI_EVENT_ETH_CONNECTED, /**< ethernet phy link up */ |
| WIFI_EVENT_ETH_DISCONNECTED, /**< ethernet phy link down */ |
| WIFI_EVENT_ETH_GOT_IP, /**< ethernet got IP from connected AP */ |
| WIFI_EVENT_MAX |
| } wifi_event_id_t; |
| |
| |
| typedef enum { |
| CSI_IF_WIFI_STA = 0, /**< CSI station interface */ |
| CSI_IF_WIFI_AP, /**< CSI soft-AP interface */ |
| CSI_IF_ETH, /**< CSI ethernet interface */ |
| CSI_IF_MAX |
| } csi_interface_t; |
| |
| typedef enum { |
| WIFI_MODE_NULL = 0, /**< null mode */ |
| WIFI_MODE_STA, /**< WiFi station mode */ |
| WIFI_MODE_AP, /**< WiFi soft-AP mode */ |
| WIFI_MODE_APSTA, /**< WiFi station + soft-AP mode */ |
| WIFI_MODE_MAX |
| } wifi_mode_t; |
| |
| typedef csi_interface_t wifi_interface_t; |
| |
| #define WIFI_IF_STA CSI_IF_WIFI_STA |
| #define WIFI_IF_AP CSI_IF_WIFI_AP |
| |
| typedef enum { |
| WIFI_COUNTRY_CN = 0, /**< country China, channel range [1, 14] */ |
| WIFI_COUNTRY_JP, /**< country Japan, channel range [1, 14] */ |
| WIFI_COUNTRY_US, /**< country USA, channel range [1, 11] */ |
| WIFI_COUNTRY_EU, /**< country Europe, channel range [1, 13] */ |
| WIFI_COUNTRY_MAX |
| } wifi_country_t; |
| |
| typedef enum { |
| WIFI_AUTH_OPEN = 0, /**< authenticate mode : open */ |
| WIFI_AUTH_WEP, /**< authenticate mode : WEP */ |
| WIFI_AUTH_WPA_PSK, /**< authenticate mode : WPA_PSK */ |
| WIFI_AUTH_WPA2_PSK, /**< authenticate mode : WPA2_PSK */ |
| WIFI_AUTH_WPA_WPA2_PSK, /**< authenticate mode : WPA_WPA2_PSK */ |
| WIFI_AUTH_WPA2_ENTERPRISE, /**< authenticate mode : WPA2_ENTERPRISE */ |
| WIFI_AUTH_MAX |
| } wifi_auth_mode_t; |
| |
| enum { |
| WIFI_REASON_UNSPECIFIED = 1, |
| WIFI_REASON_AUTH_EXPIRE = 2, |
| WIFI_REASON_AUTH_LEAVE = 3, |
| WIFI_REASON_ASSOC_EXPIRE = 4, |
| WIFI_REASON_ASSOC_TOOMANY = 5, |
| WIFI_REASON_NOT_AUTHED = 6, |
| WIFI_REASON_NOT_ASSOCED = 7, |
| WIFI_REASON_ASSOC_LEAVE = 8, |
| WIFI_REASON_ASSOC_NOT_AUTHED = 9, |
| WIFI_REASON_DISASSOC_PWRCAP_BAD = 10, |
| WIFI_REASON_DISASSOC_SUPCHAN_BAD = 11, |
| WIFI_REASON_IE_INVALID = 13, |
| WIFI_REASON_MIC_FAILURE = 14, |
| WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT = 15, |
| WIFI_REASON_GROUP_KEY_UPDATE_TIMEOUT = 16, |
| WIFI_REASON_IE_IN_4WAY_DIFFERS = 17, |
| WIFI_REASON_GROUP_CIPHER_INVALID = 18, |
| WIFI_REASON_PAIRWISE_CIPHER_INVALID = 19, |
| WIFI_REASON_AKMP_INVALID = 20, |
| WIFI_REASON_UNSUPP_RSN_IE_VERSION = 21, |
| WIFI_REASON_INVALID_RSN_IE_CAP = 22, |
| WIFI_REASON_802_1X_AUTH_FAILED = 23, |
| WIFI_REASON_CIPHER_SUITE_REJECTED = 24, |
| |
| WIFI_REASON_BEACON_TIMEOUT = 200, |
| WIFI_REASON_NO_AP_FOUND = 201, |
| WIFI_REASON_AUTH_FAIL = 202, |
| WIFI_REASON_ASSOC_FAIL = 203, |
| WIFI_REASON_HANDSHAKE_TIMEOUT = 204, |
| }; |
| |
| typedef enum { |
| WIFI_SECOND_CHAN_NONE = 0, /**< the channel width is HT20 */ |
| WIFI_SECOND_CHAN_ABOVE, /**< the channel width is HT40 and the second channel is above the primary channel */ |
| WIFI_SECOND_CHAN_BELOW, /**< the channel width is HT40 and the second channel is below the primary channel */ |
| } wifi_second_chan_t; |
| |
| typedef enum { |
| WIFI_SCAN_TYPE_ACTIVE = 0, /**< active scan */ |
| WIFI_SCAN_TYPE_PASSIVE, /**< passive scan */ |
| } wifi_scan_type_t; |
| |
| typedef struct { |
| uint32_t min; /**< minimum active scan time per channel, units: millisecond */ |
| uint32_t max; /**< maximum active scan time per channel, units: millisecond, values above 1500ms may |
| cause station to disconnect from AP and are not recommended. */ |
| } wifi_active_scan_time_t; |
| |
| typedef union { |
| wifi_active_scan_time_t active; /**< active scan time per channel */ |
| uint32_t passive; /**< passive scan time per channel, units: millisecond, values above 1500ms may |
| cause station to disconnect from AP and are not recommended. */ |
| } wifi_scan_time_t; |
| |
| typedef struct { |
| uint8_t *ssid; /**< SSID of AP */ |
| uint8_t *bssid; /**< MAC address of AP */ |
| uint8_t channel; /**< channel, scan the specific channel */ |
| bool show_hidden; /**< enable to scan AP whose SSID is hidden */ |
| wifi_scan_type_t scan_type; /**< scan type, active or passive */ |
| wifi_scan_time_t scan_time; /**< scan time per channel */ |
| } wifi_scan_config_t; |
| |
| typedef struct { |
| uint8_t bssid[6]; /**< MAC address of AP */ |
| uint8_t ssid[32]; /**< SSID of AP */ |
| uint8_t primary; /**< channel of AP */ |
| wifi_second_chan_t second; /**< second channel of AP */ |
| int8_t rssi; /**< signal strength of AP */ |
| wifi_auth_mode_t authmode; /**< authmode of AP */ |
| uint32_t low_rate_enable:1; /**< bit: 0 flag to identify if low rate is enabled or not */ |
| uint32_t reserved:31; /**< bit: 1..31 reserved */ |
| } wifi_ap_record_t; |
| |
| typedef enum { |
| WIFI_PS_NONE, /**< No power save */ |
| WIFI_PS_MODEM, /**< Modem power save */ |
| } wifi_ps_type_t; |
| |
| #define WIFI_PROTOCOL_11B 1 |
| #define WIFI_PROTOCOL_11G 2 |
| #define WIFI_PROTOCOL_11N 4 |
| #define WIFI_PROTOCOL_LR 8 |
| |
| typedef enum { |
| WIFI_BW_HT20 = 1, /* Bandwidth is HT20 */ |
| WIFI_BW_HT40, /* Bandwidth is HT40 */ |
| WIFI_BW_HT20_HT40, |
| } wifi_bandwidth_t; |
| |
| typedef struct { |
| uint8_t ssid[32]; /**< SSID of soft-AP */ |
| uint8_t password[64]; /**< Password of soft-AP */ |
| uint8_t ssid_len; /**< Length of SSID. If softap_config.ssid_len==0, check the SSID until there is a termination character; otherwise, set the SSID length according to softap_config.ssid_len. */ |
| uint8_t channel; /**< Channel of soft-AP */ |
| wifi_auth_mode_t authmode; /**< Auth mode of soft-AP. Do not support AUTH_WEP in soft-AP mode */ |
| uint8_t ssid_hidden; /**< Broadcast SSID or not, default 0, broadcast the SSID */ |
| uint8_t max_connection; /**< Max number of stations allowed to connect in, default 4, max 4 */ |
| uint16_t beacon_interval; /**< Beacon interval, 100 ~ 60000 ms, default 100 ms */ |
| } wifi_ap_config_t; |
| |
| typedef struct { |
| uint8_t ssid[32]; /**< SSID of target AP*/ |
| uint8_t password[64]; /**< password of target AP*/ |
| bool bssid_set; /**< whether set MAC address of target AP or not. Generally, station_config.bssid_set needs to be 0; and it needs to be 1 only when users need to check the MAC address of the AP.*/ |
| uint8_t bssid[6]; /**< MAC address of target AP*/ |
| } wifi_sta_config_t; |
| |
| typedef union { |
| wifi_ap_config_t ap; /**< configuration of AP */ |
| wifi_sta_config_t sta; /**< configuration of STA */ |
| } wifi_config_t; |
| |
| typedef struct { |
| uint8_t mac[6]; /**< mac address of sta that associated with soft-AP */ |
| } wifi_sta_info_t; |
| |
| #define CSI_WIFI_MAX_CONN_NUM (10) /**< max number of stations which can connect to soft-AP */ |
| |
| typedef struct { |
| wifi_sta_info_t sta[CSI_WIFI_MAX_CONN_NUM]; /**< station list */ |
| int num; /**< number of station that associated with soft-AP */ |
| } wifi_sta_list_t; |
| |
| typedef enum { |
| WIFI_STORAGE_FLASH, /**< all configuration will strore in both memory and flash */ |
| WIFI_STORAGE_RAM, /**< all configuration will only store in the memory */ |
| } wifi_storage_t; |
| |
| /** |
| * @brief Vendor IE type |
| * |
| */ |
| typedef enum { |
| WIFI_VND_IE_TYPE_BEACON, |
| WIFI_VND_IE_TYPE_PROBE_REQ, |
| WIFI_VND_IE_TYPE_PROBE_RCSI, |
| WIFI_VND_IE_TYPE_ASSOC_REQ, |
| WIFI_VND_IE_TYPE_ASSOC_RCSI, |
| } wifi_vendor_ie_type_t; |
| |
| /** |
| * @brief Vendor IE index |
| * |
| */ |
| typedef enum { |
| WIFI_VND_IE_ID_0, |
| WIFI_VND_IE_ID_1, |
| } wifi_vendor_ie_id_t; |
| |
| typedef struct { |
| signed rssi:8; /**< signal intensity of packet */ |
| unsigned rate:5; /**< data rate */ |
| unsigned :1; /**< reserve */ |
| unsigned sig_mode:2; /**< 0:is not 11n packet; 1:is 11n packet */ |
| unsigned :16; /**< reserve */ |
| unsigned mcs:7; /**< if is 11n packet, shows the modulation(range from 0 to 76) */ |
| unsigned cwb:1; /**< if is 11n packet, shows if is HT40 packet or not */ |
| unsigned :16; /**< reserve */ |
| unsigned smoothing:1; /**< reserve */ |
| unsigned not_sounding:1; /**< reserve */ |
| unsigned :1; /**< reserve */ |
| unsigned aggregation:1; /**< Aggregation */ |
| unsigned stbc:2; /**< STBC */ |
| unsigned fec_coding:1; /**< if is 11n packet, shows if is LDPC packet or not */ |
| unsigned sgi:1; /**< SGI */ |
| unsigned noise_floor:8; /**< noise floor */ |
| unsigned ampdu_cnt:8; /**< ampdu cnt */ |
| unsigned channel:4; /**< which channel this packet in */ |
| unsigned :12; /**< reserve */ |
| unsigned timestamp:32; /**< timestamp */ |
| unsigned :32; /**< reserve */ |
| unsigned :32; /**< reserve */ |
| unsigned sig_len:12; /**< It is really lenth of packet */ |
| unsigned :12; /**< reserve */ |
| unsigned rx_state:8; /**< rx state */ |
| } wifi_pkt_rx_ctrl_t; |
| |
| typedef struct { |
| wifi_pkt_rx_ctrl_t rx_ctrl; |
| uint8_t payload[0]; /**< ieee80211 packet buff, The length of payload is described by sig_len */ |
| } wifi_promiscuous_pkt_t; |
| |
| /** |
| * @brief Promiscuous frame type |
| * |
| */ |
| typedef enum { |
| WIFI_PKT_CTRL, /**< control type, receive packet buf is wifi_pkt_rx_ctrl_t */ |
| WIFI_PKT_MGMT, /**< management type, receive packet buf is wifi_promiscuous_pkt_t */ |
| WIFI_PKT_DATA, /**< data type, receive packet buf is wifi_promiscuous_pkt_t */ |
| WIFI_PKT_MISC, /**< other type, receive packet buf is wifi_promiscuous_pkt_t */ |
| } wifi_promiscuous_pkt_type_t; |
| |
| #define CSI_OK 0 |
| #define CSI_FAIL -1 |
| |
| #define CSI_ERR_NO_MEM 0x101 |
| #define CSI_ERR_INVALID_ARG 0x102 |
| #define CSI_ERR_INVALID_STATE 0x103 |
| #define CSI_ERR_INVALID_SIZE 0x104 |
| #define CSI_ERR_NOT_FOUND 0x105 |
| #define CSI_ERR_NOT_SUPPORTED 0x106 |
| #define CSI_ERR_TIMEOUT 0x107 |
| #define CSI_ERR_INVALID_RCSIONSE 0x108 |
| #define CSI_ERR_INVALID_CRC 0x109 |
| |
| //#define CSI_ERR_WIFI_BASE 0x3000 /*!< Starting number of WiFi error codes */ |
| |
| #define CSI_ERR_WIFI_OK CSI_OK /*!< No error */ |
| #define CSI_ERR_WIFI_FAIL CSI_FAIL /*!< General fail code */ |
| #define CSI_ERR_WIFI_NO_MEM CSI_ERR_NO_MEM /*!< Out of memory */ |
| #define CSI_ERR_WIFI_ARG CSI_ERR_INVALID_ARG /*!< Invalid argument */ |
| #define CSI_ERR_WIFI_NOT_SUPPORT CSI_ERR_NOT_SUPPORTED /*!< Indicates that API is not supported yet */ |
| |
| #define CSI_ERR_WIFI_NOT_INIT (CSI_DRV_ERRNO_WIFI_BASE + 1) /*!< WiFi driver was not installed by csi_wifi_init */ |
| #define CSI_ERR_WIFI_NOT_STARTED (CSI_DRV_ERRNO_WIFI_BASE + 2) /*!< WiFi driver was not started by csi_wifi_start */ |
| #define CSI_ERR_WIFI_IF (CSI_DRV_ERRNO_WIFI_BASE + 3) /*!< WiFi interface error */ |
| #define CSI_ERR_WIFI_MODE (CSI_DRV_ERRNO_WIFI_BASE + 4) /*!< WiFi mode error */ |
| #define CSI_ERR_WIFI_STATE (CSI_DRV_ERRNO_WIFI_BASE + 5) /*!< WiFi internal state error */ |
| #define CSI_ERR_WIFI_CONN (CSI_DRV_ERRNO_WIFI_BASE + 6) /*!< WiFi internal control block of station or soft-AP error */ |
| #define CSI_ERR_WIFI_NVS (CSI_DRV_ERRNO_WIFI_BASE + 7) /*!< WiFi internal NVS module error */ |
| #define CSI_ERR_WIFI_MAC (CSI_DRV_ERRNO_WIFI_BASE + 8) /*!< MAC address is invalid */ |
| #define CSI_ERR_WIFI_SSID (CSI_DRV_ERRNO_WIFI_BASE + 9) /*!< SSID is invalid */ |
| #define CSI_ERR_WIFI_PASSWORD (CSI_DRV_ERRNO_WIFI_BASE + 10) /*!< Password is invalid */ |
| #define CSI_ERR_WIFI_TIMEOUT (CSI_DRV_ERRNO_WIFI_BASE + 11) /*!< Timeout error */ |
| #define CSI_ERR_WIFI_WAKE_FAIL (CSI_DRV_ERRNO_WIFI_BASE + 12) /*!< WiFi is in sleep state(RF closed) and wakeup fail */ |
| |
| typedef enum |
| { |
| FRAME_FILTER_MODE_FORWARD = 1, /*!< Packet filter engine forwards matching packets, discards non-matching packets */ |
| FRAME_FILTER_MODE_DISCARD = 0, /*!< Packet filter engine discards matching packets, forwards non-matching packets */ |
| } frame_filter_mode_t; |
| |
| typedef enum |
| { |
| FRAME_FILTER_RULE_POSITIVE_MATCHING = 0, /*!< Specifies that a filter should match a given pattern */ |
| FRAME_FILTER_RULE_NEGATIVE_MATCHING = 1, /*!< Specifies that a filter should NOT match a given pattern */ |
| } frame_filter_rule_t; |
| |
| /** |
| * Structure describing a frame filter list item |
| */ |
| typedef struct |
| { |
| uint32_t id; /*!< Unique identifier for a packet filter item */ |
| frame_filter_rule_t rule; /*!< Filter matches are either POSITIVE or NEGATIVE matching */ |
| uint16_t offset; /*!< Offset in bytes to start filtering (referenced to the start of the ethernet packet) */ |
| uint16_t mask_size; /*!< Size of the mask in bytes */ |
| uint8_t* mask; /*!< Pattern mask bytes to be ANDed with the pattern eg. "\xff00" (must be in network byte order) */ |
| uint8_t* pattern; /*!< Pattern bytes used to filter eg. "\x0800" (must be in network byte order) */ |
| bool enabled_status; /*!< When returned from mhd_get_packet_filters, indicates if the filter is enabled */ |
| } wifi_frame_filter_t; |
| |
| struct wifi_frame_filter_list |
| { |
| struct wifi_frame_filter_list* next; |
| }; |
| typedef struct wifi_frame_filter_list wifi_frame_filter_list_t; |
| |
| typedef void (*wifi_event_cb_t)(uint32_t event); ///< Signal WiFi Event. Events refer to wifi_event_id_t |
| |
| /** |
| * @brief Init WiFi |
| * Alloc resource for WiFi driver, such as WiFi control structure, RX/TX buffer, |
| * WiFi NVS structure etc, this WiFi also start WiFi task |
| * |
| * @attention 1. This API must be called before all other WiFi API can be called |
| * |
| * @param cb callback to handle WiFi event |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NO_MEM: out of memory |
| * - others: refer to error code csi_err.h |
| */ |
| int32_t csi_wifi_init(wifi_event_cb_t *cb); |
| |
| /** |
| * @brief Deinit WiFi |
| * Free all resource allocated in csi_wifi_init and stop WiFi task |
| * |
| * @attention 1. This API should be called if you want to remove WiFi driver from the system |
| * |
| * @return CSI_OK: succeed |
| */ |
| int32_t csi_wifi_deinit(void); |
| |
| /** |
| * @brief Set the WiFi operating mode |
| * |
| * Set the WiFi operating mode as station, soft-AP or station+soft-AP, |
| * The default mode is soft-AP mode. |
| * |
| * @param mode WiFi operating mode |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - others: refer to error code in csi_err.h |
| */ |
| int32_t csi_wifi_set_mode(wifi_mode_t mode); |
| |
| /** |
| * @brief Get current operating mode of WiFi |
| * |
| * @param[out] mode store current WiFi mode |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| */ |
| int32_t csi_wifi_get_mode(wifi_mode_t *mode); |
| |
| /** |
| * @brief Start WiFi according to current configuration |
| * If mode is WIFI_MODE_STA, it create station control block and start station |
| * If mode is WIFI_MODE_AP, it create soft-AP control block and start soft-AP |
| * If mode is WIFI_MODE_APSTA, it create soft-AP and station control block and start soft-AP and station |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_NO_MEM: out of memory |
| * - CSI_ERR_WIFI_CONN: WiFi internal error, station or soft-AP control block wrong |
| * - CSI_ERR_WIFI_FAIL: other WiFi internal errors |
| */ |
| int32_t csi_wifi_start(void); |
| |
| /** |
| * @brief Stop WiFi |
| * If mode is WIFI_MODE_STA, it stop station and free station control block |
| * If mode is WIFI_MODE_AP, it stop soft-AP and free soft-AP control block |
| * If mode is WIFI_MODE_APSTA, it stop station/soft-AP and free station/soft-AP control block |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| */ |
| int32_t csi_wifi_stop(void); |
| |
| /** |
| * @brief Restore WiFi stack persistent settings to default values |
| * |
| * This function will reset settings made using the following APIs: |
| * - csi_wifi_get_auto_connect, |
| * - csi_wifi_set_protocol, |
| * - csi_wifi_set_config related |
| * - csi_wifi_set_mode |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| */ |
| int32_t csi_wifi_restore(void); |
| |
| /** |
| * @brief Connect the WiFi station to the AP. |
| * |
| * @attention 1. This API only impact WIFI_MODE_STA or WIFI_MODE_APSTA mode |
| * @attention 2. If connecting to an AP, call csi_wifi_disconnect to disconnect. |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_NOT_START: WiFi is not started by csi_wifi_start |
| * - CSI_ERR_WIFI_CONN: WiFi internal error, station or soft-AP control block wrong |
| * - CSI_ERR_WIFI_SSID: SSID of AP which station connects is invalid |
| */ |
| int32_t csi_wifi_connect(void); |
| |
| /** |
| * @brief Disconnect the WiFi station from the AP. |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi was not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_NOT_STARTED: WiFi was not started by csi_wifi_start |
| * - CSI_ERR_WIFI_FAIL: other WiFi internal errors |
| */ |
| int32_t csi_wifi_disconnect(void); |
| |
| /** |
| * @brief deauthenticate all stations or associated id equals to aid |
| * |
| * @param aid when aid is 0, deauthenticate all stations, otherwise deauthenticate station whose associated id is aid |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_NOT_STARTED: WiFi was not started by csi_wifi_start |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_MODE: WiFi mode is wrong |
| */ |
| int32_t csi_wifi_deauth_sta(uint16_t aid); |
| |
| /** |
| * @brief Scan all available APs. |
| * |
| * @attention If this API is called, the found APs are stored in WiFi driver dynamic allocated memory and that |
| * will be freed in csi_wifi_get_ap_list, so generally, call csi_wifi_get_ap_list to cause |
| * the memory to be freed once the scan is done |
| * @attention The values of maximum active scan time and passive scan time per channel are limited to 1500 milliseconds. |
| * Values above 1500ms may cause station to disconnect from AP and are not recommended. |
| * |
| * @param config configuration of scanning |
| * @param block if block is true, this API will block the caller until the scan is done, otherwise |
| * it will return immediately |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_NOT_STARTED: WiFi was not started by csi_wifi_start |
| * - CSI_ERR_WIFI_TIMEOUT: blocking scan is timeout |
| * - others: refer to error code in csi_err.h |
| */ |
| int32_t csi_wifi_scan_start(wifi_scan_config_t *config, bool block); |
| |
| /** |
| * @brief Stop the scan in process |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_NOT_STARTED: WiFi is not started by csi_wifi_start |
| */ |
| int32_t csi_wifi_scan_stop(void); |
| |
| /** |
| * @brief Get AP list found in last scan |
| * |
| * @param[inout] number As input param, it stores max AP number ap_records can hold. |
| * As output param, it receives the actual AP number this API returns. |
| * @param ap_records wifi_ap_record_t array to hold the found APs |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_NOT_STARTED: WiFi is not started by csi_wifi_start |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_NO_MEM: out of memory |
| */ |
| int32_t csi_wifi_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records); |
| |
| |
| /** |
| * @brief Get information of AP which station is associated with |
| * |
| * @param ap_info the wifi_ap_record_t to hold AP information |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - others: fail |
| */ |
| int32_t csi_wifi_sta_get_ap_info(wifi_ap_record_t *ap_info); |
| |
| /** |
| * @brief Set current power save type |
| * |
| * @attention Default power save type is WIFI_PS_NONE. |
| * |
| * @param type power save type |
| * |
| * @return CSI_ERR_WIFI_NOT_SUPPORT: not supported yet |
| */ |
| int32_t csi_wifi_set_ps(wifi_ps_type_t type); |
| |
| /** |
| * @brief Get current power save type |
| * |
| * @attention Default power save type is WIFI_PS_NONE. |
| * |
| * @param[out] type: store current power save type |
| * |
| * @return CSI_ERR_WIFI_NOT_SUPPORT: not supported yet |
| */ |
| int32_t csi_wifi_get_ps(wifi_ps_type_t *type); |
| |
| /** |
| * @brief Set protocol type of specified interface |
| * The default protocol is (WIFI_PROTOCOL_11B|WIFI_PROTOCOL_11G|WIFI_PROTOCOL_11N) |
| * |
| * @attention Currently we only support 802.11b or 802.11bg or 802.11bgn mode |
| * |
| * @param ifx interfaces |
| * @param protocol_bitmap WiFi protocol bitmap |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_IF: invalid interface |
| * - others: refer to error codes in csi_err.h |
| */ |
| int32_t csi_wifi_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap); |
| |
| /** |
| * @brief Get the current protocol bitmap of the specified interface |
| * |
| * @param ifx interface |
| * @param[out] protocol_bitmap store current WiFi protocol bitmap of interface ifx |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_IF: invalid interface |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - others: refer to error codes in csi_err.h |
| */ |
| int32_t csi_wifi_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap); |
| |
| /** |
| * @brief Set the bandwidth of specified interface |
| * |
| * @attention 1. API return false if try to configure an interface that is not enabled |
| * @attention 2. WIFI_BW_HT40 is supported only when the interface support 11N |
| * |
| * @param ifx interface to be configured |
| * @param bw bandwidth |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_IF: invalid interface |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - others: refer to error codes in csi_err.h |
| */ |
| int32_t csi_wifi_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw); |
| |
| /** |
| * @brief Get the bandwidth of specified interface |
| * |
| * @attention 1. API return false if try to get a interface that is not enable |
| * |
| * @param ifx interface to be configured |
| * @param[out] bw store bandwidth of interface ifx |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_IF: invalid interface |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| */ |
| int32_t csi_wifi_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw); |
| |
| /** |
| * @brief Set primary/secondary channel |
| * |
| * @attention 1. This is a special API for sniffer |
| * @attention 2. This API should be called after csi_wifi_start() or csi_wifi_set_promiscuous() |
| * |
| * @param primary for HT20, primary is the channel number, for HT40, primary is the primary channel |
| * @param second for HT20, second is ignored, for HT40, second is the second channel |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_IF: invalid interface |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| */ |
| int32_t csi_wifi_set_channel(uint8_t primary, wifi_second_chan_t second); |
| |
| /** |
| * @brief Get the primary/secondary channel |
| * |
| * @attention 1. API return false if try to get a interface that is not enable |
| * |
| * @param[out] primary store current primary channel |
| * @param[out] second store current second channel |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| */ |
| int32_t csi_wifi_get_channel(uint8_t *primary, wifi_second_chan_t *second); |
| |
| /** |
| * @brief Set country code |
| * The default value is WIFI_COUNTRY_CN |
| * |
| * @param country country type |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - others: refer to error code in csi_err.h |
| */ |
| int32_t csi_wifi_set_country(wifi_country_t country); |
| |
| /** |
| * @brief Get country code |
| * |
| * @param country store current country |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| */ |
| int32_t csi_wifi_get_country(wifi_country_t *country); |
| |
| /** |
| * @brief Set MAC address of the WiFi station or the soft-AP interface. |
| * |
| * @attention 1. This API can only be called when the interface is disabled |
| * @attention 2. soft-AP and station have different MAC addresses, do not set them to be the same. |
| * @attention 3. The bit 0 of the first byte of MAC address can not be 1. For example, the MAC address |
| * can set to be "1a:XX:XX:XX:XX:XX", but can not be "15:XX:XX:XX:XX:XX". |
| * |
| * @param ifx interface |
| * @param mac the MAC address |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_IF: invalid interface |
| * - CSI_ERR_WIFI_MAC: invalid mac address |
| * - CSI_ERR_WIFI_MODE: WiFi mode is wrong |
| * - others: refer to error codes in csi_err.h |
| */ |
| int32_t csi_wifi_set_mac(wifi_interface_t ifx, uint8_t mac[6]); |
| |
| /** |
| * @brief Get mac of specified interface |
| * |
| * @param ifx interface |
| * @param[out] mac store mac of the interface ifx |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_IF: invalid interface |
| */ |
| int32_t csi_wifi_get_mac(wifi_interface_t ifx, uint8_t mac[6]); |
| |
| /** |
| * @brief The RX callback function in the promiscuous mode. |
| * Each time a packet is received, the callback function will be called. |
| * |
| * @param buf Data received. Type of data in buffer (wifi_promiscuous_pkt_t or wifi_pkt_rx_ctrl_t) indicated by 'type' parameter. |
| * @param type promiscuous packet type. |
| * |
| */ |
| typedef void (* wifi_promiscuous_cb_t)(void *buf, wifi_promiscuous_pkt_type_t type); |
| |
| /** |
| * @brief Register the RX callback function in the promiscuous mode. |
| * |
| * Each time a packet is received, the registered callback function will be called. |
| * |
| * @param cb callback |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| */ |
| int32_t csi_wifi_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb); |
| |
| /** |
| * @brief Enable the promiscuous mode. |
| * |
| * @param en false - disable, true - enable |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| */ |
| int32_t csi_wifi_set_promiscuous(bool en); |
| |
| /** |
| * @brief Get the promiscuous mode. |
| * |
| * @param[out] en store the current status of promiscuous mode |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| */ |
| int32_t csi_wifi_get_promiscuous(bool *en); |
| |
| /** |
| * @brief Set the configuration of STA or AP |
| * |
| * @attention 1. This API can be called only when specified interface is enabled, otherwise, API fail |
| * @attention 2. For station configuration, bssid_set needs to be 0; and it needs to be 1 only when users need to check the MAC address of the AP. |
| * @attention 3. Limited to only one channel, so when in the soft-AP+station mode, the soft-AP will adjust its channel automatically to be the same as |
| * the channel of the station. |
| * |
| * @param ifx interface |
| * @param conf station or soft-AP configuration |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_IF: invalid interface |
| * - CSI_ERR_WIFI_MODE: invalid mode |
| * - CSI_ERR_WIFI_PASSWORD: invalid password |
| * - CSI_ERR_WIFI_NVS: WiFi internal NVS error |
| * - others: refer to the erro code in csi_err.h |
| */ |
| int32_t csi_wifi_set_config(wifi_interface_t ifx, wifi_config_t *conf); |
| |
| /** |
| * @brief Get configuration of specified interface |
| * |
| * @param ifx interface |
| * @param[out] conf station or soft-AP configuration |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_IF: invalid interface |
| */ |
| int32_t csi_wifi_get_config(wifi_interface_t ifx, wifi_config_t *conf); |
| |
| /** |
| * @brief Get STAs associated with soft-AP |
| * |
| * @attention SSC only API |
| * |
| * @param[out] sta station list |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_MODE: WiFi mode is wrong |
| * - CSI_ERR_WIFI_CONN: WiFi internal error, the station/soft-AP control block is invalid |
| */ |
| int32_t csi_wifi_ap_get_sta_list(wifi_sta_list_t *sta); |
| |
| |
| /** |
| * @brief Set the WiFi API configuration storage type |
| * |
| * @attention 1. The default value is WIFI_STORAGE_FLASH |
| * |
| * @param storage : storage type |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| */ |
| int32_t csi_wifi_set_storage(wifi_storage_t storage); |
| |
| /** |
| * @brief Set auto connect |
| * The default value is true |
| * |
| * @param en : true - enable auto connect / false - disable auto connect |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_MODE: WiFi internal error, the station/soft-AP control block is invalid |
| * - others: refer to error code in csi_err.h |
| */ |
| int32_t csi_wifi_set_auto_connect(bool en); |
| |
| /** |
| * @brief Get the auto connect flag |
| * |
| * @param[out] en store current auto connect configuration |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| */ |
| int32_t csi_wifi_get_auto_connect(bool *en); |
| |
| /** |
| * @brief Set vendor specific element |
| * |
| * @param enable enable or not |
| * @param type information element type |
| * @param idx information element index |
| * @param vnd_ie pointer to a vendor specific element |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| * - CSI_ERR_WIFI_ARG: invalid argument |
| * - CSI_ERR_WIFI_NO_MEM: out of memory |
| */ |
| int32_t csi_wifi_set_vendor_ie(bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, uint8_t *vnd_ie); |
| |
| /** |
| * @brief Define function pointer for vendor specific element callback |
| * @param ctx reserved |
| * @param type information element type |
| * @param sa source address |
| * @param vnd_ie pointer to a vendor specific element |
| * @param rssi received signal strength indication |
| */ |
| typedef void (*csi_vendor_ie_cb_t) (void *ctx, wifi_vendor_ie_type_t type, const uint8_t sa[6], const uint8_t *vnd_ie, int rssi); |
| |
| /** |
| * @brief Set vendor specific element callback |
| * |
| * @param cb callback function |
| * @param ctx reserved |
| * |
| * @return |
| * - CSI_OK: succeed |
| * - CSI_ERR_WIFI_NOT_INIT: WiFi is not initialized by csi_wifi_init |
| */ |
| int32_t csi_wifi_set_vendor_ie_cb(csi_vendor_ie_cb_t cb, void *ctx); |
| |
| /** |
| * @brief get whether the wifi driver is allowed to transmit data or not |
| * |
| * @return |
| * - true : upper layer should stop to transmit data to wifi driver |
| * - false : upper layer can transmit data to wifi driver |
| */ |
| bool csi_wifi_tx_is_stop(void); |
| |
| /** |
| * @brief free the rx buffer which allocated by wifi driver |
| * |
| * @param buffer: rx buffer pointer |
| */ |
| void csi_wifi_free_rx_buffer(void *buffer); |
| |
| /** |
| * @brief transmit the buffer via wifi driver |
| * |
| * @param wifi_if : wifi interface id |
| * @param buffer : the buffer to be tansmit |
| * @param len : the length of buffer |
| * |
| * @return |
| * - ERR_OK : Successfully transmit the buffer to wifi driver |
| * - ERR_MEM : Out of memory |
| * - ERR_IF : WiFi driver error |
| * - ERR_ARG : Invalid argument |
| */ |
| int csi_wifi_tx(wifi_interface_t wifi_if, void *buffer, uint16_t len); |
| |
| /** |
| * @brief The WiFi RX callback function |
| * |
| * Each time the WiFi need to forward the packets to high layer, the callback function will be called. |
| * ebuf is rx buffer allocated by wifi driver |
| */ |
| typedef int32_t (*wifi_rxcb_t)(void *buffer, uint16_t len, void *ebuf); |
| |
| /** |
| * @brief Set the WiFi RX callback |
| * |
| * @attention 1. Currently we support only one RX callback for each interface |
| * |
| * @param ifx : interface |
| * @param fn : WiFi RX callback |
| * |
| * @return |
| * - CSI_OK : succeed |
| * - others : fail |
| */ |
| int32_t csi_wifi_reg_rxcb(wifi_interface_t ifx, wifi_rxcb_t fn); |
| |
| /** |
| \brief Add Frame Filter Setting with Filter ID. |
| \param[in] filter Pointer to filter setting |
| \return |
| */ |
| int32_t csi_wifi_add_framefilter(const wifi_frame_filter_t *filter); |
| |
| /** |
| \brief Remove Frame Filter Setting. |
| \param[in] filter_id Frame Filter ID |
| \return |
| */ |
| int32_t csi_wifi_remove_framefilter(uint32_t filter_id); |
| |
| /** |
| \brief Enable/Disable Specified Frame Filter ID. |
| \param[in] filter_id Frame Filter ID |
| \param[in] en Enable or disable |
| \return |
| */ |
| int32_t csi_wifi_en_framefilter(uint32_t filter_id, bool en); |
| |
| /** |
| \brief Get frame filter table list. |
| \param[in] list frame filter table list |
| \param[in] count_out the count of filter setting added |
| \param[in] max_count max filter setting can be supported |
| \return |
| */ |
| int32_t csi_wifi_get_framefilter(wifi_frame_filter_list_t* list, uint32_t* count_out, uint32_t max_count); |
| |
| /** |
| * @brief This function gets the radio status of the Wi-Fi driver. |
| * |
| * @param[out] on_off indicates the Wi-Fi radio is on or off. |
| * |
| * Value |Definition | |
| * ------------------------------|------------------------------------------------------------------------| |
| * \b 0 | OFF, the Wi-Fi radio is turned off, and Wi-Fi TX/RX is disabled.| |
| * \b 1 | ON, the Wi-Fi radio is turned on, and Wi-Fi TX/RX is enabled.| |
| * |
| * |
| * @return >=0 the operation completed successfully, <0 the operation failed. |
| * |
| * @note In repeater mode, both Wi-Fi interface and Wi-Fi radio are turned on/off at the same time. |
| */ |
| int32_t wifi_config_get_radio(uint8_t *on_off); |
| |
| /** |
| * @brief This function sets the radio status of the Wi-Fi driver. This operation takes effect immediately. |
| * |
| * @param[in] on_off indicates the Wi-Fi radio is on or off. |
| * |
| * Value |Definition | |
| * ------------------------------|------------------------------------------------------------------------| |
| * \b 0 | OFF, the Wi-Fi radio is turned off, and Wi-Fi TX/RX is disabled| |
| * \b 1 | ON, the Wi-Fi radio is turned on, and Wi-Fi TX/RX is enabled| |
| * |
| * @return >=0 the operation completed successfully, <0 the operation failed. |
| * |
| * @note In repeater mode, both Wi-Fi interface and Wi-Fi radio are turned on/off at the same time. |
| */ |
| int32_t wifi_config_set_radio(uint8_t on_off); |
| |
| /** |
| * @brief This function gets the RSSI of the connected AP. It's only used for the STA mode and while the station is connected to the AP. |
| * |
| * @param[out] rssi returns the RSSI of the connected AP. |
| * |
| * @return >=0 the operation completed successfully, <0 the operation failed. |
| * |
| * |
| */ |
| int32_t csi_wifi_connection_get_rssi(int8_t *rssi); |
| |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* __CSI_WIFI_H__ */ |
| |
| |
