wen/luban-lite
1
0
Fork 0
mirror of https://gitee.com/Vancouver2017/luban-lite.git synced 2025-12-24 21:18:54 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
b4033d8696b77dddcafce4e00eaaf2a01ccc38fb
luban-lite/bsp/peripheral/wireless/atbm603x/hal/atbm_wifi_driver_api.c
刘可亮 8bca5e8332 v1.0.4
2024-04-03 16:40:57 +08:00

1623 lines
45 KiB
C
Raw Blame History

/**************************************************************************************************************
* altobeam RTOS API
*
* Copyright (c) 2018, altobeam.inc All rights reserved.
*
* The source code contains proprietary information of AltoBeam, and shall not be distributed,
* copied, reproduced, or disclosed in whole or in part without prior written permission of AltoBeam.
*****************************************************************************************************************/
#include "atbm_hal.h"
#include "atbm_wifi_driver_api.h"
#include "atbm_etf.h"
extern struct atbmwifi_common g_hw_prv;
/*ATBM WIFI READY*/
extern atbm_void* atbm_wifi_vif_get(int id);
extern atbm_int32 atbm_etf_start_tx(atbm_int32 channel,atbm_int32 rate_value,atbm_int32 is_40M, atbm_int32 greedfiled);
extern atbm_int32 atbm_etf_stop_tx(atbm_void);
extern atbm_int32 atbm_etf_start_rx(atbm_int32 channel ,atbm_int32 is_40M);
extern atbm_int32 atbm_etf_stop_rx(atbm_void);
extern atbm_int32 atbm_etf_start_tx_single_tone(atbm_int32 channel,atbm_int32 rate_value,atbm_int32 is_40M, atbm_int32 greedfiled);
extern atbm_int32 atbm_etf_PT_Test_start(atbm_uint8 if_id,/*atbm_int32 targetFreq, atbm_int32 rssiFilter, atbm_int32 evmFilter, atbm_int32 cableLoss, */atbm_int32 isWriteEfuse);
extern atbm_int32 atbmwifi_get_rssi_avg(atbm_void);
extern atbm_int32 atbmwifi_set_tx_time(atbm_uint32 time_period, atbm_uint32 time_transmit);
extern atbm_int32 atbmwifi_set_retry(atbm_uint32 retry_num, atbm_uint32 retry_time_ms);
extern atbm_int32 atbmwifi_set_txpower(atbm_uint32 txpower_idx);
extern atbm_int32 atbmwifi_set_tx_rate(atbm_int32 rate);
extern atbm_int32 atbmwifi_set_sgi(atbm_uint32 sgi);
extern atbm_int32 atbmwifi_set_rate_txpower_mode(atbm_uint32 txpower_idx);
extern atbm_int32 atbmwifi_get_lmacLog_to_host(atbm_uint32 value);
extern atbm_int32 atbm_set_debug_to_host(atbm_uint32 value);
extern int atbm_etf_start_tx(int channel,int rate_value,int is_40M, int greedfiled);
extern int atbm_etf_stop_tx(void);
extern int atbm_etf_start_rx(int channel ,int is_40M);
extern int atbm_etf_stop_rx(void);
extern atbm_int32 atbmwifi_dev_set_adaptive(atbm_int32 val);
atbm_int32 atbm_wifi_get_current_mode_vif(atbm_uint8 if_id); //0 : sta, 1: SW AP
/****************************************************************************
* Function: atbm_wifi_hw_init
*
* Purpose: This function is used to initialize and start atbm wifi hardware.
may be GPO, BUS PROBE, firmware init etc.
*
* Parameters: none
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
****************************************************************************/
atbm_int32 atbm_wifi_hw_init(atbm_void)
{
#if ATBM_USB_BUS
atbm_usb_module_init();
#else
atbm_sdio_module_init();
#endif
return 0;
}
/****************************************************************************
* Function: atbm_wifi_hw_deinit
*
* Purpose: This function is used to release and clean up the driver
*
* Parameters: none
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
****************************************************************************/
atbm_int32 atbm_wifi_hw_deinit(atbm_void)
{
#if ATBM_USB_BUS
atbm_usb_module_exit();
#else
atbm_sdio_module_exit();
#endif
return 0;
}
/****************************************************************************
* Function: atbm_wifi_vif_get
*
* Purpose: This function is used to get atbm wifi interface id priv.
*
* Parameters: 0:Station InterfaceId, 1 Ap InterfaceId
*
* Returns: void
****************************************************************************/
atbm_void* atbm_wifi_vif_get(int if_id)
{
atbm_int32 waitloop = 100;
/*Wait for atbmwifi fw & hmac done*/
struct atbmwifi_vif *priv;
while(1) {
priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL){
atbm_SleepMs(50);
}else{
break;
}
if(waitloop-- < 0){
wifi_printk(WIFI_ALWAYS,"wait atbm_wifi_vif_get +timeout drop\n");
break;
}
}
return (atbm_void *)priv;
}
/****************************************************************************
* Function: atbm_wifi_on
*
* Purpose: This function is used to initialize and start atbm wifi module as AP mode or STA mode.
*
* Parameters: AP_sta_mode 0: Ap Mode, 1 STA mode
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
****************************************************************************/
atbm_void* atbm_wifi_on_vif(ATBM_WIFI_MODE AP_sta_mode,atbm_uint8 if_id)
{
atbm_int32 CurrentMode;
struct atbmwifi_vif *priv;
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS,"priv==NULL\n");
return ATBM_NULL;
}
/*Get Curret Mode,If Conf Mode is not equal CurrentMode,Do Modify to conf Mode */
CurrentMode = atbm_wifi_get_current_mode_vif(if_id);
if(atbmwifi_is_ap_mode(CurrentMode) &&(AP_sta_mode == ATBM_WIFI_AP_MODE)){
wifi_printk(WIFI_ALWAYS,"<WARNING>atbm_wifi_on_vif+_mode %d+\n",CurrentMode);
return (atbm_void* )priv->ndev;
}
if(atbmwifi_is_sta_mode(CurrentMode) &&(AP_sta_mode == ATBM_WIFI_STA_MODE)){
wifi_printk(WIFI_ALWAYS,"<WARNING>atbm_wifi_on_vif+_mode %d+\n",CurrentMode);
return (atbm_void* )priv->ndev;
}
if(AP_sta_mode == ATBM_WIFI_AP_MODE)
{
atbmwifi_start_wifimode(priv,ATBM_NL80211_IFTYPE_AP);
}
if(AP_sta_mode == ATBM_WIFI_STA_MODE)
{
atbmwifi_start_wifimode(priv,ATBM_NL80211_IFTYPE_STATION);
}
return (atbm_void* )priv->ndev;
}
/****************************************************************************
* Function: atbm_wifi_on
*
* Purpose: This function is used to start atbm wifi module.
*
* Returns: Returns none.
*****************************************************************************/
atbm_void* atbm_wifi_on( ATBM_WIFI_MODE AP_sta_mode)
{
int if_id=0;
switch (AP_sta_mode){
case ATBM_NL80211_IFTYPE_STATION:
case ATBM_NL80211_IFTYPE_P2P_CLIENT:
if_id=0;
break;
case ATBM_NL80211_IFTYPE_AP:
case ATBM_NL80211_IFTYPE_P2P_GO:
if_id=1;
break;
default:
wifi_printk(WIFI_ALWAYS,"Mode cant support,Pls check it !!!\n");
return ATBM_NULL;
}
return atbm_wifi_on_vif(AP_sta_mode,if_id);
}
/****************************************************************************
* Function: atbm_wifi_off
*
* Purpose: This function is used to stop atbm wifi module.
*
* Returns: Returns none.
*****************************************************************************/
atbm_void atbm_wifi_off_vif(atbm_uint8 if_id)
{
atbm_int32 i32current_mode;
struct atbmwifi_vif *priv=ATBM_NULL;
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL)
return ;
i32current_mode = atbm_wifi_get_current_mode_vif(if_id); // get current mode
atbmwifi_stop_wifimode(priv,priv->iftype);
}
atbm_void atbm_wifi_off(atbm_uint8 if_id)
{
atbm_wifi_off_vif(if_id);
}
/****************************************************************************
* Function: atbm_wifi_scan_network
*
* Purpose: This function is used to ask driver to perform channel scan and return scan result.
*
* Parameters: scan_buf Buffer to store the information of the found APs
* buf_size Size of the buffer
*
* Returns: Returns 0 if succeed, 1 if some remained untaken, otherwise a negative error code.
******************************************************************************/
int atbm_wifi_scan_network_vif(atbm_uint8 if_id,char* scan_buf, atbm_uint32 buf_size)
{
WLAN_BSS_INFO *bss_info;
WLAN_SCAN_RESULT *pScanResult;
struct atbmwifi_scan_result_info *info;
atbm_int32 waitloop = 10;
atbm_int32 i=0;
struct atbmwifi_vif *priv=ATBM_NULL;
priv=_atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(ATBM_NULL==priv){
return -1;
}
wifi_printk(WIFI_ALWAYS,"atbm_wifi_scan_network_vif(%d) \n",priv->iftype);
//wifi_printk(WIFI_ALWAYS,"taken(%d) len(%d)\n",priv->scan_ret.taken, priv->scan_ret.len);
if(priv->scan_ret.taken < priv->scan_ret.len){
goto get_result;
}
priv->scan_ret.taken = 0;
priv->scan_no_connect_back = priv->scan_no_connect;
priv->scan_expire = INITIAL_SCAN_EXPIRE;
if(atbmwifi_scan(priv)){
return -2;
}
wifi_printk(WIFI_ALWAYS,"wait scan done++\n");
//wait scan done,, wait scan complete
while(1){
atbm_mdelay(1000);
if(priv->scan.in_progress==0)
break;
if(waitloop-- <=0){
wifi_printk(WIFI_ALWAYS,"wait scan done++timeout drop\n");
return -2;
}
}
wifi_printk(WIFI_ALWAYS,"wait scan done--,scan_ret.len(%d)\n",priv->scan_ret.len);
get_result:
//atbm_wifi_get_scaned_list(scan_buf, buf_size);
pScanResult = (WLAN_SCAN_RESULT*)scan_buf;
pScanResult->count = 0;
bss_info = (WLAN_BSS_INFO *)(&pScanResult->bss_info[0]);
if(buf_size<sizeof(WLAN_SCAN_RESULT))
{
wifi_printk(WIFI_ERROR,"scan_buf very little x1\n");
return -1;
}
//will copy to user API and delete AP list from driver's ap list. here porting for Mstar
for(i=priv->scan_ret.taken;i<priv->scan_ret.len;i++){
info = priv->scan_ret.info + i;
if((char *)(bss_info + 1) > scan_buf+buf_size)
{
wifi_printk(WIFI_ERROR,"scan_buf very little x2\n");
return 1;
}
//Copy ATBM scanned bss list to platform dependent BSS list
bss_info->SSID_len = info->ssidlen;
if( bss_info->SSID_len > 32 )
{
wifi_printk(WIFI_ALWAYS,"atbm_wifi_scan_network_vif SSID_len(%d)\n",bss_info->SSID_len);
bss_info->SSID_len = 32;
}
atbm_memcpy(bss_info->SSID, info->ssid, bss_info->SSID_len);
atbm_memcpy(bss_info->BSSID, info->BSSID, ATBM_ETH_ALEN);
bss_info->beacon_period = info->beacon_interval;
bss_info->capability = info->capability;
bss_info->chanspec = info->channel;
bss_info->RSSI = (atbm_uint16)info->rssi;
bss_info->dtim_period = info->dtim_period;
bss_info->security = info->security;
bss_info->length = sizeof(WLAN_BSS_INFO); //no ies
bss_info++;
pScanResult->count++;
priv->scan_ret.taken++;
}
priv->scan_ret.len = 0;
priv->scan_no_connect = priv->scan_no_connect_back;
wifi_printk(WIFI_ALWAYS,"wait scan done,pScanResult->count(%d)\n",pScanResult->count);
return 0;
}
int atbm_wifi_scan_network(char* scan_buf, atbm_uint32 buf_size)
{
return atbm_wifi_scan_network_vif(0,scan_buf,buf_size);
}
/****************************************************************************
* Function: atbm_wifi_get_mode
*
* Purpose: This function is used to get wifi mode
*
* Parameters: None
*
* Returns: Returns 0 if in STA mode, 1 in SW AP mode.
******************************************************************************/
atbm_int32 atbm_wifi_get_current_mode_vif(atbm_uint8 if_id) //0 : sta, 1: SW AP
{
struct atbmwifi_vif *priv=ATBM_NULL;
if(if_id>=2){
return -1;
}
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL)
return -1;
return priv->iftype ;
}
atbm_int32 atbm_wifi_get_current_mode(atbm_void) //0 : sta, 1: SW AP
{
return atbm_wifi_get_current_mode_vif(0); //default mode.
}
/****************************************************************************
* Function: atbm_wifi_get_mac_address
*
* Purpose: This function is used to get wifi MAC address
*
* Parameters: point to buffer of MAC address
*
* Returns: None.
******************************************************************************/
atbm_void atbm_wifi_get_mac_address_vif(atbm_uint8 if_id,unsigned char *addr)
{
struct atbmwifi_vif *priv=ATBM_NULL;
if(if_id>=2){
return;
}
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL)
return;
if(addr == ATBM_NULL)
{
return;
}
atbm_memcpy(addr, priv->mac_addr, 6); //AP or STA
}
atbm_void atbm_wifi_get_mac_address(unsigned char *addr)
{
atbm_wifi_get_mac_address_vif(0,addr);
}
/****************************************************************************
* Function: atbm_wifi_sta_join_ap
*
* Purpose: This function is used to ask driver to join a network.
*
* Parameters: ssid SSID of the AP used to join a network
* authMode authentication mode used to join a network
* encryption encryption mode used to join a network
* key passphrase used to join a network
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_int32 atbm_wifi_sta_join_ap_vif(atbm_uint8 if_id,char *ssid, char *bssid, WLAN_AUTH_MODE authMode, WLAN_ENCRYPTION encryption, char *key)
{
ATBM_SECURITY_TYPE key_mgmt;
atbm_int32 ret;
switch(authMode){
case WLAN_WPA_AUTH_DISABLED:
case WLAN_WPA_AUTH_NONE:
if(encryption == WLAN_ENCRYPT_WEP){
key_mgmt = ATBM_KEY_WEP;
}else if(encryption == WLAN_ENCRYPT_WEP_SHARED){
key_mgmt = ATBM_KEY_WEP_SHARE;
}else{
key_mgmt = ATBM_KEY_NONE;
}
break;
case WLAN_WPA_AUTH_PSK:
key_mgmt = ATBM_KEY_WPA;
break;
case WLAN_WPA2_AUTH_PSK:
key_mgmt = ATBM_KEY_WPA2;
break;
case WLAN_MIX_AUTH_PSK:
key_mgmt = ATBM_KEY_MIX;
break;
#if CONFIG_SAE
case WLAN_WPA_AUTH_SAE:
key_mgmt = ATBM_KEY_SAE;
break;
#endif
default:
key_mgmt = ATBM_KEY_NONE;
}
if(bssid){
struct atbmwifi_vif *priv=_atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,0);
atbm_memcpy(priv->config.bssid,bssid,6);
}
ret=wifi_ConnectAP_vif(if_id,(unsigned char *)ssid,strlen(ssid),(unsigned char *)key, key ? strlen(key) : 0, key_mgmt);
return ret;
}
atbm_int32 atbm_wifi_sta_join_ap(char *ssid, char *bssid, WLAN_AUTH_MODE authMode, WLAN_ENCRYPTION encryption, char *key)
{
atbm_int32 ret=0;
/* Station/ P2p-Client Will use if_id 0*/
ret=atbm_wifi_sta_join_ap_vif(0,/*if_id*/ssid, bssid, authMode, encryption,key);
return ret;
}
#if FAST_CONNECT_MODE
atbm_int32 atbm_wifi_set_fast_connect_mode(atbm_uint8 enable, atbm_uint8 channel, atbm_uint8 *pmk)
{
struct atbmwifi_vif *priv=ATBM_NULL;
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,0);
struct atbmwifi_cfg *config = &priv->config;
if(enable){
priv->fast_connect = 1;
priv->fast_channel = channel;
if(pmk && pmk[0] != '\0'){
config->psk_set = 1;
atbm_memcpy(config->psk, pmk, 32);
}else{
config->psk_set = 0;
}
}else{
priv->fast_connect = 0;
config->psk_set = 0;
}
return 0;
}
atbm_int32 atbm_wifi_get_fast_connect_info(atbm_uint8 *channel, atbm_uint8 *pmk)
{
struct atbmwifi_vif *priv=ATBM_NULL;
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,0);
struct atbmwifi_cfg *config = &priv->config;
*channel = config->channel_index;
if(config->psk_set){
atbm_memcpy(pmk, config->psk, 32);
}
return 0;
}
#endif
#if FAST_CONNECT_NO_SCAN
static struct atbmwifi_cfg hmac_cfg;
//First connect:config serve as ssid while bss as password
atbm_int32 atbm_wifi_fast_link_noscan(FAST_LINK_INFO * finfo)
{
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, 0);
struct atbmwifi_cfg80211_bss *bss;
struct atbmwifi_cfg *config, *save_config;
if(priv==ATBM_NULL){
return 0;
}
bss = &priv->bss;
config = atbmwifi_get_config(priv);
save_config = (struct atbmwifi_cfg *)finfo->config;
if(finfo->enable){
priv->fast_conn_noscan = 1;
config->ssid_len = save_config->ssid_len;
config->password_len= save_config->password_len;
atbm_memcpy(config->ssid, save_config->ssid, save_config->ssid_len);
atbm_memcpy(priv->ssid, save_config->ssid, save_config->ssid_len);
atbm_memcpy(config->password, save_config->password, save_config->password_len);
config->auth_alg = save_config->auth_alg;
config->privacy = save_config->privacy;
config->key_mgmt = save_config->key_mgmt;
config->key_id = save_config->key_id;
config->psk_set = save_config->psk_set;
config->channel_index = save_config->channel_index;
priv->ssid_length = save_config->ssid_len;
#if CONFIG_IEEE80211W
config->ieee80211w=save_config->ieee80211w;
#endif
atbm_memcpy(config->psk, save_config->psk, sizeof(config->psk));
#if ATBM_DRIVER_PROCESS_BA
((struct atbmwifi_cfg80211_bss *)(finfo->bss))->sta_priv.ampdu_mlme.init = bss->sta_priv.ampdu_mlme.init;
#endif
atbm_memcpy(bss, finfo->bss, sizeof(struct atbmwifi_cfg80211_bss));
if(bss->len_information_elements){
bss->information_elements = (atbm_uint8 *)atbm_kmalloc(bss->len_information_elements, GFP_KERNEL);
if(bss->information_elements){
atbm_memcpy(bss->information_elements, finfo->ie, bss->len_information_elements);
}
}
bss->channel_type = 0;
bss->rc_priv = ATBM_NULL;
atbm_memcpy(priv->daddr,bss->bssid,6);
atbm_memcpy(priv->bssid,bss->bssid,6);
priv->auth_retry = 1;
return atbmwifi_wpa_event_queue((atbm_void*)priv, ATBM_NULL,
ATBM_NULL,WPA_EVENT__SUPPLICANT_START_CONNECT,ATBM_WPA_EVENT_NOACK);
}else{
priv->fast_conn_noscan = 0;
atbm_memset(config, 0, sizeof(struct atbmwifi_cfg));
atbm_memset(bss, 0, sizeof(struct atbmwifi_cfg80211_bss));
config->psk_set = 0;
priv->auth_retry = 0;
return atbm_wifi_sta_join_ap((char *)finfo->config,NULL,0,0,(char *)finfo->bss);
}
}
atbm_void atbm_wifi_get_linkinfo_noscan(FAST_LINK_INFO * finfo)
{
struct atbmwifi_vif *priv=ATBM_NULL;
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,0);
if(priv==ATBM_NULL){
return;
}
struct atbmwifi_cfg80211_bss *bss = &priv->bss;
struct atbmwifi_cfg *config = atbmwifi_get_config(priv);
if(sizeof(finfo->config) < sizeof(struct atbmwifi_cfg)
|| (sizeof(finfo->bss) < sizeof(struct atbmwifi_cfg80211_bss))){
wifi_printk(WIFI_DBG_ERROR,"FAST_LINK_INFO overflow (%d)(%d)!!!\n",
sizeof(struct atbmwifi_cfg) ,sizeof(struct atbmwifi_cfg80211_bss));
return ;
}
finfo->enable = 1;
atbm_memcpy(finfo->config, config, sizeof(struct atbmwifi_cfg));
finfo->ssid_offset = offsetof(struct atbmwifi_cfg, ssid);
finfo->psk_offset = offsetof(struct atbmwifi_cfg, password);
if(bss->len_information_elements){
if(bss->len_information_elements <= sizeof(finfo->ie)){
atbm_memcpy(finfo->ie, bss->information_elements, bss->len_information_elements);
}else{
if((bss->len_information_elements = atbm_wifi_reserve_key_ie(finfo->ie, sizeof(finfo->ie), bss->information_elements, bss->len_information_elements)) <= 0){
wifi_printk(WIFI_ALWAYS, "error:cannot save ies for fastlink!!\n");
}
}
}
atbm_memcpy(finfo->bss, bss, sizeof(struct atbmwifi_cfg80211_bss));
}
#endif
atbm_int32 atbm_wifi_sta_disjoin_ap()
{
struct atbmwifi_vif *priv=ATBM_NULL;
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,0);
if(priv==ATBM_NULL){
return 0;
}
if(!atbm_wifi_initialed(priv->if_id)){
wifi_printk(WIFI_DBG_ERROR,"atbm_wifi_initialed err\n");
return -1;
}
atbm_wifi_off(0);
return 0;
}
int atbm_wifi_isconnected(atbm_uint8 if_id)
{
struct atbmwifi_vif *priv=ATBM_NULL;
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_DBG_ERROR,"not init\n");
return 0;
}
return priv->connect_ok;
}
/****************************************************************************
* Function: atbm_wifi_get_driver_version
*
* Purpose: This function is used to return the driver's release version
*
* Parameters: None
*
* Returns: Returns the driver release version
*****************************************************************************
*/
signed char* atbm_wifi_get_driver_version(atbm_void)
{
struct atbmwifi_vif *priv=ATBM_NULL;
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,0);
if(priv==ATBM_NULL){
return 0;
}
return (signed char*)0;
}
/****************************************************************************
* Function: wlan_get_connection_info
*
* Purpose: This function is used to get the current connection information at STA mode
*
* Parameters: wlan connection information
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
int atbm_wifi_get_connected_info_vif(atbm_uint8 if_id,ATBM_WLAN_CONNECTION_INFO *wlan_connection_info )
{
struct atbmwifi_vif *priv=ATBM_NULL;
if(if_id>=2){
return -1;
}
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL)
return -1;
if(wlan_connection_info->Ssid != ATBM_NULL)
{
wlan_connection_info->Ssid_len = priv->ssid_length;
atbm_memcpy(wlan_connection_info->Ssid, priv->ssid, wlan_connection_info->Ssid_len);
}
wlan_connection_info->channel = priv->bss.channel_num;
//RSSI, PHY rate?? mapping? or current used rx/tx rate?//from rx_status
wlan_connection_info->Rssi = priv->bss.rssi;
return 0;
}
int atbm_wifi_get_connected_info(ATBM_WLAN_CONNECTION_INFO *wlan_connection_info )
{
return atbm_wifi_get_connected_info_vif(0,wlan_connection_info);
}
/*************************************************************************************
************** SW AP functions *********
**************************************************************************************/
/****************************************************************************
* Function: atbm_wifi_ap_create
*
* Purpose: This function is used to create a SW AP network
*
* Parameters: ssid SSID of the SW AP to be created
* authMode Authentication mode used for the SW AP
* encryption Encryption mode used for the SW AP
* key Passphrase used for the SW AP
* channel Channel used for the SW AP
* ssidBcst 0: to broadcast SSID, 1: to hide SSID
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_int32 atbm_wifi_ap_create_vif(atbm_uint8 if_id,char* ssid, int authMode, int encryption,
char *key, int channel, ATBM_BOOL ssidBcst )
{
ATBM_SECURITY_TYPE key_mgmt;
switch(authMode){
case WLAN_WPA_AUTH_DISABLED:
case WLAN_WPA_AUTH_NONE:
if(encryption == WLAN_ENCRYPT_WEP){
key_mgmt= ATBM_KEY_WEP;
}else if(encryption == WLAN_ENCRYPT_WEP_SHARED){
key_mgmt= ATBM_KEY_WEP_SHARE;
}else{
key_mgmt = ATBM_KEY_NONE;
}
break;
case WLAN_WPA_AUTH_PSK:
key_mgmt = ATBM_KEY_WPA;
break;
case WLAN_WPA2_AUTH_PSK:
key_mgmt = ATBM_KEY_WPA2;
break;
case WLAN_MIX_AUTH_PSK:
key_mgmt=ATBM_KEY_MIX;
break;
case WLAN_WPA_AUTH_SAE:
key_mgmt=ATBM_KEY_SAE_COMPIT;
break;
default:
key_mgmt = ATBM_KEY_NONE;
}
//add Auth mode and channel
wifi_StartAP_vif(if_id,(unsigned char *)ssid,strlen(ssid), (unsigned char *)key, strlen(key),channel,key_mgmt,ssidBcst);
return 0;
}
atbm_int32 atbm_wifi_ap_create(char* ssid, int authMode, int encryption,
char *key, int channel, ATBM_BOOL ssidBcst )
{
return atbm_wifi_ap_create_vif(1,ssid,authMode,encryption,key,channel,ssidBcst);
}
/****************************************************************************
* Function: wlan_get_assoc_list
*
* Purpose: This function is used to the associated client list in SW AP mode
*
* Parameters: buf The buffer to store the associated client list
* uiBufSize size of the buffer
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
* For ioctls that take a list of MAC addresses *
******************************************************************************/
atbm_int32 atbm_wifi_get_associated_client_list_vif(atbm_uint8 if_id,atbm_void *pchBuf, unsigned int uiBufSize)
{
WLAN_MACLIST *maclist = (WLAN_MACLIST*)pchBuf;
struct atbmwifi_vif *priv=ATBM_NULL;
if(if_id>=2){
return -1;
}
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL)
return -1;
atbm_memset(pchBuf, 0, uiBufSize);
if(maclist->count > ATBMWIFI__MAX_STA_IN_AP_MODE)
{
maclist->count = ATBMWIFI__MAX_STA_IN_AP_MODE;
}
maclist->count = atbmwifi_get_hard_linked_macs(priv, maclist->ea[0].mac, maclist->count);
return 0;
}
atbm_int32 atbm_wifi_get_associated_client_list(atbm_uint8 *pchBuf, atbm_uint32 uiBufSize)
{
return atbm_wifi_get_associated_client_list_vif(1,pchBuf, uiBufSize);
}
atbm_int32 atbmwifi_enable_lmaclog(atbm_uint32 value ){
return atbmwifi_get_lmacLog_to_host(value);
}
atbm_int32 atbm_wifi_get_rssi_avg(atbm_void)
{
return atbmwifi_get_rssi_avg();
}
atbm_int32 atbm_wifi_set_tx_time(atbm_uint32 time_period, atbm_uint32 time_transmit)
{
return atbmwifi_set_tx_time(time_period, time_transmit);
}
atbm_int32 atbm_wifi_set_retry(atbm_uint32 retry_num, atbm_uint32 retry_time_ms)
{
return atbmwifi_set_retry(retry_num, retry_time_ms);
}
atbm_int32 atbm_wifi_set_txpower(atbm_uint32 txpower_idx)
{
return atbmwifi_set_txpower(txpower_idx);
}
atbm_int32 atbm_wifi_set_txpower_mode(atbm_uint32 txpower_idx)
{
return atbmwifi_set_rate_txpower_mode(txpower_idx);
}
atbm_int32 atbm_wifi_set_tx_rate(atbm_int32 rate)
{
return atbmwifi_set_tx_rate(rate);
}
atbm_int32 atbm_wifi_set_sgi(atbm_uint32 sgi)
{
return atbmwifi_set_sgi(sgi);
}
atbm_int32 atbm_wifi_set_adptive(atbm_uint32 value)
{
return atbmwifi_dev_set_adaptive(value);
}
atbm_int32 atbm_wifi_get_256BITSEFUSE(atbm_uint8 *data, atbm_uint32 length)
{
int ret = 0;
int i;
struct atbmwifi_common *hw_priv = &g_hw_prv;;
if((data == NULL) || (length != 32)){
wifi_printk(WIFI_ERROR, "invalid parameter,please try again!\n");
return -1;
}
if ((ret = wsm_get_SIGMSTAR_256BITSEFUSE(hw_priv, data, length)) == 0){
wifi_printk(WIFI_ERROR, "Get efuse data:\n");
for(i = 0; i < length; i++)
{
wifi_printk(WIFI_ALWAYS, "%x ", data[i]);
}
wifi_printk(WIFI_ALWAYS, "\n");
return ret;
}
else{
wifi_printk(WIFI_ERROR, "read efuse failed\n");
return -1;
}
return ret;
}
atbm_int32 atbm_wifi_set_256BITSEFUSE(atbm_uint8 *data, atbm_uint32 length)
{
atbm_int32 i;
atbm_int32 ret = 0;
struct atbmwifi_common *hw_priv = &g_hw_prv;;
if((data == NULL) || (length != 32)){
wifi_printk(WIFI_ERROR, "invalid parameter,please try again!\n");
return -1;
}
if ((ret = wsm_set_SIGMSTAR_256BITSEFUSE(hw_priv, data, length)) == 0){
wifi_printk(WIFI_ALWAYS, "Set efuse data:\n");
for(i = 0; i < length; i++)
{
wifi_printk(WIFI_ALWAYS, "%x ", data[i]);
}
wifi_printk(WIFI_ALWAYS, "\n");
return ret;
}
else{
wifi_printk(WIFI_ERROR, "write efuse failed\n");
return -1;
}
return ret;
}
extern int wsm_efuse_change_data_cmd(struct atbmwifi_common *hw_priv, const struct efuse_headr *arg, int if_id);
int atbm_save_efuse(struct atbmwifi_common *hw_priv, struct efuse_headr *efuse_save)
{
int ret = 0;
int iResult=0;
//struct atbm_vif *vif;
struct efuse_headr efuse_bak;
ret = wsm_efuse_change_data_cmd(hw_priv, efuse_save,0);
if (ret == LMC_STATUS_CODE__EFUSE_FIRST_WRITE)
{
iResult = -3;
}else if (ret == LMC_STATUS_CODE__EFUSE_PARSE_FAILED)
{
iResult = -4;
}else if (ret == LMC_STATUS_CODE__EFUSE_FULL)
{
iResult = -5;
}else if (ret == LMC_STATUS_CODE__EFUSE_VERSION_CHANGE)
{
iResult = -6;
}else
{
iResult = 0;
}
wsm_get_efuse_data(hw_priv,(void *)&efuse_bak, sizeof(struct efuse_headr));
if(atbm_memcmp((void *)&efuse_bak,(void *)efuse_save, sizeof(struct efuse_headr)) !=0)
{
iResult = -2;
}else
{
iResult = 0;
}
return iResult;
}
/*
txpower_idx: [-16:16] -> [-8:0.5:8]dB -> [-80:5:80]/10 dB
*/
atbm_int32 atbm_wifi_set_rate_txpower_mode(atbm_int32 txpower_idx)
{
return atbmwifi_set_rate_txpower_mode(txpower_idx);
}
/*************************************************************************************
************** Manufacturing test functions *********
**************************************************************************************/
atbm_void atbm_wifi_mfg_start(atbm_void)
{
wifi_printk(WIFI_ALWAYS, "atbm_wifi_mfg_start()\n");
return;
}
/**************************************************************************************
* Function: atbm_wifi_mfg_set_pktTxBG
*
* Purpose: This function is used to perform manufacturing 11b/g continuous TX test
*
* Parameters: channel Channel used for TX
* rate 11b/g rate used for TX
* powerValue Output power index, -1 means default power
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
****************************************************************************************/
atbm_int32 atbm_wifi_mfg_set_pktTxBG(WLAN_CHANNEL channel, WLAN_RATE rate, atbm_int32 powerValue)
{
atbm_int32 rate_val = 0;
wifi_printk(WIFI_ALWAYS, "atbm_wifi_mfg_set_pktTxBG()\n");
if(channel < 1 || channel > 14){
wifi_printk(WIFI_DBG_ERROR, "invalid channel! %d\n", channel);
return -1;
}
switch(rate){
//11b
case WLAN_RATE_1M: rate_val = 10;
break;
case WLAN_RATE_2M: rate_val = 20;
break;
case WLAN_RATE_5M5: rate_val = 55;
break;
case WLAN_RATE_11M: rate_val = 110;
break;
//11g
case WLAN_RATE_6M: rate_val = 60;
break;
case WLAN_RATE_9M: rate_val = 90;
break;
case WLAN_RATE_12M: rate_val = 120;
break;
case WLAN_RATE_18M: rate_val = 180;
break;
case WLAN_RATE_24M: rate_val = 240;
break;
case WLAN_RATE_36M: rate_val = 360;
break;
case WLAN_RATE_48M: rate_val = 480;
break;
case WLAN_RATE_54M: rate_val = 540;
break;
default:
wifi_printk(WIFI_DBG_ERROR, "invalid rate! %d\n", rate);
return -1;
}
//txpower_idx: [-16:16] -> [-8:0.5:8]dB -> [-80:5:80]/10 dB
if(powerValue > 16 || powerValue < -16){
wifi_printk(WIFI_DBG_ERROR, "invalid txpower index! %d\n", powerValue);
return -1;
}
if(atbm_wifi_set_rate_txpower_mode(powerValue) < 0){
wifi_printk(WIFI_DBG_ERROR, "set rate txpower mode failed! %d\n", powerValue);
return -1;
}
if(atbm_etf_start_tx(channel, rate_val, 0/*40M*/, 0/*greedfiled*/) < 0){
wifi_printk(WIFI_DBG_ERROR, "start tx bg failed!\n");
return -1;
}
return 0;
}
/***********************************************************************************
* Function: atbm_wifi_mfg_set_PktTxN
*
* Purpose: This function is used to perform manufacturing 11n continuous TX test
*
* Parameters: channel Channel used for TX
* rate 11n rate used for TX
* powerValue Output power index, -1 means default power
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
************************************************************************************/
atbm_int32 atbm_wifi_mfg_set_PktTxN(WLAN_CHANNEL channel, WLAN_RATE rate, atbm_int32 powerValue)
{
atbm_int32 rate_val = 0;
wifi_printk(WIFI_ALWAYS, "atbm_wifi_mfg_set_PktTxN()\n");
if(channel < 1 || channel > 14){
wifi_printk(WIFI_DBG_ERROR, "invalid channel! %d\n", channel);
return -1;
}
switch(rate){
case WLAN_MCS_RATE_0: rate_val = 65;
break;
case WLAN_MCS_RATE_1: rate_val = 130;
break;
case WLAN_MCS_RATE_2: rate_val = 195;
break;
case WLAN_MCS_RATE_3: rate_val = 260;
break;
case WLAN_MCS_RATE_4: rate_val = 390;
break;
case WLAN_MCS_RATE_5: rate_val = 520;
break;
case WLAN_MCS_RATE_6: rate_val = 585;
break;
case WLAN_MCS_RATE_7: rate_val = 650;
break;
default:
wifi_printk(WIFI_DBG_ERROR, "invalid rate! %d\n", rate);
return -1;
}
//txpower_idx: [-16:16] -> [-8:0.5:8]dB -> [-80:5:80]/10 dB
if(powerValue > 16 || powerValue < -16){
wifi_printk(WIFI_DBG_ERROR, "invalid txpower index! %d\n", powerValue);
return -1;
}
if(atbm_wifi_set_rate_txpower_mode(powerValue) < 0){
wifi_printk(WIFI_DBG_ERROR, "set rate txpower mode failed! %d\n", powerValue);
return -1;
}
if(atbm_etf_start_tx(channel, rate_val, 1/*40M*/, 0/*greedfiled*/) < 0){
wifi_printk(WIFI_DBG_ERROR, "start tx bg failed!\n");
return -1;
}
return 0;
}
atbm_int32 atbm_wifi_mfg_PT_Test(atbm_uint8 if_id,/*atbm_int32 targetFreq, atbm_int32 rssiFilter, atbm_int32 evmFilter, atbm_int32 cableLoss, */atbm_int32 isWriteEfuse)
{
atbm_etf_PT_Test_start(if_id,/*targetFreq, rssiFilter, evmFilter, cableLoss, */isWriteEfuse);
return 0;
}
/****************************************************************************
* Function: atbm_wifi_mfg_CarrierTone
*
* Purpose: This function is used to perform manufacturing non-modulation TX test
*
* Parameters: channel Channel used for test
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_int32 atbm_wifi_mfg_CarrierTone(WLAN_CHANNEL channel)
{
atbm_int32 rate_val = 65;
wifi_printk(WIFI_ALWAYS, "atbm_wifi_mfg_CarrierTone()\n");
if(channel < 1 || channel > 14){
wifi_printk(WIFI_DBG_ERROR, "invalid channel! %d\n", channel);
return -1;
}
if(atbm_etf_start_tx_single_tone(channel, rate_val, 0/*40M*/, 0) < 0){
wifi_printk(WIFI_DBG_ERROR, "start tx CarrierTone failed!\n");
return -1;
}
return 0;
}
int atbm_wifi_etf_start_tx(int channel,int rate_value,int is_40M, int greedfiled)
{
return atbm_etf_start_tx(channel, rate_value, is_40M, greedfiled);
}
int atbm_wifi_etf_stop_tx()
{
return atbm_etf_stop_tx();
}
int atbm_wifi_etf_start_rx(int channel ,int is_40M)
{
return atbm_etf_start_rx(channel, is_40M);
}
int atbm_wifi_etf_stop_rx()
{
return atbm_etf_stop_rx();
}
/****************************************************************************
* Function: atbm_wifi_mfg_set_PktRxMode
*
* Purpose: This function is used to perform manufacturing RX test
*
* Parameters: channel Channel used for RX
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_int32 atbm_wifi_mfg_set_PktRxMode(WLAN_CHANNEL channel)
{
wifi_printk(WIFI_ALWAYS, "atbm_wifi_mfg_set_PktRxMode()\n");
if(channel < 1 || channel > 14){
wifi_printk(WIFI_DBG_ERROR, "invalid channel! %d\n", channel);
return -1;
}
if(atbm_etf_start_rx(channel, 0/*40M*/) < 0){
wifi_printk(WIFI_DBG_ERROR, "start etf rx failed!\n");
return -1;
}
return 0;
}
/****************************************************************************
* Function: atbm_wifi_mfg_get_RxPkt
*
* Purpose: This function is used to get received packet count
*
* Parameters: uiCount Received packet count
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_int32 atbm_wifi_mfg_get_RxPkt(atbm_uint32* uiCount)
{
wifi_printk(WIFI_ALWAYS, "atbm_wifi_mfg_get_RxPkt()\n");
return 0;
}
/****************************************************************************
* Function: atbm_wifi_mfg_stop
*
* Purpose: This function is used to stop manufacturing test
*
* Parameters: None
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_int32 atbm_wifi_mfg_stop(atbm_void)
{
wifi_printk(WIFI_ALWAYS, "atbm_wifi_mfg_stop()\n");
atbm_etf_stop_rx();
atbm_etf_stop_tx();
return 0;
}
extern atbm_void atbm_ht_smt_setting(atbm_void);
atbm_uint8 atbm_smartconfig_start(void)
{
/*Station if_id ==0*/
int if_id=0;
struct smartconfig_config st_cfg = {0};
{
st_cfg.type = CONFIG_TP_ATBM_SMART;
st_cfg.magic_cnt = 1;
st_cfg.magic_time = 70;
st_cfg.payload_time = 12000;
};
atbm_ht_smt_setting();
smartconfig_start(&st_cfg,if_id);
return 0;
}
atbm_uint8 atbm_smartconfig_stop(void)
{
/*Station if_id ==0*/
int if_id=0;
smartconfig_stop(if_id);
return 0;
}
#if CONFIG_WPS
/****************************************************************************
* Function: atbmwps_start_pbc
*
* Purpose: This function is used to start wps->pbc mode
*
* Parameters: None
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_uint8 atbm_wpspbc_start(ATBM_WIFI_MODE AP_sta_mode)
{
int ret;
int if_id;
struct atbmwifi_vif *priv=ATBM_NULL;
switch (AP_sta_mode){
case ATBM_NL80211_IFTYPE_STATION:
case ATBM_NL80211_IFTYPE_P2P_CLIENT:
if_id=0;
break;
case ATBM_NL80211_IFTYPE_AP:
case ATBM_NL80211_IFTYPE_P2P_GO:
if_id=1;
break;
default:
wifi_printk(WIFI_ALWAYS,"Mode cant support,Pls check it !!!\n");
return -1;
}
atbm_wifi_on(AP_sta_mode);
priv= _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
ret=atbmwps_start_pbc(priv,ATBM_NULL);
return ret;
}
/****************************************************************************
* Function: atbmwps_start_pin
*
* Purpose: This function is used to start wps->pin mode
*
* Parameters: None
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_uint8 atbm_wpspin_start(ATBM_WIFI_MODE AP_sta_mode,const char *pin)
{
int ret;
int if_id;
struct atbmwifi_vif *priv=ATBM_NULL;
switch (AP_sta_mode){
case ATBM_NL80211_IFTYPE_STATION:
case ATBM_NL80211_IFTYPE_P2P_CLIENT:
if_id=0;
break;
case ATBM_NL80211_IFTYPE_AP:
case ATBM_NL80211_IFTYPE_P2P_GO:
if_id=1;
break;
default:
wifi_printk(WIFI_ALWAYS,"Mode cant support,Pls check it !!!\n");
return -1;
}
atbm_wifi_on(AP_sta_mode);
priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
ret = atbmwps_start_pin(priv, pin, NULL, 0);
return ret;
}
/****************************************************************************
* Function: atbmwps_cancel
*
* Purpose: This function is used to cancel wps func
*
* Parameters: None
*
* Returns: Returns 0 if succeed, otherwise a negative error code.
******************************************************************************/
atbm_uint8 atbm_wpsmode_cancel(ATBM_WIFI_MODE AP_sta_mode)
{
int ret;
int if_id;
struct atbmwifi_vif *priv=ATBM_NULL;
switch (AP_sta_mode){
case ATBM_NL80211_IFTYPE_STATION:
case ATBM_NL80211_IFTYPE_P2P_CLIENT:
if_id=0;
break;
case ATBM_NL80211_IFTYPE_AP:
case ATBM_NL80211_IFTYPE_P2P_GO:
if_id=1;
break;
default:
wifi_printk(WIFI_ALWAYS,"Mode cant support,Pls check it !!!\n");
return -1;
}
priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
ret = atbmwps_cancel(priv);
atbm_wifi_off(AP_sta_mode);
return ret;
}
#endif
#if BENTU_OS
/****************************************************************************
* Function: atbm_wifi_get_if_status
*
* Purpose: This function is used to get interface setup status
*
* Parameters: if_id 0: Sta interface, 1 AP interface
*
* Returns: 1:interface on, 0:interface off.
****************************************************************************/
ATBM_WIFI_IFACE_STATE atbm_wifi_get_if_status(ATBM_WIFI_MODE mode)
{
int if_id = -1;
struct atbmwifi_vif *priv;
if((mode == ATBM_WIFI_STA_MODE) || (mode == ATBM_WIFI_P2P_CLIENT)){
if_id = 0;
}else if((mode == ATBM_WIFI_AP_MODE) || (mode == ATBM_WIFI_P2P_GO)){
if_id = 1;
}else{
wifi_printk(WIFI_ALWAYS,"%s not support mode %d\n", __func__, mode);
return -1;//ATBM_WIFI_IFACE_ERR;
}
priv = atbm_wifi_vif_get(if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS,"%s iface(%d) is not init\n", __func__, if_id);
return -1;//ATBM_WIFI_IFACE_ERR;
}
if(priv->iftype == ATBM_NUM_NL80211_IFTYPES){
return 0;//ATBM_WIFI_IFACE_OFF;
}else{
return 1;//ATBM_WIFI_IFACE_ON;
}
}
#endif
#if CONFIG_P2P
/* if all interface is occupied, then stop AP mode first */
struct atbmwifi_vif * p2p_get_available_ifpriv(){
return _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,0);
}
/****************************************************************************
* Function: atbm_wifi_p2p_start
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_start()
{
int ret = 0;
struct atbmwifi_vif *priv = p2p_get_available_ifpriv();
g_hw_prv.p2p_if_id = priv->if_id;
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
atbm_p2p_start(priv);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_find
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_find(int timeout)
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
ret = atbm_p2p_find_only(priv, timeout);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_find
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_find_accept(int go_intent)
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
ret = atbm_p2p_find_wait_connect(priv, go_intent);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_find_stop
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_find_stop(int timeout)
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
atbm_p2p_stop_find(priv);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_find_stop
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_listen_accept(int go_intent, int channel)
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
atbm_p2p_listen_wait_connect(priv, go_intent, channel);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_show_peers
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_show_peers()
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
atbm_p2p_get_peers(priv);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_go_start
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_go_start()
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
atbm_p2p_go_start(priv);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_go_start
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_go_stop()
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
atbm_p2p_go_stop(priv);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_connect
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_connect(atbm_uint8 *mac, int go_intent)
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
atbm_p2p_stop_find(priv);
atbm_SleepMs(200);
ret = atbm_p2p_auto_connect(priv, mac, go_intent);
_error:
return ret;
}
/****************************************************************************
* Function: atbm_wifi_p2p_stop
*
* Purpose: This function is used to create p2p main task
*
* Parameters: None
*
* Returns: None
******************************************************************************/
int atbm_wifi_p2p_stop()
{
int ret = 0;
struct atbmwifi_vif *priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv, g_hw_prv.p2p_if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS, "p2p:error, priv is NULL\n");
ret = -1;
goto _error;
}
ret = atbm_p2p_deinit(priv);
_error:
return ret;
}
#endif
atbm_int8 atbm_wifi_get_bssid(atbm_uint8 *bssid, atbm_int32 if_id)
{
struct atbmwifi_vif *priv;
priv = _atbmwifi_hwpriv_to_vifpriv(&g_hw_prv,if_id);
if(priv == ATBM_NULL){
wifi_printk(WIFI_ALWAYS,"%s priv is null\n", __func__);
return -1;
}
//get station connection status
if((bssid==ATBM_NULL) || (atbm_wifi_isconnected(if_id) == 0)){
return -1;
}
atbm_memcpy(bssid, priv->bssid, ATBM_ETH_ALEN);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink