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