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