wifi_api.h

Go to the documentation of this file.

/* Copyright Statement:
 *
 * (C) 2005-2017 MediaTek Inc. All rights reserved.
 *
 * This software/firmware and related documentation ("MediaTek Software") are
 * protected under relevant copyright laws. The information contained herein
 * is confidential and proprietary to MediaTek Inc. ("MediaTek") and/or its licensors.
 * Without the prior written permission of MediaTek and/or its licensors,
 * any reproduction, modification, use or disclosure of MediaTek Software,
 * and information contained herein, in whole or in part, shall be strictly prohibited.
 * You may only use, reproduce, modify, or distribute (as applicable) MediaTek Software
 * if you have agreed to and been bound by the applicable license agreement with
 * MediaTek ("License Agreement") and been granted explicit permission to do so within
 * the License Agreement ("Permitted User"). If you are not a Permitted User,
 * please cease any access or use of MediaTek Software immediately.
 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
 * THAT MEDIATEK SOFTWARE RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES
 * ARE PROVIDED TO RECEIVER ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
 * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
 * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
 * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
 * SUPPLIED WITH MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
 * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
 * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
 * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
 * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
 * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
 * CUMULATIVE LIABILITY WITH RESPECT TO MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
 * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE MEDIATEK SOFTWARE AT ISSUE,
 * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
 * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
 */

#ifndef __WIFI_API_H__
#define __WIFI_API_H__

#include "stdint.h"
#include "stdbool.h"


