drivers/staging/wilc1000/wilc_wfi_cfgoperations.c

   1 /*!
   2  *  @file       wilc_wfi_cfgopertaions.c
   3  *  @brief      CFG80211 Function Implementation functionality
   4  *  @author     aabouzaeid
   5  *                      mabubakr
   6  *                      mdaftedar
   7  *                      zsalah
   8  *  @sa         wilc_wfi_cfgopertaions.h top level OS wrapper file
   9  *  @date       31 Aug 2010
  10  *  @version    1.0
  11  */
  12
  13 #include "wilc_wfi_cfgoperations.h"
  14 #include "wilc_wlan.c"
  15 #ifdef WILC_SDIO
  16 #include "linux_wlan_sdio.h"
  17 #endif
  18 #include <linux/errno.h>
  19
  20 #define IS_MANAGMEMENT                          0x100
  21 #define IS_MANAGMEMENT_CALLBACK                 0x080
  22 #define IS_MGMT_STATUS_SUCCES                   0x040
  23 #define GET_PKT_OFFSET(a) (((a) >> 22) & 0x1ff)
  24
  25 extern int linux_wlan_get_firmware(perInterface_wlan_t *p_nic);
  26 extern u16 Set_machw_change_vir_if(bool bValue);
  27
  28 extern int mac_open(struct net_device *ndev);
  29 extern int mac_close(struct net_device *ndev);
  30
  31 tstrNetworkInfo astrLastScannedNtwrksShadow[MAX_NUM_SCANNED_NETWORKS_SHADOW];
  32 u32 u32LastScannedNtwrksCountShadow;
  33 struct timer_list hDuringIpTimer;
  34 struct timer_list hAgingTimer;
  35 static u8 op_ifcs;
  36 extern u8 u8ConnectedSSID[6];
  37
  38 u8 g_wilc_initialized = 1;
  39 extern linux_wlan_t *g_linux_wlan;
  40 extern bool g_obtainingIP;
  41
  42 #define CHAN2G(_channel, _freq, _flags) {        \
  43                 .band             = IEEE80211_BAND_2GHZ, \
  44                 .center_freq      = (_freq),             \
  45                 .hw_value         = (_channel),          \
  46                 .flags            = (_flags),            \
  47                 .max_antenna_gain = 0,                   \
  48                 .max_power        = 30,                  \
  49 }
  50
  51 /*Frequency range for channels*/
  52 static struct ieee80211_channel WILC_WFI_2ghz_channels[] = {
  53         CHAN2G(1,  2412, 0),
  54         CHAN2G(2,  2417, 0),
  55         CHAN2G(3,  2422, 0),
  56         CHAN2G(4,  2427, 0),
  57         CHAN2G(5,  2432, 0),
  58         CHAN2G(6,  2437, 0),
  59         CHAN2G(7,  2442, 0),
  60         CHAN2G(8,  2447, 0),
  61         CHAN2G(9,  2452, 0),
  62         CHAN2G(10, 2457, 0),
  63         CHAN2G(11, 2462, 0),
  64         CHAN2G(12, 2467, 0),
  65         CHAN2G(13, 2472, 0),
  66         CHAN2G(14, 2484, 0),
  67 };
  68
  69 #define RATETAB_ENT(_rate, _hw_value, _flags) { \
  70                 .bitrate  = (_rate),                    \
  71                 .hw_value = (_hw_value),                \
  72                 .flags    = (_flags),                   \
  73 }
  74
  75
  76 /* Table 6 in section 3.2.1.1 */
  77 static struct ieee80211_rate WILC_WFI_rates[] = {
  78         RATETAB_ENT(10,  0,  0),
  79         RATETAB_ENT(20,  1,  0),
  80         RATETAB_ENT(55,  2,  0),
  81         RATETAB_ENT(110, 3,  0),
  82         RATETAB_ENT(60,  9,  0),
  83         RATETAB_ENT(90,  6,  0),
  84         RATETAB_ENT(120, 7,  0),
  85         RATETAB_ENT(180, 8,  0),
  86         RATETAB_ENT(240, 9,  0),
  87         RATETAB_ENT(360, 10, 0),
  88         RATETAB_ENT(480, 11, 0),
  89         RATETAB_ENT(540, 12, 0),
  90 };
  91
  92 struct p2p_mgmt_data {
  93         int size;
  94         u8 *buff;
  95 };
  96
  97 /*Global variable used to state the current  connected STA channel*/
  98 u8 u8WLANChannel = INVALID_CHANNEL;
  99
 100 u8 u8CurrChannel;
 101
 102 u8 u8P2P_oui[] = {0x50, 0x6f, 0x9A, 0x09};
 103 u8 u8P2Plocalrandom = 0x01;
 104 u8 u8P2Precvrandom = 0x00;
 105 u8 u8P2P_vendorspec[] = {0xdd, 0x05, 0x00, 0x08, 0x40, 0x03};
 106 bool bWilc_ie;
 107
 108 static struct ieee80211_supported_band WILC_WFI_band_2ghz = {
 109         .channels = WILC_WFI_2ghz_channels,
 110         .n_channels = ARRAY_SIZE(WILC_WFI_2ghz_channels),
 111         .bitrates = WILC_WFI_rates,
 112         .n_bitrates = ARRAY_SIZE(WILC_WFI_rates),
 113 };
 114
 115
 116 struct add_key_params {
 117         u8 key_idx;
 118         bool pairwise;
 119         u8 *mac_addr;
 120 };
 121 struct add_key_params g_add_gtk_key_params;
 122 struct wilc_wfi_key g_key_gtk_params;
 123 struct add_key_params g_add_ptk_key_params;
 124 struct wilc_wfi_key g_key_ptk_params;
 125 struct wilc_wfi_wep_key g_key_wep_params;
 126 bool g_ptk_keys_saved;
 127 bool g_gtk_keys_saved;
 128 bool g_wep_keys_saved;
 129
 130 #define AGING_TIME      (9 * 1000)
 131 #define duringIP_TIME 15000
 132
 133 void clear_shadow_scan(void *pUserVoid)
 134 {
 135         int i;
 136
 137         if (op_ifcs == 0) {
 138                 del_timer_sync(&hAgingTimer);
 139                 PRINT_INFO(CORECONFIG_DBG, "destroy aging timer\n");
 140
 141                 for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
 142                         if (astrLastScannedNtwrksShadow[u32LastScannedNtwrksCountShadow].pu8IEs != NULL) {
 143                                 kfree(astrLastScannedNtwrksShadow[i].pu8IEs);
 144                                 astrLastScannedNtwrksShadow[u32LastScannedNtwrksCountShadow].pu8IEs = NULL;
 145                         }
 146
 147                         host_int_freeJoinParams(astrLastScannedNtwrksShadow[i].pJoinParams);
 148                         astrLastScannedNtwrksShadow[i].pJoinParams = NULL;
 149                 }
 150                 u32LastScannedNtwrksCountShadow = 0;
 151         }
 152
 153 }
 154
 155 u32 get_rssi_avg(tstrNetworkInfo *pstrNetworkInfo)
 156 {
 157         u8 i;
 158         int rssi_v = 0;
 159         u8 num_rssi = (pstrNetworkInfo->strRssi.u8Full) ? NUM_RSSI : (pstrNetworkInfo->strRssi.u8Index);
 160
 161         for (i = 0; i < num_rssi; i++)
 162                 rssi_v += pstrNetworkInfo->strRssi.as8RSSI[i];
 163
 164         rssi_v /= num_rssi;
 165         return rssi_v;
 166 }
 167
 168 void refresh_scan(void *pUserVoid, u8 all, bool bDirectScan)
 169 {
 170         struct wilc_priv *priv;
 171         struct wiphy *wiphy;
 172         struct cfg80211_bss *bss = NULL;
 173         int i;
 174         int rssi = 0;
 175
 176         priv = (struct wilc_priv *)pUserVoid;
 177         wiphy = priv->dev->ieee80211_ptr->wiphy;
 178
 179         for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
 180                 tstrNetworkInfo *pstrNetworkInfo;
 181
 182                 pstrNetworkInfo = &(astrLastScannedNtwrksShadow[i]);
 183
 184
 185                 if ((!pstrNetworkInfo->u8Found) || all) {
 186                         s32 s32Freq;
 187                         struct ieee80211_channel *channel;
 188
 189                         if (pstrNetworkInfo != NULL) {
 190
 191                                 s32Freq = ieee80211_channel_to_frequency((s32)pstrNetworkInfo->u8channel, IEEE80211_BAND_2GHZ);
 192                                 channel = ieee80211_get_channel(wiphy, s32Freq);
 193
 194                                 rssi = get_rssi_avg(pstrNetworkInfo);
 195                                 if (memcmp("DIRECT-", pstrNetworkInfo->au8ssid, 7) || bDirectScan)      {
 196                                         bss = cfg80211_inform_bss(wiphy, channel, CFG80211_BSS_FTYPE_UNKNOWN, pstrNetworkInfo->au8bssid, pstrNetworkInfo->u64Tsf, pstrNetworkInfo->u16CapInfo,
 197                                                                   pstrNetworkInfo->u16BeaconPeriod, (const u8 *)pstrNetworkInfo->pu8IEs,
 198                                                                   (size_t)pstrNetworkInfo->u16IEsLen, (((s32)rssi) * 100), GFP_KERNEL);
 199                                         cfg80211_put_bss(wiphy, bss);
 200                                 }
 201                         }
 202
 203                 }
 204         }
 205
 206 }
 207
 208 void reset_shadow_found(void *pUserVoid)
 209 {
 210         int i;
 211
 212         for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
 213                 astrLastScannedNtwrksShadow[i].u8Found = 0;
 214
 215         }
 216 }
 217
 218 void update_scan_time(void *pUserVoid)
 219 {
 220         int i;
 221
 222         for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
 223                 astrLastScannedNtwrksShadow[i].u32TimeRcvdInScan = jiffies;
 224         }
 225 }
 226
 227 static void remove_network_from_shadow(unsigned long arg)
 228 {
 229         unsigned long now = jiffies;
 230         int i, j;
 231
 232
 233         for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
 234                 if (time_after(now, astrLastScannedNtwrksShadow[i].u32TimeRcvdInScan + (unsigned long)(SCAN_RESULT_EXPIRE))) {
 235                         PRINT_D(CFG80211_DBG, "Network expired in ScanShadow: %s\n", astrLastScannedNtwrksShadow[i].au8ssid);
 236
 237                         if (astrLastScannedNtwrksShadow[i].pu8IEs != NULL) {
 238                                 kfree(astrLastScannedNtwrksShadow[i].pu8IEs);
 239                                 astrLastScannedNtwrksShadow[i].pu8IEs = NULL;
 240                         }
 241
 242                         host_int_freeJoinParams(astrLastScannedNtwrksShadow[i].pJoinParams);
 243
 244                         for (j = i; (j < u32LastScannedNtwrksCountShadow - 1); j++) {
 245                                 astrLastScannedNtwrksShadow[j] = astrLastScannedNtwrksShadow[j + 1];
 246                         }
 247                         u32LastScannedNtwrksCountShadow--;
 248                 }
 249         }
 250
 251         PRINT_D(CFG80211_DBG, "Number of cached networks: %d\n", u32LastScannedNtwrksCountShadow);
 252         if (u32LastScannedNtwrksCountShadow != 0) {
 253                 hAgingTimer.data = arg;
 254                 mod_timer(&hAgingTimer, jiffies + msecs_to_jiffies(AGING_TIME));
 255         } else {
 256                 PRINT_D(CFG80211_DBG, "No need to restart Aging timer\n");
 257         }
 258 }
 259
 260 static void clear_duringIP(unsigned long arg)
 261 {
 262         PRINT_D(GENERIC_DBG, "GO:IP Obtained , enable scan\n");
 263         g_obtainingIP = false;
 264 }
 265
 266 int is_network_in_shadow(tstrNetworkInfo *pstrNetworkInfo, void *pUserVoid)
 267 {
 268         int state = -1;
 269         int i;
 270
 271         if (u32LastScannedNtwrksCountShadow == 0) {
 272                 PRINT_D(CFG80211_DBG, "Starting Aging timer\n");
 273                 hAgingTimer.data = (unsigned long)pUserVoid;
 274                 mod_timer(&hAgingTimer, jiffies + msecs_to_jiffies(AGING_TIME));
 275                 state = -1;
 276         } else {
 277                 /* Linear search for now */
 278                 for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
 279                         if (memcmp(astrLastScannedNtwrksShadow[i].au8bssid,
 280                                         pstrNetworkInfo->au8bssid, 6) == 0) {
 281                                 state = i;
 282                                 break;
 283                         }
 284                 }
 285         }
 286         return state;
 287 }
 288
 289 void add_network_to_shadow(tstrNetworkInfo *pstrNetworkInfo, void *pUserVoid, void *pJoinParams)
 290 {
 291         int ap_found = is_network_in_shadow(pstrNetworkInfo, pUserVoid);
 292         u32 ap_index = 0;
 293         u8 rssi_index = 0;
 294
 295         if (u32LastScannedNtwrksCountShadow >= MAX_NUM_SCANNED_NETWORKS_SHADOW) {
 296                 PRINT_D(CFG80211_DBG, "Shadow network reached its maximum limit\n");
 297                 return;
 298         }
 299         if (ap_found == -1) {
 300                 ap_index = u32LastScannedNtwrksCountShadow;
 301                 u32LastScannedNtwrksCountShadow++;
 302
 303         } else {
 304                 ap_index = ap_found;
 305         }
 306         rssi_index = astrLastScannedNtwrksShadow[ap_index].strRssi.u8Index;
 307         astrLastScannedNtwrksShadow[ap_index].strRssi.as8RSSI[rssi_index++] = pstrNetworkInfo->s8rssi;
 308         if (rssi_index == NUM_RSSI) {
 309                 rssi_index = 0;
 310                 astrLastScannedNtwrksShadow[ap_index].strRssi.u8Full = 1;
 311         }
 312         astrLastScannedNtwrksShadow[ap_index].strRssi.u8Index = rssi_index;
 313
 314         astrLastScannedNtwrksShadow[ap_index].s8rssi = pstrNetworkInfo->s8rssi;
 315         astrLastScannedNtwrksShadow[ap_index].u16CapInfo = pstrNetworkInfo->u16CapInfo;
 316
 317         astrLastScannedNtwrksShadow[ap_index].u8SsidLen = pstrNetworkInfo->u8SsidLen;
 318         memcpy(astrLastScannedNtwrksShadow[ap_index].au8ssid,
 319                     pstrNetworkInfo->au8ssid, pstrNetworkInfo->u8SsidLen);
 320
 321         memcpy(astrLastScannedNtwrksShadow[ap_index].au8bssid,
 322                     pstrNetworkInfo->au8bssid, ETH_ALEN);
 323
 324         astrLastScannedNtwrksShadow[ap_index].u16BeaconPeriod = pstrNetworkInfo->u16BeaconPeriod;
 325         astrLastScannedNtwrksShadow[ap_index].u8DtimPeriod = pstrNetworkInfo->u8DtimPeriod;
 326         astrLastScannedNtwrksShadow[ap_index].u8channel = pstrNetworkInfo->u8channel;
 327
 328         astrLastScannedNtwrksShadow[ap_index].u16IEsLen = pstrNetworkInfo->u16IEsLen;
 329         astrLastScannedNtwrksShadow[ap_index].u64Tsf = pstrNetworkInfo->u64Tsf;
 330         if (ap_found != -1)
 331                 kfree(astrLastScannedNtwrksShadow[ap_index].pu8IEs);
 332         astrLastScannedNtwrksShadow[ap_index].pu8IEs =
 333                 kmalloc(pstrNetworkInfo->u16IEsLen, GFP_KERNEL);        /* will be deallocated by the WILC_WFI_CfgScan() function */
 334         memcpy(astrLastScannedNtwrksShadow[ap_index].pu8IEs,
 335                     pstrNetworkInfo->pu8IEs, pstrNetworkInfo->u16IEsLen);
 336
 337         astrLastScannedNtwrksShadow[ap_index].u32TimeRcvdInScan = jiffies;
 338         astrLastScannedNtwrksShadow[ap_index].u32TimeRcvdInScanCached = jiffies;
 339         astrLastScannedNtwrksShadow[ap_index].u8Found = 1;
 340         if (ap_found != -1)
 341                 host_int_freeJoinParams(astrLastScannedNtwrksShadow[ap_index].pJoinParams);
 342         astrLastScannedNtwrksShadow[ap_index].pJoinParams = pJoinParams;
 343
 344 }
 345
 346
 347 /**
 348  *  @brief      CfgScanResult
 349  *  @details  Callback function which returns the scan results found
 350  *
 351  *  @param[in] tenuScanEvent enuScanEvent: enum, indicating the scan event triggered, whether that is
 352  *                        SCAN_EVENT_NETWORK_FOUND or SCAN_EVENT_DONE
 353  *                        tstrNetworkInfo* pstrNetworkInfo: structure holding the scan results information
 354  *                        void* pUserVoid: Private structure associated with the wireless interface
 355  *  @return     NONE
 356  *  @author     mabubakr
 357  *  @date
 358  *  @version    1.0
 359  */
 360 static void CfgScanResult(tenuScanEvent enuScanEvent, tstrNetworkInfo *pstrNetworkInfo, void *pUserVoid, void *pJoinParams)
 361 {
 362         struct wilc_priv *priv;
 363         struct wiphy *wiphy;
 364         s32 s32Freq;
 365         struct ieee80211_channel *channel;
 366         struct cfg80211_bss *bss = NULL;
 367
 368         priv = (struct wilc_priv *)pUserVoid;
 369         if (priv->bCfgScanning == true) {
 370                 if (enuScanEvent == SCAN_EVENT_NETWORK_FOUND) {
 371                         wiphy = priv->dev->ieee80211_ptr->wiphy;
 372
 373                         if (!wiphy)
 374                                 return;
 375
 376                         if (wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC
 377                             &&
 378                             ((((s32)pstrNetworkInfo->s8rssi) * 100) < 0
 379                              ||
 380                              (((s32)pstrNetworkInfo->s8rssi) * 100) > 100)
 381                             ) {
 382                                 PRINT_ER("wiphy signal type fial\n");
 383                                 return;
 384                         }
 385
 386                         if (pstrNetworkInfo != NULL) {
 387                                 s32Freq = ieee80211_channel_to_frequency((s32)pstrNetworkInfo->u8channel, IEEE80211_BAND_2GHZ);
 388                                 channel = ieee80211_get_channel(wiphy, s32Freq);
 389
 390                                 if (!channel)
 391                                         return;
 392
 393                                 PRINT_INFO(CFG80211_DBG, "Network Info:: CHANNEL Frequency: %d, RSSI: %d, CapabilityInfo: %d,"
 394                                            "BeaconPeriod: %d\n", channel->center_freq, (((s32)pstrNetworkInfo->s8rssi) * 100),
 395                                            pstrNetworkInfo->u16CapInfo, pstrNetworkInfo->u16BeaconPeriod);
 396
 397                                 if (pstrNetworkInfo->bNewNetwork == true) {
 398                                         if (priv->u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) { /* TODO: mostafa: to be replaced by */
 399                                                 /*               max_scan_ssids */
 400                                                 PRINT_D(CFG80211_DBG, "Network %s found\n", pstrNetworkInfo->au8ssid);
 401
 402
 403                                                 priv->u32RcvdChCount++;
 404
 405
 406
 407                                                 if (pJoinParams == NULL) {
 408                                                         PRINT_INFO(CORECONFIG_DBG, ">> Something really bad happened\n");
 409                                                 }
 410                                                 add_network_to_shadow(pstrNetworkInfo, priv, pJoinParams);
 411
 412                                                 /*P2P peers are sent to WPA supplicant and added to shadow table*/
 413
 414                                                 if (!(memcmp("DIRECT-", pstrNetworkInfo->au8ssid, 7))) {
 415                                                         bss = cfg80211_inform_bss(wiphy, channel, CFG80211_BSS_FTYPE_UNKNOWN,  pstrNetworkInfo->au8bssid, pstrNetworkInfo->u64Tsf, pstrNetworkInfo->u16CapInfo,
 416                                                                                   pstrNetworkInfo->u16BeaconPeriod, (const u8 *)pstrNetworkInfo->pu8IEs,
 417                                                                                   (size_t)pstrNetworkInfo->u16IEsLen, (((s32)pstrNetworkInfo->s8rssi) * 100), GFP_KERNEL);
 418                                                         cfg80211_put_bss(wiphy, bss);
 419                                                 }
 420
 421
 422                                         } else {
 423                                                 PRINT_ER("Discovered networks exceeded the max limit\n");
 424                                         }
 425                                 } else {
 426                                         u32 i;
 427                                         /* So this network is discovered before, we'll just update its RSSI */
 428                                         for (i = 0; i < priv->u32RcvdChCount; i++) {
 429                                                 if (memcmp(astrLastScannedNtwrksShadow[i].au8bssid, pstrNetworkInfo->au8bssid, 6) == 0) {
 430                                                         PRINT_D(CFG80211_DBG, "Update RSSI of %s\n", astrLastScannedNtwrksShadow[i].au8ssid);
 431
 432                                                         astrLastScannedNtwrksShadow[i].s8rssi = pstrNetworkInfo->s8rssi;
 433                                                         astrLastScannedNtwrksShadow[i].u32TimeRcvdInScan = jiffies;
 434                                                         break;
 435                                                 }
 436                                         }
 437                                 }
 438                         }
 439                 } else if (enuScanEvent == SCAN_EVENT_DONE)    {
 440                         PRINT_D(CFG80211_DBG, "Scan Done[%p]\n", priv->dev);
 441                         PRINT_D(CFG80211_DBG, "Refreshing Scan ...\n");
 442                         refresh_scan(priv, 1, false);
 443
 444                         if (priv->u32RcvdChCount > 0)
 445                                 PRINT_D(CFG80211_DBG, "%d Network(s) found\n", priv->u32RcvdChCount);
 446                         else
 447                                 PRINT_D(CFG80211_DBG, "No networks found\n");
 448
 449                         down(&(priv->hSemScanReq));
 450
 451                         if (priv->pstrScanReq != NULL) {
 452                                 cfg80211_scan_done(priv->pstrScanReq, false);
 453                                 priv->u32RcvdChCount = 0;
 454                                 priv->bCfgScanning = false;
 455                                 priv->pstrScanReq = NULL;
 456                         }
 457                         up(&(priv->hSemScanReq));
 458
 459                 }
 460                 /*Aborting any scan operation during mac close*/
 461                 else if (enuScanEvent == SCAN_EVENT_ABORTED) {
 462                         down(&(priv->hSemScanReq));
 463
 464                         PRINT_D(CFG80211_DBG, "Scan Aborted\n");
 465                         if (priv->pstrScanReq != NULL) {
 466
 467                                 update_scan_time(priv);
 468                                 refresh_scan(priv, 1, false);
 469
 470                                 cfg80211_scan_done(priv->pstrScanReq, false);
 471                                 priv->bCfgScanning = false;
 472                                 priv->pstrScanReq = NULL;
 473                         }
 474                         up(&(priv->hSemScanReq));
 475                 }
 476         }
 477 }
 478
 479
 480 /**
 481  *  @brief      WILC_WFI_Set_PMKSA
 482  *  @details  Check if pmksa is cached and set it.
 483  *  @param[in]
 484  *  @return     int : Return 0 on Success
 485  *  @author     mdaftedar
 486  *  @date       01 MAR 2012
 487  *  @version    1.0
 488  */
 489 int WILC_WFI_Set_PMKSA(u8 *bssid, struct wilc_priv *priv)
 490 {
 491         u32 i;
 492         s32 s32Error = 0;
 493
 494
 495         for (i = 0; i < priv->pmkid_list.numpmkid; i++) {
 496
 497                 if (!memcmp(bssid, priv->pmkid_list.pmkidlist[i].bssid,
 498                                  ETH_ALEN)) {
 499                         PRINT_D(CFG80211_DBG, "PMKID successful comparison");
 500
 501                         /*If bssid is found, set the values*/
 502                         s32Error = host_int_set_pmkid_info(priv->hWILCWFIDrv, &priv->pmkid_list);
 503
 504                         if (s32Error != 0)
 505                                 PRINT_ER("Error in pmkid\n");
 506
 507                         break;
 508                 }
 509         }
 510
 511         return s32Error;
 512
 513
 514 }
 515 int linux_wlan_set_bssid(struct net_device *wilc_netdev, u8 *pBSSID);
 516
 517
 518 /**
 519  *  @brief      CfgConnectResult
 520  *  @details
 521  *  @param[in] tenuConnDisconnEvent enuConnDisconnEvent: Type of connection response either
 522  *                        connection response or disconnection notification.
 523  *                        tstrConnectInfo* pstrConnectInfo: COnnection information.
 524  *                        u8 u8MacStatus: Mac Status from firmware
 525  *                        tstrDisconnectNotifInfo* pstrDisconnectNotifInfo: Disconnection Notification
 526  *                        void* pUserVoid: Private data associated with wireless interface
 527  *  @return     NONE
 528  *  @author     mabubakr
 529  *  @date       01 MAR 2012
 530  *  @version    1.0
 531  */
 532 int connecting;
 533
 534 static void CfgConnectResult(tenuConnDisconnEvent enuConnDisconnEvent,
 535                              tstrConnectInfo *pstrConnectInfo,
 536                              u8 u8MacStatus,
 537                              tstrDisconnectNotifInfo *pstrDisconnectNotifInfo,
 538                              void *pUserVoid)
 539 {
 540         struct wilc_priv *priv;
 541         struct net_device *dev;
 542         tstrWILC_WFIDrv *pstrWFIDrv;
 543         u8 NullBssid[ETH_ALEN] = {0};
 544
 545         connecting = 0;
 546
 547         priv = (struct wilc_priv *)pUserVoid;
 548         dev = priv->dev;
 549         pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
 550
 551         if (enuConnDisconnEvent == CONN_DISCONN_EVENT_CONN_RESP) {
 552                 /*Initialization*/
 553                 u16 u16ConnectStatus = WLAN_STATUS_SUCCESS;
 554
 555                 u16ConnectStatus = pstrConnectInfo->u16ConnectStatus;
 556
 557                 PRINT_D(CFG80211_DBG, " Connection response received = %d\n", u8MacStatus);
 558
 559                 if ((u8MacStatus == MAC_DISCONNECTED) &&
 560                     (pstrConnectInfo->u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
 561                         /* The case here is that our station was waiting for association response frame and has just received it containing status code
 562                          *  = SUCCESSFUL_STATUSCODE, while mac status is MAC_DISCONNECTED (which means something wrong happened) */
 563                         u16ConnectStatus = WLAN_STATUS_UNSPECIFIED_FAILURE;
 564                         linux_wlan_set_bssid(priv->dev, NullBssid);
 565                         memset(u8ConnectedSSID, 0, ETH_ALEN);
 566
 567                         /*Invalidate u8WLANChannel value on wlan0 disconnect*/
 568                         if (!pstrWFIDrv->u8P2PConnect)
 569                                 u8WLANChannel = INVALID_CHANNEL;
 570
 571                         PRINT_ER("Unspecified failure: Connection status %d : MAC status = %d\n", u16ConnectStatus, u8MacStatus);
 572                 }
 573
 574                 if (u16ConnectStatus == WLAN_STATUS_SUCCESS) {
 575                         bool bNeedScanRefresh = false;
 576                         u32 i;
 577
 578                         PRINT_INFO(CFG80211_DBG, "Connection Successful:: BSSID: %x%x%x%x%x%x\n", pstrConnectInfo->au8bssid[0],
 579                                    pstrConnectInfo->au8bssid[1], pstrConnectInfo->au8bssid[2], pstrConnectInfo->au8bssid[3], pstrConnectInfo->au8bssid[4], pstrConnectInfo->au8bssid[5]);
 580                         memcpy(priv->au8AssociatedBss, pstrConnectInfo->au8bssid, ETH_ALEN);
 581
 582
 583                         for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
 584                                 if (memcmp(astrLastScannedNtwrksShadow[i].au8bssid,
 585                                                 pstrConnectInfo->au8bssid, ETH_ALEN) == 0) {
 586                                         unsigned long now = jiffies;
 587
 588                                         if (time_after(now,
 589                                                        astrLastScannedNtwrksShadow[i].u32TimeRcvdInScanCached + (unsigned long)(nl80211_SCAN_RESULT_EXPIRE - (1 * HZ)))) {
 590                                                 bNeedScanRefresh = true;
 591                                         }
 592
 593                                         break;
 594                                 }
 595                         }
 596
 597                         if (bNeedScanRefresh) {
 598                                 /*Also, refrsh DIRECT- results if */
 599                                 refresh_scan(priv, 1, true);
 600
 601                         }
 602
 603                 }
 604
 605
 606                 PRINT_D(CFG80211_DBG, "Association request info elements length = %zu\n", pstrConnectInfo->ReqIEsLen);
 607
 608                 PRINT_D(CFG80211_DBG, "Association response info elements length = %d\n", pstrConnectInfo->u16RespIEsLen);
 609
 610                 cfg80211_connect_result(dev, pstrConnectInfo->au8bssid,
 611                                         pstrConnectInfo->pu8ReqIEs, pstrConnectInfo->ReqIEsLen,
 612                                         pstrConnectInfo->pu8RespIEs, pstrConnectInfo->u16RespIEsLen,
 613                                         u16ConnectStatus, GFP_KERNEL);                         /* TODO: mostafa: u16ConnectStatus to */
 614                 /* be replaced by pstrConnectInfo->u16ConnectStatus */
 615         } else if (enuConnDisconnEvent == CONN_DISCONN_EVENT_DISCONN_NOTIF)    {
 616                 g_obtainingIP = false;
 617                 PRINT_ER("Received MAC_DISCONNECTED from firmware with reason %d on dev [%p]\n",
 618                          pstrDisconnectNotifInfo->u16reason, priv->dev);
 619                 u8P2Plocalrandom = 0x01;
 620                 u8P2Precvrandom = 0x00;
 621                 bWilc_ie = false;
 622                 memset(priv->au8AssociatedBss, 0, ETH_ALEN);
 623                 linux_wlan_set_bssid(priv->dev, NullBssid);
 624                 memset(u8ConnectedSSID, 0, ETH_ALEN);
 625
 626                 /*Invalidate u8WLANChannel value on wlan0 disconnect*/
 627                 if (!pstrWFIDrv->u8P2PConnect)
 628                         u8WLANChannel = INVALID_CHANNEL;
 629                 /*Incase "P2P CLIENT Connected" send deauthentication reason by 3 to force the WPA_SUPPLICANT to directly change
 630                  *      virtual interface to station*/
 631                 if ((pstrWFIDrv->IFC_UP) && (dev == g_linux_wlan->strInterfaceInfo[1].wilc_netdev)) {
 632                         pstrDisconnectNotifInfo->u16reason = 3;
 633                 }
 634                 /*Incase "P2P CLIENT during connection(not connected)" send deauthentication reason by 1 to force the WPA_SUPPLICANT
 635                  *      to scan again and retry the connection*/
 636                 else if ((!pstrWFIDrv->IFC_UP) && (dev == g_linux_wlan->strInterfaceInfo[1].wilc_netdev)) {
 637                         pstrDisconnectNotifInfo->u16reason = 1;
 638                 }
 639                 cfg80211_disconnected(dev, pstrDisconnectNotifInfo->u16reason, pstrDisconnectNotifInfo->ie,
 640                                       pstrDisconnectNotifInfo->ie_len, false,
 641                                       GFP_KERNEL);
 642
 643         }
 644
 645 }
 646
 647
 648 /**
 649  *  @brief      set_channel
 650  *  @details    Set channel for a given wireless interface. Some devices
 651  *                      may support multi-channel operation (by channel hopping) so cfg80211
 652  *                      doesn't verify much. Note, however, that the passed netdev may be
 653  *                      %NULL as well if the user requested changing the channel for the
 654  *                      device itself, or for a monitor interface.
 655  *  @param[in]
 656  *  @return     int : Return 0 on Success
 657  *  @author     mdaftedar
 658  *  @date       01 MAR 2012
 659  *  @version    1.0
 660  */
 661 static int set_channel(struct wiphy *wiphy,
 662                        struct cfg80211_chan_def *chandef)
 663 {
 664
 665         u32 channelnum = 0;
 666         struct wilc_priv *priv;
 667         s32 s32Error = 0;
 668
 669         priv = wiphy_priv(wiphy);
 670
 671         channelnum = ieee80211_frequency_to_channel(chandef->chan->center_freq);
 672         PRINT_D(CFG80211_DBG, "Setting channel %d with frequency %d\n", channelnum, chandef->chan->center_freq);
 673
 674         u8CurrChannel = channelnum;
 675         s32Error   = host_int_set_mac_chnl_num(priv->hWILCWFIDrv, channelnum);
 676
 677         if (s32Error != 0)
 678                 PRINT_ER("Error in setting channel %d\n", channelnum);
 679
 680         return s32Error;
 681 }
 682
 683 /**
 684  *  @brief      scan
 685  *  @details    Request to do a scan. If returning zero, the scan request is given
 686  *                      the driver, and will be valid until passed to cfg80211_scan_done().
 687  *                      For scan results, call cfg80211_inform_bss(); you can call this outside
 688  *                      the scan/scan_done bracket too.
 689  *  @param[in]
 690  *  @return     int : Return 0 on Success
 691  *  @author     mabubakr
 692  *  @date       01 MAR 2012
 693  *  @version    1.0
 694  */
 695
 696 static int scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
 697 {
 698         struct wilc_priv *priv;
 699         u32 i;
 700         s32 s32Error = 0;
 701         u8 au8ScanChanList[MAX_NUM_SCANNED_NETWORKS];
 702         tstrHiddenNetwork strHiddenNetwork;
 703
 704         priv = wiphy_priv(wiphy);
 705
 706         priv->pstrScanReq = request;
 707
 708         priv->u32RcvdChCount = 0;
 709
 710         host_int_set_wfi_drv_handler(priv->hWILCWFIDrv);
 711
 712
 713         reset_shadow_found(priv);
 714
 715         priv->bCfgScanning = true;
 716         if (request->n_channels <= MAX_NUM_SCANNED_NETWORKS) { /* TODO: mostafa: to be replaced by */
 717                 /*               max_scan_ssids */
 718                 for (i = 0; i < request->n_channels; i++) {
 719                         au8ScanChanList[i] = (u8)ieee80211_frequency_to_channel(request->channels[i]->center_freq);
 720                         PRINT_INFO(CFG80211_DBG, "ScanChannel List[%d] = %d,", i, au8ScanChanList[i]);
 721                 }
 722
 723                 PRINT_D(CFG80211_DBG, "Requested num of scan channel %d\n", request->n_channels);
 724                 PRINT_D(CFG80211_DBG, "Scan Request IE len =  %zu\n", request->ie_len);
 725
 726                 PRINT_D(CFG80211_DBG, "Number of SSIDs %d\n", request->n_ssids);
 727
 728                 if (request->n_ssids >= 1) {
 729
 730
 731                         strHiddenNetwork.pstrHiddenNetworkInfo = kmalloc(request->n_ssids * sizeof(tstrHiddenNetwork), GFP_KERNEL);
 732                         strHiddenNetwork.u8ssidnum = request->n_ssids;
 733
 734
 735                         for (i = 0; i < request->n_ssids; i++) {
 736
 737                                 if (request->ssids[i].ssid != NULL && request->ssids[i].ssid_len != 0) {
 738                                         strHiddenNetwork.pstrHiddenNetworkInfo[i].pu8ssid = kmalloc(request->ssids[i].ssid_len, GFP_KERNEL);
 739                                         memcpy(strHiddenNetwork.pstrHiddenNetworkInfo[i].pu8ssid, request->ssids[i].ssid, request->ssids[i].ssid_len);
 740                                         strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen = request->ssids[i].ssid_len;
 741                                 } else {
 742                                         PRINT_D(CFG80211_DBG, "Received one NULL SSID\n");
 743                                         strHiddenNetwork.u8ssidnum -= 1;
 744                                 }
 745                         }
 746                         PRINT_D(CFG80211_DBG, "Trigger Scan Request\n");
 747                         s32Error = host_int_scan(priv->hWILCWFIDrv, USER_SCAN, ACTIVE_SCAN,
 748                                                  au8ScanChanList, request->n_channels,
 749                                                  (const u8 *)request->ie, request->ie_len,
 750                                                  CfgScanResult, (void *)priv, &strHiddenNetwork);
 751                 } else {
 752                         PRINT_D(CFG80211_DBG, "Trigger Scan Request\n");
 753                         s32Error = host_int_scan(priv->hWILCWFIDrv, USER_SCAN, ACTIVE_SCAN,
 754                                                  au8ScanChanList, request->n_channels,
 755                                                  (const u8 *)request->ie, request->ie_len,
 756                                                  CfgScanResult, (void *)priv, NULL);
 757                 }
 758
 759         } else {
 760                 PRINT_ER("Requested num of scanned channels is greater than the max, supported"
 761                          " channels\n");
 762         }
 763
 764         if (s32Error != 0) {
 765                 s32Error = -EBUSY;
 766                 PRINT_WRN(CFG80211_DBG, "Device is busy: Error(%d)\n", s32Error);
 767         }
 768
 769         return s32Error;
 770 }
 771
 772 /**
 773  *  @brief      connect
 774  *  @details    Connect to the ESS with the specified parameters. When connected,
 775  *                      call cfg80211_connect_result() with status code %WLAN_STATUS_SUCCESS.
 776  *                      If the connection fails for some reason, call cfg80211_connect_result()
 777  *                      with the status from the AP.
 778  *  @param[in]
 779  *  @return     int : Return 0 on Success
 780  *  @author     mabubakr
 781  *  @date       01 MAR 2012
 782  *  @version    1.0
 783  */
 784 static int connect(struct wiphy *wiphy, struct net_device *dev,
 785                    struct cfg80211_connect_params *sme)
 786 {
 787         s32 s32Error = 0;
 788         u32 i;
 789         u8 u8security = NO_ENCRYPT;
 790         AUTHTYPE_T tenuAuth_type = ANY;
 791         char *pcgroup_encrypt_val = NULL;
 792         char *pccipher_group = NULL;
 793         char *pcwpa_version = NULL;
 794
 795         struct wilc_priv *priv;
 796         tstrWILC_WFIDrv *pstrWFIDrv;
 797         tstrNetworkInfo *pstrNetworkInfo = NULL;
 798
 799
 800         connecting = 1;
 801         priv = wiphy_priv(wiphy);
 802         pstrWFIDrv = (tstrWILC_WFIDrv *)(priv->hWILCWFIDrv);
 803
 804         host_int_set_wfi_drv_handler(priv->hWILCWFIDrv);
 805
 806         PRINT_D(CFG80211_DBG, "Connecting to SSID [%s] on netdev [%p] host if [%p]\n", sme->ssid, dev, priv->hWILCWFIDrv);
 807         if (!(strncmp(sme->ssid, "DIRECT-", 7))) {
 808                 PRINT_D(CFG80211_DBG, "Connected to Direct network,OBSS disabled\n");
 809                 pstrWFIDrv->u8P2PConnect = 1;
 810         } else
 811                 pstrWFIDrv->u8P2PConnect = 0;
 812         PRINT_INFO(CFG80211_DBG, "Required SSID = %s\n , AuthType = %d\n", sme->ssid, sme->auth_type);
 813
 814         for (i = 0; i < u32LastScannedNtwrksCountShadow; i++) {
 815                 if ((sme->ssid_len == astrLastScannedNtwrksShadow[i].u8SsidLen) &&
 816                     memcmp(astrLastScannedNtwrksShadow[i].au8ssid,
 817                                 sme->ssid,
 818                                 sme->ssid_len) == 0) {
 819                         PRINT_INFO(CFG80211_DBG, "Network with required SSID is found %s\n", sme->ssid);
 820                         if (sme->bssid == NULL) {
 821                                 /* BSSID is not passed from the user, so decision of matching
 822                                  * is done by SSID only */
 823                                 PRINT_INFO(CFG80211_DBG, "BSSID is not passed from the user\n");
 824                                 break;
 825                         } else {
 826                                 /* BSSID is also passed from the user, so decision of matching
 827                                  * should consider also this passed BSSID */
 828                                 if (memcmp(astrLastScannedNtwrksShadow[i].au8bssid,
 829                                                 sme->bssid,
 830                                                 ETH_ALEN) == 0) {
 831                                         PRINT_INFO(CFG80211_DBG, "BSSID is passed from the user and matched\n");
 832                                         break;
 833                                 }
 834                         }
 835                 }
 836         }
 837
 838         if (i < u32LastScannedNtwrksCountShadow) {
 839                 PRINT_D(CFG80211_DBG, "Required bss is in scan results\n");
 840
 841                 pstrNetworkInfo = &(astrLastScannedNtwrksShadow[i]);
 842
 843                 PRINT_INFO(CFG80211_DBG, "network BSSID to be associated: %x%x%x%x%x%x\n",
 844                            pstrNetworkInfo->au8bssid[0], pstrNetworkInfo->au8bssid[1],
 845                            pstrNetworkInfo->au8bssid[2], pstrNetworkInfo->au8bssid[3],
 846                            pstrNetworkInfo->au8bssid[4], pstrNetworkInfo->au8bssid[5]);
 847         } else {
 848                 s32Error = -ENOENT;
 849                 if (u32LastScannedNtwrksCountShadow == 0)
 850                         PRINT_D(CFG80211_DBG, "No Scan results yet\n");
 851                 else
 852                         PRINT_D(CFG80211_DBG, "Required bss not in scan results: Error(%d)\n", s32Error);
 853
 854                 goto done;
 855         }
 856
 857         priv->WILC_WFI_wep_default = 0;
 858         memset(priv->WILC_WFI_wep_key, 0, sizeof(priv->WILC_WFI_wep_key));
 859         memset(priv->WILC_WFI_wep_key_len, 0, sizeof(priv->WILC_WFI_wep_key_len));
 860
 861         PRINT_INFO(CFG80211_DBG, "sme->crypto.wpa_versions=%x\n", sme->crypto.wpa_versions);
 862         PRINT_INFO(CFG80211_DBG, "sme->crypto.cipher_group=%x\n", sme->crypto.cipher_group);
 863
 864         PRINT_INFO(CFG80211_DBG, "sme->crypto.n_ciphers_pairwise=%d\n", sme->crypto.n_ciphers_pairwise);
 865
 866         if (INFO) {
 867                 for (i = 0; i < sme->crypto.n_ciphers_pairwise; i++)
 868                         PRINT_D(CORECONFIG_DBG, "sme->crypto.ciphers_pairwise[%d]=%x\n", i, sme->crypto.ciphers_pairwise[i]);
 869         }
 870
 871         if (sme->crypto.cipher_group != NO_ENCRYPT) {
 872                 /* To determine the u8security value, first we check the group cipher suite then {in case of WPA or WPA2}
 873                  *  we will add to it the pairwise cipher suite(s) */
 874                 pcwpa_version = "Default";
 875                 PRINT_D(CORECONFIG_DBG, ">> sme->crypto.wpa_versions: %x\n", sme->crypto.wpa_versions);
 876                 if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_WEP40) {
 877                         u8security = ENCRYPT_ENABLED | WEP;
 878                         pcgroup_encrypt_val = "WEP40";
 879                         pccipher_group = "WLAN_CIPHER_SUITE_WEP40";
 880                         PRINT_INFO(CFG80211_DBG, "WEP Default Key Idx = %d\n", sme->key_idx);
 881
 882                         if (INFO) {
 883                                 for (i = 0; i < sme->key_len; i++)
 884                                         PRINT_D(CORECONFIG_DBG, "WEP Key Value[%d] = %d\n", i, sme->key[i]);
 885                         }
 886                         priv->WILC_WFI_wep_default = sme->key_idx;
 887                         priv->WILC_WFI_wep_key_len[sme->key_idx] = sme->key_len;
 888                         memcpy(priv->WILC_WFI_wep_key[sme->key_idx], sme->key, sme->key_len);
 889
 890                         g_key_wep_params.key_len = sme->key_len;
 891                         g_key_wep_params.key = kmalloc(sme->key_len, GFP_KERNEL);
 892                         memcpy(g_key_wep_params.key, sme->key, sme->key_len);
 893                         g_key_wep_params.key_idx = sme->key_idx;
 894                         g_wep_keys_saved = true;
 895
 896                         host_int_set_WEPDefaultKeyID(priv->hWILCWFIDrv, sme->key_idx);
 897                         host_int_add_wep_key_bss_sta(priv->hWILCWFIDrv, sme->key, sme->key_len, sme->key_idx);
 898                 } else if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_WEP104)   {
 899                         u8security = ENCRYPT_ENABLED | WEP | WEP_EXTENDED;
 900                         pcgroup_encrypt_val = "WEP104";
 901                         pccipher_group = "WLAN_CIPHER_SUITE_WEP104";
 902
 903                         priv->WILC_WFI_wep_default = sme->key_idx;
 904                         priv->WILC_WFI_wep_key_len[sme->key_idx] = sme->key_len;
 905                         memcpy(priv->WILC_WFI_wep_key[sme->key_idx], sme->key, sme->key_len);
 906
 907                         g_key_wep_params.key_len = sme->key_len;
 908                         g_key_wep_params.key = kmalloc(sme->key_len, GFP_KERNEL);
 909                         memcpy(g_key_wep_params.key, sme->key, sme->key_len);
 910                         g_key_wep_params.key_idx = sme->key_idx;
 911                         g_wep_keys_saved = true;
 912
 913                         host_int_set_WEPDefaultKeyID(priv->hWILCWFIDrv, sme->key_idx);
 914                         host_int_add_wep_key_bss_sta(priv->hWILCWFIDrv, sme->key, sme->key_len, sme->key_idx);
 915                 } else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)   {
 916                         if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_TKIP) {
 917                                 u8security = ENCRYPT_ENABLED | WPA2 | TKIP;
 918                                 pcgroup_encrypt_val = "WPA2_TKIP";
 919                                 pccipher_group = "TKIP";
 920                         } else {     /* TODO: mostafa: here we assume that any other encryption type is AES */
 921                                      /* tenuSecurity_t = WPA2_AES; */
 922                                 u8security = ENCRYPT_ENABLED | WPA2 | AES;
 923                                 pcgroup_encrypt_val = "WPA2_AES";
 924                                 pccipher_group = "AES";
 925                         }
 926                         pcwpa_version = "WPA_VERSION_2";
 927                 } else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)   {
 928                         if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_TKIP) {
 929                                 u8security = ENCRYPT_ENABLED | WPA | TKIP;
 930                                 pcgroup_encrypt_val = "WPA_TKIP";
 931                                 pccipher_group = "TKIP";
 932                         } else {     /* TODO: mostafa: here we assume that any other encryption type is AES */
 933                                      /* tenuSecurity_t = WPA_AES; */
 934                                 u8security = ENCRYPT_ENABLED | WPA | AES;
 935                                 pcgroup_encrypt_val = "WPA_AES";
 936                                 pccipher_group = "AES";
 937
 938                         }
 939                         pcwpa_version = "WPA_VERSION_1";
 940
 941                 } else {
 942                         s32Error = -ENOTSUPP;
 943                         PRINT_ER("Not supported cipher: Error(%d)\n", s32Error);
 944
 945                         goto done;
 946                 }
 947
 948         }
 949
 950         /* After we set the u8security value from checking the group cipher suite, {in case of WPA or WPA2} we will
 951          *   add to it the pairwise cipher suite(s) */
 952         if ((sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
 953             || (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)) {
 954                 for (i = 0; i < sme->crypto.n_ciphers_pairwise; i++) {
 955                         if (sme->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP) {
 956                                 u8security = u8security | TKIP;
 957                         } else {     /* TODO: mostafa: here we assume that any other encryption type is AES */
 958                                 u8security = u8security | AES;
 959                         }
 960                 }
 961         }
 962
 963         PRINT_D(CFG80211_DBG, "Adding key with cipher group = %x\n", sme->crypto.cipher_group);
 964
 965         PRINT_D(CFG80211_DBG, "Authentication Type = %d\n", sme->auth_type);
 966         switch (sme->auth_type) {
 967         case NL80211_AUTHTYPE_OPEN_SYSTEM:
 968                 PRINT_D(CFG80211_DBG, "In OPEN SYSTEM\n");
 969                 tenuAuth_type = OPEN_SYSTEM;
 970                 break;
 971
 972         case NL80211_AUTHTYPE_SHARED_KEY:
 973                 tenuAuth_type = SHARED_KEY;
 974                 PRINT_D(CFG80211_DBG, "In SHARED KEY\n");
 975                 break;
 976
 977         default:
 978                 PRINT_D(CFG80211_DBG, "Automatic Authentation type = %d\n", sme->auth_type);
 979         }
 980
 981
 982         /* ai: key_mgmt: enterprise case */
 983         if (sme->crypto.n_akm_suites) {
 984                 switch (sme->crypto.akm_suites[0]) {
 985                 case WLAN_AKM_SUITE_8021X:
 986                         tenuAuth_type = IEEE8021;
 987                         break;
 988
 989                 default:
 990                         break;
 991                 }
 992         }
 993
 994
 995         PRINT_INFO(CFG80211_DBG, "Required Channel = %d\n", pstrNetworkInfo->u8channel);
 996
 997         PRINT_INFO(CFG80211_DBG, "Group encryption value = %s\n Cipher Group = %s\n WPA version = %s\n",
 998                    pcgroup_encrypt_val, pccipher_group, pcwpa_version);
 999
1000         u8CurrChannel = pstrNetworkInfo->u8channel;
1001
1002         if (!pstrWFIDrv->u8P2PConnect) {
1003                 u8WLANChannel = pstrNetworkInfo->u8channel;
1004         }
1005
1006         linux_wlan_set_bssid(dev, pstrNetworkInfo->au8bssid);
1007
1008         s32Error = host_int_set_join_req(priv->hWILCWFIDrv, pstrNetworkInfo->au8bssid, sme->ssid,
1009                                          sme->ssid_len, sme->ie, sme->ie_len,
1010                                          CfgConnectResult, (void *)priv, u8security,
1011                                          tenuAuth_type, pstrNetworkInfo->u8channel,
1012                                          pstrNetworkInfo->pJoinParams);
1013         if (s32Error != 0) {
1014                 PRINT_ER("host_int_set_join_req(): Error(%d)\n", s32Error);
1015                 s32Error = -ENOENT;
1016                 goto done;
1017         }
1018
1019 done:
1020
1021         return s32Error;
1022 }
1023
1024
1025 /**
1026  *  @brief      disconnect
1027  *  @details    Disconnect from the BSS/ESS.
1028  *  @param[in]
1029  *  @return     int : Return 0 on Success
1030  *  @author     mdaftedar
1031  *  @date       01 MAR 2012
1032  *  @version    1.0
1033  */
1034 static int disconnect(struct wiphy *wiphy, struct net_device *dev, u16 reason_code)
1035 {
1036         s32 s32Error = 0;
1037         struct wilc_priv *priv;
1038         tstrWILC_WFIDrv *pstrWFIDrv;
1039         u8 NullBssid[ETH_ALEN] = {0};
1040
1041         connecting = 0;
1042         priv = wiphy_priv(wiphy);
1043
1044         /*Invalidate u8WLANChannel value on wlan0 disconnect*/
1045         pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
1046         if (!pstrWFIDrv->u8P2PConnect)
1047                 u8WLANChannel = INVALID_CHANNEL;
1048         linux_wlan_set_bssid(priv->dev, NullBssid);
1049
1050         PRINT_D(CFG80211_DBG, "Disconnecting with reason code(%d)\n", reason_code);
1051
1052         u8P2Plocalrandom = 0x01;
1053         u8P2Precvrandom = 0x00;
1054         bWilc_ie = false;
1055         pstrWFIDrv->u64P2p_MgmtTimeout = 0;
1056
1057         s32Error = host_int_disconnect(priv->hWILCWFIDrv, reason_code);
1058         if (s32Error != 0) {
1059                 PRINT_ER("Error in disconnecting: Error(%d)\n", s32Error);
1060                 s32Error = -EINVAL;
1061         }
1062
1063         return s32Error;
1064 }
1065
1066 /**
1067  *  @brief      add_key
1068  *  @details    Add a key with the given parameters. @mac_addr will be %NULL
1069  *                      when adding a group key.
1070  *  @param[in] key : key buffer; TKIP: 16-byte temporal key, 8-byte Tx Mic key, 8-byte Rx Mic Key
1071  *  @return     int : Return 0 on Success
1072  *  @author     mdaftedar
1073  *  @date       01 MAR 2012
1074  *  @version    1.0
1075  */
1076 static int add_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
1077                    bool pairwise,
1078                    const u8 *mac_addr, struct key_params *params)
1079
1080 {
1081         s32 s32Error = 0, KeyLen = params->key_len;
1082         u32 i;
1083         struct wilc_priv *priv;
1084         const u8 *pu8RxMic = NULL;
1085         const u8 *pu8TxMic = NULL;
1086         u8 u8mode = NO_ENCRYPT;
1087         u8 u8gmode = NO_ENCRYPT;
1088         u8 u8pmode = NO_ENCRYPT;
1089         AUTHTYPE_T tenuAuth_type = ANY;
1090
1091         priv = wiphy_priv(wiphy);
1092
1093         PRINT_D(CFG80211_DBG, "Adding key with cipher suite = %x\n", params->cipher);
1094
1095         PRINT_D(CFG80211_DBG, "%p %p %d\n", wiphy, netdev, key_index);
1096
1097         PRINT_D(CFG80211_DBG, "key %x %x %x\n", params->key[0],
1098                 params->key[1],
1099                 params->key[2]);
1100
1101
1102         switch (params->cipher) {
1103         case WLAN_CIPHER_SUITE_WEP40:
1104         case WLAN_CIPHER_SUITE_WEP104:
1105                 if (priv->wdev->iftype == NL80211_IFTYPE_AP) {
1106
1107                         priv->WILC_WFI_wep_default = key_index;
1108                         priv->WILC_WFI_wep_key_len[key_index] = params->key_len;
1109                         memcpy(priv->WILC_WFI_wep_key[key_index], params->key, params->key_len);
1110
1111                         PRINT_D(CFG80211_DBG, "Adding AP WEP Default key Idx = %d\n", key_index);
1112                         PRINT_D(CFG80211_DBG, "Adding AP WEP Key len= %d\n", params->key_len);
1113
1114                         for (i = 0; i < params->key_len; i++)
1115                                 PRINT_D(CFG80211_DBG, "WEP AP key val[%d] = %x\n", i, params->key[i]);
1116
1117                         tenuAuth_type = OPEN_SYSTEM;
1118
1119                         if (params->cipher == WLAN_CIPHER_SUITE_WEP40)
1120                                 u8mode = ENCRYPT_ENABLED | WEP;
1121                         else
1122                                 u8mode = ENCRYPT_ENABLED | WEP | WEP_EXTENDED;
1123
1124                         host_int_add_wep_key_bss_ap(priv->hWILCWFIDrv, params->key, params->key_len, key_index, u8mode, tenuAuth_type);
1125                         break;
1126                 }
1127                 if (memcmp(params->key, priv->WILC_WFI_wep_key[key_index], params->key_len)) {
1128                         priv->WILC_WFI_wep_default = key_index;
1129                         priv->WILC_WFI_wep_key_len[key_index] = params->key_len;
1130                         memcpy(priv->WILC_WFI_wep_key[key_index], params->key, params->key_len);
1131
1132                         PRINT_D(CFG80211_DBG, "Adding WEP Default key Idx = %d\n", key_index);
1133                         PRINT_D(CFG80211_DBG, "Adding WEP Key length = %d\n", params->key_len);
1134                         if (INFO) {
1135                                 for (i = 0; i < params->key_len; i++)
1136                                         PRINT_INFO(CFG80211_DBG, "WEP key value[%d] = %d\n", i, params->key[i]);
1137                         }
1138                         host_int_add_wep_key_bss_sta(priv->hWILCWFIDrv, params->key, params->key_len, key_index);
1139                 }
1140
1141                 break;
1142
1143         case WLAN_CIPHER_SUITE_TKIP:
1144         case WLAN_CIPHER_SUITE_CCMP:
1145                 if (priv->wdev->iftype == NL80211_IFTYPE_AP || priv->wdev->iftype == NL80211_IFTYPE_P2P_GO) {
1146
1147                         if (priv->wilc_gtk[key_index] == NULL) {
1148                                 priv->wilc_gtk[key_index] = kmalloc(sizeof(struct wilc_wfi_key), GFP_KERNEL);
1149                                 priv->wilc_gtk[key_index]->key = NULL;
1150                                 priv->wilc_gtk[key_index]->seq = NULL;
1151
1152                         }
1153                         if (priv->wilc_ptk[key_index] == NULL) {
1154                                 priv->wilc_ptk[key_index] = kmalloc(sizeof(struct wilc_wfi_key), GFP_KERNEL);
1155                                 priv->wilc_ptk[key_index]->key = NULL;
1156                                 priv->wilc_ptk[key_index]->seq = NULL;
1157                         }
1158
1159
1160
1161                         if (!pairwise) {
1162                                 if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
1163                                         u8gmode = ENCRYPT_ENABLED | WPA | TKIP;
1164                                 else
1165                                         u8gmode = ENCRYPT_ENABLED | WPA2 | AES;
1166
1167                                 priv->wilc_groupkey = u8gmode;
1168
1169                                 if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1170
1171                                         pu8TxMic = params->key + 24;
1172                                         pu8RxMic = params->key + 16;
1173                                         KeyLen = params->key_len - 16;
1174                                 }
1175                                 /* if there has been previous allocation for the same index through its key, free that memory and allocate again*/
1176                                 if (priv->wilc_gtk[key_index]->key)
1177                                         kfree(priv->wilc_gtk[key_index]->key);
1178
1179                                 priv->wilc_gtk[key_index]->key = kmalloc(params->key_len, GFP_KERNEL);
1180                                 memcpy(priv->wilc_gtk[key_index]->key, params->key, params->key_len);
1181
1182                                 /* if there has been previous allocation for the same index through its seq, free that memory and allocate again*/
1183                                 if (priv->wilc_gtk[key_index]->seq)
1184                                         kfree(priv->wilc_gtk[key_index]->seq);
1185
1186                                 if ((params->seq_len) > 0) {
1187                                         priv->wilc_gtk[key_index]->seq = kmalloc(params->seq_len, GFP_KERNEL);
1188                                         memcpy(priv->wilc_gtk[key_index]->seq, params->seq, params->seq_len);
1189                                 }
1190
1191                                 priv->wilc_gtk[key_index]->cipher = params->cipher;
1192                                 priv->wilc_gtk[key_index]->key_len = params->key_len;
1193                                 priv->wilc_gtk[key_index]->seq_len = params->seq_len;
1194
1195                                 if (INFO) {
1196                                         for (i = 0; i < params->key_len; i++)
1197                                                 PRINT_INFO(CFG80211_DBG, "Adding group key value[%d] = %x\n", i, params->key[i]);
1198                                         for (i = 0; i < params->seq_len; i++)
1199                                                 PRINT_INFO(CFG80211_DBG, "Adding group seq value[%d] = %x\n", i, params->seq[i]);
1200                                 }
1201
1202
1203                                 host_int_add_rx_gtk(priv->hWILCWFIDrv, params->key, KeyLen,
1204                                                     key_index, params->seq_len, params->seq, pu8RxMic, pu8TxMic, AP_MODE, u8gmode);
1205
1206                         } else {
1207                                 PRINT_INFO(CFG80211_DBG, "STA Address: %x%x%x%x%x\n", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4]);
1208
1209                                 if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
1210                                         u8pmode = ENCRYPT_ENABLED | WPA | TKIP;
1211                                 else
1212                                         u8pmode = priv->wilc_groupkey | AES;
1213
1214
1215                                 if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1216
1217                                         pu8TxMic = params->key + 24;
1218                                         pu8RxMic = params->key + 16;
1219                                         KeyLen = params->key_len - 16;
1220                                 }
1221
1222                                 if (priv->wilc_ptk[key_index]->key)
1223                                         kfree(priv->wilc_ptk[key_index]->key);
1224
1225                                 priv->wilc_ptk[key_index]->key = kmalloc(params->key_len, GFP_KERNEL);
1226
1227                                 if (priv->wilc_ptk[key_index]->seq)
1228                                         kfree(priv->wilc_ptk[key_index]->seq);
1229
1230                                 if ((params->seq_len) > 0)
1231                                         priv->wilc_ptk[key_index]->seq = kmalloc(params->seq_len, GFP_KERNEL);
1232
1233                                 if (INFO) {
1234                                         for (i = 0; i < params->key_len; i++)
1235                                                 PRINT_INFO(CFG80211_DBG, "Adding pairwise key value[%d] = %x\n", i, params->key[i]);
1236
1237                                         for (i = 0; i < params->seq_len; i++)
1238                                                 PRINT_INFO(CFG80211_DBG, "Adding group seq value[%d] = %x\n", i, params->seq[i]);
1239                                 }
1240
1241                                 memcpy(priv->wilc_ptk[key_index]->key, params->key, params->key_len);
1242
1243                                 if ((params->seq_len) > 0)
1244                                         memcpy(priv->wilc_ptk[key_index]->seq, params->seq, params->seq_len);
1245
1246                                 priv->wilc_ptk[key_index]->cipher = params->cipher;
1247                                 priv->wilc_ptk[key_index]->key_len = params->key_len;
1248                                 priv->wilc_ptk[key_index]->seq_len = params->seq_len;
1249
1250                                 host_int_add_ptk(priv->hWILCWFIDrv, params->key, KeyLen, mac_addr,
1251                                                  pu8RxMic, pu8TxMic, AP_MODE, u8pmode, key_index);
1252                         }
1253                         break;
1254                 }
1255
1256                 {
1257                         u8mode = 0;
1258                         if (!pairwise) {
1259                                 if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1260                                         /* swap the tx mic by rx mic */
1261                                         pu8RxMic = params->key + 24;
1262                                         pu8TxMic = params->key + 16;
1263                                         KeyLen = params->key_len - 16;
1264                                 }
1265
1266                                 /*save keys only on interface 0 (wifi interface)*/
1267                                 if (!g_gtk_keys_saved && netdev == g_linux_wlan->strInterfaceInfo[0].wilc_netdev) {
1268                                         g_add_gtk_key_params.key_idx = key_index;
1269                                         g_add_gtk_key_params.pairwise = pairwise;
1270                                         if (!mac_addr) {
1271                                                 g_add_gtk_key_params.mac_addr = NULL;
1272                                         } else {
1273                                                 g_add_gtk_key_params.mac_addr = kmalloc(ETH_ALEN, GFP_KERNEL);
1274                                                 memcpy(g_add_gtk_key_params.mac_addr, mac_addr, ETH_ALEN);
1275                                         }
1276                                         g_key_gtk_params.key_len = params->key_len;
1277                                         g_key_gtk_params.seq_len = params->seq_len;
1278                                         g_key_gtk_params.key =  kmalloc(params->key_len, GFP_KERNEL);
1279                                         memcpy(g_key_gtk_params.key, params->key, params->key_len);
1280                                         if (params->seq_len > 0) {
1281                                                 g_key_gtk_params.seq =  kmalloc(params->seq_len, GFP_KERNEL);
1282                                                 memcpy(g_key_gtk_params.seq, params->seq, params->seq_len);
1283                                         }
1284                                         g_key_gtk_params.cipher = params->cipher;
1285
1286                                         PRINT_D(CFG80211_DBG, "key %x %x %x\n", g_key_gtk_params.key[0],
1287                                                 g_key_gtk_params.key[1],
1288                                                 g_key_gtk_params.key[2]);
1289                                         g_gtk_keys_saved = true;
1290                                 }
1291
1292                                 host_int_add_rx_gtk(priv->hWILCWFIDrv, params->key, KeyLen,
1293                                                     key_index, params->seq_len, params->seq, pu8RxMic, pu8TxMic, STATION_MODE, u8mode);
1294                         } else {
1295                                 if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1296                                         /* swap the tx mic by rx mic */
1297                                         pu8RxMic = params->key + 24;
1298                                         pu8TxMic = params->key + 16;
1299                                         KeyLen = params->key_len - 16;
1300                                 }
1301
1302                                 /*save keys only on interface 0 (wifi interface)*/
1303                                 if (!g_ptk_keys_saved && netdev == g_linux_wlan->strInterfaceInfo[0].wilc_netdev) {
1304                                         g_add_ptk_key_params.key_idx = key_index;
1305                                         g_add_ptk_key_params.pairwise = pairwise;
1306                                         if (!mac_addr) {
1307                                                 g_add_ptk_key_params.mac_addr = NULL;
1308                                         } else {
1309                                                 g_add_ptk_key_params.mac_addr = kmalloc(ETH_ALEN, GFP_KERNEL);
1310                                                 memcpy(g_add_ptk_key_params.mac_addr, mac_addr, ETH_ALEN);
1311                                         }
1312                                         g_key_ptk_params.key_len = params->key_len;
1313                                         g_key_ptk_params.seq_len = params->seq_len;
1314                                         g_key_ptk_params.key =  kmalloc(params->key_len, GFP_KERNEL);
1315                                         memcpy(g_key_ptk_params.key, params->key, params->key_len);
1316                                         if (params->seq_len > 0) {
1317                                                 g_key_ptk_params.seq =  kmalloc(params->seq_len, GFP_KERNEL);
1318                                                 memcpy(g_key_ptk_params.seq, params->seq, params->seq_len);
1319                                         }
1320                                         g_key_ptk_params.cipher = params->cipher;
1321
1322                                         PRINT_D(CFG80211_DBG, "key %x %x %x\n", g_key_ptk_params.key[0],
1323                                                 g_key_ptk_params.key[1],
1324                                                 g_key_ptk_params.key[2]);
1325                                         g_ptk_keys_saved = true;
1326                                 }
1327
1328                                 host_int_add_ptk(priv->hWILCWFIDrv, params->key, KeyLen, mac_addr,
1329                                                  pu8RxMic, pu8TxMic, STATION_MODE, u8mode, key_index);
1330                                 PRINT_D(CFG80211_DBG, "Adding pairwise key\n");
1331                                 if (INFO) {
1332                                         for (i = 0; i < params->key_len; i++)
1333                                                 PRINT_INFO(CFG80211_DBG, "Adding pairwise key value[%d] = %d\n", i, params->key[i]);
1334                                 }
1335                         }
1336                 }
1337                 break;
1338
1339         default:
1340                 PRINT_ER("Not supported cipher: Error(%d)\n", s32Error);
1341                 s32Error = -ENOTSUPP;
1342
1343         }
1344
1345         return s32Error;
1346 }
1347
1348 /**
1349  *  @brief      del_key
1350  *  @details    Remove a key given the @mac_addr (%NULL for a group key)
1351  *                      and @key_index, return -ENOENT if the key doesn't exist.
1352  *  @param[in]
1353  *  @return     int : Return 0 on Success
1354  *  @author     mdaftedar
1355  *  @date       01 MAR 2012
1356  *  @version    1.0
1357  */
1358 static int del_key(struct wiphy *wiphy, struct net_device *netdev,
1359                    u8 key_index,
1360                    bool pairwise,
1361                    const u8 *mac_addr)
1362 {
1363         struct wilc_priv *priv;
1364         s32 s32Error = 0;
1365
1366         priv = wiphy_priv(wiphy);
1367
1368         /*delete saved keys, if any*/
1369         if (netdev == g_linux_wlan->strInterfaceInfo[0].wilc_netdev) {
1370                 g_ptk_keys_saved = false;
1371                 g_gtk_keys_saved = false;
1372                 g_wep_keys_saved = false;
1373
1374                 /*Delete saved WEP keys params, if any*/
1375                 if (g_key_wep_params.key != NULL) {
1376                         kfree(g_key_wep_params.key);
1377                         g_key_wep_params.key = NULL;
1378                 }
1379
1380                 /*freeing memory allocated by "wilc_gtk" and "wilc_ptk" in "WILC_WIFI_ADD_KEY"*/
1381
1382                 if ((priv->wilc_gtk[key_index]) != NULL) {
1383
1384                         if (priv->wilc_gtk[key_index]->key != NULL) {
1385
1386                                 kfree(priv->wilc_gtk[key_index]->key);
1387                                 priv->wilc_gtk[key_index]->key = NULL;
1388                         }
1389                         if (priv->wilc_gtk[key_index]->seq) {
1390
1391                                 kfree(priv->wilc_gtk[key_index]->seq);
1392                                 priv->wilc_gtk[key_index]->seq = NULL;
1393                         }
1394
1395                         kfree(priv->wilc_gtk[key_index]);
1396                         priv->wilc_gtk[key_index] = NULL;
1397
1398                 }
1399
1400                 if ((priv->wilc_ptk[key_index]) != NULL) {
1401
1402                         if (priv->wilc_ptk[key_index]->key) {
1403
1404                                 kfree(priv->wilc_ptk[key_index]->key);
1405                                 priv->wilc_ptk[key_index]->key = NULL;
1406                         }
1407                         if (priv->wilc_ptk[key_index]->seq) {
1408
1409                                 kfree(priv->wilc_ptk[key_index]->seq);
1410                                 priv->wilc_ptk[key_index]->seq = NULL;
1411                         }
1412                         kfree(priv->wilc_ptk[key_index]);
1413                         priv->wilc_ptk[key_index] = NULL;
1414                 }
1415
1416                 /*Delete saved PTK and GTK keys params, if any*/
1417                 if (g_key_ptk_params.key != NULL) {
1418                         kfree(g_key_ptk_params.key);
1419                         g_key_ptk_params.key = NULL;
1420                 }
1421                 if (g_key_ptk_params.seq != NULL) {
1422                         kfree(g_key_ptk_params.seq);
1423                         g_key_ptk_params.seq = NULL;
1424                 }
1425
1426                 if (g_key_gtk_params.key != NULL) {
1427                         kfree(g_key_gtk_params.key);
1428                         g_key_gtk_params.key = NULL;
1429                 }
1430                 if (g_key_gtk_params.seq != NULL) {
1431                         kfree(g_key_gtk_params.seq);
1432                         g_key_gtk_params.seq = NULL;
1433                 }
1434
1435                 /*Reset WILC_CHANGING_VIR_IF register to allow adding futrue keys to CE H/W*/
1436                 Set_machw_change_vir_if(false);
1437         }
1438
1439         if (key_index >= 0 && key_index <= 3) {
1440                 memset(priv->WILC_WFI_wep_key[key_index], 0, priv->WILC_WFI_wep_key_len[key_index]);
1441                 priv->WILC_WFI_wep_key_len[key_index] = 0;
1442
1443                 PRINT_D(CFG80211_DBG, "Removing WEP key with index = %d\n", key_index);
1444                 host_int_remove_wep_key(priv->hWILCWFIDrv, key_index);
1445         } else {
1446                 PRINT_D(CFG80211_DBG, "Removing all installed keys\n");
1447                 host_int_remove_key(priv->hWILCWFIDrv, mac_addr);
1448         }
1449
1450         return s32Error;
1451 }
1452
1453 /**
1454  *  @brief      get_key
1455  *  @details    Get information about the key with the given parameters.
1456  *                      @mac_addr will be %NULL when requesting information for a group
1457  *                      key. All pointers given to the @callback function need not be valid
1458  *                      after it returns. This function should return an error if it is
1459  *                      not possible to retrieve the key, -ENOENT if it doesn't exist.
1460  *  @param[in]
1461  *  @return     int : Return 0 on Success
1462  *  @author     mdaftedar
1463  *  @date       01 MAR 2012
1464  *  @version    1.0
1465  */
1466 static int get_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
1467                    bool pairwise,
1468                    const u8 *mac_addr, void *cookie, void (*callback)(void *cookie, struct key_params *))
1469 {
1470
1471         s32 s32Error = 0;
1472
1473         struct wilc_priv *priv;
1474         struct  key_params key_params;
1475         u32 i;
1476
1477         priv = wiphy_priv(wiphy);
1478
1479
1480         if (!pairwise)
1481         {
1482                 PRINT_D(CFG80211_DBG, "Getting group key idx: %x\n", key_index);
1483
1484                 key_params.key = priv->wilc_gtk[key_index]->key;
1485                 key_params.cipher = priv->wilc_gtk[key_index]->cipher;
1486                 key_params.key_len = priv->wilc_gtk[key_index]->key_len;
1487                 key_params.seq = priv->wilc_gtk[key_index]->seq;
1488                 key_params.seq_len = priv->wilc_gtk[key_index]->seq_len;
1489                 if (INFO) {
1490                         for (i = 0; i < key_params.key_len; i++)
1491                                 PRINT_INFO(CFG80211_DBG, "Retrieved key value %x\n", key_params.key[i]);
1492                 }
1493         } else {
1494                 PRINT_D(CFG80211_DBG, "Getting pairwise  key\n");
1495
1496                 key_params.key = priv->wilc_ptk[key_index]->key;
1497                 key_params.cipher = priv->wilc_ptk[key_index]->cipher;
1498                 key_params.key_len = priv->wilc_ptk[key_index]->key_len;
1499                 key_params.seq = priv->wilc_ptk[key_index]->seq;
1500                 key_params.seq_len = priv->wilc_ptk[key_index]->seq_len;
1501         }
1502
1503         callback(cookie, &key_params);
1504
1505         return s32Error;        /* priv->wilc_gtk->key_len ?0 : -ENOENT; */
1506 }
1507
1508 /**
1509  *  @brief      set_default_key
1510  *  @details    Set the default management frame key on an interface
1511  *  @param[in]
1512  *  @return     int : Return 0 on Success.
1513  *  @author     mdaftedar
1514  *  @date       01 MAR 2012
1515  *  @version    1.0
1516  */
1517 static int set_default_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
1518                            bool unicast, bool multicast)
1519 {
1520         s32 s32Error = 0;
1521         struct wilc_priv *priv;
1522
1523
1524         priv = wiphy_priv(wiphy);
1525
1526         PRINT_D(CFG80211_DBG, "Setting default key with idx = %d\n", key_index);
1527
1528         if (key_index != priv->WILC_WFI_wep_default) {
1529
1530                 host_int_set_WEPDefaultKeyID(priv->hWILCWFIDrv, key_index);
1531         }
1532
1533         return s32Error;
1534 }
1535
1536 /**
1537  *  @brief      WILC_WFI_dump_survey
1538  *  @details    Get site survey information
1539  *  @param[in]
1540  *  @return     int : Return 0 on Success.
1541  *  @author     mdaftedar
1542  *  @date       01 MAR 2012
1543  *  @version    1.0
1544  */
1545 static int WILC_WFI_dump_survey(struct wiphy *wiphy, struct net_device *netdev,
1546                                 int idx, struct survey_info *info)
1547 {
1548         s32 s32Error = 0;
1549
1550
1551         if (idx != 0) {
1552                 s32Error = -ENOENT;
1553                 PRINT_ER("Error Idx value doesn't equal zero: Error(%d)\n", s32Error);
1554
1555         }
1556
1557         return s32Error;
1558 }
1559
1560
1561 /**
1562  *  @brief      get_station
1563  *  @details    Get station information for the station identified by @mac
1564  *  @param[in]   NONE
1565  *  @return     int : Return 0 on Success.
1566  *  @author     mdaftedar
1567  *  @date       01 MAR 2012
1568  *  @version    1.0
1569  */
1570
1571 static int get_station(struct wiphy *wiphy, struct net_device *dev,
1572                        const u8 *mac, struct station_info *sinfo)
1573 {
1574         s32 s32Error = 0;
1575         struct wilc_priv *priv;
1576         perInterface_wlan_t *nic;
1577         u32 i = 0;
1578         u32 associatedsta = 0;
1579         u32 inactive_time = 0;
1580         priv = wiphy_priv(wiphy);
1581         nic = netdev_priv(dev);
1582
1583         if (nic->iftype == AP_MODE || nic->iftype == GO_MODE) {
1584                 PRINT_D(HOSTAPD_DBG, "Getting station parameters\n");
1585
1586                 PRINT_INFO(HOSTAPD_DBG, ": %x%x%x%x%x\n", mac[0], mac[1], mac[2], mac[3], mac[4]);
1587
1588                 for (i = 0; i < NUM_STA_ASSOCIATED; i++) {
1589
1590                         if (!(memcmp(mac, priv->assoc_stainfo.au8Sta_AssociatedBss[i], ETH_ALEN))) {
1591                                 associatedsta = i;
1592                                 break;
1593                         }
1594
1595                 }
1596
1597                 if (associatedsta == -1) {
1598                         s32Error = -ENOENT;
1599                         PRINT_ER("Station required is not associated : Error(%d)\n", s32Error);
1600
1601                         return s32Error;
1602                 }
1603
1604                 sinfo->filled |= BIT(NL80211_STA_INFO_INACTIVE_TIME);
1605
1606                 host_int_get_inactive_time(priv->hWILCWFIDrv, mac, &(inactive_time));
1607                 sinfo->inactive_time = 1000 * inactive_time;
1608                 PRINT_D(CFG80211_DBG, "Inactive time %d\n", sinfo->inactive_time);
1609
1610         }
1611
1612         if (nic->iftype == STATION_MODE) {
1613                 tstrStatistics strStatistics;
1614
1615                 host_int_get_statistics(priv->hWILCWFIDrv, &strStatistics);
1616
1617                 sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL) |
1618                                                 BIT(NL80211_STA_INFO_RX_PACKETS) |
1619                                                 BIT(NL80211_STA_INFO_TX_PACKETS) |
1620                                                 BIT(NL80211_STA_INFO_TX_FAILED) |
1621                                                 BIT(NL80211_STA_INFO_TX_BITRATE);
1622
1623                 sinfo->signal           =  strStatistics.s8RSSI;
1624                 sinfo->rx_packets   =  strStatistics.u32RxCount;
1625                 sinfo->tx_packets   =  strStatistics.u32TxCount + strStatistics.u32TxFailureCount;
1626                 sinfo->tx_failed        =  strStatistics.u32TxFailureCount;
1627                 sinfo->txrate.legacy = strStatistics.u8LinkSpeed * 10;
1628
1629                 if ((strStatistics.u8LinkSpeed > TCP_ACK_FILTER_LINK_SPEED_THRESH) && (strStatistics.u8LinkSpeed != DEFAULT_LINK_SPEED))
1630                         Enable_TCP_ACK_Filter(true);
1631                 else if (strStatistics.u8LinkSpeed != DEFAULT_LINK_SPEED)
1632                         Enable_TCP_ACK_Filter(false);
1633
1634                 PRINT_D(CORECONFIG_DBG, "*** stats[%d][%d][%d][%d][%d]\n", sinfo->signal, sinfo->rx_packets, sinfo->tx_packets,
1635                         sinfo->tx_failed, sinfo->txrate.legacy);
1636         }
1637         return s32Error;
1638 }
1639
1640
1641 /**
1642  *  @brief      change_bss
1643  *  @details    Modify parameters for a given BSS.
1644  *  @param[in]
1645  *   -use_cts_prot: Whether to use CTS protection
1646  *          (0 = no, 1 = yes, -1 = do not change)
1647  *  -use_short_preamble: Whether the use of short preambles is allowed
1648  *          (0 = no, 1 = yes, -1 = do not change)
1649  *  -use_short_slot_time: Whether the use of short slot time is allowed
1650  *          (0 = no, 1 = yes, -1 = do not change)
1651  *  -basic_rates: basic rates in IEEE 802.11 format
1652  *          (or NULL for no change)
1653  *  -basic_rates_len: number of basic rates
1654  *  -ap_isolate: do not forward packets between connected stations
1655  *  -ht_opmode: HT Operation mode
1656  *         (u16 = opmode, -1 = do not change)
1657  *  @return     int : Return 0 on Success.
1658  *  @author     mdaftedar
1659  *  @date       01 MAR 2012
1660  *  @version    1.0
1661  */
1662 static int change_bss(struct wiphy *wiphy, struct net_device *dev,
1663                       struct bss_parameters *params)
1664 {
1665         PRINT_D(CFG80211_DBG, "Changing Bss parametrs\n");
1666         return 0;
1667 }
1668
1669 /**
1670  *  @brief      WILC_WFI_auth
1671  *  @details    Request to authenticate with the specified peer
1672  *  @param[in]
1673  *  @return     int : Return 0 on Success.
1674  *  @author     mdaftedar
1675  *  @date       01 MAR 2012
1676  *  @version    1.0
1677  */
1678 static int WILC_WFI_auth(struct wiphy *wiphy, struct net_device *dev,
1679                          struct cfg80211_auth_request *req)
1680 {
1681         PRINT_D(CFG80211_DBG, "In Authentication Function\n");
1682         return 0;
1683 }
1684
1685 /**
1686  *  @brief      WILC_WFI_assoc
1687  *  @details    Request to (re)associate with the specified peer
1688  *  @param[in]
1689  *  @return     int : Return 0 on Success.
1690  *  @author     mdaftedar
1691  *  @date       01 MAR 2012
1692  *  @version    1.0
1693  */
1694 static int WILC_WFI_assoc(struct wiphy *wiphy, struct net_device *dev,
1695                           struct cfg80211_assoc_request *req)
1696 {
1697         PRINT_D(CFG80211_DBG, "In Association Function\n");
1698         return 0;
1699 }
1700
1701 /**
1702  *  @brief      WILC_WFI_deauth
1703  *  @details    Request to deauthenticate from the specified peer
1704  *  @param[in]
1705  *  @return     int : Return 0 on Success.
1706  *  @author     mdaftedar
1707  *  @date       01 MAR 2012
1708  *  @version    1.0
1709  */
1710 static int  WILC_WFI_deauth(struct wiphy *wiphy, struct net_device *dev,
1711                             struct cfg80211_deauth_request *req, void *cookie)
1712 {
1713         PRINT_D(CFG80211_DBG, "In De-authentication Function\n");
1714         return 0;
1715 }
1716
1717 /**
1718  *  @brief      WILC_WFI_disassoc
1719  *  @details    Request to disassociate from the specified peer
1720  *  @param[in]
1721  *  @return     int : Return 0 on Success
1722  *  @author     mdaftedar
1723  *  @date       01 MAR 2012
1724  *  @version    1.0
1725  */
1726 static int  WILC_WFI_disassoc(struct wiphy *wiphy, struct net_device *dev,
1727                               struct cfg80211_disassoc_request *req, void *cookie)
1728 {
1729         PRINT_D(CFG80211_DBG, "In Disassociation Function\n");
1730         return 0;
1731 }
1732
1733 /**
1734  *  @brief      set_wiphy_params
1735  *  @details    Notify that wiphy parameters have changed;
1736  *  @param[in]   Changed bitfield (see &enum wiphy_params_flags) describes which values
1737  *                      have changed.
1738  *  @return     int : Return 0 on Success
1739  *  @author     mdaftedar
1740  *  @date       01 MAR 2012
1741  *  @version    1.0
1742  */
1743 static int set_wiphy_params(struct wiphy *wiphy, u32 changed)
1744 {
1745         s32 s32Error = 0;
1746         tstrCfgParamVal pstrCfgParamVal;
1747         struct wilc_priv *priv;
1748
1749         priv = wiphy_priv(wiphy);
1750
1751         pstrCfgParamVal.u32SetCfgFlag = 0;
1752         PRINT_D(CFG80211_DBG, "Setting Wiphy params\n");
1753
1754         if (changed & WIPHY_PARAM_RETRY_SHORT) {
1755                 PRINT_D(CFG80211_DBG, "Setting WIPHY_PARAM_RETRY_SHORT %d\n",
1756                         priv->dev->ieee80211_ptr->wiphy->retry_short);
1757                 pstrCfgParamVal.u32SetCfgFlag  |= RETRY_SHORT;
1758                 pstrCfgParamVal.short_retry_limit = priv->dev->ieee80211_ptr->wiphy->retry_short;
1759         }
1760         if (changed & WIPHY_PARAM_RETRY_LONG) {
1761
1762                 PRINT_D(CFG80211_DBG, "Setting WIPHY_PARAM_RETRY_LONG %d\n", priv->dev->ieee80211_ptr->wiphy->retry_long);
1763                 pstrCfgParamVal.u32SetCfgFlag |= RETRY_LONG;
1764                 pstrCfgParamVal.long_retry_limit = priv->dev->ieee80211_ptr->wiphy->retry_long;
1765
1766         }
1767         if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
1768                 PRINT_D(CFG80211_DBG, "Setting WIPHY_PARAM_FRAG_THRESHOLD %d\n", priv->dev->ieee80211_ptr->wiphy->frag_threshold);
1769                 pstrCfgParamVal.u32SetCfgFlag |= FRAG_THRESHOLD;
1770                 pstrCfgParamVal.frag_threshold = priv->dev->ieee80211_ptr->wiphy->frag_threshold;
1771
1772         }
1773
1774         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1775                 PRINT_D(CFG80211_DBG, "Setting WIPHY_PARAM_RTS_THRESHOLD %d\n", priv->dev->ieee80211_ptr->wiphy->rts_threshold);
1776
1777                 pstrCfgParamVal.u32SetCfgFlag |= RTS_THRESHOLD;
1778                 pstrCfgParamVal.rts_threshold = priv->dev->ieee80211_ptr->wiphy->rts_threshold;
1779
1780         }
1781
1782         PRINT_D(CFG80211_DBG, "Setting CFG params in the host interface\n");
1783         s32Error = hif_set_cfg(priv->hWILCWFIDrv, &pstrCfgParamVal);
1784         if (s32Error)
1785                 PRINT_ER("Error in setting WIPHY PARAMS\n");
1786
1787
1788         return s32Error;
1789 }
1790
1791 /**
1792  *  @brief      WILC_WFI_set_bitrate_mask
1793  *  @details    set the bitrate mask configuration
1794  *  @param[in]
1795  *  @return     int : Return 0 on Success
1796  *  @author     mdaftedar
1797  *  @date       01 MAR 2012
1798  *  @version    1.0
1799  */
1800 static int WILC_WFI_set_bitrate_mask(struct wiphy *wiphy,
1801                                      struct net_device *dev, const u8 *peer,
1802                                      const struct cfg80211_bitrate_mask *mask)
1803 {
1804         s32 s32Error = 0;
1805
1806         PRINT_D(CFG80211_DBG, "Setting Bitrate mask function\n");
1807         return s32Error;
1808
1809 }
1810
1811 /**
1812  *  @brief      set_pmksa
1813  *  @details    Cache a PMKID for a BSSID. This is mostly useful for fullmac
1814  *                      devices running firmwares capable of generating the (re) association
1815  *                      RSN IE. It allows for faster roaming between WPA2 BSSIDs.
1816  *  @param[in]
1817  *  @return     int : Return 0 on Success
1818  *  @author     mdaftedar
1819  *  @date       01 MAR 2012
1820  *  @version    1.0
1821  */
1822 static int set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1823                      struct cfg80211_pmksa *pmksa)
1824 {
1825         u32 i;
1826         s32 s32Error = 0;
1827         u8 flag = 0;
1828
1829         struct wilc_priv *priv = wiphy_priv(wiphy);
1830
1831         PRINT_D(CFG80211_DBG, "Setting PMKSA\n");
1832
1833
1834         for (i = 0; i < priv->pmkid_list.numpmkid; i++) {
1835                 if (!memcmp(pmksa->bssid, priv->pmkid_list.pmkidlist[i].bssid,
1836                                  ETH_ALEN)) {
1837                         /*If bssid already exists and pmkid value needs to reset*/
1838                         flag = PMKID_FOUND;
1839                         PRINT_D(CFG80211_DBG, "PMKID already exists\n");
1840                         break;
1841                 }
1842         }
1843         if (i < WILC_MAX_NUM_PMKIDS) {
1844                 PRINT_D(CFG80211_DBG, "Setting PMKID in private structure\n");
1845                 memcpy(priv->pmkid_list.pmkidlist[i].bssid, pmksa->bssid,
1846                             ETH_ALEN);
1847                 memcpy(priv->pmkid_list.pmkidlist[i].pmkid, pmksa->pmkid,
1848                             PMKID_LEN);
1849                 if (!(flag == PMKID_FOUND))
1850                         priv->pmkid_list.numpmkid++;
1851         } else {
1852                 PRINT_ER("Invalid PMKID index\n");
1853                 s32Error = -EINVAL;
1854         }
1855
1856         if (!s32Error) {
1857                 PRINT_D(CFG80211_DBG, "Setting pmkid in the host interface\n");
1858                 s32Error = host_int_set_pmkid_info(priv->hWILCWFIDrv, &priv->pmkid_list);
1859         }
1860         return s32Error;
1861 }
1862
1863 /**
1864  *  @brief      del_pmksa
1865  *  @details    Delete a cached PMKID.
1866  *  @param[in]
1867  *  @return     int : Return 0 on Success
1868  *  @author     mdaftedar
1869  *  @date       01 MAR 2012
1870  *  @version    1.0
1871  */
1872 static int del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1873                      struct cfg80211_pmksa *pmksa)
1874 {
1875
1876         u32 i;
1877         u8 flag = 0;
1878         s32 s32Error = 0;
1879
1880         struct wilc_priv *priv = wiphy_priv(wiphy);
1881
1882         PRINT_D(CFG80211_DBG, "Deleting PMKSA keys\n");
1883
1884         for (i = 0; i < priv->pmkid_list.numpmkid; i++) {
1885                 if (!memcmp(pmksa->bssid, priv->pmkid_list.pmkidlist[i].bssid,
1886                                  ETH_ALEN)) {
1887                         /*If bssid is found, reset the values*/
1888                         PRINT_D(CFG80211_DBG, "Reseting PMKID values\n");
1889                         memset(&priv->pmkid_list.pmkidlist[i], 0, sizeof(tstrHostIFpmkid));
1890                         flag = PMKID_FOUND;
1891                         break;
1892                 }
1893         }
1894
1895         if (i < priv->pmkid_list.numpmkid && priv->pmkid_list.numpmkid > 0) {
1896                 for (; i < (priv->pmkid_list.numpmkid - 1); i++) {
1897                         memcpy(priv->pmkid_list.pmkidlist[i].bssid,
1898                                     priv->pmkid_list.pmkidlist[i + 1].bssid,
1899                                     ETH_ALEN);
1900                         memcpy(priv->pmkid_list.pmkidlist[i].pmkid,
1901                                     priv->pmkid_list.pmkidlist[i].pmkid,
1902                                     PMKID_LEN);
1903                 }
1904                 priv->pmkid_list.numpmkid--;
1905         } else {
1906                 s32Error = -EINVAL;
1907         }
1908
1909         return s32Error;
1910 }
1911
1912 /**
1913  *  @brief      flush_pmksa
1914  *  @details    Flush all cached PMKIDs.
1915  *  @param[in]
1916  *  @return     int : Return 0 on Success
1917  *  @author     mdaftedar
1918  *  @date       01 MAR 2012
1919  *  @version    1.0
1920  */
1921 static int flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1922 {
1923         struct wilc_priv *priv = wiphy_priv(wiphy);
1924
1925         PRINT_D(CFG80211_DBG,  "Flushing  PMKID key values\n");
1926
1927         /*Get cashed Pmkids and set all with zeros*/
1928         memset(&priv->pmkid_list, 0, sizeof(tstrHostIFpmkidAttr));
1929
1930         return 0;
1931 }
1932
1933
1934 /**
1935  *  @brief      WILC_WFI_CfgParseRxAction
1936  *  @details Function parses the received  frames and modifies the following attributes:
1937  *                -GO Intent
1938  *                  -Channel list
1939  *                  -Operating Channel
1940  *
1941  *  @param[in] u8* Buffer, u32 length
1942  *  @return     NONE.
1943  *  @author     mdaftedar
1944  *  @date       12 DEC 2012
1945  *  @version
1946  */
1947
1948 void WILC_WFI_CfgParseRxAction(u8 *buf, u32 len)
1949 {
1950         u32 index = 0;
1951         u32 i = 0, j = 0;
1952
1953         u8 op_channel_attr_index = 0;
1954         u8 channel_list_attr_index = 0;
1955
1956         while (index < len) {
1957                 if (buf[index] == GO_INTENT_ATTR_ID) {
1958                         buf[index + 3] = (buf[index + 3]  & 0x01) | (0x00 << 1);
1959                 }
1960
1961                 if (buf[index] ==  CHANLIST_ATTR_ID)
1962                         channel_list_attr_index = index;
1963                 else if (buf[index] ==  OPERCHAN_ATTR_ID)
1964                         op_channel_attr_index = index;
1965                 index += buf[index + 1] + 3; /* ID,Length byte */
1966         }
1967
1968         if (u8WLANChannel != INVALID_CHANNEL)
1969         {
1970                 /*Modify channel list attribute*/
1971                 if (channel_list_attr_index) {
1972                         PRINT_D(GENERIC_DBG, "Modify channel list attribute\n");
1973                         for (i = channel_list_attr_index + 3; i < ((channel_list_attr_index + 3) + buf[channel_list_attr_index + 1]); i++) {
1974                                 if (buf[i] == 0x51) {
1975                                         for (j = i + 2; j < ((i + 2) + buf[i + 1]); j++) {
1976                                                 buf[j] = u8WLANChannel;
1977                                         }
1978                                         break;
1979                                 }
1980                         }
1981                 }
1982                 /*Modify operating channel attribute*/
1983                 if (op_channel_attr_index) {
1984                         PRINT_D(GENERIC_DBG, "Modify operating channel attribute\n");
1985                         buf[op_channel_attr_index + 6] = 0x51;
1986                         buf[op_channel_attr_index + 7] = u8WLANChannel;
1987                 }
1988         }
1989 }
1990
1991 /**
1992  *  @brief      WILC_WFI_CfgParseTxAction
1993  *  @details Function parses the transmitted  action frames and modifies the
1994  *               GO Intent attribute
1995  *  @param[in] u8* Buffer, u32 length, bool bOperChan, u8 iftype
1996  *  @return     NONE.
1997  *  @author     mdaftedar
1998  *  @date       12 DEC 2012
1999  *  @version
2000  */
2001 void WILC_WFI_CfgParseTxAction(u8 *buf, u32 len, bool bOperChan, u8 iftype)
2002 {
2003         u32 index = 0;
2004         u32 i = 0, j = 0;
2005
2006         u8 op_channel_attr_index = 0;
2007         u8 channel_list_attr_index = 0;
2008
2009         while (index < len) {
2010                 if (buf[index] == GO_INTENT_ATTR_ID) {
2011                         buf[index + 3] = (buf[index + 3]  & 0x01) | (0x0f << 1);
2012
2013                         break;
2014                 }
2015
2016                 if (buf[index] ==  CHANLIST_ATTR_ID)
2017                         channel_list_attr_index = index;
2018                 else if (buf[index] ==  OPERCHAN_ATTR_ID)
2019                         op_channel_attr_index = index;
2020                 index += buf[index + 1] + 3; /* ID,Length byte */
2021         }
2022
2023         if (u8WLANChannel != INVALID_CHANNEL && bOperChan)
2024         {
2025                 /*Modify channel list attribute*/
2026                 if (channel_list_attr_index) {
2027                         PRINT_D(GENERIC_DBG, "Modify channel list attribute\n");
2028                         for (i = channel_list_attr_index + 3; i < ((channel_list_attr_index + 3) + buf[channel_list_attr_index + 1]); i++) {
2029                                 if (buf[i] == 0x51) {
2030                                         for (j = i + 2; j < ((i + 2) + buf[i + 1]); j++) {
2031                                                 buf[j] = u8WLANChannel;
2032                                         }
2033                                         break;
2034                                 }
2035                         }
2036                 }
2037                 /*Modify operating channel attribute*/
2038                 if (op_channel_attr_index) {
2039                         PRINT_D(GENERIC_DBG, "Modify operating channel attribute\n");
2040                         buf[op_channel_attr_index + 6] = 0x51;
2041                         buf[op_channel_attr_index + 7] = u8WLANChannel;
2042                 }
2043         }
2044 }
2045
2046 /*  @brief                       WILC_WFI_p2p_rx
2047  *  @details
2048  *  @param[in]
2049  *
2050  *  @return             None
2051  *  @author             Mai Daftedar
2052  *  @date                       2 JUN 2013
2053  *  @version            1.0
2054  */
2055
2056 void WILC_WFI_p2p_rx (struct net_device *dev, u8 *buff, u32 size)
2057 {
2058
2059         struct wilc_priv *priv;
2060         u32 header, pkt_offset;
2061         tstrWILC_WFIDrv *pstrWFIDrv;
2062         u32 i = 0;
2063         s32 s32Freq;
2064
2065         priv = wiphy_priv(dev->ieee80211_ptr->wiphy);
2066         pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
2067
2068         /* Get WILC header */
2069         memcpy(&header, (buff - HOST_HDR_OFFSET), HOST_HDR_OFFSET);
2070
2071         /* The packet offset field conain info about what type of managment frame */
2072         /* we are dealing with and ack status */
2073         pkt_offset = GET_PKT_OFFSET(header);
2074
2075         if (pkt_offset & IS_MANAGMEMENT_CALLBACK) {
2076                 if (buff[FRAME_TYPE_ID] == IEEE80211_STYPE_PROBE_RESP) {
2077                         PRINT_D(GENERIC_DBG, "Probe response ACK\n");
2078                         cfg80211_mgmt_tx_status(priv->wdev, priv->u64tx_cookie, buff, size, true, GFP_KERNEL);
2079                         return;
2080                 } else {
2081                         if (pkt_offset & IS_MGMT_STATUS_SUCCES) {
2082                                 PRINT_D(GENERIC_DBG, "Success Ack - Action frame category: %x Action Subtype: %d Dialog T: %x OR %x\n", buff[ACTION_CAT_ID], buff[ACTION_SUBTYPE_ID],
2083                                         buff[ACTION_SUBTYPE_ID + 1], buff[P2P_PUB_ACTION_SUBTYPE + 1]);
2084                                 cfg80211_mgmt_tx_status(priv->wdev, priv->u64tx_cookie, buff, size, true, GFP_KERNEL);
2085                         } else {
2086                                 PRINT_D(GENERIC_DBG, "Fail Ack - Action frame category: %x Action Subtype: %d Dialog T: %x OR %x\n", buff[ACTION_CAT_ID], buff[ACTION_SUBTYPE_ID],
2087                                         buff[ACTION_SUBTYPE_ID + 1], buff[P2P_PUB_ACTION_SUBTYPE + 1]);
2088                                 cfg80211_mgmt_tx_status(priv->wdev, priv->u64tx_cookie, buff, size, false, GFP_KERNEL);
2089                         }
2090                         return;
2091                 }
2092         } else {
2093
2094                 PRINT_D(GENERIC_DBG, "Rx Frame Type:%x\n", buff[FRAME_TYPE_ID]);
2095
2096                 /*Upper layer is informed that the frame is received on this freq*/
2097                 s32Freq = ieee80211_channel_to_frequency(u8CurrChannel, IEEE80211_BAND_2GHZ);
2098
2099                 if (ieee80211_is_action(buff[FRAME_TYPE_ID])) {
2100                         PRINT_D(GENERIC_DBG, "Rx Action Frame Type: %x %x\n", buff[ACTION_SUBTYPE_ID], buff[P2P_PUB_ACTION_SUBTYPE]);
2101
2102                         if (priv->bCfgScanning == true && time_after_eq(jiffies, (unsigned long)pstrWFIDrv->u64P2p_MgmtTimeout)) {
2103                                 PRINT_D(GENERIC_DBG, "Receiving action frames from wrong channels\n");
2104                                 return;
2105                         }
2106                         if (buff[ACTION_CAT_ID] == PUB_ACTION_ATTR_ID) {
2107
2108                                 switch (buff[ACTION_SUBTYPE_ID]) {
2109                                 case GAS_INTIAL_REQ:
2110                                         PRINT_D(GENERIC_DBG, "GAS INITIAL REQ %x\n", buff[ACTION_SUBTYPE_ID]);
2111                                         break;
2112
2113                                 case GAS_INTIAL_RSP:
2114                                         PRINT_D(GENERIC_DBG, "GAS INITIAL RSP %x\n", buff[ACTION_SUBTYPE_ID]);
2115                                         break;
2116
2117                                 case PUBLIC_ACT_VENDORSPEC:
2118                                         /*Now we have a public action vendor specific action frame, check if its a p2p public action frame
2119                                          * based on the standard its should have the p2p_oui attribute with the following values 50 6f 9A 09*/
2120                                         if (!memcmp(u8P2P_oui, &buff[ACTION_SUBTYPE_ID + 1], 4)) {
2121                                                 if ((buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP)) {
2122                                                         if (!bWilc_ie) {
2123                                                                 for (i = P2P_PUB_ACTION_SUBTYPE; i < size; i++) {
2124                                                                         if (!memcmp(u8P2P_vendorspec, &buff[i], 6)) {
2125                                                                                 u8P2Precvrandom = buff[i + 6];
2126                                                                                 bWilc_ie = true;
2127                                                                                 PRINT_D(GENERIC_DBG, "WILC Vendor specific IE:%02x\n", u8P2Precvrandom);
2128                                                                                 break;
2129                                                                         }
2130                                                                 }
2131                                                         }
2132                                                 }
2133                                                 if (u8P2Plocalrandom > u8P2Precvrandom) {
2134                                                         if ((buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP
2135                                                               || buff[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_REQ || buff[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_RSP)) {
2136                                                                 for (i = P2P_PUB_ACTION_SUBTYPE + 2; i < size; i++) {
2137                                                                         if (buff[i] == P2PELEM_ATTR_ID && !(memcmp(u8P2P_oui, &buff[i + 2], 4))) {
2138                                                                                 WILC_WFI_CfgParseRxAction(&buff[i + 6], size - (i + 6));
2139                                                                                 break;
2140                                                                         }
2141                                                                 }
2142                                                         }
2143                                                 } else
2144                                                         PRINT_D(GENERIC_DBG, "PEER WILL BE GO LocaRand=%02x RecvRand %02x\n", u8P2Plocalrandom, u8P2Precvrandom);
2145                                         }
2146
2147
2148                                         if ((buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP) && (bWilc_ie))   {
2149                                                 PRINT_D(GENERIC_DBG, "Sending P2P to host without extra elemnt\n");
2150                                                 /* extra attribute for sig_dbm: signal strength in mBm, or 0 if unknown */
2151                                                 cfg80211_rx_mgmt(priv->wdev, s32Freq, 0, buff, size - 7, 0);
2152                                                 return;
2153                                         }
2154                                         break;
2155
2156                                 default:
2157                                         PRINT_D(GENERIC_DBG, "NOT HANDLED PUBLIC ACTION FRAME TYPE:%x\n", buff[ACTION_SUBTYPE_ID]);
2158                                         break;
2159                                 }
2160                         }
2161                 }
2162
2163                 cfg80211_rx_mgmt(priv->wdev, s32Freq, 0, buff, size - 7, 0);
2164         }
2165 }
2166
2167 /**
2168  *  @brief                      WILC_WFI_mgmt_tx_complete
2169  *  @details            Returns result of writing mgmt frame to VMM (Tx buffers are freed here)
2170  *  @param[in]          priv
2171  *                              transmitting status
2172  *  @return             None
2173  *  @author             Amr Abdelmoghny
2174  *  @date                       20 MAY 2013
2175  *  @version            1.0
2176  */
2177 static void WILC_WFI_mgmt_tx_complete(void *priv, int status)
2178 {
2179         struct p2p_mgmt_data *pv_data = (struct p2p_mgmt_data *)priv;
2180
2181
2182         kfree(pv_data->buff);
2183         kfree(pv_data);
2184 }
2185
2186 /**
2187  * @brief               WILC_WFI_RemainOnChannelReady
2188  *  @details    Callback function, called from handle_remain_on_channel on being ready on channel
2189  *  @param
2190  *  @return     none
2191  *  @author     Amr abdelmoghny
2192  *  @date               9 JUNE 2013
2193  *  @version
2194  */
2195
2196 static void WILC_WFI_RemainOnChannelReady(void *pUserVoid)
2197 {
2198         struct wilc_priv *priv;
2199
2200         priv = (struct wilc_priv *)pUserVoid;
2201
2202         PRINT_D(HOSTINF_DBG, "Remain on channel ready\n");
2203
2204         priv->bInP2PlistenState = true;
2205
2206         cfg80211_ready_on_channel(priv->wdev,
2207                                   priv->strRemainOnChanParams.u64ListenCookie,
2208                                   priv->strRemainOnChanParams.pstrListenChan,
2209                                   priv->strRemainOnChanParams.u32ListenDuration,
2210                                   GFP_KERNEL);
2211 }
2212
2213 /**
2214  * @brief               WILC_WFI_RemainOnChannelExpired
2215  *  @details    Callback function, called on expiration of remain-on-channel duration
2216  *  @param
2217  *  @return     none
2218  *  @author     Amr abdelmoghny
2219  *  @date               15 MAY 2013
2220  *  @version
2221  */
2222
2223 static void WILC_WFI_RemainOnChannelExpired(void *pUserVoid, u32 u32SessionID)
2224 {
2225         struct wilc_priv *priv;
2226
2227         priv = (struct wilc_priv *)pUserVoid;
2228
2229         if (u32SessionID == priv->strRemainOnChanParams.u32ListenSessionID) {
2230                 PRINT_D(GENERIC_DBG, "Remain on channel expired\n");
2231
2232                 priv->bInP2PlistenState = false;
2233
2234                 /*Inform wpas of remain-on-channel expiration*/
2235                 cfg80211_remain_on_channel_expired(priv->wdev,
2236                                                    priv->strRemainOnChanParams.u64ListenCookie,
2237                                                    priv->strRemainOnChanParams.pstrListenChan,
2238                                                    GFP_KERNEL);
2239         } else {
2240                 PRINT_D(GENERIC_DBG, "Received ID 0x%x Expected ID 0x%x (No match)\n", u32SessionID
2241                         , priv->strRemainOnChanParams.u32ListenSessionID);
2242         }
2243 }
2244
2245
2246 /**
2247  *  @brief      remain_on_channel
2248  *  @details    Request the driver to remain awake on the specified
2249  *                      channel for the specified duration to complete an off-channel
2250  *                      operation (e.g., public action frame exchange). When the driver is
2251  *                      ready on the requested channel, it must indicate this with an event
2252  *                      notification by calling cfg80211_ready_on_channel().
2253  *  @param[in]
2254  *  @return     int : Return 0 on Success
2255  *  @author     mdaftedar
2256  *  @date       01 MAR 2012
2257  *  @version    1.0
2258  */
2259 static int remain_on_channel(struct wiphy *wiphy,
2260                              struct wireless_dev *wdev,
2261                              struct ieee80211_channel *chan,
2262                              unsigned int duration, u64 *cookie)
2263 {
2264         s32 s32Error = 0;
2265         struct wilc_priv *priv;
2266
2267         priv = wiphy_priv(wiphy);
2268
2269         PRINT_D(GENERIC_DBG, "Remaining on channel %d\n", chan->hw_value);
2270
2271
2272         if (wdev->iftype == NL80211_IFTYPE_AP) {
2273                 PRINT_D(GENERIC_DBG, "Required remain-on-channel while in AP mode");
2274                 return s32Error;
2275         }
2276
2277         u8CurrChannel = chan->hw_value;
2278
2279         /*Setting params needed by WILC_WFI_RemainOnChannelExpired()*/
2280         priv->strRemainOnChanParams.pstrListenChan = chan;
2281         priv->strRemainOnChanParams.u64ListenCookie = *cookie;
2282         priv->strRemainOnChanParams.u32ListenDuration = duration;
2283         priv->strRemainOnChanParams.u32ListenSessionID++;
2284
2285         s32Error = host_int_remain_on_channel(priv->hWILCWFIDrv
2286                                               , priv->strRemainOnChanParams.u32ListenSessionID
2287                                               , duration
2288                                               , chan->hw_value
2289                                               , WILC_WFI_RemainOnChannelExpired
2290                                               , WILC_WFI_RemainOnChannelReady
2291                                               , (void *)priv);
2292
2293         return s32Error;
2294 }
2295
2296 /**
2297  *  @brief      cancel_remain_on_channel
2298  *  @details    Cancel an on-going remain-on-channel operation.
2299  *                      This allows the operation to be terminated prior to timeout based on
2300  *                      the duration value.
2301  *  @param[in]   struct wiphy *wiphy,
2302  *  @param[in]  struct net_device *dev
2303  *  @param[in]  u64 cookie,
2304  *  @return     int : Return 0 on Success
2305  *  @author     mdaftedar
2306  *  @date       01 MAR 2012
2307  *  @version    1.0
2308  */
2309 static int cancel_remain_on_channel(struct wiphy *wiphy,
2310                                     struct wireless_dev *wdev,
2311                                     u64 cookie)
2312 {
2313         s32 s32Error = 0;
2314         struct wilc_priv *priv;
2315
2316         priv = wiphy_priv(wiphy);
2317
2318         PRINT_D(CFG80211_DBG, "Cancel remain on channel\n");
2319
2320         s32Error = host_int_ListenStateExpired(priv->hWILCWFIDrv, priv->strRemainOnChanParams.u32ListenSessionID);
2321         return s32Error;
2322 }
2323 /**
2324  *  @brief       WILC_WFI_add_wilcvendorspec
2325  *  @details    Adding WILC information elemet to allow two WILC devices to
2326  *                              identify each other and connect
2327  *  @param[in]   u8 * buf
2328  *  @return     void
2329  *  @author     mdaftedar
2330  *  @date       01 JAN 2014
2331  *  @version    1.0
2332  */
2333 void WILC_WFI_add_wilcvendorspec(u8 *buff)
2334 {
2335         memcpy(buff, u8P2P_vendorspec, sizeof(u8P2P_vendorspec));
2336 }
2337 /**
2338  *  @brief      WILC_WFI_mgmt_tx_frame
2339  *  @details
2340  *
2341  *  @param[in]
2342  *  @return     NONE.
2343  *  @author     mdaftedar
2344  *  @date       01 JUL 2012
2345  *  @version
2346  */
2347 extern linux_wlan_t *g_linux_wlan;
2348 extern bool bEnablePS;
2349 static int mgmt_tx(struct wiphy *wiphy,
2350                    struct wireless_dev *wdev,
2351                    struct cfg80211_mgmt_tx_params *params,
2352                    u64 *cookie)
2353 {
2354         struct ieee80211_channel *chan = params->chan;
2355         unsigned int wait = params->wait;
2356         const u8 *buf = params->buf;
2357         size_t len = params->len;
2358         const struct ieee80211_mgmt *mgmt;
2359         struct p2p_mgmt_data *mgmt_tx;
2360         struct wilc_priv *priv;
2361         s32 s32Error = 0;
2362         tstrWILC_WFIDrv *pstrWFIDrv;
2363         u32 i;
2364         perInterface_wlan_t *nic;
2365         u32 buf_len = len + sizeof(u8P2P_vendorspec) + sizeof(u8P2Plocalrandom);
2366
2367         nic = netdev_priv(wdev->netdev);
2368         priv = wiphy_priv(wiphy);
2369         pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
2370
2371         *cookie = (unsigned long)buf;
2372         priv->u64tx_cookie = *cookie;
2373         mgmt = (const struct ieee80211_mgmt *) buf;
2374
2375         if (ieee80211_is_mgmt(mgmt->frame_control)) {
2376
2377                 /*mgmt frame allocation*/
2378                 mgmt_tx = kmalloc(sizeof(struct p2p_mgmt_data), GFP_KERNEL);
2379                 if (mgmt_tx == NULL) {
2380                         PRINT_ER("Failed to allocate memory for mgmt_tx structure\n");
2381                         return -EFAULT;
2382                 }
2383                 mgmt_tx->buff = kmalloc(buf_len, GFP_KERNEL);
2384                 if (mgmt_tx->buff == NULL) {
2385                         PRINT_ER("Failed to allocate memory for mgmt_tx buff\n");
2386                         kfree(mgmt_tx);
2387                         return -EFAULT;
2388                 }
2389                 memcpy(mgmt_tx->buff, buf, len);
2390                 mgmt_tx->size = len;
2391
2392
2393                 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
2394                         PRINT_D(GENERIC_DBG, "TX: Probe Response\n");
2395                         PRINT_D(GENERIC_DBG, "Setting channel: %d\n", chan->hw_value);
2396                         host_int_set_mac_chnl_num(priv->hWILCWFIDrv, chan->hw_value);
2397                         /*Save the current channel after we tune to it*/
2398                         u8CurrChannel = chan->hw_value;
2399                 } else if (ieee80211_is_action(mgmt->frame_control))   {
2400                         PRINT_D(GENERIC_DBG, "ACTION FRAME:%x\n", (u16)mgmt->frame_control);
2401
2402
2403                         if (buf[ACTION_CAT_ID] == PUB_ACTION_ATTR_ID) {
2404                                 /*Only set the channel, if not a negotiation confirmation frame
2405                                  * (If Negotiation confirmation frame, force it
2406                                  * to be transmitted on the same negotiation channel)*/
2407
2408                                 if (buf[ACTION_SUBTYPE_ID] != PUBLIC_ACT_VENDORSPEC ||
2409                                     buf[P2P_PUB_ACTION_SUBTYPE] != GO_NEG_CONF) {
2410                                         PRINT_D(GENERIC_DBG, "Setting channel: %d\n", chan->hw_value);
2411                                         host_int_set_mac_chnl_num(priv->hWILCWFIDrv, chan->hw_value);
2412                                         /*Save the current channel after we tune to it*/
2413                                         u8CurrChannel = chan->hw_value;
2414                                 }
2415                                 switch (buf[ACTION_SUBTYPE_ID]) {
2416                                 case GAS_INTIAL_REQ:
2417                                 {
2418                                         PRINT_D(GENERIC_DBG, "GAS INITIAL REQ %x\n", buf[ACTION_SUBTYPE_ID]);
2419                                         break;
2420                                 }
2421
2422                                 case GAS_INTIAL_RSP:
2423                                 {
2424                                         PRINT_D(GENERIC_DBG, "GAS INITIAL RSP %x\n", buf[ACTION_SUBTYPE_ID]);
2425                                         break;
2426                                 }
2427
2428                                 case PUBLIC_ACT_VENDORSPEC:
2429                                 {
2430                                         /*Now we have a public action vendor specific action frame, check if its a p2p public action frame
2431                                          * based on the standard its should have the p2p_oui attribute with the following values 50 6f 9A 09*/
2432                                         if (!memcmp(u8P2P_oui, &buf[ACTION_SUBTYPE_ID + 1], 4)) {
2433                                                 /*For the connection of two WILC's connection generate a rand number to determine who will be a GO*/
2434                                                 if ((buf[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP)) {
2435                                                         if (u8P2Plocalrandom == 1 && u8P2Precvrandom < u8P2Plocalrandom) {
2436                                                                 get_random_bytes(&u8P2Plocalrandom, 1);
2437                                                                 /*Increment the number to prevent if its 0*/
2438                                                                 u8P2Plocalrandom++;
2439                                                         }
2440                                                 }
2441
2442                                                 if ((buf[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP
2443                                                       || buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_RSP)) {
2444                                                         if (u8P2Plocalrandom > u8P2Precvrandom) {
2445                                                                 PRINT_D(GENERIC_DBG, "LOCAL WILL BE GO LocaRand=%02x RecvRand %02x\n", u8P2Plocalrandom, u8P2Precvrandom);
2446
2447                                                                 /*Search for the p2p information information element , after the Public action subtype theres a byte for teh dialog token, skip that*/
2448                                                                 for (i = P2P_PUB_ACTION_SUBTYPE + 2; i < len; i++) {
2449                                                                         if (buf[i] == P2PELEM_ATTR_ID && !(memcmp(u8P2P_oui, &buf[i + 2], 4))) {
2450                                                                                 if (buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_RSP)
2451                                                                                         WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), true, nic->iftype);
2452
2453                                                                                 /*If using supplicant go intent, no need at all*/
2454                                                                                 /*to parse transmitted negotiation frames*/
2455                                                                                 else
2456                                                                                         WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), false, nic->iftype);
2457                                                                                 break;
2458                                                                         }
2459                                                                 }
2460
2461                                                                 if (buf[P2P_PUB_ACTION_SUBTYPE] != P2P_INV_REQ && buf[P2P_PUB_ACTION_SUBTYPE] != P2P_INV_RSP) {
2462                                                                         WILC_WFI_add_wilcvendorspec(&mgmt_tx->buff[len]);
2463                                                                         mgmt_tx->buff[len + sizeof(u8P2P_vendorspec)] = u8P2Plocalrandom;
2464                                                                         mgmt_tx->size = buf_len;
2465                                                                 }
2466                                                         } else
2467                                                                 PRINT_D(GENERIC_DBG, "PEER WILL BE GO LocaRand=%02x RecvRand %02x\n", u8P2Plocalrandom, u8P2Precvrandom);
2468                                                 }
2469
2470                                         } else {
2471                                                 PRINT_D(GENERIC_DBG, "Not a P2P public action frame\n");
2472                                         }
2473
2474                                         break;
2475                                 }
2476
2477                                 default:
2478                                 {
2479                                         PRINT_D(GENERIC_DBG, "NOT HANDLED PUBLIC ACTION FRAME TYPE:%x\n", buf[ACTION_SUBTYPE_ID]);
2480                                         break;
2481                                 }
2482                                 }
2483
2484                         }
2485
2486                         PRINT_D(GENERIC_DBG, "TX: ACTION FRAME Type:%x : Chan:%d\n", buf[ACTION_SUBTYPE_ID], chan->hw_value);
2487                         pstrWFIDrv->u64P2p_MgmtTimeout = (jiffies + msecs_to_jiffies(wait));
2488
2489                         PRINT_D(GENERIC_DBG, "Current Jiffies: %lu Timeout:%llu\n", jiffies, pstrWFIDrv->u64P2p_MgmtTimeout);
2490
2491                 }
2492
2493                 wilc_wlan_txq_add_mgmt_pkt(mgmt_tx, mgmt_tx->buff,
2494                                            mgmt_tx->size,
2495                                            WILC_WFI_mgmt_tx_complete);
2496         } else {
2497                 PRINT_D(GENERIC_DBG, "This function transmits only management frames\n");
2498         }
2499         return s32Error;
2500 }
2501
2502 static int mgmt_tx_cancel_wait(struct wiphy *wiphy,
2503                                struct wireless_dev *wdev,
2504                                u64 cookie)
2505 {
2506         struct wilc_priv *priv;
2507         tstrWILC_WFIDrv *pstrWFIDrv;
2508
2509         priv = wiphy_priv(wiphy);
2510         pstrWFIDrv = (tstrWILC_WFIDrv *)priv->hWILCWFIDrv;
2511
2512
2513         PRINT_D(GENERIC_DBG, "Tx Cancel wait :%lu\n", jiffies);
2514         pstrWFIDrv->u64P2p_MgmtTimeout = jiffies;
2515
2516         if (priv->bInP2PlistenState == false) {
2517                 cfg80211_remain_on_channel_expired(priv->wdev,
2518                                                    priv->strRemainOnChanParams.u64ListenCookie,
2519                                                    priv->strRemainOnChanParams.pstrListenChan,
2520                                                    GFP_KERNEL);
2521         }
2522
2523         return 0;
2524 }
2525
2526 /**
2527  *  @brief      wilc_mgmt_frame_register
2528  *  @details Notify driver that a management frame type was
2529  *              registered. Note that this callback may not sleep, and cannot run
2530  *                      concurrently with itself.
2531  *  @param[in]
2532  *  @return     NONE.
2533  *  @author     mdaftedar
2534  *  @date       01 JUL 2012
2535  *  @version
2536  */
2537 void wilc_mgmt_frame_register(struct wiphy *wiphy, struct wireless_dev *wdev,
2538                               u16 frame_type, bool reg)
2539 {
2540
2541         struct wilc_priv *priv;
2542         perInterface_wlan_t *nic;
2543
2544
2545         priv = wiphy_priv(wiphy);
2546         nic = netdev_priv(priv->wdev->netdev);
2547
2548
2549
2550         if (!frame_type)
2551                 return;
2552
2553         PRINT_D(GENERIC_DBG, "Frame registering Frame Type: %x: Boolean: %d\n", frame_type, reg);
2554         switch (frame_type) {
2555         case PROBE_REQ:
2556         {
2557                 nic->g_struct_frame_reg[0].frame_type = frame_type;
2558                 nic->g_struct_frame_reg[0].reg = reg;
2559         }
2560         break;
2561
2562         case ACTION:
2563         {
2564                 nic->g_struct_frame_reg[1].frame_type = frame_type;
2565                 nic->g_struct_frame_reg[1].reg = reg;
2566         }
2567         break;
2568
2569         default:
2570         {
2571                 break;
2572         }
2573
2574         }
2575         /*If mac is closed, then return*/
2576         if (!g_linux_wlan->wilc1000_initialized) {
2577                 PRINT_D(GENERIC_DBG, "Return since mac is closed\n");
2578                 return;
2579         }
2580         host_int_frame_register(priv->hWILCWFIDrv, frame_type, reg);
2581
2582
2583 }
2584
2585 /**
2586  *  @brief      set_cqm_rssi_config
2587  *  @details    Configure connection quality monitor RSSI threshold.
2588  *  @param[in]   struct wiphy *wiphy:
2589  *  @param[in]  struct net_device *dev:
2590  *  @param[in]          s32 rssi_thold:
2591  *  @param[in]  u32 rssi_hyst:
2592  *  @return     int : Return 0 on Success
2593  *  @author     mdaftedar
2594  *  @date       01 MAR 2012
2595  *  @version    1.0
2596  */
2597 static int set_cqm_rssi_config(struct wiphy *wiphy, struct net_device *dev,
2598                                s32 rssi_thold, u32 rssi_hyst)
2599 {
2600         PRINT_D(CFG80211_DBG, "Setting CQM RSSi Function\n");
2601         return 0;
2602
2603 }
2604 /**
2605  *  @brief      dump_station
2606  *  @details    Configure connection quality monitor RSSI threshold.
2607  *  @param[in]   struct wiphy *wiphy:
2608  *  @param[in]  struct net_device *dev
2609  *  @param[in]          int idx
2610  *  @param[in]  u8 *mac
2611  *  @param[in]  struct station_info *sinfo
2612  *  @return     int : Return 0 on Success
2613  *  @author     mdaftedar
2614  *  @date       01 MAR 2012
2615  *  @version    1.0
2616  */
2617 static int dump_station(struct wiphy *wiphy, struct net_device *dev,
2618                         int idx, u8 *mac, struct station_info *sinfo)
2619 {
2620         struct wilc_priv *priv;
2621
2622         PRINT_D(CFG80211_DBG, "Dumping station information\n");
2623
2624         if (idx != 0)
2625                 return -ENOENT;
2626
2627         priv = wiphy_priv(wiphy);
2628
2629         sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
2630
2631         host_int_get_rssi(priv->hWILCWFIDrv, &(sinfo->signal));
2632
2633         return 0;
2634
2635 }
2636
2637
2638 /**
2639  *  @brief      set_power_mgmt
2640  *  @details
2641  *  @param[in]
2642  *  @return     int : Return 0 on Success.
2643  *  @author     mdaftedar
2644  *  @date       01 JUL 2012
2645  *  @version    1.0
2646  */
2647 static int set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
2648                           bool enabled, int timeout)
2649 {
2650         struct wilc_priv *priv;
2651
2652         PRINT_D(CFG80211_DBG, " Power save Enabled= %d , TimeOut = %d\n", enabled, timeout);
2653
2654         if (wiphy == NULL)
2655                 return -ENOENT;
2656
2657         priv = wiphy_priv(wiphy);
2658         if (priv->hWILCWFIDrv == NULL) {
2659                 PRINT_ER("Driver is NULL\n");
2660                 return -EIO;
2661         }
2662
2663         if (bEnablePS)
2664                 host_int_set_power_mgmt(priv->hWILCWFIDrv, enabled, timeout);
2665
2666
2667         return 0;
2668
2669 }
2670
2671 /**
2672  *  @brief      change_virtual_intf
2673  *  @details    Change type/configuration of virtual interface,
2674  *                      keep the struct wireless_dev's iftype updated.
2675  *  @param[in]   NONE
2676  *  @return     int : Return 0 on Success.
2677  *  @author     mdaftedar
2678  *  @date       01 MAR 2012
2679  *  @version    1.0
2680  */
2681 void wilc1000_wlan_deinit(linux_wlan_t *nic);
2682 int wilc1000_wlan_init(struct net_device *dev, perInterface_wlan_t *p_nic);
2683
2684 static int change_virtual_intf(struct wiphy *wiphy, struct net_device *dev,
2685                                enum nl80211_iftype type, u32 *flags, struct vif_params *params)
2686 {
2687         s32 s32Error = 0;
2688         struct wilc_priv *priv;
2689         perInterface_wlan_t *nic;
2690         u8 interface_type;
2691         u16 TID = 0;
2692         u8 i;
2693
2694         nic = netdev_priv(dev);
2695         priv = wiphy_priv(wiphy);
2696
2697         PRINT_D(HOSTAPD_DBG, "In Change virtual interface function\n");
2698         PRINT_D(HOSTAPD_DBG, "Wireless interface name =%s\n", dev->name);
2699         u8P2Plocalrandom = 0x01;
2700         u8P2Precvrandom = 0x00;
2701
2702         bWilc_ie = false;
2703
2704         g_obtainingIP = false;
2705         del_timer(&hDuringIpTimer);
2706         PRINT_D(GENERIC_DBG, "Changing virtual interface, enable scan\n");
2707         /*Set WILC_CHANGING_VIR_IF register to disallow adding futrue keys to CE H/W*/
2708         if (g_ptk_keys_saved && g_gtk_keys_saved) {
2709                 Set_machw_change_vir_if(true);
2710         }
2711
2712         switch (type) {
2713         case NL80211_IFTYPE_STATION:
2714                 connecting = 0;
2715                 PRINT_D(HOSTAPD_DBG, "Interface type = NL80211_IFTYPE_STATION\n");
2716
2717                 /* send delba over wlan interface */
2718
2719
2720                 dev->ieee80211_ptr->iftype = type;
2721                 priv->wdev->iftype = type;
2722                 nic->monitor_flag = 0;
2723                 nic->iftype = STATION_MODE;
2724
2725                 /*Remove the enteries of the previously connected clients*/
2726                 memset(priv->assoc_stainfo.au8Sta_AssociatedBss, 0, MAX_NUM_STA * ETH_ALEN);
2727                 interface_type = nic->iftype;
2728                 nic->iftype = STATION_MODE;
2729
2730                 if (g_linux_wlan->wilc1000_initialized) {
2731                         host_int_del_All_Rx_BASession(priv->hWILCWFIDrv, g_linux_wlan->strInterfaceInfo[0].aBSSID, TID);
2732                         /* ensure that the message Q is empty */
2733                         host_int_wait_msg_queue_idle();
2734
2735                         /*Eliminate host interface blocking state*/
2736                         up(&g_linux_wlan->cfg_event);
2737
2738                         wilc1000_wlan_deinit(g_linux_wlan);
2739                         wilc1000_wlan_init(dev, nic);
2740                         g_wilc_initialized = 1;
2741                         nic->iftype = interface_type;
2742
2743                         /*Setting interface 1 drv handler and mac address in newly downloaded FW*/
2744                         host_int_set_wfi_drv_handler(g_linux_wlan->strInterfaceInfo[0].drvHandler);
2745                         host_int_set_MacAddress(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2746                                                 g_linux_wlan->strInterfaceInfo[0].aSrcAddress);
2747                         host_int_set_operation_mode(priv->hWILCWFIDrv, STATION_MODE);
2748
2749                         /*Add saved WEP keys, if any*/
2750                         if (g_wep_keys_saved) {
2751                                 host_int_set_WEPDefaultKeyID(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2752                                                              g_key_wep_params.key_idx);
2753                                 host_int_add_wep_key_bss_sta(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2754                                                              g_key_wep_params.key,
2755                                                              g_key_wep_params.key_len,
2756                                                              g_key_wep_params.key_idx);
2757                         }
2758
2759                         /*No matter the driver handler passed here, it will be overwriiten*/
2760                         /*in Handle_FlushConnect() with gu8FlushedJoinReqDrvHandler*/
2761                         host_int_flush_join_req(priv->hWILCWFIDrv);
2762
2763                         /*Add saved PTK and GTK keys, if any*/
2764                         if (g_ptk_keys_saved && g_gtk_keys_saved) {
2765                                 PRINT_D(CFG80211_DBG, "ptk %x %x %x\n", g_key_ptk_params.key[0],
2766                                         g_key_ptk_params.key[1],
2767                                         g_key_ptk_params.key[2]);
2768                                 PRINT_D(CFG80211_DBG, "gtk %x %x %x\n", g_key_gtk_params.key[0],
2769                                         g_key_gtk_params.key[1],
2770                                         g_key_gtk_params.key[2]);
2771                                 add_key(g_linux_wlan->strInterfaceInfo[0].wilc_netdev->ieee80211_ptr->wiphy,
2772                                         g_linux_wlan->strInterfaceInfo[0].wilc_netdev,
2773                                         g_add_ptk_key_params.key_idx,
2774                                         g_add_ptk_key_params.pairwise,
2775                                         g_add_ptk_key_params.mac_addr,
2776                                         (struct key_params *)(&g_key_ptk_params));
2777
2778                                 add_key(g_linux_wlan->strInterfaceInfo[0].wilc_netdev->ieee80211_ptr->wiphy,
2779                                         g_linux_wlan->strInterfaceInfo[0].wilc_netdev,
2780                                         g_add_gtk_key_params.key_idx,
2781                                         g_add_gtk_key_params.pairwise,
2782                                         g_add_gtk_key_params.mac_addr,
2783                                         (struct key_params *)(&g_key_gtk_params));
2784                         }
2785
2786                         if (g_linux_wlan->wilc1000_initialized) {
2787                                 for (i = 0; i < num_reg_frame; i++) {
2788                                         PRINT_D(INIT_DBG, "Frame registering Type: %x - Reg: %d\n", nic->g_struct_frame_reg[i].frame_type,
2789                                                 nic->g_struct_frame_reg[i].reg);
2790                                         host_int_frame_register(priv->hWILCWFIDrv,
2791                                                                 nic->g_struct_frame_reg[i].frame_type,
2792                                                                 nic->g_struct_frame_reg[i].reg);
2793                                 }
2794                         }
2795
2796                         bEnablePS = true;
2797                         host_int_set_power_mgmt(priv->hWILCWFIDrv, 1, 0);
2798                 }
2799                 break;
2800
2801         case NL80211_IFTYPE_P2P_CLIENT:
2802                 bEnablePS = false;
2803                 host_int_set_power_mgmt(priv->hWILCWFIDrv, 0, 0);
2804                 connecting = 0;
2805                 PRINT_D(HOSTAPD_DBG, "Interface type = NL80211_IFTYPE_P2P_CLIENT\n");
2806
2807                 host_int_del_All_Rx_BASession(priv->hWILCWFIDrv, g_linux_wlan->strInterfaceInfo[0].aBSSID, TID);
2808
2809                 dev->ieee80211_ptr->iftype = type;
2810                 priv->wdev->iftype = type;
2811                 nic->monitor_flag = 0;
2812
2813                 PRINT_D(HOSTAPD_DBG, "Downloading P2P_CONCURRENCY_FIRMWARE\n");
2814                 nic->iftype = CLIENT_MODE;
2815
2816
2817                 if (g_linux_wlan->wilc1000_initialized) {
2818                         /* ensure that the message Q is empty */
2819                         host_int_wait_msg_queue_idle();
2820
2821                         wilc1000_wlan_deinit(g_linux_wlan);
2822                         wilc1000_wlan_init(dev, nic);
2823                         g_wilc_initialized = 1;
2824
2825                         host_int_set_wfi_drv_handler(g_linux_wlan->strInterfaceInfo[0].drvHandler);
2826                         host_int_set_MacAddress(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2827                                                 g_linux_wlan->strInterfaceInfo[0].aSrcAddress);
2828                         host_int_set_operation_mode(priv->hWILCWFIDrv, STATION_MODE);
2829
2830                         /*Add saved WEP keys, if any*/
2831                         if (g_wep_keys_saved) {
2832                                 host_int_set_WEPDefaultKeyID(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2833                                                              g_key_wep_params.key_idx);
2834                                 host_int_add_wep_key_bss_sta(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2835                                                              g_key_wep_params.key,
2836                                                              g_key_wep_params.key_len,
2837                                                              g_key_wep_params.key_idx);
2838                         }
2839
2840                         /*No matter the driver handler passed here, it will be overwriiten*/
2841                         /*in Handle_FlushConnect() with gu8FlushedJoinReqDrvHandler*/
2842                         host_int_flush_join_req(priv->hWILCWFIDrv);
2843
2844                         /*Add saved PTK and GTK keys, if any*/
2845                         if (g_ptk_keys_saved && g_gtk_keys_saved) {
2846                                 PRINT_D(CFG80211_DBG, "ptk %x %x %x\n", g_key_ptk_params.key[0],
2847                                         g_key_ptk_params.key[1],
2848                                         g_key_ptk_params.key[2]);
2849                                 PRINT_D(CFG80211_DBG, "gtk %x %x %x\n", g_key_gtk_params.key[0],
2850                                         g_key_gtk_params.key[1],
2851                                         g_key_gtk_params.key[2]);
2852                                 add_key(g_linux_wlan->strInterfaceInfo[0].wilc_netdev->ieee80211_ptr->wiphy,
2853                                         g_linux_wlan->strInterfaceInfo[0].wilc_netdev,
2854                                         g_add_ptk_key_params.key_idx,
2855                                         g_add_ptk_key_params.pairwise,
2856                                         g_add_ptk_key_params.mac_addr,
2857                                         (struct key_params *)(&g_key_ptk_params));
2858
2859                                 add_key(g_linux_wlan->strInterfaceInfo[0].wilc_netdev->ieee80211_ptr->wiphy,
2860                                         g_linux_wlan->strInterfaceInfo[0].wilc_netdev,
2861                                         g_add_gtk_key_params.key_idx,
2862                                         g_add_gtk_key_params.pairwise,
2863                                         g_add_gtk_key_params.mac_addr,
2864                                         (struct key_params *)(&g_key_gtk_params));
2865                         }
2866
2867                         /*Refresh scan, to refresh the scan results to the wpa_supplicant. Set MachHw to false to enable further key installments*/
2868                         refresh_scan(priv, 1, true);
2869                         Set_machw_change_vir_if(false);
2870
2871                         if (g_linux_wlan->wilc1000_initialized) {
2872                                 for (i = 0; i < num_reg_frame; i++) {
2873                                         PRINT_D(INIT_DBG, "Frame registering Type: %x - Reg: %d\n", nic->g_struct_frame_reg[i].frame_type,
2874                                                 nic->g_struct_frame_reg[i].reg);
2875                                         host_int_frame_register(priv->hWILCWFIDrv,
2876                                                                 nic->g_struct_frame_reg[i].frame_type,
2877                                                                 nic->g_struct_frame_reg[i].reg);
2878                                 }
2879                         }
2880                 }
2881                 break;
2882
2883         case NL80211_IFTYPE_AP:
2884                 bEnablePS = false;
2885                 PRINT_D(HOSTAPD_DBG, "Interface type = NL80211_IFTYPE_AP %d\n", type);
2886                 dev->ieee80211_ptr->iftype = type;
2887                 priv->wdev->iftype = type;
2888                 nic->iftype = AP_MODE;
2889                 PRINT_D(CORECONFIG_DBG, "priv->hWILCWFIDrv[%p]\n", priv->hWILCWFIDrv);
2890
2891                 PRINT_D(HOSTAPD_DBG, "Downloading AP firmware\n");
2892                 linux_wlan_get_firmware(nic);
2893                 /*If wilc is running, then close-open to actually get new firmware running (serves P2P)*/
2894                 if (g_linux_wlan->wilc1000_initialized) {
2895                         nic->iftype = AP_MODE;
2896                         g_linux_wlan->wilc1000_initialized = 1;
2897                         mac_close(dev);
2898                         mac_open(dev);
2899
2900                         for (i = 0; i < num_reg_frame; i++) {
2901                                 PRINT_D(INIT_DBG, "Frame registering Type: %x - Reg: %d\n", nic->g_struct_frame_reg[i].frame_type,
2902                                         nic->g_struct_frame_reg[i].reg);
2903                                 host_int_frame_register(priv->hWILCWFIDrv,
2904                                                         nic->g_struct_frame_reg[i].frame_type,
2905                                                         nic->g_struct_frame_reg[i].reg);
2906                         }
2907                 }
2908                 break;
2909
2910         case NL80211_IFTYPE_P2P_GO:
2911                 PRINT_D(GENERIC_DBG, "start duringIP timer\n");
2912
2913                 g_obtainingIP = true;
2914                 mod_timer(&hDuringIpTimer, jiffies + msecs_to_jiffies(duringIP_TIME));
2915                 host_int_set_power_mgmt(priv->hWILCWFIDrv, 0, 0);
2916                 /*Delete block ack has to be the latest config packet*/
2917                 /*sent before downloading new FW. This is because it blocks on*/
2918                 /*hWaitResponse semaphore, which allows previous config*/
2919                 /*packets to actually take action on old FW*/
2920                 host_int_del_All_Rx_BASession(priv->hWILCWFIDrv, g_linux_wlan->strInterfaceInfo[0].aBSSID, TID);
2921                 bEnablePS = false;
2922                 PRINT_D(HOSTAPD_DBG, "Interface type = NL80211_IFTYPE_GO\n");
2923                 dev->ieee80211_ptr->iftype = type;
2924                 priv->wdev->iftype = type;
2925
2926                 PRINT_D(CORECONFIG_DBG, "priv->hWILCWFIDrv[%p]\n", priv->hWILCWFIDrv);
2927
2928                 PRINT_D(HOSTAPD_DBG, "Downloading P2P_CONCURRENCY_FIRMWARE\n");
2929
2930
2931                 nic->iftype = GO_MODE;
2932
2933                 /* ensure that the message Q is empty */
2934                 host_int_wait_msg_queue_idle();
2935                 wilc1000_wlan_deinit(g_linux_wlan);
2936                 wilc1000_wlan_init(dev, nic);
2937                 g_wilc_initialized = 1;
2938
2939
2940                 /*Setting interface 1 drv handler and mac address in newly downloaded FW*/
2941                 host_int_set_wfi_drv_handler(g_linux_wlan->strInterfaceInfo[0].drvHandler);
2942                 host_int_set_MacAddress(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2943                                         g_linux_wlan->strInterfaceInfo[0].aSrcAddress);
2944                 host_int_set_operation_mode(priv->hWILCWFIDrv, AP_MODE);
2945
2946                 /*Add saved WEP keys, if any*/
2947                 if (g_wep_keys_saved) {
2948                         host_int_set_WEPDefaultKeyID(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2949                                                      g_key_wep_params.key_idx);
2950                         host_int_add_wep_key_bss_sta(g_linux_wlan->strInterfaceInfo[0].drvHandler,
2951                                                      g_key_wep_params.key,
2952                                                      g_key_wep_params.key_len,
2953                                                      g_key_wep_params.key_idx);
2954                 }
2955
2956                 /*No matter the driver handler passed here, it will be overwriiten*/
2957                 /*in Handle_FlushConnect() with gu8FlushedJoinReqDrvHandler*/
2958                 host_int_flush_join_req(priv->hWILCWFIDrv);
2959
2960                 /*Add saved PTK and GTK keys, if any*/
2961                 if (g_ptk_keys_saved && g_gtk_keys_saved) {
2962                         PRINT_D(CFG80211_DBG, "ptk %x %x %x cipher %x\n", g_key_ptk_params.key[0],
2963                                 g_key_ptk_params.key[1],
2964                                 g_key_ptk_params.key[2],
2965                                 g_key_ptk_params.cipher);
2966                         PRINT_D(CFG80211_DBG, "gtk %x %x %x cipher %x\n", g_key_gtk_params.key[0],
2967                                 g_key_gtk_params.key[1],
2968                                 g_key_gtk_params.key[2],
2969                                 g_key_gtk_params.cipher);
2970                         add_key(g_linux_wlan->strInterfaceInfo[0].wilc_netdev->ieee80211_ptr->wiphy,
2971                                 g_linux_wlan->strInterfaceInfo[0].wilc_netdev,
2972                                 g_add_ptk_key_params.key_idx,
2973                                 g_add_ptk_key_params.pairwise,
2974                                 g_add_ptk_key_params.mac_addr,
2975                                 (struct key_params *)(&g_key_ptk_params));
2976
2977                         add_key(g_linux_wlan->strInterfaceInfo[0].wilc_netdev->ieee80211_ptr->wiphy,
2978                                 g_linux_wlan->strInterfaceInfo[0].wilc_netdev,
2979                                 g_add_gtk_key_params.key_idx,
2980                                 g_add_gtk_key_params.pairwise,
2981                                 g_add_gtk_key_params.mac_addr,
2982                                 (struct key_params *)(&g_key_gtk_params));
2983                 }
2984
2985                 if (g_linux_wlan->wilc1000_initialized) {
2986                         for (i = 0; i < num_reg_frame; i++) {
2987                                 PRINT_D(INIT_DBG, "Frame registering Type: %x - Reg: %d\n", nic->g_struct_frame_reg[i].frame_type,
2988                                         nic->g_struct_frame_reg[i].reg);
2989                                 host_int_frame_register(priv->hWILCWFIDrv,
2990                                                         nic->g_struct_frame_reg[i].frame_type,
2991                                                         nic->g_struct_frame_reg[i].reg);
2992                         }
2993                 }
2994                 break;
2995
2996         default:
2997                 PRINT_ER("Unknown interface type= %d\n", type);
2998                 s32Error = -EINVAL;
2999                 return s32Error;
3000                 break;
3001         }
3002
3003         return s32Error;
3004 }
3005
3006 /* (austin.2013-07-23)
3007  *
3008  *      To support revised cfg80211_ops
3009  *
3010  *              add_beacon --> start_ap
3011  *              set_beacon --> change_beacon
3012  *              del_beacon --> stop_ap
3013  *
3014  *              beacon_parameters  -->  cfg80211_ap_settings
3015  *                                                              cfg80211_beacon_data
3016  *
3017  *      applicable for linux kernel 3.4+
3018  */
3019
3020 /**
3021  *  @brief      start_ap
3022  *  @details    Add a beacon with given parameters, @head, @interval
3023  *                      and @dtim_period will be valid, @tail is optional.
3024  *  @param[in]   wiphy
3025  *  @param[in]   dev    The net device structure
3026  *  @param[in]   settings       cfg80211_ap_settings parameters for the beacon to be added
3027  *  @return     int : Return 0 on Success.
3028  *  @author     austin
3029  *  @date       23 JUL 2013
3030  *  @version    1.0
3031  */
3032 static int start_ap(struct wiphy *wiphy, struct net_device *dev,
3033                     struct cfg80211_ap_settings *settings)
3034 {
3035         struct cfg80211_beacon_data *beacon = &(settings->beacon);
3036         struct wilc_priv *priv;
3037         s32 s32Error = 0;
3038
3039         priv = wiphy_priv(wiphy);
3040         PRINT_D(HOSTAPD_DBG, "Starting ap\n");
3041
3042         PRINT_D(HOSTAPD_DBG, "Interval = %d\n DTIM period = %d\n Head length = %zu Tail length = %zu\n",
3043                 settings->beacon_interval, settings->dtim_period, beacon->head_len, beacon->tail_len);
3044
3045         s32Error = set_channel(wiphy, &settings->chandef);
3046
3047         if (s32Error != 0)
3048                 PRINT_ER("Error in setting channel\n");
3049
3050         linux_wlan_set_bssid(dev, g_linux_wlan->strInterfaceInfo[0].aSrcAddress);
3051
3052         s32Error = host_int_add_beacon(priv->hWILCWFIDrv,
3053                                         settings->beacon_interval,
3054                                         settings->dtim_period,
3055                                         beacon->head_len, (u8 *)beacon->head,
3056                                         beacon->tail_len, (u8 *)beacon->tail);
3057
3058         return s32Error;
3059 }
3060
3061 /**
3062  *  @brief      change_beacon
3063  *  @details    Add a beacon with given parameters, @head, @interval
3064  *                      and @dtim_period will be valid, @tail is optional.
3065  *  @param[in]   wiphy
3066  *  @param[in]   dev    The net device structure
3067  *  @param[in]   beacon cfg80211_beacon_data for the beacon to be changed
3068  *  @return     int : Return 0 on Success.
3069  *  @author     austin
3070  *  @date       23 JUL 2013
3071  *  @version    1.0
3072  */
3073 static int change_beacon(struct wiphy *wiphy, struct net_device *dev,
3074                          struct cfg80211_beacon_data *beacon)
3075 {
3076         struct wilc_priv *priv;
3077         s32 s32Error = 0;
3078
3079         priv = wiphy_priv(wiphy);
3080         PRINT_D(HOSTAPD_DBG, "Setting beacon\n");
3081
3082
3083         s32Error = host_int_add_beacon(priv->hWILCWFIDrv,
3084                                         0,
3085                                         0,
3086                                         beacon->head_len, (u8 *)beacon->head,
3087                                         beacon->tail_len, (u8 *)beacon->tail);
3088
3089         return s32Error;
3090 }
3091
3092 /**
3093  *  @brief      stop_ap
3094  *  @details    Remove beacon configuration and stop sending the beacon.
3095  *  @param[in]
3096  *  @return     int : Return 0 on Success.
3097  *  @author     austin
3098  *  @date       23 JUL 2013
3099  *  @version    1.0
3100  */
3101 static int stop_ap(struct wiphy *wiphy, struct net_device *dev)
3102 {
3103         s32 s32Error = 0;
3104         struct wilc_priv *priv;
3105         u8 NullBssid[ETH_ALEN] = {0};
3106
3107         if (!wiphy)
3108                 return -EFAULT;
3109
3110         priv = wiphy_priv(wiphy);
3111
3112         PRINT_D(HOSTAPD_DBG, "Deleting beacon\n");
3113
3114         linux_wlan_set_bssid(dev, NullBssid);
3115
3116         s32Error = host_int_del_beacon(priv->hWILCWFIDrv);
3117
3118         if (s32Error)
3119                 PRINT_ER("Host delete beacon fail\n");
3120
3121         return s32Error;
3122 }
3123
3124 /**
3125  *  @brief      add_station
3126  *  @details    Add a new station.
3127  *  @param[in]
3128  *  @return     int : Return 0 on Success.
3129  *  @author     mdaftedar
3130  *  @date       01 MAR 2012
3131  *  @version    1.0
3132  */
3133 static int add_station(struct wiphy *wiphy, struct net_device *dev,
3134                        const u8 *mac, struct station_parameters *params)
3135 {
3136         s32 s32Error = 0;
3137         struct wilc_priv *priv;
3138         struct add_sta_param strStaParams = { {0} };
3139         perInterface_wlan_t *nic;
3140
3141         if (!wiphy)
3142                 return -EFAULT;
3143
3144         priv = wiphy_priv(wiphy);
3145         nic = netdev_priv(dev);
3146
3147         if (nic->iftype == AP_MODE || nic->iftype == GO_MODE) {
3148                 memcpy(strStaParams.au8BSSID, mac, ETH_ALEN);
3149                 memcpy(priv->assoc_stainfo.au8Sta_AssociatedBss[params->aid], mac, ETH_ALEN);
3150                 strStaParams.u16AssocID = params->aid;
3151                 strStaParams.u8NumRates = params->supported_rates_len;
3152                 strStaParams.pu8Rates = params->supported_rates;
3153
3154                 PRINT_D(CFG80211_DBG, "Adding station parameters %d\n", params->aid);
3155
3156                 PRINT_D(CFG80211_DBG, "BSSID = %x%x%x%x%x%x\n", priv->assoc_stainfo.au8Sta_AssociatedBss[params->aid][0], priv->assoc_stainfo.au8Sta_AssociatedBss[params->aid][1], priv->assoc_stainfo.au8Sta_AssociatedBss[params->aid][2], priv->assoc_stainfo.au8Sta_AssociatedBss[params->aid][3], priv->assoc_stainfo.au8Sta_AssociatedBss[params->aid][4],
3157                         priv->assoc_stainfo.au8Sta_AssociatedBss[params->aid][5]);
3158                 PRINT_D(HOSTAPD_DBG, "ASSOC ID = %d\n", strStaParams.u16AssocID);
3159                 PRINT_D(HOSTAPD_DBG, "Number of supported rates = %d\n", strStaParams.u8NumRates);
3160
3161                 if (params->ht_capa == NULL) {
3162                         strStaParams.bIsHTSupported = false;
3163                 } else {
3164                         strStaParams.bIsHTSupported = true;
3165                         strStaParams.u16HTCapInfo = params->ht_capa->cap_info;
3166                         strStaParams.u8AmpduParams = params->ht_capa->ampdu_params_info;
3167                         memcpy(strStaParams.au8SuppMCsSet, &params->ht_capa->mcs, WILC_SUPP_MCS_SET_SIZE);
3168                         strStaParams.u16HTExtParams = params->ht_capa->extended_ht_cap_info;
3169                         strStaParams.u32TxBeamformingCap = params->ht_capa->tx_BF_cap_info;
3170                         strStaParams.u8ASELCap = params->ht_capa->antenna_selection_info;
3171                 }
3172
3173                 strStaParams.u16FlagsMask = params->sta_flags_mask;
3174                 strStaParams.u16FlagsSet = params->sta_flags_set;
3175
3176                 PRINT_D(HOSTAPD_DBG, "IS HT supported = %d\n", strStaParams.bIsHTSupported);
3177                 PRINT_D(HOSTAPD_DBG, "Capability Info = %d\n", strStaParams.u16HTCapInfo);
3178                 PRINT_D(HOSTAPD_DBG, "AMPDU Params = %d\n", strStaParams.u8AmpduParams);
3179                 PRINT_D(HOSTAPD_DBG, "HT Extended params = %d\n", strStaParams.u16HTExtParams);
3180                 PRINT_D(HOSTAPD_DBG, "Tx Beamforming Cap = %d\n", strStaParams.u32TxBeamformingCap);
3181                 PRINT_D(HOSTAPD_DBG, "Antenna selection info = %d\n", strStaParams.u8ASELCap);
3182                 PRINT_D(HOSTAPD_DBG, "Flag Mask = %d\n", strStaParams.u16FlagsMask);
3183                 PRINT_D(HOSTAPD_DBG, "Flag Set = %d\n", strStaParams.u16FlagsSet);
3184
3185                 s32Error = host_int_add_station(priv->hWILCWFIDrv, &strStaParams);
3186                 if (s32Error)
3187                         PRINT_ER("Host add station fail\n");
3188         }
3189
3190         return s32Error;
3191 }
3192
3193 /**
3194  *  @brief      del_station
3195  *  @details    Remove a station; @mac may be NULL to remove all stations.
3196  *  @param[in]
3197  *  @return     int : Return 0 on Success.
3198  *  @author     mdaftedar
3199  *  @date       01 MAR 2012
3200  *  @version    1.0
3201  */
3202 static int del_station(struct wiphy *wiphy, struct net_device *dev,
3203                        struct station_del_parameters *params)
3204 {
3205         const u8 *mac = params->mac;
3206         s32 s32Error = 0;
3207         struct wilc_priv *priv;
3208         perInterface_wlan_t *nic;
3209
3210         if (!wiphy)
3211                 return -EFAULT;
3212
3213         priv = wiphy_priv(wiphy);
3214         nic = netdev_priv(dev);
3215
3216         if (nic->iftype == AP_MODE || nic->iftype == GO_MODE) {
3217                 PRINT_D(HOSTAPD_DBG, "Deleting station\n");
3218
3219
3220                 if (mac == NULL) {
3221                         PRINT_D(HOSTAPD_DBG, "All associated stations\n");
3222                         s32Error = host_int_del_allstation(priv->hWILCWFIDrv, priv->assoc_stainfo.au8Sta_AssociatedBss);
3223                 } else {
3224                         PRINT_D(HOSTAPD_DBG, "With mac address: %x%x%x%x%x%x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
3225                 }
3226
3227                 s32Error = host_int_del_station(priv->hWILCWFIDrv, mac);
3228
3229                 if (s32Error)
3230                         PRINT_ER("Host delete station fail\n");
3231         }
3232         return s32Error;
3233 }
3234
3235 /**
3236  *  @brief      change_station
3237  *  @details    Modify a given station.
3238  *  @param[in]
3239  *  @return     int : Return 0 on Success.
3240  *  @author     mdaftedar
3241  *  @date       01 MAR 2012
3242  *  @version    1.0
3243  */
3244 static int change_station(struct wiphy *wiphy, struct net_device *dev,
3245                           const u8 *mac, struct station_parameters *params)
3246 {
3247         s32 s32Error = 0;
3248         struct wilc_priv *priv;
3249         struct add_sta_param strStaParams = { {0} };
3250         perInterface_wlan_t *nic;
3251
3252
3253         PRINT_D(HOSTAPD_DBG, "Change station paramters\n");
3254
3255         if (!wiphy)
3256                 return -EFAULT;
3257
3258         priv = wiphy_priv(wiphy);
3259         nic = netdev_priv(dev);
3260
3261         if (nic->iftype == AP_MODE || nic->iftype == GO_MODE) {
3262                 memcpy(strStaParams.au8BSSID, mac, ETH_ALEN);
3263                 strStaParams.u16AssocID = params->aid;
3264                 strStaParams.u8NumRates = params->supported_rates_len;
3265                 strStaParams.pu8Rates = params->supported_rates;
3266
3267                 PRINT_D(HOSTAPD_DBG, "BSSID = %x%x%x%x%x%x\n", strStaParams.au8BSSID[0], strStaParams.au8BSSID[1], strStaParams.au8BSSID[2], strStaParams.au8BSSID[3], strStaParams.au8BSSID[4],
3268                         strStaParams.au8BSSID[5]);
3269                 PRINT_D(HOSTAPD_DBG, "ASSOC ID = %d\n", strStaParams.u16AssocID);
3270                 PRINT_D(HOSTAPD_DBG, "Number of supported rates = %d\n", strStaParams.u8NumRates);
3271
3272                 if (params->ht_capa == NULL) {
3273                         strStaParams.bIsHTSupported = false;
3274                 } else {
3275                         strStaParams.bIsHTSupported = true;
3276                         strStaParams.u16HTCapInfo = params->ht_capa->cap_info;
3277                         strStaParams.u8AmpduParams = params->ht_capa->ampdu_params_info;
3278                         memcpy(strStaParams.au8SuppMCsSet, &params->ht_capa->mcs, WILC_SUPP_MCS_SET_SIZE);
3279                         strStaParams.u16HTExtParams = params->ht_capa->extended_ht_cap_info;
3280                         strStaParams.u32TxBeamformingCap = params->ht_capa->tx_BF_cap_info;
3281                         strStaParams.u8ASELCap = params->ht_capa->antenna_selection_info;
3282
3283                 }
3284
3285                 strStaParams.u16FlagsMask = params->sta_flags_mask;
3286                 strStaParams.u16FlagsSet = params->sta_flags_set;
3287
3288                 PRINT_D(HOSTAPD_DBG, "IS HT supported = %d\n", strStaParams.bIsHTSupported);
3289                 PRINT_D(HOSTAPD_DBG, "Capability Info = %d\n", strStaParams.u16HTCapInfo);
3290                 PRINT_D(HOSTAPD_DBG, "AMPDU Params = %d\n", strStaParams.u8AmpduParams);
3291                 PRINT_D(HOSTAPD_DBG, "HT Extended params = %d\n", strStaParams.u16HTExtParams);
3292                 PRINT_D(HOSTAPD_DBG, "Tx Beamforming Cap = %d\n", strStaParams.u32TxBeamformingCap);
3293                 PRINT_D(HOSTAPD_DBG, "Antenna selection info = %d\n", strStaParams.u8ASELCap);
3294                 PRINT_D(HOSTAPD_DBG, "Flag Mask = %d\n", strStaParams.u16FlagsMask);
3295                 PRINT_D(HOSTAPD_DBG, "Flag Set = %d\n", strStaParams.u16FlagsSet);
3296
3297                 s32Error = host_int_edit_station(priv->hWILCWFIDrv, &strStaParams);
3298                 if (s32Error)
3299                         PRINT_ER("Host edit station fail\n");
3300         }
3301         return s32Error;
3302 }
3303
3304
3305 /**
3306  *  @brief      add_virtual_intf
3307  *  @details
3308  *  @param[in]
3309  *  @return     int : Return 0 on Success.
3310  *  @author     mdaftedar
3311  *  @date       01 JUL 2012
3312  *  @version    1.0
3313  */
3314 static struct wireless_dev *add_virtual_intf(struct wiphy *wiphy,
3315                                              const char *name,
3316                                              unsigned char name_assign_type,
3317                                              enum nl80211_iftype type,
3318                                              u32 *flags,
3319                                              struct vif_params *params)
3320 {
3321         perInterface_wlan_t *nic;
3322         struct wilc_priv *priv;
3323         struct net_device *new_ifc = NULL;
3324
3325         priv = wiphy_priv(wiphy);
3326
3327
3328
3329         PRINT_D(HOSTAPD_DBG, "Adding monitor interface[%p]\n", priv->wdev->netdev);
3330
3331         nic = netdev_priv(priv->wdev->netdev);
3332
3333
3334         if (type == NL80211_IFTYPE_MONITOR) {
3335                 PRINT_D(HOSTAPD_DBG, "Monitor interface mode: Initializing mon interface virtual device driver\n");
3336                 PRINT_D(HOSTAPD_DBG, "Adding monitor interface[%p]\n", nic->wilc_netdev);
3337                 new_ifc = WILC_WFI_init_mon_interface(name, nic->wilc_netdev);
3338                 if (new_ifc != NULL) {
3339                         PRINT_D(HOSTAPD_DBG, "Setting monitor flag in private structure\n");
3340                         nic = netdev_priv(priv->wdev->netdev);
3341                         nic->monitor_flag = 1;
3342                 } else
3343                         PRINT_ER("Error in initializing monitor interface\n ");
3344         }
3345         return priv->wdev;
3346 }
3347
3348 /**
3349  *  @brief      del_virtual_intf
3350  *  @details
3351  *  @param[in]
3352  *  @return     int : Return 0 on Success.
3353  *  @author     mdaftedar
3354  *  @date       01 JUL 2012
3355  *  @version    1.0
3356  */
3357 static int del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
3358 {
3359         PRINT_D(HOSTAPD_DBG, "Deleting virtual interface\n");
3360         return 0;
3361 }
3362
3363 static struct cfg80211_ops wilc_cfg80211_ops = {
3364
3365         .set_monitor_channel = set_channel,
3366         .scan = scan,
3367         .connect = connect,
3368         .disconnect = disconnect,
3369         .add_key = add_key,
3370         .del_key = del_key,
3371         .get_key = get_key,
3372         .set_default_key = set_default_key,
3373         .add_virtual_intf = add_virtual_intf,
3374         .del_virtual_intf = del_virtual_intf,
3375         .change_virtual_intf = change_virtual_intf,
3376
3377         .start_ap = start_ap,
3378         .change_beacon = change_beacon,
3379         .stop_ap = stop_ap,
3380         .add_station = add_station,
3381         .del_station = del_station,
3382         .change_station = change_station,
3383         .get_station = get_station,
3384         .dump_station = dump_station,
3385         .change_bss = change_bss,
3386         .set_wiphy_params = set_wiphy_params,
3387
3388         .set_pmksa = set_pmksa,
3389         .del_pmksa = del_pmksa,
3390         .flush_pmksa = flush_pmksa,
3391         .remain_on_channel = remain_on_channel,
3392         .cancel_remain_on_channel = cancel_remain_on_channel,
3393         .mgmt_tx_cancel_wait = mgmt_tx_cancel_wait,
3394         .mgmt_tx = mgmt_tx,
3395         .mgmt_frame_register = wilc_mgmt_frame_register,
3396         .set_power_mgmt = set_power_mgmt,
3397         .set_cqm_rssi_config = set_cqm_rssi_config,
3398
3399 };
3400
3401
3402
3403
3404
3405 /**
3406  *  @brief      WILC_WFI_update_stats
3407  *  @details    Modify parameters for a given BSS.
3408  *  @param[in]
3409  *  @return     int : Return 0 on Success.
3410  *  @author     mdaftedar
3411  *  @date       01 MAR 2012
3412  *  @version    1.0
3413  */
3414 int WILC_WFI_update_stats(struct wiphy *wiphy, u32 pktlen, u8 changed)
3415 {
3416
3417         struct wilc_priv *priv;
3418
3419         priv = wiphy_priv(wiphy);
3420         switch (changed) {
3421
3422         case WILC_WFI_RX_PKT:
3423         {
3424                 priv->netstats.rx_packets++;
3425                 priv->netstats.rx_bytes += pktlen;
3426                 priv->netstats.rx_time = get_jiffies_64();
3427         }
3428         break;
3429
3430         case WILC_WFI_TX_PKT:
3431         {
3432                 priv->netstats.tx_packets++;
3433                 priv->netstats.tx_bytes += pktlen;
3434                 priv->netstats.tx_time = get_jiffies_64();
3435
3436         }
3437         break;
3438
3439         default:
3440                 break;
3441         }
3442         return 0;
3443 }
3444
3445 /**
3446  *  @brief      WILC_WFI_CfgAlloc
3447  *  @details    Allocation of the wireless device structure and assigning it
3448  *              to the cfg80211 operations structure.
3449  *  @param[in]   NONE
3450  *  @return     wireless_dev : Returns pointer to wireless_dev structure.
3451  *  @author     mdaftedar
3452  *  @date       01 MAR 2012
3453  *  @version    1.0
3454  */
3455 struct wireless_dev *WILC_WFI_CfgAlloc(void)
3456 {
3457
3458         struct wireless_dev *wdev;
3459
3460
3461         PRINT_D(CFG80211_DBG, "Allocating wireless device\n");
3462         /*Allocating the wireless device structure*/
3463         wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
3464         if (!wdev) {
3465                 PRINT_ER("Cannot allocate wireless device\n");
3466                 goto _fail_;
3467         }
3468
3469         /*Creating a new wiphy, linking wireless structure with the wiphy structure*/
3470         wdev->wiphy = wiphy_new(&wilc_cfg80211_ops, sizeof(struct wilc_priv));
3471         if (!wdev->wiphy) {
3472                 PRINT_ER("Cannot allocate wiphy\n");
3473                 goto _fail_mem_;
3474
3475         }
3476
3477         /* enable 802.11n HT */
3478         WILC_WFI_band_2ghz.ht_cap.ht_supported = 1;
3479         WILC_WFI_band_2ghz.ht_cap.cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
3480         WILC_WFI_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3481         WILC_WFI_band_2ghz.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K;
3482         WILC_WFI_band_2ghz.ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
3483
3484         /*wiphy bands*/
3485         wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &WILC_WFI_band_2ghz;
3486
3487         return wdev;
3488
3489 _fail_mem_:
3490         kfree(wdev);
3491 _fail_:
3492         return NULL;
3493
3494 }
3495 /**
3496  *  @brief      wilc_create_wiphy
3497  *  @details    Registering of the wiphy structure and interface modes
3498  *  @param[in]   NONE
3499  *  @return     NONE
3500  *  @author     mdaftedar
3501  *  @date       01 MAR 2012
3502  *  @version    1.0
3503  */
3504 struct wireless_dev *wilc_create_wiphy(struct net_device *net)
3505 {
3506         struct wilc_priv *priv;
3507         struct wireless_dev *wdev;
3508         s32 s32Error = 0;
3509
3510         PRINT_D(CFG80211_DBG, "Registering wifi device\n");
3511
3512         wdev = WILC_WFI_CfgAlloc();
3513         if (wdev == NULL) {
3514                 PRINT_ER("CfgAlloc Failed\n");
3515                 return NULL;
3516         }
3517
3518
3519         /*Return hardware description structure (wiphy)'s priv*/
3520         priv = wdev_priv(wdev);
3521         sema_init(&(priv->SemHandleUpdateStats), 1);
3522
3523         /*Link the wiphy with wireless structure*/
3524         priv->wdev = wdev;
3525
3526         /*Maximum number of probed ssid to be added by user for the scan request*/
3527         wdev->wiphy->max_scan_ssids = MAX_NUM_PROBED_SSID;
3528         /*Maximum number of pmkids to be cashed*/
3529         wdev->wiphy->max_num_pmkids = WILC_MAX_NUM_PMKIDS;
3530         PRINT_INFO(CFG80211_DBG, "Max number of PMKIDs = %d\n", wdev->wiphy->max_num_pmkids);
3531
3532         wdev->wiphy->max_scan_ie_len = 1000;
3533
3534         /*signal strength in mBm (100*dBm) */
3535         wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
3536
3537         /*Set the availaible cipher suites*/
3538         wdev->wiphy->cipher_suites = cipher_suites;
3539         wdev->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3540         /*Setting default managment types: for register action frame:  */
3541         wdev->wiphy->mgmt_stypes = wilc_wfi_cfg80211_mgmt_types;
3542
3543         wdev->wiphy->max_remain_on_channel_duration = 500;
3544         /*Setting the wiphy interfcae mode and type before registering the wiphy*/
3545         wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_MONITOR) | BIT(NL80211_IFTYPE_P2P_GO) |
3546                 BIT(NL80211_IFTYPE_P2P_CLIENT);
3547         wdev->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3548         wdev->iftype = NL80211_IFTYPE_STATION;
3549
3550
3551
3552         PRINT_INFO(CFG80211_DBG, "Max scan ids = %d,Max scan IE len = %d,Signal Type = %d,Interface Modes = %d,Interface Type = %d\n",
3553                    wdev->wiphy->max_scan_ssids, wdev->wiphy->max_scan_ie_len, wdev->wiphy->signal_type,
3554                    wdev->wiphy->interface_modes, wdev->iftype);
3555
3556         #ifdef WILC_SDIO
3557         set_wiphy_dev(wdev->wiphy, &local_sdio_func->dev);
3558         #endif
3559
3560         /*Register wiphy structure*/
3561         s32Error = wiphy_register(wdev->wiphy);
3562         if (s32Error) {
3563                 PRINT_ER("Cannot register wiphy device\n");
3564                 /*should define what action to be taken in such failure*/
3565         } else {
3566                 PRINT_D(CFG80211_DBG, "Successful Registering\n");
3567         }
3568
3569         priv->dev = net;
3570         return wdev;
3571
3572
3573 }
3574 /**
3575  *  @brief      WILC_WFI_WiphyFree
3576  *  @details    Freeing allocation of the wireless device structure
3577  *  @param[in]   NONE
3578  *  @return     NONE
3579  *  @author     mdaftedar
3580  *  @date       01 MAR 2012
3581  *  @version    1.0
3582  */
3583 int wilc_init_host_int(struct net_device *net)
3584 {
3585
3586         int s32Error = 0;
3587
3588         struct wilc_priv *priv;
3589
3590         PRINT_D(INIT_DBG, "Host[%p][%p]\n", net, net->ieee80211_ptr);
3591         priv = wdev_priv(net->ieee80211_ptr);
3592         if (op_ifcs == 0) {
3593                 setup_timer(&hAgingTimer, remove_network_from_shadow, 0);
3594                 setup_timer(&hDuringIpTimer, clear_duringIP, 0);
3595         }
3596         op_ifcs++;
3597         if (s32Error < 0) {
3598                 PRINT_ER("Failed to creat refresh Timer\n");
3599                 return s32Error;
3600         }
3601
3602         priv->gbAutoRateAdjusted = false;
3603
3604         priv->bInP2PlistenState = false;
3605
3606         sema_init(&(priv->hSemScanReq), 1);
3607         s32Error = host_int_init(&priv->hWILCWFIDrv);
3608         if (s32Error)
3609                 PRINT_ER("Error while initializing hostinterface\n");
3610
3611         return s32Error;
3612 }
3613
3614 /**
3615  *  @brief      WILC_WFI_WiphyFree
3616  *  @details    Freeing allocation of the wireless device structure
3617  *  @param[in]   NONE
3618  *  @return     NONE
3619  *  @author     mdaftedar
3620  *  @date       01 MAR 2012
3621  *  @version    1.0
3622  */
3623 int wilc_deinit_host_int(struct net_device *net)
3624 {
3625         int s32Error = 0;
3626
3627         struct wilc_priv *priv;
3628
3629         priv = wdev_priv(net->ieee80211_ptr);
3630
3631         priv->gbAutoRateAdjusted = false;
3632
3633         priv->bInP2PlistenState = false;
3634
3635         op_ifcs--;
3636
3637         s32Error = host_int_deinit(priv->hWILCWFIDrv);
3638
3639         /* Clear the Shadow scan */
3640         clear_shadow_scan(priv);
3641         if (op_ifcs == 0) {
3642                 PRINT_D(CORECONFIG_DBG, "destroy during ip\n");
3643                 del_timer_sync(&hDuringIpTimer);
3644         }
3645
3646         if (s32Error)
3647                 PRINT_ER("Error while deintializing host interface\n");
3648
3649         return s32Error;
3650 }
3651
3652
3653 /**
3654  *  @brief      WILC_WFI_WiphyFree
3655  *  @details    Freeing allocation of the wireless device structure
3656  *  @param[in]   NONE
3657  *  @return     NONE
3658  *  @author     mdaftedar
3659  *  @date       01 MAR 2012
3660  *  @version    1.0
3661  */
3662 void wilc_free_wiphy(struct net_device *net)
3663 {
3664         PRINT_D(CFG80211_DBG, "Unregistering wiphy\n");
3665
3666         if (!net) {
3667                 PRINT_D(INIT_DBG, "net_device is NULL\n");
3668                 return;
3669         }
3670
3671         if (!net->ieee80211_ptr) {
3672                 PRINT_D(INIT_DBG, "ieee80211_ptr is NULL\n");
3673                 return;
3674         }
3675
3676         if (!net->ieee80211_ptr->wiphy) {
3677                 PRINT_D(INIT_DBG, "wiphy is NULL\n");
3678                 return;
3679         }
3680
3681         wiphy_unregister(net->ieee80211_ptr->wiphy);
3682
3683         PRINT_D(INIT_DBG, "Freeing wiphy\n");
3684         wiphy_free(net->ieee80211_ptr->wiphy);
3685         kfree(net->ieee80211_ptr);
3686 }