#include "wilc_wfi_cfgoperations.h"
#include "wilc_wlan.c"
#ifdef WILC_SDIO
-#include "linux_wlan_sdio.h" /* tony : for set_wiphy_dev() */
+#include "linux_wlan_sdio.h"
#endif
-
+#include <linux/errno.h>
#define IS_MANAGMEMENT 0x100
#define IS_MANAGMEMENT_CALLBACK 0x080
tstrNetworkInfo astrLastScannedNtwrksShadow[MAX_NUM_SCANNED_NETWORKS_SHADOW];
u32 u32LastScannedNtwrksCountShadow;
-#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
struct timer_list hDuringIpTimer;
-#endif
struct timer_list hAgingTimer;
static u8 op_ifcs;
extern u8 u8ConnectedSSID[6];
-/*BugID_5137*/
u8 g_wilc_initialized = 1;
extern linux_wlan_t *g_linux_wlan;
-#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
extern bool g_obtainingIP;
-#endif
#define CHAN2G(_channel, _freq, _flags) { \
.band = IEEE80211_BAND_2GHZ, \
RATETAB_ENT(540, 12, 0),
};
-#ifdef WILC_P2P
struct p2p_mgmt_data {
int size;
u8 *buff;
/*Global variable used to state the current connected STA channel*/
u8 u8WLANChannel = INVALID_CHANNEL;
-/*BugID_5442*/
-u8 u8CurrChannel;
+u8 curr_channel;
u8 u8P2P_oui[] = {0x50, 0x6f, 0x9A, 0x09};
u8 u8P2Plocalrandom = 0x01;
u8 u8P2Precvrandom = 0x00;
u8 u8P2P_vendorspec[] = {0xdd, 0x05, 0x00, 0x08, 0x40, 0x03};
bool bWilc_ie;
-#endif
static struct ieee80211_supported_band WILC_WFI_band_2ghz = {
.channels = WILC_WFI_2ghz_channels,
};
-/*BugID_5137*/
struct add_key_params {
u8 key_idx;
bool pairwise;
struct add_key_params g_add_ptk_key_params;
struct wilc_wfi_key g_key_ptk_params;
struct wilc_wfi_wep_key g_key_wep_params;
-u8 g_flushing_in_progress;
bool g_ptk_keys_saved;
bool g_gtk_keys_saved;
bool g_wep_keys_saved;
}
-uint32_t get_rssi_avg(tstrNetworkInfo *pstrNetworkInfo)
+u32 get_rssi_avg(tstrNetworkInfo *pstrNetworkInfo)
{
- uint8_t i;
+ u8 i;
int rssi_v = 0;
- uint8_t num_rssi = (pstrNetworkInfo->strRssi.u8Full) ? NUM_RSSI : (pstrNetworkInfo->strRssi.u8Index);
+ u8 num_rssi = (pstrNetworkInfo->strRssi.u8Full) ? NUM_RSSI : (pstrNetworkInfo->strRssi.u8Index);
for (i = 0; i < num_rssi; i++)
rssi_v += pstrNetworkInfo->strRssi.as8RSSI[i];
return rssi_v;
}
-void refresh_scan(void *pUserVoid, uint8_t all, bool bDirectScan)
+void refresh_scan(void *pUserVoid, u8 all, bool bDirectScan)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
struct wiphy *wiphy;
struct cfg80211_bss *bss = NULL;
int i;
int rssi = 0;
- priv = (struct WILC_WFI_priv *)pUserVoid;
+ priv = (struct wilc_priv *)pUserVoid;
wiphy = priv->dev->ieee80211_ptr->wiphy;
for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
}
}
-#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
static void clear_duringIP(unsigned long arg)
{
PRINT_D(GENERIC_DBG, "GO:IP Obtained , enable scan\n");
g_obtainingIP = false;
}
-#endif
-int8_t is_network_in_shadow(tstrNetworkInfo *pstrNetworkInfo, void *pUserVoid)
+int is_network_in_shadow(tstrNetworkInfo *pstrNetworkInfo, void *pUserVoid)
{
- int8_t state = -1;
+ int state = -1;
int i;
if (u32LastScannedNtwrksCountShadow == 0) {
void add_network_to_shadow(tstrNetworkInfo *pstrNetworkInfo, void *pUserVoid, void *pJoinParams)
{
- int8_t ap_found = is_network_in_shadow(pstrNetworkInfo, pUserVoid);
- uint32_t ap_index = 0;
- uint8_t rssi_index = 0;
+ int ap_found = is_network_in_shadow(pstrNetworkInfo, pUserVoid);
+ u32 ap_index = 0;
+ u8 rssi_index = 0;
if (u32LastScannedNtwrksCountShadow >= MAX_NUM_SCANNED_NETWORKS_SHADOW) {
PRINT_D(CFG80211_DBG, "Shadow network reached its maximum limit\n");
*/
static void CfgScanResult(tenuScanEvent enuScanEvent, tstrNetworkInfo *pstrNetworkInfo, void *pUserVoid, void *pJoinParams)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
struct wiphy *wiphy;
s32 s32Freq;
struct ieee80211_channel *channel;
- s32 s32Error = WILC_SUCCESS;
struct cfg80211_bss *bss = NULL;
- priv = (struct WILC_WFI_priv *)pUserVoid;
+ priv = (struct wilc_priv *)pUserVoid;
if (priv->bCfgScanning == true) {
if (enuScanEvent == SCAN_EVENT_NETWORK_FOUND) {
wiphy = priv->dev->ieee80211_ptr->wiphy;
- WILC_NULLCHECK(s32Error, wiphy);
+
+ if (!wiphy)
+ return;
+
if (wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC
&&
((((s32)pstrNetworkInfo->s8rssi) * 100) < 0
||
(((s32)pstrNetworkInfo->s8rssi) * 100) > 100)
) {
- WILC_ERRORREPORT(s32Error, WILC_FAIL);
+ PRINT_ER("wiphy signal type fial\n");
+ return;
}
if (pstrNetworkInfo != NULL) {
s32Freq = ieee80211_channel_to_frequency((s32)pstrNetworkInfo->u8channel, IEEE80211_BAND_2GHZ);
channel = ieee80211_get_channel(wiphy, s32Freq);
- WILC_NULLCHECK(s32Error, channel);
+ if (!channel)
+ return;
PRINT_INFO(CFG80211_DBG, "Network Info:: CHANNEL Frequency: %d, RSSI: %d, CapabilityInfo: %d,"
"BeaconPeriod: %d\n", channel->center_freq, (((s32)pstrNetworkInfo->s8rssi) * 100),
up(&(priv->hSemScanReq));
}
}
-
-
- WILC_CATCH(s32Error)
- {
- }
}
* @date 01 MAR 2012
* @version 1.0
*/
-int WILC_WFI_Set_PMKSA(u8 *bssid, struct WILC_WFI_priv *priv)
+int WILC_WFI_Set_PMKSA(u8 *bssid, struct wilc_priv *priv)
{
u32 i;
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
for (i = 0; i < priv->pmkid_list.numpmkid; i++) {
/*If bssid is found, set the values*/
s32Error = host_int_set_pmkid_info(priv->hWILCWFIDrv, &priv->pmkid_list);
- if (s32Error != WILC_SUCCESS)
+ if (s32Error != 0)
PRINT_ER("Error in pmkid\n");
break;
}
-int linux_wlan_set_bssid(struct net_device *wilc_netdev, uint8_t *pBSSID);
+int linux_wlan_set_bssid(struct net_device *wilc_netdev, u8 *pBSSID);
/**
tstrDisconnectNotifInfo *pstrDisconnectNotifInfo,
void *pUserVoid)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
struct net_device *dev;
- #ifdef WILC_P2P
tstrWILC_WFIDrv *pstrWFIDrv;
- #endif
u8 NullBssid[ETH_ALEN] = {0};
connecting = 0;
- priv = (struct WILC_WFI_priv *)pUserVoid;
+ priv = (struct wilc_priv *)pUserVoid;
dev = priv->dev;
- #ifdef WILC_P2P
pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
- #endif
if (enuConnDisconnEvent == CONN_DISCONN_EVENT_CONN_RESP) {
/*Initialization*/
linux_wlan_set_bssid(priv->dev, NullBssid);
memset(u8ConnectedSSID, 0, ETH_ALEN);
- /*BugID_5457*/
/*Invalidate u8WLANChannel value on wlan0 disconnect*/
- #ifdef WILC_P2P
if (!pstrWFIDrv->u8P2PConnect)
u8WLANChannel = INVALID_CHANNEL;
- #endif
PRINT_ER("Unspecified failure: Connection status %d : MAC status = %d\n", u16ConnectStatus, u8MacStatus);
}
pstrConnectInfo->au8bssid[1], pstrConnectInfo->au8bssid[2], pstrConnectInfo->au8bssid[3], pstrConnectInfo->au8bssid[4], pstrConnectInfo->au8bssid[5]);
memcpy(priv->au8AssociatedBss, pstrConnectInfo->au8bssid, ETH_ALEN);
- /* BugID_4209: if this network has expired in the scan results in the above nl80211 layer, refresh them here by calling
- * cfg80211_inform_bss() with the last Scan results before calling cfg80211_connect_result() to avoid
- * Linux kernel warning generated at the nl80211 layer */
for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
if (memcmp(astrLastScannedNtwrksShadow[i].au8bssid,
}
if (bNeedScanRefresh) {
- /*BugID_5418*/
/*Also, refrsh DIRECT- results if */
refresh_scan(priv, 1, true);
u16ConnectStatus, GFP_KERNEL); /* TODO: mostafa: u16ConnectStatus to */
/* be replaced by pstrConnectInfo->u16ConnectStatus */
} else if (enuConnDisconnEvent == CONN_DISCONN_EVENT_DISCONN_NOTIF) {
- #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
g_obtainingIP = false;
- #endif
PRINT_ER("Received MAC_DISCONNECTED from firmware with reason %d on dev [%p]\n",
pstrDisconnectNotifInfo->u16reason, priv->dev);
u8P2Plocalrandom = 0x01;
linux_wlan_set_bssid(priv->dev, NullBssid);
memset(u8ConnectedSSID, 0, ETH_ALEN);
- /*BugID_5457*/
/*Invalidate u8WLANChannel value on wlan0 disconnect*/
- #ifdef WILC_P2P
if (!pstrWFIDrv->u8P2PConnect)
u8WLANChannel = INVALID_CHANNEL;
- #endif
- /*BugID_5315*/
/*Incase "P2P CLIENT Connected" send deauthentication reason by 3 to force the WPA_SUPPLICANT to directly change
* virtual interface to station*/
if ((pstrWFIDrv->IFC_UP) && (dev == g_linux_wlan->strInterfaceInfo[1].wilc_netdev)) {
pstrDisconnectNotifInfo->u16reason = 3;
}
- /*BugID_5315*/
/*Incase "P2P CLIENT during connection(not connected)" send deauthentication reason by 1 to force the WPA_SUPPLICANT
* to scan again and retry the connection*/
else if ((!pstrWFIDrv->IFC_UP) && (dev == g_linux_wlan->strInterfaceInfo[1].wilc_netdev)) {
static int set_channel(struct wiphy *wiphy,
struct cfg80211_chan_def *chandef)
{
-
u32 channelnum = 0;
- struct WILC_WFI_priv *priv;
- s32 s32Error = WILC_SUCCESS;
+ struct wilc_priv *priv;
+ int result = 0;
priv = wiphy_priv(wiphy);
channelnum = ieee80211_frequency_to_channel(chandef->chan->center_freq);
PRINT_D(CFG80211_DBG, "Setting channel %d with frequency %d\n", channelnum, chandef->chan->center_freq);
- u8CurrChannel = channelnum;
- s32Error = host_int_set_mac_chnl_num(priv->hWILCWFIDrv, channelnum);
+ curr_channel = channelnum;
+ result = host_int_set_mac_chnl_num(priv->hWILCWFIDrv, channelnum);
- if (s32Error != WILC_SUCCESS)
+ if (result != 0)
PRINT_ER("Error in setting channel %d\n", channelnum);
- return s32Error;
+ return result;
}
/**
* @version 1.0
*/
-/*
- * kernel version 3.8.8 supported
- * tony, sswd, WILC-KR, 2013-10-29
- */
static int scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
u32 i;
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
u8 au8ScanChanList[MAX_NUM_SCANNED_NETWORKS];
- tstrHiddenNetwork strHiddenNetwork;
+ struct hidden_network strHiddenNetwork;
priv = wiphy_priv(wiphy);
if (request->n_ssids >= 1) {
- strHiddenNetwork.pstrHiddenNetworkInfo = kmalloc(request->n_ssids * sizeof(tstrHiddenNetwork), GFP_KERNEL);
+ strHiddenNetwork.pstrHiddenNetworkInfo = kmalloc(request->n_ssids * sizeof(struct hidden_network), GFP_KERNEL);
strHiddenNetwork.u8ssidnum = request->n_ssids;
- /*BugID_4156*/
for (i = 0; i < request->n_ssids; i++) {
if (request->ssids[i].ssid != NULL && request->ssids[i].ssid_len != 0) {
" channels\n");
}
- if (s32Error != WILC_SUCCESS) {
+ if (s32Error != 0) {
s32Error = -EBUSY;
PRINT_WRN(CFG80211_DBG, "Device is busy: Error(%d)\n", s32Error);
}
static int connect(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_connect_params *sme)
{
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
u32 i;
u8 u8security = NO_ENCRYPT;
- AUTHTYPE_T tenuAuth_type = ANY;
+ enum AUTHTYPE tenuAuth_type = ANY;
char *pcgroup_encrypt_val = NULL;
char *pccipher_group = NULL;
char *pcwpa_version = NULL;
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
tstrWILC_WFIDrv *pstrWFIDrv;
tstrNetworkInfo *pstrNetworkInfo = NULL;
host_int_set_wfi_drv_handler(priv->hWILCWFIDrv);
PRINT_D(CFG80211_DBG, "Connecting to SSID [%s] on netdev [%p] host if [%p]\n", sme->ssid, dev, priv->hWILCWFIDrv);
- #ifdef WILC_P2P
if (!(strncmp(sme->ssid, "DIRECT-", 7))) {
PRINT_D(CFG80211_DBG, "Connected to Direct network,OBSS disabled\n");
pstrWFIDrv->u8P2PConnect = 1;
} else
pstrWFIDrv->u8P2PConnect = 0;
- #endif
PRINT_INFO(CFG80211_DBG, "Required SSID = %s\n , AuthType = %d\n", sme->ssid, sme->auth_type);
for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
priv->WILC_WFI_wep_key_len[sme->key_idx] = sme->key_len;
memcpy(priv->WILC_WFI_wep_key[sme->key_idx], sme->key, sme->key_len);
- /*BugID_5137*/
g_key_wep_params.key_len = sme->key_len;
g_key_wep_params.key = kmalloc(sme->key_len, GFP_KERNEL);
memcpy(g_key_wep_params.key, sme->key, sme->key_len);
priv->WILC_WFI_wep_key_len[sme->key_idx] = sme->key_len;
memcpy(priv->WILC_WFI_wep_key[sme->key_idx], sme->key, sme->key_len);
- /*BugID_5137*/
g_key_wep_params.key_len = sme->key_len;
g_key_wep_params.key = kmalloc(sme->key_len, GFP_KERNEL);
memcpy(g_key_wep_params.key, sme->key, sme->key_len);
PRINT_INFO(CFG80211_DBG, "Group encryption value = %s\n Cipher Group = %s\n WPA version = %s\n",
pcgroup_encrypt_val, pccipher_group, pcwpa_version);
- /*BugID_5442*/
- u8CurrChannel = pstrNetworkInfo->u8channel;
+ curr_channel = pstrNetworkInfo->u8channel;
if (!pstrWFIDrv->u8P2PConnect) {
u8WLANChannel = pstrNetworkInfo->u8channel;
CfgConnectResult, (void *)priv, u8security,
tenuAuth_type, pstrNetworkInfo->u8channel,
pstrNetworkInfo->pJoinParams);
- if (s32Error != WILC_SUCCESS) {
+ if (s32Error != 0) {
PRINT_ER("host_int_set_join_req(): Error(%d)\n", s32Error);
s32Error = -ENOENT;
goto done;
*/
static int disconnect(struct wiphy *wiphy, struct net_device *dev, u16 reason_code)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
- #ifdef WILC_P2P
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
tstrWILC_WFIDrv *pstrWFIDrv;
- #endif
- uint8_t NullBssid[ETH_ALEN] = {0};
+ u8 NullBssid[ETH_ALEN] = {0};
connecting = 0;
priv = wiphy_priv(wiphy);
- /*BugID_5457*/
/*Invalidate u8WLANChannel value on wlan0 disconnect*/
- #ifdef WILC_P2P
pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
if (!pstrWFIDrv->u8P2PConnect)
u8WLANChannel = INVALID_CHANNEL;
- #endif
linux_wlan_set_bssid(priv->dev, NullBssid);
PRINT_D(CFG80211_DBG, "Disconnecting with reason code(%d)\n", reason_code);
u8P2Plocalrandom = 0x01;
u8P2Precvrandom = 0x00;
bWilc_ie = false;
- #ifdef WILC_P2P
pstrWFIDrv->u64P2p_MgmtTimeout = 0;
- #endif
s32Error = host_int_disconnect(priv->hWILCWFIDrv, reason_code);
- if (s32Error != WILC_SUCCESS) {
+ if (s32Error != 0) {
PRINT_ER("Error in disconnecting: Error(%d)\n", s32Error);
s32Error = -EINVAL;
}
const u8 *mac_addr, struct key_params *params)
{
- s32 s32Error = WILC_SUCCESS, KeyLen = params->key_len;
+ s32 s32Error = 0, KeyLen = params->key_len;
u32 i;
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
const u8 *pu8RxMic = NULL;
const u8 *pu8TxMic = NULL;
u8 u8mode = NO_ENCRYPT;
- #ifdef WILC_AP_EXTERNAL_MLME
u8 u8gmode = NO_ENCRYPT;
u8 u8pmode = NO_ENCRYPT;
- AUTHTYPE_T tenuAuth_type = ANY;
- #endif
+ enum AUTHTYPE tenuAuth_type = ANY;
priv = wiphy_priv(wiphy);
PRINT_D(CFG80211_DBG, "Adding key with cipher suite = %x\n", params->cipher);
- /*BugID_5137*/
PRINT_D(CFG80211_DBG, "%p %p %d\n", wiphy, netdev, key_index);
PRINT_D(CFG80211_DBG, "key %x %x %x\n", params->key[0],
switch (params->cipher) {
case WLAN_CIPHER_SUITE_WEP40:
case WLAN_CIPHER_SUITE_WEP104:
- #ifdef WILC_AP_EXTERNAL_MLME
if (priv->wdev->iftype == NL80211_IFTYPE_AP) {
priv->WILC_WFI_wep_default = key_index;
host_int_add_wep_key_bss_ap(priv->hWILCWFIDrv, params->key, params->key_len, key_index, u8mode, tenuAuth_type);
break;
}
- #endif
if (memcmp(params->key, priv->WILC_WFI_wep_key[key_index], params->key_len)) {
priv->WILC_WFI_wep_default = key_index;
priv->WILC_WFI_wep_key_len[key_index] = params->key_len;
case WLAN_CIPHER_SUITE_TKIP:
case WLAN_CIPHER_SUITE_CCMP:
- #ifdef WILC_AP_EXTERNAL_MLME
if (priv->wdev->iftype == NL80211_IFTYPE_AP || priv->wdev->iftype == NL80211_IFTYPE_P2P_GO) {
if (priv->wilc_gtk[key_index] == NULL) {
}
break;
}
- #endif
{
u8mode = 0;
KeyLen = params->key_len - 16;
}
- /*BugID_5137*/
/*save keys only on interface 0 (wifi interface)*/
if (!g_gtk_keys_saved && netdev == g_linux_wlan->strInterfaceInfo[0].wilc_netdev) {
g_add_gtk_key_params.key_idx = key_index;
KeyLen = params->key_len - 16;
}
- /*BugID_5137*/
/*save keys only on interface 0 (wifi interface)*/
if (!g_ptk_keys_saved && netdev == g_linux_wlan->strInterfaceInfo[0].wilc_netdev) {
g_add_ptk_key_params.key_idx = key_index;
bool pairwise,
const u8 *mac_addr)
{
- struct WILC_WFI_priv *priv;
- s32 s32Error = WILC_SUCCESS;
+ struct wilc_priv *priv;
+ s32 s32Error = 0;
priv = wiphy_priv(wiphy);
- /*BugID_5137*/
/*delete saved keys, if any*/
if (netdev == g_linux_wlan->strInterfaceInfo[0].wilc_netdev) {
g_ptk_keys_saved = false;
/*freeing memory allocated by "wilc_gtk" and "wilc_ptk" in "WILC_WIFI_ADD_KEY"*/
- #ifdef WILC_AP_EXTERNAL_MLME
if ((priv->wilc_gtk[key_index]) != NULL) {
if (priv->wilc_gtk[key_index]->key != NULL) {
kfree(priv->wilc_ptk[key_index]);
priv->wilc_ptk[key_index] = NULL;
}
- #endif
/*Delete saved PTK and GTK keys params, if any*/
if (g_key_ptk_params.key != NULL) {
const u8 *mac_addr, void *cookie, void (*callback)(void *cookie, struct key_params *))
{
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
struct key_params key_params;
u32 i;
static int set_default_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
bool unicast, bool multicast)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
priv = wiphy_priv(wiphy);
static int WILC_WFI_dump_survey(struct wiphy *wiphy, struct net_device *netdev,
int idx, struct survey_info *info)
{
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
if (idx != 0) {
static int get_station(struct wiphy *wiphy, struct net_device *dev,
const u8 *mac, struct station_info *sinfo)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
perInterface_wlan_t *nic;
- #ifdef WILC_AP_EXTERNAL_MLME
u32 i = 0;
u32 associatedsta = 0;
u32 inactive_time = 0;
- #endif
priv = wiphy_priv(wiphy);
nic = netdev_priv(dev);
- #ifdef WILC_AP_EXTERNAL_MLME
if (nic->iftype == AP_MODE || nic->iftype == GO_MODE) {
PRINT_D(HOSTAPD_DBG, "Getting station parameters\n");
PRINT_D(CFG80211_DBG, "Inactive time %d\n", sinfo->inactive_time);
}
- #endif
if (nic->iftype == STATION_MODE) {
tstrStatistics strStatistics;
host_int_get_statistics(priv->hWILCWFIDrv, &strStatistics);
- /*
- * tony: 2013-11-13
- * tx_failed introduced more than
- * kernel version 3.0.0
- */
sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL) |
BIT(NL80211_STA_INFO_RX_PACKETS) |
BIT(NL80211_STA_INFO_TX_PACKETS) |
sinfo->tx_failed = strStatistics.u32TxFailureCount;
sinfo->txrate.legacy = strStatistics.u8LinkSpeed * 10;
-#ifdef TCP_ENHANCEMENTS
if ((strStatistics.u8LinkSpeed > TCP_ACK_FILTER_LINK_SPEED_THRESH) && (strStatistics.u8LinkSpeed != DEFAULT_LINK_SPEED))
Enable_TCP_ACK_Filter(true);
else if (strStatistics.u8LinkSpeed != DEFAULT_LINK_SPEED)
Enable_TCP_ACK_Filter(false);
-#endif
PRINT_D(CORECONFIG_DBG, "*** stats[%d][%d][%d][%d][%d]\n", sinfo->signal, sinfo->rx_packets, sinfo->tx_packets,
sinfo->tx_failed, sinfo->txrate.legacy);
*/
static int set_wiphy_params(struct wiphy *wiphy, u32 changed)
{
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
tstrCfgParamVal pstrCfgParamVal;
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
priv = wiphy_priv(wiphy);
struct net_device *dev, const u8 *peer,
const struct cfg80211_bitrate_mask *mask)
{
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
PRINT_D(CFG80211_DBG, "Setting Bitrate mask function\n");
return s32Error;
struct cfg80211_pmksa *pmksa)
{
u32 i;
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
u8 flag = 0;
- struct WILC_WFI_priv *priv = wiphy_priv(wiphy);
+ struct wilc_priv *priv = wiphy_priv(wiphy);
PRINT_D(CFG80211_DBG, "Setting PMKSA\n");
u32 i;
u8 flag = 0;
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
- struct WILC_WFI_priv *priv = wiphy_priv(wiphy);
+ struct wilc_priv *priv = wiphy_priv(wiphy);
PRINT_D(CFG80211_DBG, "Deleting PMKSA keys\n");
*/
static int flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
{
- struct WILC_WFI_priv *priv = wiphy_priv(wiphy);
+ struct wilc_priv *priv = wiphy_priv(wiphy);
PRINT_D(CFG80211_DBG, "Flushing PMKID key values\n");
return 0;
}
-#ifdef WILC_P2P
/**
* @brief WILC_WFI_CfgParseRxAction
u32 index = 0;
u32 i = 0, j = 0;
- /*BugID_5460*/
- #ifdef USE_SUPPLICANT_GO_INTENT
- u8 intent;
- u8 tie_breaker;
- bool is_wilc_go = true;
- #endif
u8 op_channel_attr_index = 0;
u8 channel_list_attr_index = 0;
while (index < len) {
if (buf[index] == GO_INTENT_ATTR_ID) {
- #ifdef USE_SUPPLICANT_GO_INTENT
- /*BugID_5460*/
- /*Case 1: If we are going to be p2p client, no need to modify channels attributes*/
- /*In negotiation frames, go intent attr value determines who will be GO*/
- intent = GET_GO_INTENT(buf[index + 3]);
- tie_breaker = GET_TIE_BREAKER(buf[index + 3]);
- if (intent > SUPPLICANT_GO_INTENT
- || (intent == SUPPLICANT_GO_INTENT && tie_breaker == 1)) {
- PRINT_D(GENERIC_DBG, "WILC will be client (intent %d tie breaker %d)\n", intent, tie_breaker);
- is_wilc_go = false;
- } else {
- PRINT_D(GENERIC_DBG, "WILC will be GO (intent %d tie breaker %d)\n", intent, tie_breaker);
- is_wilc_go = true;
- }
-
- #else /* USE_SUPPLICANT_GO_INTENT */
- #ifdef FORCE_P2P_CLIENT
- buf[index + 3] = (buf[index + 3] & 0x01) | (0x0f << 1);
- #else
buf[index + 3] = (buf[index + 3] & 0x01) | (0x00 << 1);
- #endif
- #endif /* USE_SUPPLICANT_GO_INTENT */
- }
-
- #ifdef USE_SUPPLICANT_GO_INTENT
- /*Case 2: If group bssid attribute is present, no need to modify channels attributes*/
- /*In invitation req and rsp, group bssid attr presence determines who will be GO*/
- if (buf[index] == GROUP_BSSID_ATTR_ID) {
- PRINT_D(GENERIC_DBG, "Group BSSID: %2x:%2x:%2x\n", buf[index + 3]
- , buf[index + 4]
- , buf[index + 5]);
- is_wilc_go = false;
}
- #endif /* USE_SUPPLICANT_GO_INTENT */
if (buf[index] == CHANLIST_ATTR_ID)
channel_list_attr_index = index;
index += buf[index + 1] + 3; /* ID,Length byte */
}
- #ifdef USE_SUPPLICANT_GO_INTENT
- if (u8WLANChannel != INVALID_CHANNEL && is_wilc_go)
- #else
if (u8WLANChannel != INVALID_CHANNEL)
- #endif
{
/*Modify channel list attribute*/
if (channel_list_attr_index) {
u8 op_channel_attr_index = 0;
u8 channel_list_attr_index = 0;
- #ifdef USE_SUPPLICANT_GO_INTENT
- bool is_wilc_go = false;
-
- /*BugID_5460*/
- /*Case 1: If we are already p2p client, no need to modify channels attributes*/
- /*This to handle the case of inviting a p2p peer to join an existing group which we are a member in*/
- if (iftype == CLIENT_MODE)
- return;
- #endif
while (index < len) {
- #ifdef USE_SUPPLICANT_GO_INTENT
- /*Case 2: If group bssid attribute is present, no need to modify channels attributes*/
- /*In invitation req and rsp, group bssid attr presence determines who will be GO*/
- /*Note: If we are already p2p client, group bssid attr may also be present (handled in Case 1)*/
- if (buf[index] == GROUP_BSSID_ATTR_ID) {
- PRINT_D(GENERIC_DBG, "Group BSSID: %2x:%2x:%2x\n", buf[index + 3]
- , buf[index + 4]
- , buf[index + 5]);
- is_wilc_go = true;
- }
-
- #else /* USE_SUPPLICANT_GO_INTENT */
if (buf[index] == GO_INTENT_ATTR_ID) {
- #ifdef FORCE_P2P_CLIENT
- buf[index + 3] = (buf[index + 3] & 0x01) | (0x00 << 1);
- #else
buf[index + 3] = (buf[index + 3] & 0x01) | (0x0f << 1);
- #endif
break;
}
- #endif
if (buf[index] == CHANLIST_ATTR_ID)
channel_list_attr_index = index;
index += buf[index + 1] + 3; /* ID,Length byte */
}
- #ifdef USE_SUPPLICANT_GO_INTENT
- /*No need to check bOperChan since only transmitted invitation frames are parsed*/
- if (u8WLANChannel != INVALID_CHANNEL && is_wilc_go)
- #else
if (u8WLANChannel != INVALID_CHANNEL && bOperChan)
- #endif
{
/*Modify channel list attribute*/
if (channel_list_attr_index) {
* @version 1.0
*/
-void WILC_WFI_p2p_rx (struct net_device *dev, uint8_t *buff, uint32_t size)
+void WILC_WFI_p2p_rx (struct net_device *dev, u8 *buff, u32 size)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
u32 header, pkt_offset;
tstrWILC_WFIDrv *pstrWFIDrv;
u32 i = 0;
PRINT_D(GENERIC_DBG, "Rx Frame Type:%x\n", buff[FRAME_TYPE_ID]);
- /*BugID_5442*/
/*Upper layer is informed that the frame is received on this freq*/
- s32Freq = ieee80211_channel_to_frequency(u8CurrChannel, IEEE80211_BAND_2GHZ);
+ s32Freq = ieee80211_channel_to_frequency(curr_channel, IEEE80211_BAND_2GHZ);
if (ieee80211_is_action(buff[FRAME_TYPE_ID])) {
PRINT_D(GENERIC_DBG, "Rx Action Frame Type: %x %x\n", buff[ACTION_SUBTYPE_ID], buff[P2P_PUB_ACTION_SUBTYPE]);
static void WILC_WFI_RemainOnChannelReady(void *pUserVoid)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
- priv = (struct WILC_WFI_priv *)pUserVoid;
+ priv = (struct wilc_priv *)pUserVoid;
PRINT_D(HOSTINF_DBG, "Remain on channel ready\n");
static void WILC_WFI_RemainOnChannelExpired(void *pUserVoid, u32 u32SessionID)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
- priv = (struct WILC_WFI_priv *)pUserVoid;
+ priv = (struct wilc_priv *)pUserVoid;
- /*BugID_5477*/
if (u32SessionID == priv->strRemainOnChanParams.u32ListenSessionID) {
PRINT_D(GENERIC_DBG, "Remain on channel expired\n");
struct ieee80211_channel *chan,
unsigned int duration, u64 *cookie)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
priv = wiphy_priv(wiphy);
PRINT_D(GENERIC_DBG, "Remaining on channel %d\n", chan->hw_value);
- /*BugID_4800: if in AP mode, return.*/
- /*This check is to handle the situation when user*/
- /*requests "create group" during a running scan*/
if (wdev->iftype == NL80211_IFTYPE_AP) {
PRINT_D(GENERIC_DBG, "Required remain-on-channel while in AP mode");
return s32Error;
}
- u8CurrChannel = chan->hw_value;
+ curr_channel = chan->hw_value;
/*Setting params needed by WILC_WFI_RemainOnChannelExpired()*/
priv->strRemainOnChanParams.pstrListenChan = chan;
struct wireless_dev *wdev,
u64 cookie)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
priv = wiphy_priv(wiphy);
*/
extern linux_wlan_t *g_linux_wlan;
extern bool bEnablePS;
-int WILC_WFI_mgmt_tx(struct wiphy *wiphy,
- struct wireless_dev *wdev,
- struct cfg80211_mgmt_tx_params *params,
- u64 *cookie)
+static int mgmt_tx(struct wiphy *wiphy,
+ struct wireless_dev *wdev,
+ struct cfg80211_mgmt_tx_params *params,
+ u64 *cookie)
{
struct ieee80211_channel *chan = params->chan;
unsigned int wait = params->wait;
size_t len = params->len;
const struct ieee80211_mgmt *mgmt;
struct p2p_mgmt_data *mgmt_tx;
- struct WILC_WFI_priv *priv;
- s32 s32Error = WILC_SUCCESS;
+ struct wilc_priv *priv;
+ s32 s32Error = 0;
tstrWILC_WFIDrv *pstrWFIDrv;
u32 i;
perInterface_wlan_t *nic;
mgmt_tx = kmalloc(sizeof(struct p2p_mgmt_data), GFP_KERNEL);
if (mgmt_tx == NULL) {
PRINT_ER("Failed to allocate memory for mgmt_tx structure\n");
- return WILC_FAIL;
+ return -EFAULT;
}
mgmt_tx->buff = kmalloc(buf_len, GFP_KERNEL);
if (mgmt_tx->buff == NULL) {
PRINT_ER("Failed to allocate memory for mgmt_tx buff\n");
kfree(mgmt_tx);
- return WILC_FAIL;
+ return -EFAULT;
}
memcpy(mgmt_tx->buff, buf, len);
mgmt_tx->size = len;
PRINT_D(GENERIC_DBG, "Setting channel: %d\n", chan->hw_value);
host_int_set_mac_chnl_num(priv->hWILCWFIDrv, chan->hw_value);
/*Save the current channel after we tune to it*/
- u8CurrChannel = chan->hw_value;
+ curr_channel = chan->hw_value;
} else if (ieee80211_is_action(mgmt->frame_control)) {
PRINT_D(GENERIC_DBG, "ACTION FRAME:%x\n", (u16)mgmt->frame_control);
- /*BugID_4847*/
if (buf[ACTION_CAT_ID] == PUB_ACTION_ATTR_ID) {
- /*BugID_4847*/
/*Only set the channel, if not a negotiation confirmation frame
* (If Negotiation confirmation frame, force it
* to be transmitted on the same negotiation channel)*/
PRINT_D(GENERIC_DBG, "Setting channel: %d\n", chan->hw_value);
host_int_set_mac_chnl_num(priv->hWILCWFIDrv, chan->hw_value);
/*Save the current channel after we tune to it*/
- u8CurrChannel = chan->hw_value;
+ curr_channel = chan->hw_value;
}
switch (buf[ACTION_SUBTYPE_ID]) {
case GAS_INTIAL_REQ:
if (buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_RSP)
WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), true, nic->iftype);
- /*BugID_5460*/
/*If using supplicant go intent, no need at all*/
/*to parse transmitted negotiation frames*/
- #ifndef USE_SUPPLICANT_GO_INTENT
else
WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), false, nic->iftype);
- #endif
break;
}
}
}
- g_linux_wlan->oup.wlan_add_mgmt_to_tx_que(mgmt_tx, mgmt_tx->buff, mgmt_tx->size, WILC_WFI_mgmt_tx_complete);
+ wilc_wlan_txq_add_mgmt_pkt(mgmt_tx, mgmt_tx->buff,
+ mgmt_tx->size,
+ WILC_WFI_mgmt_tx_complete);
} else {
PRINT_D(GENERIC_DBG, "This function transmits only management frames\n");
}
return s32Error;
}
-int mgmt_tx_cancel_wait(struct wiphy *wiphy,
- struct wireless_dev *wdev,
- u64 cookie)
+static int mgmt_tx_cancel_wait(struct wiphy *wiphy,
+ struct wireless_dev *wdev,
+ u64 cookie)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
tstrWILC_WFIDrv *pstrWFIDrv;
priv = wiphy_priv(wiphy);
pstrWFIDrv->u64P2p_MgmtTimeout = jiffies;
if (priv->bInP2PlistenState == false) {
- /* Bug 5504: This is just to avoid connection failure when getting stuck when the supplicant
- * considers the driver falsely that it is in Listen state */
cfg80211_remain_on_channel_expired(priv->wdev,
priv->strRemainOnChanParams.u64ListenCookie,
priv->strRemainOnChanParams.pstrListenChan,
}
/**
- * @brief WILC_WFI_frame_register
+ * @brief wilc_mgmt_frame_register
* @details Notify driver that a management frame type was
* registered. Note that this callback may not sleep, and cannot run
* concurrently with itself.
* @date 01 JUL 2012
* @version
*/
-void WILC_WFI_frame_register(struct wiphy *wiphy,
- struct wireless_dev *wdev,
- u16 frame_type, bool reg)
+void wilc_mgmt_frame_register(struct wiphy *wiphy, struct wireless_dev *wdev,
+ u16 frame_type, bool reg)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
perInterface_wlan_t *nic;
- /*BugID_5137*/
if (!frame_type)
return;
}
-#endif /*WILC_P2P*/
/**
- * @brief WILC_WFI_set_cqm_rssi_config
+ * @brief set_cqm_rssi_config
* @details Configure connection quality monitor RSSI threshold.
* @param[in] struct wiphy *wiphy:
* @param[in] struct net_device *dev:
* @date 01 MAR 2012
* @version 1.0
*/
-static int WILC_WFI_set_cqm_rssi_config(struct wiphy *wiphy,
- struct net_device *dev, s32 rssi_thold, u32 rssi_hyst)
+static int set_cqm_rssi_config(struct wiphy *wiphy, struct net_device *dev,
+ s32 rssi_thold, u32 rssi_hyst)
{
PRINT_D(CFG80211_DBG, "Setting CQM RSSi Function\n");
return 0;
static int dump_station(struct wiphy *wiphy, struct net_device *dev,
int idx, u8 *mac, struct station_info *sinfo)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
PRINT_D(CFG80211_DBG, "Dumping station information\n");
/**
- * @brief WILC_WFI_set_power_mgmt
+ * @brief set_power_mgmt
* @details
* @param[in]
* @return int : Return 0 on Success.
* @author mdaftedar
* @date 01 JUL 2012
- * @version 1.0WILC_WFI_set_cqmWILC_WFI_set_cqm_rssi_configWILC_WFI_set_cqm_rssi_configWILC_WFI_set_cqm_rssi_configWILC_WFI_set_cqm_rssi_config_rssi_config
+ * @version 1.0
*/
-int WILC_WFI_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
- bool enabled, int timeout)
+static int set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
+ bool enabled, int timeout)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
PRINT_D(CFG80211_DBG, " Power save Enabled= %d , TimeOut = %d\n", enabled, timeout);
host_int_set_power_mgmt(priv->hWILCWFIDrv, enabled, timeout);
- return WILC_SUCCESS;
+ return 0;
}
-#ifdef WILC_AP_EXTERNAL_MLME
+
/**
* @brief change_virtual_intf
* @details Change type/configuration of virtual interface,
static int change_virtual_intf(struct wiphy *wiphy, struct net_device *dev,
enum nl80211_iftype type, u32 *flags, struct vif_params *params)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
perInterface_wlan_t *nic;
u8 interface_type;
u16 TID = 0;
- #ifdef WILC_P2P
u8 i;
- #endif
nic = netdev_priv(dev);
priv = wiphy_priv(wiphy);
bWilc_ie = false;
- #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
g_obtainingIP = false;
del_timer(&hDuringIpTimer);
PRINT_D(GENERIC_DBG, "Changing virtual interface, enable scan\n");
- #endif
- /*BugID_5137*/
/*Set WILC_CHANGING_VIR_IF register to disallow adding futrue keys to CE H/W*/
if (g_ptk_keys_saved && g_gtk_keys_saved) {
Set_machw_change_vir_if(true);
/*Remove the enteries of the previously connected clients*/
memset(priv->assoc_stainfo.au8Sta_AssociatedBss, 0, MAX_NUM_STA * ETH_ALEN);
- #ifdef WILC_P2P
interface_type = nic->iftype;
nic->iftype = STATION_MODE;
/* ensure that the message Q is empty */
host_int_wait_msg_queue_idle();
- /*BugID_5213*/
/*Eliminate host interface blocking state*/
up(&g_linux_wlan->cfg_event);
(struct key_params *)(&g_key_gtk_params));
}
- /*BugID_4847: registered frames in firmware are now*/
- /*lost due to mac close. So re-register those frames*/
if (g_linux_wlan->wilc1000_initialized) {
for (i = 0; i < num_reg_frame; i++) {
PRINT_D(INIT_DBG, "Frame registering Type: %x - Reg: %d\n", nic->g_struct_frame_reg[i].frame_type,
bEnablePS = true;
host_int_set_power_mgmt(priv->hWILCWFIDrv, 1, 0);
}
- #endif
break;
case NL80211_IFTYPE_P2P_CLIENT:
priv->wdev->iftype = type;
nic->monitor_flag = 0;
- #ifdef WILC_P2P
-
PRINT_D(HOSTAPD_DBG, "Downloading P2P_CONCURRENCY_FIRMWARE\n");
nic->iftype = CLIENT_MODE;
refresh_scan(priv, 1, true);
Set_machw_change_vir_if(false);
- /*BugID_4847: registered frames in firmware are now lost
- * due to mac close. So re-register those frames */
if (g_linux_wlan->wilc1000_initialized) {
for (i = 0; i < num_reg_frame; i++) {
PRINT_D(INIT_DBG, "Frame registering Type: %x - Reg: %d\n", nic->g_struct_frame_reg[i].frame_type,
}
}
}
- #endif
break;
case NL80211_IFTYPE_AP:
PRINT_D(HOSTAPD_DBG, "Downloading AP firmware\n");
linux_wlan_get_firmware(nic);
- #ifdef WILC_P2P
/*If wilc is running, then close-open to actually get new firmware running (serves P2P)*/
if (g_linux_wlan->wilc1000_initialized) {
nic->iftype = AP_MODE;
mac_close(dev);
mac_open(dev);
- /*BugID_4847: registered frames in firmware are now lost
- * due to mac close. So re-register those frames */
for (i = 0; i < num_reg_frame; i++) {
PRINT_D(INIT_DBG, "Frame registering Type: %x - Reg: %d\n", nic->g_struct_frame_reg[i].frame_type,
nic->g_struct_frame_reg[i].reg);
nic->g_struct_frame_reg[i].reg);
}
}
- #endif
break;
case NL80211_IFTYPE_P2P_GO:
PRINT_D(GENERIC_DBG, "start duringIP timer\n");
- #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
g_obtainingIP = true;
mod_timer(&hDuringIpTimer, jiffies + msecs_to_jiffies(duringIP_TIME));
- #endif
host_int_set_power_mgmt(priv->hWILCWFIDrv, 0, 0);
- /*BugID_5222*/
/*Delete block ack has to be the latest config packet*/
/*sent before downloading new FW. This is because it blocks on*/
/*hWaitResponse semaphore, which allows previous config*/
PRINT_D(CORECONFIG_DBG, "priv->hWILCWFIDrv[%p]\n", priv->hWILCWFIDrv);
- #ifdef WILC_P2P
PRINT_D(HOSTAPD_DBG, "Downloading P2P_CONCURRENCY_FIRMWARE\n");
- #if 1
nic->iftype = GO_MODE;
/* ensure that the message Q is empty */
g_key_gtk_params.key[1],
g_key_gtk_params.key[2],
g_key_gtk_params.cipher);
- #if 1
add_key(g_linux_wlan->strInterfaceInfo[0].wilc_netdev->ieee80211_ptr->wiphy,
g_linux_wlan->strInterfaceInfo[0].wilc_netdev,
g_add_ptk_key_params.key_idx,
g_add_gtk_key_params.pairwise,
g_add_gtk_key_params.mac_addr,
(struct key_params *)(&g_key_gtk_params));
- #endif
}
- #endif
- /*BugID_4847: registered frames in firmware are now*/
- /*lost due to mac close. So re-register those frames*/
if (g_linux_wlan->wilc1000_initialized) {
for (i = 0; i < num_reg_frame; i++) {
PRINT_D(INIT_DBG, "Frame registering Type: %x - Reg: %d\n", nic->g_struct_frame_reg[i].frame_type,
nic->g_struct_frame_reg[i].reg);
}
}
- #endif
break;
default:
struct cfg80211_ap_settings *settings)
{
struct cfg80211_beacon_data *beacon = &(settings->beacon);
- struct WILC_WFI_priv *priv;
- s32 s32Error = WILC_SUCCESS;
+ struct wilc_priv *priv;
+ s32 s32Error = 0;
priv = wiphy_priv(wiphy);
PRINT_D(HOSTAPD_DBG, "Starting ap\n");
s32Error = set_channel(wiphy, &settings->chandef);
- if (s32Error != WILC_SUCCESS)
+ if (s32Error != 0)
PRINT_ER("Error in setting channel\n");
linux_wlan_set_bssid(dev, g_linux_wlan->strInterfaceInfo[0].aSrcAddress);
static int change_beacon(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_beacon_data *beacon)
{
- struct WILC_WFI_priv *priv;
- s32 s32Error = WILC_SUCCESS;
+ struct wilc_priv *priv;
+ s32 s32Error = 0;
priv = wiphy_priv(wiphy);
PRINT_D(HOSTAPD_DBG, "Setting beacon\n");
*/
static int stop_ap(struct wiphy *wiphy, struct net_device *dev)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
u8 NullBssid[ETH_ALEN] = {0};
-
- WILC_NULLCHECK(s32Error, wiphy);
+ if (!wiphy)
+ return -EFAULT;
priv = wiphy_priv(wiphy);
PRINT_D(HOSTAPD_DBG, "Deleting beacon\n");
- /*BugID_5188*/
linux_wlan_set_bssid(dev, NullBssid);
s32Error = host_int_del_beacon(priv->hWILCWFIDrv);
- WILC_ERRORCHECK(s32Error);
+ if (s32Error)
+ PRINT_ER("Host delete beacon fail\n");
- WILC_CATCH(s32Error)
- {
- }
return s32Error;
}
static int add_station(struct wiphy *wiphy, struct net_device *dev,
const u8 *mac, struct station_parameters *params)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
- tstrWILC_AddStaParam strStaParams = { {0} };
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
+ struct add_sta_param strStaParams = { {0} };
perInterface_wlan_t *nic;
-
- WILC_NULLCHECK(s32Error, wiphy);
+ if (!wiphy)
+ return -EFAULT;
priv = wiphy_priv(wiphy);
nic = netdev_priv(dev);
PRINT_D(HOSTAPD_DBG, "Flag Set = %d\n", strStaParams.u16FlagsSet);
s32Error = host_int_add_station(priv->hWILCWFIDrv, &strStaParams);
- WILC_ERRORCHECK(s32Error);
+ if (s32Error)
+ PRINT_ER("Host add station fail\n");
}
- WILC_CATCH(s32Error)
- {
- }
return s32Error;
}
struct station_del_parameters *params)
{
const u8 *mac = params->mac;
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
perInterface_wlan_t *nic;
- WILC_NULLCHECK(s32Error, wiphy);
+ if (!wiphy)
+ return -EFAULT;
priv = wiphy_priv(wiphy);
nic = netdev_priv(dev);
s32Error = host_int_del_station(priv->hWILCWFIDrv, mac);
- WILC_ERRORCHECK(s32Error);
- }
- WILC_CATCH(s32Error)
- {
+ if (s32Error)
+ PRINT_ER("Host delete station fail\n");
}
return s32Error;
}
static int change_station(struct wiphy *wiphy, struct net_device *dev,
const u8 *mac, struct station_parameters *params)
{
- s32 s32Error = WILC_SUCCESS;
- struct WILC_WFI_priv *priv;
- tstrWILC_AddStaParam strStaParams = { {0} };
+ s32 s32Error = 0;
+ struct wilc_priv *priv;
+ struct add_sta_param strStaParams = { {0} };
perInterface_wlan_t *nic;
PRINT_D(HOSTAPD_DBG, "Change station paramters\n");
- WILC_NULLCHECK(s32Error, wiphy);
+ if (!wiphy)
+ return -EFAULT;
priv = wiphy_priv(wiphy);
nic = netdev_priv(dev);
PRINT_D(HOSTAPD_DBG, "Flag Set = %d\n", strStaParams.u16FlagsSet);
s32Error = host_int_edit_station(priv->hWILCWFIDrv, &strStaParams);
- WILC_ERRORCHECK(s32Error);
- }
- WILC_CATCH(s32Error)
- {
+ if (s32Error)
+ PRINT_ER("Host edit station fail\n");
}
return s32Error;
}
* @date 01 JUL 2012
* @version 1.0
*/
-struct wireless_dev *add_virtual_intf(struct wiphy *wiphy, const char *name,
- unsigned char name_assign_type,
- enum nl80211_iftype type, u32 *flags,
- struct vif_params *params)
+static struct wireless_dev *add_virtual_intf(struct wiphy *wiphy,
+ const char *name,
+ unsigned char name_assign_type,
+ enum nl80211_iftype type,
+ u32 *flags,
+ struct vif_params *params)
{
perInterface_wlan_t *nic;
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
struct net_device *new_ifc = NULL;
priv = wiphy_priv(wiphy);
* @date 01 JUL 2012
* @version 1.0
*/
-int del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev) /* tony for v3.8 support */
+static int del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
{
PRINT_D(HOSTAPD_DBG, "Deleting virtual interface\n");
- return WILC_SUCCESS;
+ return 0;
}
-
-
-#endif /*WILC_AP_EXTERNAL_MLME*/
-static struct cfg80211_ops WILC_WFI_cfg80211_ops = {
+static struct cfg80211_ops wilc_cfg80211_ops = {
.set_monitor_channel = set_channel,
.scan = scan,
.del_key = del_key,
.get_key = get_key,
.set_default_key = set_default_key,
- #ifdef WILC_AP_EXTERNAL_MLME
.add_virtual_intf = add_virtual_intf,
.del_virtual_intf = del_virtual_intf,
.change_virtual_intf = change_virtual_intf,
.add_station = add_station,
.del_station = del_station,
.change_station = change_station,
- #endif /* WILC_AP_EXTERNAL_MLME*/
.get_station = get_station,
.dump_station = dump_station,
.change_bss = change_bss,
.set_pmksa = set_pmksa,
.del_pmksa = del_pmksa,
.flush_pmksa = flush_pmksa,
-#ifdef WILC_P2P
.remain_on_channel = remain_on_channel,
.cancel_remain_on_channel = cancel_remain_on_channel,
.mgmt_tx_cancel_wait = mgmt_tx_cancel_wait,
- .mgmt_tx = WILC_WFI_mgmt_tx,
- .mgmt_frame_register = WILC_WFI_frame_register,
- .set_power_mgmt = WILC_WFI_set_power_mgmt,
- .set_cqm_rssi_config = WILC_WFI_set_cqm_rssi_config,
-#endif
+ .mgmt_tx = mgmt_tx,
+ .mgmt_frame_register = wilc_mgmt_frame_register,
+ .set_power_mgmt = set_power_mgmt,
+ .set_cqm_rssi_config = set_cqm_rssi_config,
};
* @return int : Return 0 on Success.
* @author mdaftedar
* @date 01 MAR 2012
- * @version 1.0WILC_WFI_set_cqmWILC_WFI_set_cqm_rssi_configWILC_WFI_set_cqm_rssi_configWILC_WFI_set_cqm_rssi_configWILC_WFI_set_cqm_rssi_config_rssi_config
+ * @version 1.0
*/
int WILC_WFI_update_stats(struct wiphy *wiphy, u32 pktlen, u8 changed)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
priv = wiphy_priv(wiphy);
-#if 1
switch (changed) {
case WILC_WFI_RX_PKT:
default:
break;
}
-#endif
return 0;
}
}
/*Creating a new wiphy, linking wireless structure with the wiphy structure*/
- wdev->wiphy = wiphy_new(&WILC_WFI_cfg80211_ops, sizeof(struct WILC_WFI_priv));
+ wdev->wiphy = wiphy_new(&wilc_cfg80211_ops, sizeof(struct wilc_priv));
if (!wdev->wiphy) {
PRINT_ER("Cannot allocate wiphy\n");
goto _fail_mem_;
}
- #ifdef WILC_AP_EXTERNAL_MLME
/* enable 802.11n HT */
WILC_WFI_band_2ghz.ht_cap.ht_supported = 1;
WILC_WFI_band_2ghz.ht_cap.cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
WILC_WFI_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
WILC_WFI_band_2ghz.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K;
WILC_WFI_band_2ghz.ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
- #endif
/*wiphy bands*/
wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &WILC_WFI_band_2ghz;
}
/**
- * @brief WILC_WFI_WiphyRegister
+ * @brief wilc_create_wiphy
* @details Registering of the wiphy structure and interface modes
* @param[in] NONE
* @return NONE
* @date 01 MAR 2012
* @version 1.0
*/
-struct wireless_dev *WILC_WFI_WiphyRegister(struct net_device *net)
+struct wireless_dev *wilc_create_wiphy(struct net_device *net)
{
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
struct wireless_dev *wdev;
- s32 s32Error = WILC_SUCCESS;
+ s32 s32Error = 0;
PRINT_D(CFG80211_DBG, "Registering wifi device\n");
/*Setting default managment types: for register action frame: */
wdev->wiphy->mgmt_stypes = wilc_wfi_cfg80211_mgmt_types;
-#ifdef WILC_P2P
wdev->wiphy->max_remain_on_channel_duration = 500;
/*Setting the wiphy interfcae mode and type before registering the wiphy*/
wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_MONITOR) | BIT(NL80211_IFTYPE_P2P_GO) |
BIT(NL80211_IFTYPE_P2P_CLIENT);
wdev->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
-#else
- wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_MONITOR);
-#endif
wdev->iftype = NL80211_IFTYPE_STATION;
wdev->wiphy->interface_modes, wdev->iftype);
#ifdef WILC_SDIO
- set_wiphy_dev(wdev->wiphy, &local_sdio_func->dev); /* tony */
+ set_wiphy_dev(wdev->wiphy, &local_sdio_func->dev);
#endif
/*Register wiphy structure*/
* @date 01 MAR 2012
* @version 1.0
*/
-int WILC_WFI_InitHostInt(struct net_device *net)
+int wilc_init_host_int(struct net_device *net)
{
- s32 s32Error = WILC_SUCCESS;
+ int s32Error = 0;
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
PRINT_D(INIT_DBG, "Host[%p][%p]\n", net, net->ieee80211_ptr);
priv = wdev_priv(net->ieee80211_ptr);
if (op_ifcs == 0) {
setup_timer(&hAgingTimer, remove_network_from_shadow, 0);
- #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
setup_timer(&hDuringIpTimer, clear_duringIP, 0);
- #endif
}
op_ifcs++;
if (s32Error < 0) {
sema_init(&(priv->hSemScanReq), 1);
s32Error = host_int_init(&priv->hWILCWFIDrv);
- if (s32Error) {
+ if (s32Error)
PRINT_ER("Error while initializing hostinterface\n");
- }
+
return s32Error;
}
* @date 01 MAR 2012
* @version 1.0
*/
-int WILC_WFI_DeInitHostInt(struct net_device *net)
+int wilc_deinit_host_int(struct net_device *net)
{
- s32 s32Error = WILC_SUCCESS;
+ int s32Error = 0;
- struct WILC_WFI_priv *priv;
+ struct wilc_priv *priv;
priv = wdev_priv(net->ieee80211_ptr);
/* Clear the Shadow scan */
clear_shadow_scan(priv);
- #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
if (op_ifcs == 0) {
PRINT_D(CORECONFIG_DBG, "destroy during ip\n");
del_timer_sync(&hDuringIpTimer);
}
- #endif
- if (s32Error) {
+ if (s32Error)
PRINT_ER("Error while deintializing host interface\n");
- }
+
return s32Error;
}
* @date 01 MAR 2012
* @version 1.0
*/
-void WILC_WFI_WiphyFree(struct net_device *net)
+void wilc_free_wiphy(struct net_device *net)
{
-
PRINT_D(CFG80211_DBG, "Unregistering wiphy\n");
- if (net == NULL) {
+ if (!net) {
PRINT_D(INIT_DBG, "net_device is NULL\n");
return;
}
- if (net->ieee80211_ptr == NULL) {
+ if (!net->ieee80211_ptr) {
PRINT_D(INIT_DBG, "ieee80211_ptr is NULL\n");
return;
}
- if (net->ieee80211_ptr->wiphy == NULL) {
+ if (!net->ieee80211_ptr->wiphy) {
PRINT_D(INIT_DBG, "wiphy is NULL\n");
return;
}
PRINT_D(INIT_DBG, "Freeing wiphy\n");
wiphy_free(net->ieee80211_ptr->wiphy);
kfree(net->ieee80211_ptr);
-
}
projects / karo-tx-linux.git / blobdiff