#ifdef __cplusplus
extern "C" {
#endif

#define WIFI_MAX_LENGTH_OF_SSID             (32)

#define WIFI_MAC_ADDRESS_LENGTH             (6)

#define WIFI_LENGTH_802_11                  (24)

#define WIFI_TIMESTAMP_LENGTH               (8)

#define WIFI_BEACON_INTERVAL_LENGTH         (2)

#define WIFI_CAPABILITY_INFO_LENGTH         (2)

#define WIFI_MAX_NUMBER_OF_STA              (16)

#define WIFI_LENGTH_PASSPHRASE              (64)

#define WIFI_LENGTH_PMK                     (32)

#define WIFI_PROFILE_BUFFER_AP              "AP"

#define WIFI_PROFILE_BUFFER_STA             "STA"

#define WIFI_PROFILE_BUFFER_COMMON          "common"

#define WIFI_PROFILE_BUFFER_LENGTH          (128)

#define WIFI_BAND_2_4_G                     (0)

#define WIFI_BAND_5_G                       (1)


#define WIFI_STATUS_LINK_DISCONNECTED       (0)

#define WIFI_STATUS_LINK_CONNECTED          (1)

#define WIFI_IOT_COMMAND_CONFIG_BANDWIDTH_20MHZ       (0x00)

#define WIFI_IOT_COMMAND_CONFIG_BANDWIDTH_40MHZ       (0x01)

#define WIFI_IOT_COMMAND_CONFIG_BANDWIDTH_2040MHZ     (WIFI_IOT_COMMAND_CONFIG_BANDWIDTH_20MHZ|WIFI_IOT_COMMAND_CONFIG_BANDWIDTH_40MHZ)


#define WIFI_MODE_STA_ONLY      (1)

#define WIFI_MODE_AP_ONLY       (2)

#define WIFI_MODE_REPEATER          (3)

#define WIFI_MODE_MONITOR       (4)

#define WIFI_MODE_P2P_ONLY          (5)

#define WIFI_PORT_STA           (0)

#define WIFI_PORT_APCLI         WIFI_PORT_STA

#define WIFI_PORT_AP            (1)

#define WIFI_NUMBER_WEP_KEYS     (4)    
#define WIFI_MAX_WEP_KEY_LENGTH  (26)   
#define WIFI_INIT_TIME_OUT      1000    
#define WIFI_WPS_MAX_LENGTH_DEVICE_NAME     (32)    
#define WIFI_WPS_MAX_LENGTH_MANUFACTURER    (64)    
#define WIFI_WPS_MAX_LENGTH_MODEL_NAME      (32)    
#define WIFI_WPS_MAX_LENGTH_MODEL_NUMBER    (32)    
#define WIFI_WPS_MAX_LENGTH_SERIAL_NUMBER   (32)    
typedef enum {
    WIFI_EVENT_IOT_CONNECTED = 0,               
    WIFI_EVENT_IOT_SCAN_COMPLETE,               
    WIFI_EVENT_IOT_DISCONNECTED,                
    WIFI_EVENT_IOT_PORT_SECURE,                 
    WIFI_EVENT_IOT_REPORT_BEACON_PROBE_RESPONSE,
    WIFI_EVENT_IOT_WPS_COMPLETE,                
    WIFI_EVENT_IOT_INIT_COMPLETE,               
    WIFI_EVENT_IOT_REPORT_FILTERED_FRAME,       
    WIFI_EVENT_IOT_CONNECTION_FAILED,          
    WIFI_EVENT_MAX_NUMBER
} wifi_event_t;

typedef enum {
    WIFI_REASON_CODE_SUCCESS,                             
    WIFI_REASON_CODE_FIND_AP_FAIL,                        
    WIFI_REASON_CODE_PREV_AUTH_INVALID,                   
    WIFI_REASON_CODE_DEAUTH_LEAVING_BSS,                  
    WIFI_REASON_CODE_DISASSOC_INACTIVITY,                 
    WIFI_REASON_CODE_DISASSOC_AP_OVERLOAD,                
    WIFI_REASON_CODE_CLASS_2_ERR,                         
    WIFI_REASON_CODE_CLASS_3_ERR,                         
    WIFI_REASON_CODE_DISASSOC_LEAVING_BSS,                
    WIFI_REASON_CODE_ASSOC_BEFORE_AUTH,                   
    WIFI_REASON_CODE_DISASSOC_PWR_CAP_UNACCEPTABLE,       
    WIFI_REASON_CODE_DISASSOC_SUP_CHS_UNACCEPTABLE,       
    WIFI_REASON_CODE_INVALID_INFO_ELEM = 13,              
    WIFI_REASON_CODE_MIC_FAILURE,                         
    WIFI_REASON_CODE_4_WAY_HANDSHAKE_TIMEOUT,             
    WIFI_REASON_CODE_GROUP_KEY_UPDATE_TIMEOUT,            
    WIFI_REASON_CODE_DIFFERENT_INFO_ELEM,                 
    WIFI_REASON_CODE_MULTICAST_CIPHER_NOT_VALID,          
    WIFI_REASON_CODE_UNICAST_CIPHER_NOT_VALID,            
    WIFI_REASON_CODE_AKMP_NOT_VALID,                      
    WIFI_REASON_CODE_UNSUPPORTED_RSNE_VERSION,            
    WIFI_REASON_CODE_INVALID_RSNE_CAPABILITIES,           
    WIFI_REASON_CODE_IEEE_802_1X_AUTH_FAILED,             
    WIFI_REASON_CODE_CIPHER_REJECT_SEC_POLICY,            
    WIFI_REASON_CODE_DONT_SUPPORT_HT_OPERATION,           
    WIFI_REASON_CODE_DONT_SUPPORT_DSS_OFDM,               
    WIFI_REASON_CODE_DONT_SUPPORT_HT,                     
    WIFI_REASON_CODE_DISASSOC_UNSPECIFIED_QOS = 32,       
    WIFI_REASON_CODE_DISASSOC_LACK_OF_BANDWIDTH,          
    WIFI_REASON_CODE_DISASSOC_ACK_LOST_POOR_CHANNEL,      
    WIFI_REASON_CODE_DISASSOC_TX_OUTSIDE_TXOP_LIMIT,      
    WIFI_REASON_CODE_PEER_WHILE_LEAVING,                  
    WIFI_REASON_CODE_PEER_REFUSE_DLP,                     
    WIFI_REASON_CODE_PEER_SETUP_REQUIRED,                 
    WIFI_REASON_CODE_PEER_TIME_OUT,                       
    WIFI_REASON_CODE_INVALID_INFORMATION_ELEMENT,         
    WIFI_REASON_CODE_INVALID_GROUP_CIPHER,                
    WIFI_REASON_CODE_INVALID_PAIRWISE_CIPHER,             
    WIFI_REASON_CODE_INVALID_AKMP,                        
    WIFI_REASON_CODE_DONT_SUPPORT_RSN_VERSION,            
    WIFI_REASON_CODE_PEER_CIPHER_UNSUPPORTED,             
    WIFI_REASON_CODE_PASSWORD_ERROR = 100                 
} wifi_reason_code_t;


typedef enum {
    WIFI_RX_FILTER_DROP_STBC_BCN_BC_MC,       
    WIFI_RX_FILTER_DROP_FCS_ERR,              
    WIFI_RX_FILTER_RESERVED,                  
    WIFI_RX_FILTER_DROP_VER_NOT_0,            
    WIFI_RX_FILTER_DROP_PROBE_REQ,            
    WIFI_RX_FILTER_DROP_MC_FRAME,             
    WIFI_RX_FILTER_DROP_BC_FRAME,             
    WIFI_RX_FILTER_DROP_BSSID_BCN = 11,       
    WIFI_RX_FILTER_RM_FRAME_REPORT_EN = 12,   
    WIFI_RX_FILTER_DROP_CTRL_RSV,             
    WIFI_RX_FILTER_DROP_CTS,                  
    WIFI_RX_FILTER_DROP_RTS,                  
    WIFI_RX_FILTER_DROP_DUPLICATE,            
    WIFI_RX_FILTER_DROP_NOT_MY_BSSID,         
    WIFI_RX_FILTER_DROP_NOT_UC2ME,            
    WIFI_RX_FILTER_DROP_DIFF_BSSID_BTIM,      
    WIFI_RX_FILTER_DROP_NDPA                  
} wifi_rx_filter_t;

typedef enum {
    WIFI_AUTH_MODE_OPEN = 0,                        
    WIFI_AUTH_MODE_SHARED,                          
    WIFI_AUTH_MODE_AUTO_WEP,                        
    WIFI_AUTH_MODE_WPA,                             
    WIFI_AUTH_MODE_WPA_PSK,                         
    WIFI_AUTH_MODE_WPA_None,                        
    WIFI_AUTH_MODE_WPA2,                            
    WIFI_AUTH_MODE_WPA2_PSK,                        
    WIFI_AUTH_MODE_WPA_WPA2,                        
    WIFI_AUTH_MODE_WPA_PSK_WPA2_PSK,                
} wifi_auth_mode_t;

typedef enum {
    WIFI_ENCRYPT_TYPE_WEP_ENABLED = 0,                                              
    WIFI_ENCRYPT_TYPE_ENCRYPT1_ENABLED = WIFI_ENCRYPT_TYPE_WEP_ENABLED,             
    WIFI_ENCRYPT_TYPE_WEP_DISABLED = 1,                                             
    WIFI_ENCRYPT_TYPE_ENCRYPT_DISABLED = WIFI_ENCRYPT_TYPE_WEP_DISABLED,            
    WIFI_ENCRYPT_TYPE_WEP_KEY_ABSENT = 2,                                           
    WIFI_ENCRYPT_TYPE_ENCRYPT_KEY_ABSENT = WIFI_ENCRYPT_TYPE_WEP_KEY_ABSENT,        
    WIFI_ENCRYPT_TYPE_WEP_NOT_SUPPORTED = 3,                                        
    WIFI_ENCRYPT_TYPE_ENCRYPT_NOT_SUPPORTED = WIFI_ENCRYPT_TYPE_WEP_NOT_SUPPORTED,  
    WIFI_ENCRYPT_TYPE_TKIP_ENABLED = 4,                                             
    WIFI_ENCRYPT_TYPE_ENCRYPT2_ENABLED = WIFI_ENCRYPT_TYPE_TKIP_ENABLED,            
    WIFI_ENCRYPT_TYPE_AES_ENABLED = 6,                                              
    WIFI_ENCRYPT_TYPE_ENCRYPT3_ENABLED = WIFI_ENCRYPT_TYPE_AES_ENABLED,             
    WIFI_ENCRYPT_TYPE_AES_KEY_ABSENT = 7,                                           
    WIFI_ENCRYPT_TYPE_TKIP_AES_MIX = 8,                                             
    WIFI_ENCRYPT_TYPE_ENCRYPT4_ENABLED = WIFI_ENCRYPT_TYPE_TKIP_AES_MIX,            
    WIFI_ENCRYPT_TYPE_TKIP_AES_KEY_ABSENT = 9,                                      
    WIFI_ENCRYPT_TYPE_GROUP_WEP40_ENABLED = 10,                                     
    WIFI_ENCRYPT_TYPE_GROUP_WEP104_ENABLED = 11,                                    
#ifdef WAPI_SUPPORT
    WIFI_ENCRYPT_TYPE_ENCRYPT_SMS4_ENABLED,                                         
#endif /* WAPI_SUPPORT */
} wifi_encrypt_type_t;


typedef enum {
    WIFI_PHY_11BG_MIXED = 0,     
    WIFI_PHY_11B,                
    WIFI_PHY_11A,                
    WIFI_PHY_11ABG_MIXED,        
    WIFI_PHY_11G,                
    WIFI_PHY_11ABGN_MIXED,       
    WIFI_PHY_11N_2_4G,           
    WIFI_PHY_11GN_MIXED,         
    WIFI_PHY_11AN_MIXED,         
    WIFI_PHY_11BGN_MIXED,        
    WIFI_PHY_11AGN_MIXED,        
    WIFI_PHY_11N_5G,             
} wifi_phy_mode_t;

typedef enum {
        WIFI_CIPHER_NONE = 0,     
        WIFI_CIPHER_WEP64,        
        WIFI_CIPHER_WEP128,       
        WIFI_CIPHER_TKIP,         
        WIFI_CIPHER_AES,          
        WIFI_CIPHER_CKIP64,       
        WIFI_CIPHER_CKIP128,      
        WIFI_CIPHER_CKIP152,      
        WIFI_CIPHER_SMS4,         
        WIFI_CIPHER_WEP152,       
        WIFI_CIPHER_BIP,          
        WIFI_CIPHER_WAPI,         
        WIFI_CIPHER_TKIP_NO_MIC   
} wifi_security_cipher_suits_t;


typedef enum {
    WIFI_BANDWIDTH_EXT_40MHZ_UP,    
    WIFI_BANDWIDTH_EXT_40MHZ_BELOW  
} wifi_bandwidth_ext_t;

typedef enum {
    WIFI_POWER_SAVING_MODE_OFF = 0,          
    WIFI_POWER_SAVING_MODE_LEGACY,           
    WIFI_POWER_SAVING_MODE_FAST              
} wifi_power_saving_mode_t;

typedef enum {
    WIFI_WPS_DPID_DEFAULT             = 0x0000,     
    WIFI_WPS_DPID_USER_SPECIFIED      = 0x0001,     
    WIFI_WPS_DPID_MACHINE_SPECIFIED   = 0x0002,     
    WIFI_WPS_DPID_REKEY               = 0x0003,     
    WIFI_WPS_DPID_PUSHBUTTON          = 0x0004,     
    WIFI_WPS_DPID_REGISTRAR_SPECIFIED = 0x0005,     
    WIFI_WPS_DPID_MAX_NUMBER          = 0xFFFF
} wps_device_password_id_t;


typedef enum {
    WIFI_WPS_CONFIG_USBA                    = 0x0001,  
    WIFI_WPS_CONFIG_ETHERNET                = 0x0002,  
    WIFI_WPS_CONFIG_LABEL                   = 0x0004,  
    WIFI_WPS_CONFIG_DISPLAY                 = 0x0008,  
    WIFI_WPS_CONFIG_EXTERNAL_NFC_TOKEN      = 0x0010,  
    WIFI_WPS_CONFIG_INTEGRATED_NFC_TOKEN    = 0x0020,  
    WIFI_WPS_CONFIG_NFC_INTERFACE           = 0x0040,  
    WIFI_WPS_CONFIG_PUSHBUTTON              = 0x0080,  
    WIFI_WPS_CONFIG_KEYPAD                  = 0x0100,  
    WIFI_WPS_CONFIG_VIRTUAL_PUSHBUTTON      = 0x0280,  
    WIFI_WPS_CONFIG_PHY_PUSHBUTTON          = 0x0480,  
    WIFI_WPS_CONFIG_VIRTUAL_DISPLAY         = 0x2008,  
    WIFI_WPS_CONFIG_PHY_DISPLAY             = 0x4008   
} wps_config_method_t;

typedef int32_t (* wifi_event_handler_t)(wifi_event_t event, uint8_t *payload, uint32_t length);


typedef wifi_event_handler_t wifi_event_handler;


typedef int32_t (* wifi_rx_handler_t)(uint8_t *payload, uint32_t length);

typedef struct {
    uint8_t ssid[WIFI_MAX_LENGTH_OF_SSID];    
    uint8_t ssid_length;                      
    uint8_t bssid_present;                    
    uint8_t bssid[WIFI_MAC_ADDRESS_LENGTH];   
    uint8_t password[WIFI_LENGTH_PASSPHRASE]; 
    uint8_t password_length;                  
} wifi_sta_config_t;


typedef struct {
    uint8_t ssid[WIFI_MAX_LENGTH_OF_SSID];    
    uint8_t ssid_length;                      
    uint8_t password[WIFI_LENGTH_PASSPHRASE]; 
    uint8_t password_length;                  
    wifi_auth_mode_t auth_mode;               
    wifi_encrypt_type_t encrypt_type;         
    uint8_t channel;                          
    uint8_t bandwidth;                        
    wifi_bandwidth_ext_t bandwidth_ext;       
} wifi_ap_config_t;


typedef struct {
    uint8_t opmode;                          
    wifi_sta_config_t sta_config;            
    wifi_ap_config_t ap_config;              
} wifi_config_t;


typedef struct {
    uint32_t sta_wep_key_index_present: 1;        
    uint32_t sta_auto_connect_present: 1;         
    uint32_t ap_wep_key_index_present: 1;         
    uint32_t ap_hidden_ssid_enable_present: 1;    
    uint32_t country_code_present: 1;             
    uint32_t sta_bandwidth_present: 1;            
    uint32_t sta_wireless_mode_present: 1;        
    uint32_t sta_listen_interval_present: 1;      
    uint32_t sta_power_save_mode_present: 1;      
    uint32_t ap_wireless_mode_present: 1;         
    uint32_t ap_dtim_interval_present: 1;         
    uint32_t reserved_bit: 21;                    
    uint32_t reserved_word[3];                    
    uint8_t sta_wep_key_index;                    
    uint8_t sta_auto_connect;                     
    uint8_t ap_wep_key_index;                     
    uint8_t ap_hidden_ssid_enable;                
    uint8_t country_code[4];                      
    uint8_t sta_bandwidth;                        
    wifi_phy_mode_t sta_wireless_mode;            
    uint8_t sta_listen_interval;                  
    wifi_power_saving_mode_t sta_power_save_mode; 
    wifi_phy_mode_t ap_wireless_mode;             
    uint8_t ap_dtim_interval;                     
} wifi_config_ext_t;


typedef struct {
    uint8_t wep_key[WIFI_NUMBER_WEP_KEYS][WIFI_MAX_WEP_KEY_LENGTH];     
    uint8_t wep_key_length[WIFI_NUMBER_WEP_KEYS];                       
    uint8_t wep_tx_key_index;                                           
} wifi_wep_key_t;


typedef struct {
    uint8_t ssid[WIFI_MAX_LENGTH_OF_SSID];          
    uint8_t ssid_length;                            
    uint8_t mac_address[WIFI_MAC_ADDRESS_LENGTH];   
    uint8_t wireless_mode;                          
    uint8_t channel;                                
    uint8_t bandwidth;                              
    uint8_t mcs;                                    
    uint8_t auth_mode;                              
    uint8_t encrypt_mode;                           
} wifi_profile_t;


typedef struct {
    bool selected_registrar;                        
    wps_device_password_id_t device_password_id;    
    wps_config_method_t configuration_methods;      
} wifi_wps_element_t;


typedef struct {
    uint8_t  is_valid;                         
    int8_t   rssi;                             
    uint8_t  ssid[WIFI_MAX_LENGTH_OF_SSID];    
    uint8_t  ssid_length;                      
    uint8_t  bssid[WIFI_MAC_ADDRESS_LENGTH];   
    uint8_t  channel;                          
    uint8_t  central_channel;                  
    bool     is_wps_supported;                 
    wifi_auth_mode_t     auth_mode;            
    wifi_encrypt_type_t  encrypt_type;         
    bool     is_hidden;                        
    uint8_t  bss_type;                         
    uint16_t beacon_interval;                  
    uint16_t capability_info;                  
    wifi_wps_element_t wps_element;            
} wifi_scan_list_item_t;

typedef struct {
    wifi_scan_list_item_t ap_data;  
    struct _wifi_scan_list_t *next; 
} wifi_scan_list_t;

typedef struct {
    int8_t          last_rssi;             
    uint8_t         reserved;              
    int16_t         average_rssi;          
} wifi_rssi_sample_t;


typedef union {
    struct {
        uint16_t mcs: 6;                      
        uint16_t ldpc: 1;                     
        uint16_t bandwidth: 2;                
        uint16_t short_gi: 1;                 
        uint16_t stbc: 1;                     
        uint16_t external_tx_beam_forming: 1; 
        uint16_t internal_tx_beam_forming: 1; 
        uint16_t mode: 3;
    } field;                                 
    uint16_t word;                           
} wifi_transmit_setting_t;

typedef struct {
    wifi_transmit_setting_t last_tx_rate;            
    uint16_t reserved_one;                           
    wifi_transmit_setting_t last_rx_rate;            
    uint16_t reserved_two;                           
    wifi_rssi_sample_t rssi_sample;                  
    uint8_t mac_address[WIFI_MAC_ADDRESS_LENGTH];    
    uint8_t power_save_mode;                         
    uint8_t bandwidth;                               
    uint8_t keep_alive;                              
    uint8_t reserved[3];                             
} wifi_sta_list_t;

typedef struct {
    uint8_t   key[16];            
    uint8_t   rx_mic[8];          
    uint8_t   tx_mic[8];          
    uint8_t   tx_tsc[6];          
    uint8_t   rx_tsc[6];          
    uint8_t   cipher_type;        
    uint8_t   key_length;         
    uint8_t   bssid[6];           
    uint8_t   type;               
} wifi_cipher_key_t;

typedef struct {
    uint8_t first_channel;        
    uint8_t num_of_channel;       
    uint8_t max_tx_power;         
    uint8_t geography;            
    bool    dfs_req;              
} wifi_channel_table_t;

typedef struct {
    uint8_t country_code[4];                
    uint8_t dfs_type;                       
    uint8_t num_of_channel_table;           
    wifi_channel_table_t channel_table[];   
} wifi_country_code_t;


#ifdef MTK_WIFI_WPS_ENABLE

typedef struct {
    char device_name[WIFI_WPS_MAX_LENGTH_DEVICE_NAME];          
    char manufacturer[WIFI_WPS_MAX_LENGTH_MANUFACTURER];        
    char model_name[WIFI_WPS_MAX_LENGTH_MODEL_NAME];            
    char model_number[WIFI_WPS_MAX_LENGTH_MODEL_NUMBER];        
    char serial_number[WIFI_WPS_MAX_LENGTH_SERIAL_NUMBER];      
} wifi_wps_device_info_t;

typedef struct {
    uint8_t  ssid[WIFI_MAX_LENGTH_OF_SSID];   
    uint32_t ssid_len;                        
    wifi_auth_mode_t     auth_mode;           
    wifi_encrypt_type_t  encrypt_type;        
    uint8_t  key_index;                       
    uint8_t  key[WIFI_LENGTH_PASSPHRASE];     
    uint32_t key_length;                      
} wifi_wps_credential_info_t;

#endif //end of MTK_WIFI_WPS_ENABLE

void wifi_init(wifi_config_t *config, wifi_config_ext_t *config_ext);

int32_t wifi_config_get_opmode(uint8_t *mode);

int32_t wifi_config_set_opmode(uint8_t mode);

int32_t wifi_config_get_mac_address(uint8_t port, uint8_t *address);

int32_t wifi_config_get_ssid(uint8_t port, uint8_t *ssid, uint8_t *ssid_length);

int32_t wifi_config_set_ssid(uint8_t port, uint8_t *ssid, uint8_t ssid_length);

int32_t wifi_config_get_bssid(uint8_t *bssid);

int32_t wifi_config_set_bssid(uint8_t *bssid);

int32_t wifi_config_set_bandwidth(uint8_t port, uint8_t bandwidth);

int32_t wifi_config_get_bandwidth(uint8_t port, uint8_t *bandwidth);

int32_t wifi_config_set_channel(uint8_t port, uint8_t channel);

int32_t wifi_config_get_channel(uint8_t port, uint8_t *channel);


int32_t wifi_config_get_wireless_mode(uint8_t port, wifi_phy_mode_t *mode);


int32_t wifi_config_set_wireless_mode(uint8_t port, wifi_phy_mode_t mode);


int32_t wifi_config_set_country_code(wifi_country_code_t *wifi_country_code);

int32_t wifi_config_get_country_code(wifi_country_code_t *wifi_country_code);

int32_t wifi_config_get_country_region(uint8_t band, uint8_t  *region);

int32_t wifi_config_set_country_region(uint8_t band, uint8_t region);

int32_t wifi_config_get_dtim_interval(uint8_t *interval);

int32_t wifi_config_set_dtim_interval(uint8_t interval);

int32_t wifi_config_get_listen_interval(uint8_t *interval);

int32_t wifi_config_set_listen_interval(uint8_t interval);

int32_t wifi_config_get_security_mode(uint8_t port, wifi_auth_mode_t *auth_mode, wifi_encrypt_type_t *encrypt_type);

int32_t wifi_config_set_security_mode(uint8_t port, wifi_auth_mode_t auth_mode, wifi_encrypt_type_t encrypt_type);

int32_t wifi_config_get_wpa_psk_key(uint8_t port, uint8_t *passphrase, uint8_t *passphrase_length);

int32_t wifi_config_set_wpa_psk_key(uint8_t port, uint8_t *passphrase, uint8_t passphrase_length);

int32_t wifi_config_get_pmk(uint8_t port, uint8_t *pmk);

int32_t wifi_config_set_pmk(uint8_t port, uint8_t *pmk);

int32_t wifi_config_get_wep_key(uint8_t port, wifi_wep_key_t *wep_keys);

int32_t wifi_config_set_wep_key(uint8_t port, wifi_wep_key_t *wep_keys);

int32_t wifi_config_reload_setting(void);

int32_t wifi_config_register_rx_handler(wifi_rx_handler_t wifi_rx_handler);

int32_t wifi_config_unregister_rx_handler(void);

int32_t wifi_config_get_rx_filter(uint32_t  *flag);

int32_t wifi_config_set_rx_filter(uint32_t flag);

int32_t wifi_config_get_smart_connection_filter(uint8_t *flag);

int32_t wifi_config_set_smart_connection_filter(uint8_t flag);

int32_t wifi_config_get_radio(uint8_t *on_off);

int32_t wifi_config_set_radio(uint8_t on_off);

int32_t wifi_connection_disconnect_ap(void);

int32_t wifi_connection_disconnect_sta(uint8_t *address);

int32_t wifi_connection_get_link_status(uint8_t *link_status);

int32_t wifi_connection_scan_init(wifi_scan_list_item_t *ap_list, uint32_t max_count);

int32_t wifi_connection_scan_deinit(void);

int32_t wifi_connection_start_scan(uint8_t *ssid, uint8_t ssid_length, uint8_t *bssid, uint8_t scan_mode, uint8_t scan_option);

int32_t wifi_connection_stop_scan(void);

int32_t wifi_connection_parse_beacon(uint8_t *pbuf, uint32_t len, wifi_scan_list_item_t *ap_data);

int32_t wifi_connection_get_sta_list(uint8_t *number, wifi_sta_list_t *sta_list);

int32_t wifi_connection_get_max_sta_number(uint8_t *sta_number);

int32_t wifi_connection_get_rssi(int8_t *rssi);

int32_t wifi_connection_register_event_handler(wifi_event_t event, wifi_event_handler_t handler);

int32_t wifi_connection_register_event_notifier(uint8_t event, wifi_event_handler_t notifier);

int32_t wifi_connection_unregister_event_handler(wifi_event_t event, wifi_event_handler_t handler);

int32_t wifi_connection_unregister_event_notifier(uint8_t event, wifi_event_handler_t notifier);

#ifdef MTK_WIFI_PROFILE_ENABLE

int32_t wifi_profile_set_opmode(uint8_t mode);

int32_t wifi_profile_get_opmode(uint8_t *mode);

int32_t wifi_profile_set_channel(uint8_t port, uint8_t channel);

int32_t wifi_profile_get_channel(uint8_t port, uint8_t *channel);

int32_t wifi_profile_set_bandwidth(uint8_t port, uint8_t bandwidth);

int32_t wifi_profile_get_bandwidth(uint8_t port, uint8_t *bandwidth);

int32_t  wifi_profile_get_mac_address(uint8_t port, uint8_t *address);

int32_t wifi_profile_set_mac_address(uint8_t port, uint8_t *address);

int32_t wifi_profile_set_ssid(uint8_t port, uint8_t *ssid , uint8_t ssid_length);

int32_t wifi_profile_get_ssid(uint8_t port, uint8_t *ssid, uint8_t *ssid_length);

int32_t wifi_profile_set_wireless_mode(uint8_t port, wifi_phy_mode_t mode);

int32_t wifi_profile_get_wireless_mode(uint8_t port, wifi_phy_mode_t *mode);

int32_t wifi_profile_set_security_mode(uint8_t port, wifi_auth_mode_t auth_mode, wifi_encrypt_type_t encrypt_type);

int32_t wifi_profile_get_security_mode(uint8_t port, wifi_auth_mode_t *auth_mode, wifi_encrypt_type_t *encrypt_type);

int32_t wifi_profile_set_wpa_psk_key(uint8_t port, uint8_t *passphrase, uint8_t passphrase_length);

int32_t wifi_profile_get_wpa_psk_key(uint8_t port, uint8_t *passphrase, uint8_t *passphrase_length);

int32_t wifi_profile_set_pmk(uint8_t port, uint8_t *pmk);

int32_t wifi_profile_get_pmk(uint8_t port, uint8_t *pmk);

int32_t wifi_profile_set_wep_key(uint8_t port, wifi_wep_key_t *wep_keys);

int32_t wifi_profile_get_wep_key(uint8_t port, wifi_wep_key_t *wep_keys);

int32_t wifi_profile_get_country_region(uint8_t band, uint8_t  *region);

int32_t wifi_profile_set_country_region(uint8_t band, uint8_t region);

int32_t wifi_profile_get_dtim_interval(uint8_t *interval);

int32_t wifi_profile_set_dtim_interval(uint8_t interval);

int32_t wifi_profile_get_listen_interval(uint8_t *interval);

int32_t wifi_profile_set_listen_interval(uint8_t interval);

int32_t wifi_profile_set_power_save_mode(uint8_t power_save_mode);

int32_t wifi_profile_get_power_save_mode(uint8_t *power_save_mode);

int32_t wifi_profile_commit_setting(char *profile_section);

int32_t wifi_profile_get_profile(uint8_t port, wifi_profile_t *profile);

#endif //MTK_WIFI_PROFILE_ENABLE

#ifdef MTK_WIFI_WPS_ENABLE

int32_t wifi_wps_config_get_pin_code(uint8_t port, uint8_t *pin_code);

int32_t wifi_wps_connection_by_pbc(uint8_t port, uint8_t *bssid);

int32_t wifi_wps_connection_by_pin(uint8_t port, uint8_t *bssid, uint8_t *pin_code);

int32_t wifi_wps_config_set_device_info(wifi_wps_device_info_t *device_info);

int32_t wifi_wps_config_get_device_info(wifi_wps_device_info_t *device_info);

int32_t wifi_wps_config_set_auto_connection(bool auto_connection);

int32_t wifi_wps_config_get_auto_connection(bool *auto_connection);

#endif //end of MTK_WIFI_WPS_ENABLE

int32_t wifi_connection_send_raw_packet(uint8_t *raw_packet, uint32_t length);




#ifdef __cplusplus
}
#endif

#endif /* __WIFI_API_H__ */