drivers/staging/wilc1000/wilc_wfi_cfgoperations.c

   1 #include "wilc_wfi_cfgoperations.h"
   2 #include "host_interface.h"
   3 #include <linux/errno.h>
   4
   5 #define NO_ENCRYPT              0
   6 #define ENCRYPT_ENABLED         BIT(0)
   7 #define WEP                     BIT(1)
   8 #define WEP_EXTENDED            BIT(2)
   9 #define WPA                     BIT(3)
  10 #define WPA2                    BIT(4)
  11 #define AES                     BIT(5)
  12 #define TKIP                    BIT(6)
  13
  14 #define FRAME_TYPE_ID                   0
  15 #define ACTION_CAT_ID                   24
  16 #define ACTION_SUBTYPE_ID               25
  17 #define P2P_PUB_ACTION_SUBTYPE          30
  18
  19 #define ACTION_FRAME                    0xd0
  20 #define GO_INTENT_ATTR_ID               0x04
  21 #define CHANLIST_ATTR_ID                0x0b
  22 #define OPERCHAN_ATTR_ID                0x11
  23 #define PUB_ACTION_ATTR_ID              0x04
  24 #define P2PELEM_ATTR_ID                 0xdd
  25
  26 #define GO_NEG_REQ                      0x00
  27 #define GO_NEG_RSP                      0x01
  28 #define GO_NEG_CONF                     0x02
  29 #define P2P_INV_REQ                     0x03
  30 #define P2P_INV_RSP                     0x04
  31 #define PUBLIC_ACT_VENDORSPEC           0x09
  32 #define GAS_INTIAL_REQ                  0x0a
  33 #define GAS_INTIAL_RSP                  0x0b
  34
  35 #define INVALID_CHANNEL                 0
  36
  37 #define nl80211_SCAN_RESULT_EXPIRE      (3 * HZ)
  38 #define SCAN_RESULT_EXPIRE              (40 * HZ)
  39
  40 static const u32 cipher_suites[] = {
  41         WLAN_CIPHER_SUITE_WEP40,
  42         WLAN_CIPHER_SUITE_WEP104,
  43         WLAN_CIPHER_SUITE_TKIP,
  44         WLAN_CIPHER_SUITE_CCMP,
  45         WLAN_CIPHER_SUITE_AES_CMAC,
  46 };
  47
  48 static const struct ieee80211_txrx_stypes
  49         wilc_wfi_cfg80211_mgmt_types[NUM_NL80211_IFTYPES] = {
  50         [NL80211_IFTYPE_STATION] = {
  51                 .tx = 0xffff,
  52                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
  53                         BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
  54         },
  55         [NL80211_IFTYPE_AP] = {
  56                 .tx = 0xffff,
  57                 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
  58                         BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
  59                         BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
  60                         BIT(IEEE80211_STYPE_DISASSOC >> 4) |
  61                         BIT(IEEE80211_STYPE_AUTH >> 4) |
  62                         BIT(IEEE80211_STYPE_DEAUTH >> 4) |
  63                         BIT(IEEE80211_STYPE_ACTION >> 4)
  64         },
  65         [NL80211_IFTYPE_P2P_CLIENT] = {
  66                 .tx = 0xffff,
  67                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
  68                         BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
  69                         BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
  70                         BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
  71                         BIT(IEEE80211_STYPE_DISASSOC >> 4) |
  72                         BIT(IEEE80211_STYPE_AUTH >> 4) |
  73                         BIT(IEEE80211_STYPE_DEAUTH >> 4)
  74         }
  75 };
  76
  77 static const struct wiphy_wowlan_support wowlan_support = {
  78         .flags = WIPHY_WOWLAN_ANY
  79 };
  80
  81 #define WILC_WFI_DWELL_PASSIVE 100
  82 #define WILC_WFI_DWELL_ACTIVE  40
  83
  84 #define TCP_ACK_FILTER_LINK_SPEED_THRESH        54
  85 #define DEFAULT_LINK_SPEED                      72
  86
  87
  88 #define IS_MANAGMEMENT                          0x100
  89 #define IS_MANAGMEMENT_CALLBACK                 0x080
  90 #define IS_MGMT_STATUS_SUCCES                   0x040
  91 #define GET_PKT_OFFSET(a) (((a) >> 22) & 0x1ff)
  92
  93 extern int wilc_mac_open(struct net_device *ndev);
  94 extern int wilc_mac_close(struct net_device *ndev);
  95
  96 static struct network_info last_scanned_shadow[MAX_NUM_SCANNED_NETWORKS_SHADOW];
  97 static u32 last_scanned_cnt;
  98 struct timer_list wilc_during_ip_timer;
  99 static struct timer_list hAgingTimer;
 100 static u8 op_ifcs;
 101
 102 u8 wilc_initialized = 1;
 103
 104 #define CHAN2G(_channel, _freq, _flags) {        \
 105                 .band             = NL80211_BAND_2GHZ, \
 106                 .center_freq      = (_freq),             \
 107                 .hw_value         = (_channel),          \
 108                 .flags            = (_flags),            \
 109                 .max_antenna_gain = 0,                   \
 110                 .max_power        = 30,                  \
 111 }
 112
 113 static struct ieee80211_channel ieee80211_2ghz_channels[] = {
 114         CHAN2G(1,  2412, 0),
 115         CHAN2G(2,  2417, 0),
 116         CHAN2G(3,  2422, 0),
 117         CHAN2G(4,  2427, 0),
 118         CHAN2G(5,  2432, 0),
 119         CHAN2G(6,  2437, 0),
 120         CHAN2G(7,  2442, 0),
 121         CHAN2G(8,  2447, 0),
 122         CHAN2G(9,  2452, 0),
 123         CHAN2G(10, 2457, 0),
 124         CHAN2G(11, 2462, 0),
 125         CHAN2G(12, 2467, 0),
 126         CHAN2G(13, 2472, 0),
 127         CHAN2G(14, 2484, 0),
 128 };
 129
 130 #define RATETAB_ENT(_rate, _hw_value, _flags) { \
 131                 .bitrate  = (_rate),                    \
 132                 .hw_value = (_hw_value),                \
 133                 .flags    = (_flags),                   \
 134 }
 135
 136 static struct ieee80211_rate ieee80211_bitrates[] = {
 137         RATETAB_ENT(10,  0,  0),
 138         RATETAB_ENT(20,  1,  0),
 139         RATETAB_ENT(55,  2,  0),
 140         RATETAB_ENT(110, 3,  0),
 141         RATETAB_ENT(60,  9,  0),
 142         RATETAB_ENT(90,  6,  0),
 143         RATETAB_ENT(120, 7,  0),
 144         RATETAB_ENT(180, 8,  0),
 145         RATETAB_ENT(240, 9,  0),
 146         RATETAB_ENT(360, 10, 0),
 147         RATETAB_ENT(480, 11, 0),
 148         RATETAB_ENT(540, 12, 0),
 149 };
 150
 151 struct p2p_mgmt_data {
 152         int size;
 153         u8 *buff;
 154 };
 155
 156 static u8 wlan_channel = INVALID_CHANNEL;
 157 static u8 curr_channel;
 158 static u8 p2p_oui[] = {0x50, 0x6f, 0x9A, 0x09};
 159 static u8 p2p_local_random = 0x01;
 160 static u8 p2p_recv_random;
 161 static u8 p2p_vendor_spec[] = {0xdd, 0x05, 0x00, 0x08, 0x40, 0x03};
 162 static bool wilc_ie;
 163
 164 static struct ieee80211_supported_band WILC_WFI_band_2ghz = {
 165         .channels = ieee80211_2ghz_channels,
 166         .n_channels = ARRAY_SIZE(ieee80211_2ghz_channels),
 167         .bitrates = ieee80211_bitrates,
 168         .n_bitrates = ARRAY_SIZE(ieee80211_bitrates),
 169 };
 170
 171
 172 struct add_key_params {
 173         u8 key_idx;
 174         bool pairwise;
 175         u8 *mac_addr;
 176 };
 177 static struct add_key_params g_add_gtk_key_params;
 178 static struct wilc_wfi_key g_key_gtk_params;
 179 static struct add_key_params g_add_ptk_key_params;
 180 static struct wilc_wfi_key g_key_ptk_params;
 181 static struct wilc_wfi_wep_key g_key_wep_params;
 182 static bool g_ptk_keys_saved;
 183 static bool g_gtk_keys_saved;
 184 static bool g_wep_keys_saved;
 185
 186 #define AGING_TIME      (9 * 1000)
 187 #define during_ip_time  15000
 188
 189 static void clear_shadow_scan(void)
 190 {
 191         int i;
 192
 193         if (op_ifcs == 0) {
 194                 del_timer_sync(&hAgingTimer);
 195
 196                 for (i = 0; i < last_scanned_cnt; i++) {
 197                         if (last_scanned_shadow[last_scanned_cnt].ies) {
 198                                 kfree(last_scanned_shadow[i].ies);
 199                                 last_scanned_shadow[last_scanned_cnt].ies = NULL;
 200                         }
 201
 202                         kfree(last_scanned_shadow[i].join_params);
 203                         last_scanned_shadow[i].join_params = NULL;
 204                 }
 205                 last_scanned_cnt = 0;
 206         }
 207 }
 208
 209 static u32 get_rssi_avg(struct network_info *network_info)
 210 {
 211         u8 i;
 212         int rssi_v = 0;
 213         u8 num_rssi = (network_info->str_rssi.u8Full) ?
 214                        NUM_RSSI : (network_info->str_rssi.u8Index);
 215
 216         for (i = 0; i < num_rssi; i++)
 217                 rssi_v += network_info->str_rssi.as8RSSI[i];
 218
 219         rssi_v /= num_rssi;
 220         return rssi_v;
 221 }
 222
 223 static void refresh_scan(void *user_void, u8 all, bool direct_scan)
 224 {
 225         struct wilc_priv *priv;
 226         struct wiphy *wiphy;
 227         struct cfg80211_bss *bss = NULL;
 228         int i;
 229         int rssi = 0;
 230
 231         priv = user_void;
 232         wiphy = priv->dev->ieee80211_ptr->wiphy;
 233
 234         for (i = 0; i < last_scanned_cnt; i++) {
 235                 struct network_info *network_info;
 236
 237                 network_info = &last_scanned_shadow[i];
 238
 239                 if (!network_info->found || all) {
 240                         s32 freq;
 241                         struct ieee80211_channel *channel;
 242
 243                         if (network_info) {
 244                                 freq = ieee80211_channel_to_frequency((s32)network_info->ch, NL80211_BAND_2GHZ);
 245                                 channel = ieee80211_get_channel(wiphy, freq);
 246
 247                                 rssi = get_rssi_avg(network_info);
 248                                 if (memcmp("DIRECT-", network_info->ssid, 7) ||
 249                                     direct_scan) {
 250                                         bss = cfg80211_inform_bss(wiphy,
 251                                                                   channel,
 252                                                                   CFG80211_BSS_FTYPE_UNKNOWN,
 253                                                                   network_info->bssid,
 254                                                                   network_info->tsf_hi,
 255                                                                   network_info->cap_info,
 256                                                                   network_info->beacon_period,
 257                                                                   (const u8 *)network_info->ies,
 258                                                                   (size_t)network_info->ies_len,
 259                                                                   (s32)rssi * 100,
 260                                                                   GFP_KERNEL);
 261                                         cfg80211_put_bss(wiphy, bss);
 262                                 }
 263                         }
 264                 }
 265         }
 266 }
 267
 268 static void reset_shadow_found(void)
 269 {
 270         int i;
 271
 272         for (i = 0; i < last_scanned_cnt; i++)
 273                 last_scanned_shadow[i].found = 0;
 274 }
 275
 276 static void update_scan_time(void)
 277 {
 278         int i;
 279
 280         for (i = 0; i < last_scanned_cnt; i++)
 281                 last_scanned_shadow[i].time_scan = jiffies;
 282 }
 283
 284 static void remove_network_from_shadow(unsigned long arg)
 285 {
 286         unsigned long now = jiffies;
 287         int i, j;
 288
 289
 290         for (i = 0; i < last_scanned_cnt; i++) {
 291                 if (time_after(now, last_scanned_shadow[i].time_scan +
 292                                (unsigned long)(SCAN_RESULT_EXPIRE))) {
 293                         kfree(last_scanned_shadow[i].ies);
 294                         last_scanned_shadow[i].ies = NULL;
 295
 296                         kfree(last_scanned_shadow[i].join_params);
 297
 298                         for (j = i; (j < last_scanned_cnt - 1); j++)
 299                                 last_scanned_shadow[j] = last_scanned_shadow[j + 1];
 300
 301                         last_scanned_cnt--;
 302                 }
 303         }
 304
 305         if (last_scanned_cnt != 0) {
 306                 hAgingTimer.data = arg;
 307                 mod_timer(&hAgingTimer, jiffies + msecs_to_jiffies(AGING_TIME));
 308         }
 309 }
 310
 311 static void clear_duringIP(unsigned long arg)
 312 {
 313         wilc_optaining_ip = false;
 314 }
 315
 316 static int is_network_in_shadow(struct network_info *pstrNetworkInfo,
 317                                 void *user_void)
 318 {
 319         int state = -1;
 320         int i;
 321
 322         if (last_scanned_cnt == 0) {
 323                 hAgingTimer.data = (unsigned long)user_void;
 324                 mod_timer(&hAgingTimer, jiffies + msecs_to_jiffies(AGING_TIME));
 325                 state = -1;
 326         } else {
 327                 for (i = 0; i < last_scanned_cnt; i++) {
 328                         if (memcmp(last_scanned_shadow[i].bssid,
 329                                    pstrNetworkInfo->bssid, 6) == 0) {
 330                                 state = i;
 331                                 break;
 332                         }
 333                 }
 334         }
 335         return state;
 336 }
 337
 338 static void add_network_to_shadow(struct network_info *pstrNetworkInfo,
 339                                   void *user_void, void *pJoinParams)
 340 {
 341         int ap_found = is_network_in_shadow(pstrNetworkInfo, user_void);
 342         u32 ap_index = 0;
 343         u8 rssi_index = 0;
 344
 345         if (last_scanned_cnt >= MAX_NUM_SCANNED_NETWORKS_SHADOW)
 346                 return;
 347
 348         if (ap_found == -1) {
 349                 ap_index = last_scanned_cnt;
 350                 last_scanned_cnt++;
 351         } else {
 352                 ap_index = ap_found;
 353         }
 354         rssi_index = last_scanned_shadow[ap_index].str_rssi.u8Index;
 355         last_scanned_shadow[ap_index].str_rssi.as8RSSI[rssi_index++] = pstrNetworkInfo->rssi;
 356         if (rssi_index == NUM_RSSI) {
 357                 rssi_index = 0;
 358                 last_scanned_shadow[ap_index].str_rssi.u8Full = 1;
 359         }
 360         last_scanned_shadow[ap_index].str_rssi.u8Index = rssi_index;
 361         last_scanned_shadow[ap_index].rssi = pstrNetworkInfo->rssi;
 362         last_scanned_shadow[ap_index].cap_info = pstrNetworkInfo->cap_info;
 363         last_scanned_shadow[ap_index].ssid_len = pstrNetworkInfo->ssid_len;
 364         memcpy(last_scanned_shadow[ap_index].ssid,
 365                pstrNetworkInfo->ssid, pstrNetworkInfo->ssid_len);
 366         memcpy(last_scanned_shadow[ap_index].bssid,
 367                pstrNetworkInfo->bssid, ETH_ALEN);
 368         last_scanned_shadow[ap_index].beacon_period = pstrNetworkInfo->beacon_period;
 369         last_scanned_shadow[ap_index].dtim_period = pstrNetworkInfo->dtim_period;
 370         last_scanned_shadow[ap_index].ch = pstrNetworkInfo->ch;
 371         last_scanned_shadow[ap_index].ies_len = pstrNetworkInfo->ies_len;
 372         last_scanned_shadow[ap_index].tsf_hi = pstrNetworkInfo->tsf_hi;
 373         if (ap_found != -1)
 374                 kfree(last_scanned_shadow[ap_index].ies);
 375         last_scanned_shadow[ap_index].ies = kmalloc(pstrNetworkInfo->ies_len,
 376                                                     GFP_KERNEL);
 377         memcpy(last_scanned_shadow[ap_index].ies,
 378                pstrNetworkInfo->ies, pstrNetworkInfo->ies_len);
 379         last_scanned_shadow[ap_index].time_scan = jiffies;
 380         last_scanned_shadow[ap_index].time_scan_cached = jiffies;
 381         last_scanned_shadow[ap_index].found = 1;
 382         if (ap_found != -1)
 383                 kfree(last_scanned_shadow[ap_index].join_params);
 384         last_scanned_shadow[ap_index].join_params = pJoinParams;
 385 }
 386
 387 static void CfgScanResult(enum scan_event scan_event,
 388                           struct network_info *network_info,
 389                           void *user_void,
 390                           void *join_params)
 391 {
 392         struct wilc_priv *priv;
 393         struct wiphy *wiphy;
 394         s32 s32Freq;
 395         struct ieee80211_channel *channel;
 396         struct cfg80211_bss *bss = NULL;
 397
 398         priv = user_void;
 399         if (priv->bCfgScanning) {
 400                 if (scan_event == SCAN_EVENT_NETWORK_FOUND) {
 401                         wiphy = priv->dev->ieee80211_ptr->wiphy;
 402
 403                         if (!wiphy)
 404                                 return;
 405
 406                         if (wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&
 407                             (((s32)network_info->rssi * 100) < 0 ||
 408                             ((s32)network_info->rssi * 100) > 100))
 409                                 return;
 410
 411                         if (network_info) {
 412                                 s32Freq = ieee80211_channel_to_frequency((s32)network_info->ch, NL80211_BAND_2GHZ);
 413                                 channel = ieee80211_get_channel(wiphy, s32Freq);
 414
 415                                 if (!channel)
 416                                         return;
 417
 418                                 if (network_info->new_network) {
 419                                         if (priv->u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) {
 420                                                 priv->u32RcvdChCount++;
 421
 422                                                 add_network_to_shadow(network_info, priv, join_params);
 423
 424                                                 if (!(memcmp("DIRECT-", network_info->ssid, 7))) {
 425                                                         bss = cfg80211_inform_bss(wiphy,
 426                                                                                   channel,
 427                                                                                   CFG80211_BSS_FTYPE_UNKNOWN,
 428                                                                                   network_info->bssid,
 429                                                                                   network_info->tsf_hi,
 430                                                                                   network_info->cap_info,
 431                                                                                   network_info->beacon_period,
 432                                                                                   (const u8 *)network_info->ies,
 433                                                                                   (size_t)network_info->ies_len,
 434                                                                                   (s32)network_info->rssi * 100,
 435                                                                                   GFP_KERNEL);
 436                                                         cfg80211_put_bss(wiphy, bss);
 437                                                 }
 438                                         }
 439                                 } else {
 440                                         u32 i;
 441
 442                                         for (i = 0; i < priv->u32RcvdChCount; i++) {
 443                                                 if (memcmp(last_scanned_shadow[i].bssid, network_info->bssid, 6) == 0) {
 444                                                         last_scanned_shadow[i].rssi = network_info->rssi;
 445                                                         last_scanned_shadow[i].time_scan = jiffies;
 446                                                         break;
 447                                                 }
 448                                         }
 449                                 }
 450                         }
 451                 } else if (scan_event == SCAN_EVENT_DONE) {
 452                         refresh_scan(priv, 1, false);
 453
 454                         mutex_lock(&priv->scan_req_lock);
 455
 456                         if (priv->pstrScanReq) {
 457                                 struct cfg80211_scan_info info = {
 458                                         .aborted = false,
 459                                 };
 460
 461                                 cfg80211_scan_done(priv->pstrScanReq, &info);
 462                                 priv->u32RcvdChCount = 0;
 463                                 priv->bCfgScanning = false;
 464                                 priv->pstrScanReq = NULL;
 465                         }
 466                         mutex_unlock(&priv->scan_req_lock);
 467                 } else if (scan_event == SCAN_EVENT_ABORTED) {
 468                         mutex_lock(&priv->scan_req_lock);
 469
 470                         if (priv->pstrScanReq) {
 471                                 struct cfg80211_scan_info info = {
 472                                         .aborted = false,
 473                                 };
 474
 475                                 update_scan_time();
 476                                 refresh_scan(priv, 1, false);
 477
 478                                 cfg80211_scan_done(priv->pstrScanReq, &info);
 479                                 priv->bCfgScanning = false;
 480                                 priv->pstrScanReq = NULL;
 481                         }
 482                         mutex_unlock(&priv->scan_req_lock);
 483                 }
 484         }
 485 }
 486
 487 int wilc_connecting;
 488
 489 static void CfgConnectResult(enum conn_event enuConnDisconnEvent,
 490                              struct connect_info *pstrConnectInfo,
 491                              u8 u8MacStatus,
 492                              struct disconnect_info *pstrDisconnectNotifInfo,
 493                              void *pUserVoid)
 494 {
 495         struct wilc_priv *priv;
 496         struct net_device *dev;
 497         struct host_if_drv *pstrWFIDrv;
 498         u8 NullBssid[ETH_ALEN] = {0};
 499         struct wilc *wl;
 500         struct wilc_vif *vif;
 501
 502         wilc_connecting = 0;
 503
 504         priv = pUserVoid;
 505         dev = priv->dev;
 506         vif = netdev_priv(dev);
 507         wl = vif->wilc;
 508         pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;
 509
 510         if (enuConnDisconnEvent == CONN_DISCONN_EVENT_CONN_RESP) {
 511                 u16 u16ConnectStatus;
 512
 513                 u16ConnectStatus = pstrConnectInfo->status;
 514
 515                 if ((u8MacStatus == MAC_DISCONNECTED) &&
 516                     (pstrConnectInfo->status == SUCCESSFUL_STATUSCODE)) {
 517                         u16ConnectStatus = WLAN_STATUS_UNSPECIFIED_FAILURE;
 518                         wilc_wlan_set_bssid(priv->dev, NullBssid,
 519                                             STATION_MODE);
 520                         eth_zero_addr(wilc_connected_ssid);
 521
 522                         if (!pstrWFIDrv->p2p_connect)
 523                                 wlan_channel = INVALID_CHANNEL;
 524
 525                         netdev_err(dev, "Unspecified failure\n");
 526                 }
 527
 528                 if (u16ConnectStatus == WLAN_STATUS_SUCCESS) {
 529                         bool bNeedScanRefresh = false;
 530                         u32 i;
 531
 532                         memcpy(priv->au8AssociatedBss, pstrConnectInfo->bssid, ETH_ALEN);
 533
 534
 535                         for (i = 0; i < last_scanned_cnt; i++) {
 536                                 if (memcmp(last_scanned_shadow[i].bssid,
 537                                            pstrConnectInfo->bssid,
 538                                            ETH_ALEN) == 0) {
 539                                         unsigned long now = jiffies;
 540
 541                                         if (time_after(now,
 542                                                        last_scanned_shadow[i].time_scan_cached +
 543                                                        (unsigned long)(nl80211_SCAN_RESULT_EXPIRE - (1 * HZ))))
 544                                                 bNeedScanRefresh = true;
 545
 546                                         break;
 547                                 }
 548                         }
 549
 550                         if (bNeedScanRefresh)
 551                                 refresh_scan(priv, 1, true);
 552                 }
 553
 554                 cfg80211_connect_result(dev, pstrConnectInfo->bssid,
 555                                         pstrConnectInfo->req_ies, pstrConnectInfo->req_ies_len,
 556                                         pstrConnectInfo->resp_ies, pstrConnectInfo->resp_ies_len,
 557                                         u16ConnectStatus, GFP_KERNEL);
 558         } else if (enuConnDisconnEvent == CONN_DISCONN_EVENT_DISCONN_NOTIF)    {
 559                 wilc_optaining_ip = false;
 560                 p2p_local_random = 0x01;
 561                 p2p_recv_random = 0x00;
 562                 wilc_ie = false;
 563                 eth_zero_addr(priv->au8AssociatedBss);
 564                 wilc_wlan_set_bssid(priv->dev, NullBssid, STATION_MODE);
 565                 eth_zero_addr(wilc_connected_ssid);
 566
 567                 if (!pstrWFIDrv->p2p_connect)
 568                         wlan_channel = INVALID_CHANNEL;
 569                 if ((pstrWFIDrv->IFC_UP) && (dev == wl->vif[1]->ndev))
 570                         pstrDisconnectNotifInfo->reason = 3;
 571                 else if ((!pstrWFIDrv->IFC_UP) && (dev == wl->vif[1]->ndev))
 572                         pstrDisconnectNotifInfo->reason = 1;
 573
 574                 cfg80211_disconnected(dev, pstrDisconnectNotifInfo->reason, pstrDisconnectNotifInfo->ie,
 575                                       pstrDisconnectNotifInfo->ie_len, false,
 576                                       GFP_KERNEL);
 577         }
 578 }
 579
 580 static int set_channel(struct wiphy *wiphy,
 581                        struct cfg80211_chan_def *chandef)
 582 {
 583         u32 channelnum = 0;
 584         struct wilc_priv *priv;
 585         int result = 0;
 586         struct wilc_vif *vif;
 587
 588         priv = wiphy_priv(wiphy);
 589         vif = netdev_priv(priv->dev);
 590
 591         channelnum = ieee80211_frequency_to_channel(chandef->chan->center_freq);
 592
 593         curr_channel = channelnum;
 594         result = wilc_set_mac_chnl_num(vif, channelnum);
 595
 596         if (result != 0)
 597                 netdev_err(priv->dev, "Error in setting channel\n");
 598
 599         return result;
 600 }
 601
 602 static int scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
 603 {
 604         struct wilc_priv *priv;
 605         u32 i;
 606         s32 s32Error = 0;
 607         u8 au8ScanChanList[MAX_NUM_SCANNED_NETWORKS];
 608         struct hidden_network strHiddenNetwork;
 609         struct wilc_vif *vif;
 610
 611         priv = wiphy_priv(wiphy);
 612         vif = netdev_priv(priv->dev);
 613
 614         priv->pstrScanReq = request;
 615
 616         priv->u32RcvdChCount = 0;
 617
 618         reset_shadow_found();
 619
 620         priv->bCfgScanning = true;
 621         if (request->n_channels <= MAX_NUM_SCANNED_NETWORKS) {
 622                 for (i = 0; i < request->n_channels; i++)
 623                         au8ScanChanList[i] = (u8)ieee80211_frequency_to_channel(request->channels[i]->center_freq);
 624
 625                 if (request->n_ssids >= 1) {
 626                         strHiddenNetwork.net_info =
 627                                 kmalloc_array(request->n_ssids,
 628                                               sizeof(struct hidden_network),
 629                                               GFP_KERNEL);
 630                         if (!strHiddenNetwork.net_info)
 631                                 return -ENOMEM;
 632                         strHiddenNetwork.n_ssids = request->n_ssids;
 633
 634
 635                         for (i = 0; i < request->n_ssids; i++) {
 636                                 if (request->ssids[i].ssid_len != 0) {
 637                                         strHiddenNetwork.net_info[i].ssid = kmalloc(request->ssids[i].ssid_len, GFP_KERNEL);
 638                                         memcpy(strHiddenNetwork.net_info[i].ssid, request->ssids[i].ssid, request->ssids[i].ssid_len);
 639                                         strHiddenNetwork.net_info[i].ssid_len = request->ssids[i].ssid_len;
 640                                 } else {
 641                                         strHiddenNetwork.n_ssids -= 1;
 642                                 }
 643                         }
 644                         s32Error = wilc_scan(vif, USER_SCAN, ACTIVE_SCAN,
 645                                              au8ScanChanList,
 646                                              request->n_channels,
 647                                              (const u8 *)request->ie,
 648                                              request->ie_len, CfgScanResult,
 649                                              (void *)priv, &strHiddenNetwork);
 650                 } else {
 651                         s32Error = wilc_scan(vif, USER_SCAN, ACTIVE_SCAN,
 652                                              au8ScanChanList,
 653                                              request->n_channels,
 654                                              (const u8 *)request->ie,
 655                                              request->ie_len, CfgScanResult,
 656                                              (void *)priv, NULL);
 657                 }
 658         } else {
 659                 netdev_err(priv->dev, "Requested scanned channels over\n");
 660         }
 661
 662         if (s32Error != 0)
 663                 s32Error = -EBUSY;
 664
 665         return s32Error;
 666 }
 667
 668 static int connect(struct wiphy *wiphy, struct net_device *dev,
 669                    struct cfg80211_connect_params *sme)
 670 {
 671         s32 s32Error = 0;
 672         u32 i;
 673         u8 u8security = NO_ENCRYPT;
 674         enum AUTHTYPE tenuAuth_type = ANY;
 675
 676         struct wilc_priv *priv;
 677         struct host_if_drv *pstrWFIDrv;
 678         struct network_info *pstrNetworkInfo = NULL;
 679         struct wilc_vif *vif;
 680
 681         wilc_connecting = 1;
 682         priv = wiphy_priv(wiphy);
 683         vif = netdev_priv(priv->dev);
 684         pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;
 685
 686         if (!(strncmp(sme->ssid, "DIRECT-", 7)))
 687                 pstrWFIDrv->p2p_connect = 1;
 688         else
 689                 pstrWFIDrv->p2p_connect = 0;
 690
 691         for (i = 0; i < last_scanned_cnt; i++) {
 692                 if ((sme->ssid_len == last_scanned_shadow[i].ssid_len) &&
 693                     memcmp(last_scanned_shadow[i].ssid,
 694                            sme->ssid,
 695                            sme->ssid_len) == 0) {
 696                         if (!sme->bssid)
 697                                 break;
 698                         else
 699                                 if (memcmp(last_scanned_shadow[i].bssid,
 700                                            sme->bssid,
 701                                            ETH_ALEN) == 0)
 702                                         break;
 703                 }
 704         }
 705
 706         if (i < last_scanned_cnt) {
 707                 pstrNetworkInfo = &last_scanned_shadow[i];
 708         } else {
 709                 s32Error = -ENOENT;
 710                 wilc_connecting = 0;
 711                 return s32Error;
 712         }
 713
 714         memset(priv->WILC_WFI_wep_key, 0, sizeof(priv->WILC_WFI_wep_key));
 715         memset(priv->WILC_WFI_wep_key_len, 0, sizeof(priv->WILC_WFI_wep_key_len));
 716
 717         if (sme->crypto.cipher_group != NO_ENCRYPT) {
 718                 if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_WEP40) {
 719                         u8security = ENCRYPT_ENABLED | WEP;
 720
 721                         priv->WILC_WFI_wep_key_len[sme->key_idx] = sme->key_len;
 722                         memcpy(priv->WILC_WFI_wep_key[sme->key_idx], sme->key, sme->key_len);
 723
 724                         g_key_wep_params.key_len = sme->key_len;
 725                         g_key_wep_params.key = kmalloc(sme->key_len, GFP_KERNEL);
 726                         memcpy(g_key_wep_params.key, sme->key, sme->key_len);
 727                         g_key_wep_params.key_idx = sme->key_idx;
 728                         g_wep_keys_saved = true;
 729
 730                         wilc_set_wep_default_keyid(vif, sme->key_idx);
 731                         wilc_add_wep_key_bss_sta(vif, sme->key, sme->key_len,
 732                                                  sme->key_idx);
 733                 } else if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_WEP104)   {
 734                         u8security = ENCRYPT_ENABLED | WEP | WEP_EXTENDED;
 735
 736                         priv->WILC_WFI_wep_key_len[sme->key_idx] = sme->key_len;
 737                         memcpy(priv->WILC_WFI_wep_key[sme->key_idx], sme->key, sme->key_len);
 738
 739                         g_key_wep_params.key_len = sme->key_len;
 740                         g_key_wep_params.key = kmalloc(sme->key_len, GFP_KERNEL);
 741                         memcpy(g_key_wep_params.key, sme->key, sme->key_len);
 742                         g_key_wep_params.key_idx = sme->key_idx;
 743                         g_wep_keys_saved = true;
 744
 745                         wilc_set_wep_default_keyid(vif, sme->key_idx);
 746                         wilc_add_wep_key_bss_sta(vif, sme->key, sme->key_len,
 747                                                  sme->key_idx);
 748                 } else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)   {
 749                         if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_TKIP)
 750                                 u8security = ENCRYPT_ENABLED | WPA2 | TKIP;
 751                         else
 752                                 u8security = ENCRYPT_ENABLED | WPA2 | AES;
 753                 } else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)   {
 754                         if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_TKIP)
 755                                 u8security = ENCRYPT_ENABLED | WPA | TKIP;
 756                         else
 757                                 u8security = ENCRYPT_ENABLED | WPA | AES;
 758                 } else {
 759                         s32Error = -ENOTSUPP;
 760                         netdev_err(dev, "Not supported cipher\n");
 761                         wilc_connecting = 0;
 762                         return s32Error;
 763                 }
 764         }
 765
 766         if ((sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
 767             || (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)) {
 768                 for (i = 0; i < sme->crypto.n_ciphers_pairwise; i++) {
 769                         if (sme->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP)
 770                                 u8security = u8security | TKIP;
 771                         else
 772                                 u8security = u8security | AES;
 773                 }
 774         }
 775
 776         switch (sme->auth_type) {
 777         case NL80211_AUTHTYPE_OPEN_SYSTEM:
 778                 tenuAuth_type = OPEN_SYSTEM;
 779                 break;
 780
 781         case NL80211_AUTHTYPE_SHARED_KEY:
 782                 tenuAuth_type = SHARED_KEY;
 783                 break;
 784
 785         default:
 786                 break;
 787         }
 788
 789         if (sme->crypto.n_akm_suites) {
 790                 switch (sme->crypto.akm_suites[0]) {
 791                 case WLAN_AKM_SUITE_8021X:
 792                         tenuAuth_type = IEEE8021;
 793                         break;
 794
 795                 default:
 796                         break;
 797                 }
 798         }
 799
 800         curr_channel = pstrNetworkInfo->ch;
 801
 802         if (!pstrWFIDrv->p2p_connect)
 803                 wlan_channel = pstrNetworkInfo->ch;
 804
 805         wilc_wlan_set_bssid(dev, pstrNetworkInfo->bssid, STATION_MODE);
 806
 807         s32Error = wilc_set_join_req(vif, pstrNetworkInfo->bssid, sme->ssid,
 808                                      sme->ssid_len, sme->ie, sme->ie_len,
 809                                      CfgConnectResult, (void *)priv,
 810                                      u8security, tenuAuth_type,
 811                                      pstrNetworkInfo->ch,
 812                                      pstrNetworkInfo->join_params);
 813         if (s32Error != 0) {
 814                 netdev_err(dev, "wilc_set_join_req(): Error\n");
 815                 s32Error = -ENOENT;
 816                 wilc_connecting = 0;
 817                 return s32Error;
 818         }
 819
 820         return s32Error;
 821 }
 822
 823 static int disconnect(struct wiphy *wiphy, struct net_device *dev, u16 reason_code)
 824 {
 825         s32 s32Error = 0;
 826         struct wilc_priv *priv;
 827         struct host_if_drv *pstrWFIDrv;
 828         struct wilc_vif *vif;
 829         struct wilc *wilc;
 830         u8 NullBssid[ETH_ALEN] = {0};
 831
 832         wilc_connecting = 0;
 833         priv = wiphy_priv(wiphy);
 834         vif = netdev_priv(priv->dev);
 835         wilc = vif->wilc;
 836
 837         if (!wilc)
 838                 return -EIO;
 839
 840         if (wilc->close) {
 841                 /* already disconnected done */
 842                 cfg80211_disconnected(dev, 0, NULL, 0, true, GFP_KERNEL);
 843                 return 0;
 844         }
 845
 846         pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;
 847         if (!pstrWFIDrv->p2p_connect)
 848                 wlan_channel = INVALID_CHANNEL;
 849         wilc_wlan_set_bssid(priv->dev, NullBssid, STATION_MODE);
 850
 851         p2p_local_random = 0x01;
 852         p2p_recv_random = 0x00;
 853         wilc_ie = false;
 854         pstrWFIDrv->p2p_timeout = 0;
 855
 856         s32Error = wilc_disconnect(vif, reason_code);
 857         if (s32Error != 0) {
 858                 netdev_err(priv->dev, "Error in disconnecting\n");
 859                 s32Error = -EINVAL;
 860         }
 861
 862         return s32Error;
 863 }
 864
 865 static int add_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
 866                    bool pairwise,
 867                    const u8 *mac_addr, struct key_params *params)
 868
 869 {
 870         s32 s32Error = 0, KeyLen = params->key_len;
 871         struct wilc_priv *priv;
 872         const u8 *pu8RxMic = NULL;
 873         const u8 *pu8TxMic = NULL;
 874         u8 u8mode = NO_ENCRYPT;
 875         u8 u8gmode = NO_ENCRYPT;
 876         u8 u8pmode = NO_ENCRYPT;
 877         enum AUTHTYPE tenuAuth_type = ANY;
 878         struct wilc *wl;
 879         struct wilc_vif *vif;
 880
 881         priv = wiphy_priv(wiphy);
 882         vif = netdev_priv(netdev);
 883         wl = vif->wilc;
 884
 885         switch (params->cipher) {
 886         case WLAN_CIPHER_SUITE_WEP40:
 887         case WLAN_CIPHER_SUITE_WEP104:
 888                 if (priv->wdev->iftype == NL80211_IFTYPE_AP) {
 889                         priv->WILC_WFI_wep_key_len[key_index] = params->key_len;
 890                         memcpy(priv->WILC_WFI_wep_key[key_index], params->key, params->key_len);
 891
 892                         tenuAuth_type = OPEN_SYSTEM;
 893
 894                         if (params->cipher == WLAN_CIPHER_SUITE_WEP40)
 895                                 u8mode = ENCRYPT_ENABLED | WEP;
 896                         else
 897                                 u8mode = ENCRYPT_ENABLED | WEP | WEP_EXTENDED;
 898
 899                         wilc_add_wep_key_bss_ap(vif, params->key,
 900                                                 params->key_len, key_index,
 901                                                 u8mode, tenuAuth_type);
 902                         break;
 903                 }
 904                 if (memcmp(params->key, priv->WILC_WFI_wep_key[key_index], params->key_len)) {
 905                         priv->WILC_WFI_wep_key_len[key_index] = params->key_len;
 906                         memcpy(priv->WILC_WFI_wep_key[key_index], params->key, params->key_len);
 907
 908                         wilc_add_wep_key_bss_sta(vif, params->key,
 909                                                  params->key_len, key_index);
 910                 }
 911
 912                 break;
 913
 914         case WLAN_CIPHER_SUITE_TKIP:
 915         case WLAN_CIPHER_SUITE_CCMP:
 916                 if (priv->wdev->iftype == NL80211_IFTYPE_AP || priv->wdev->iftype == NL80211_IFTYPE_P2P_GO) {
 917                         if (!priv->wilc_gtk[key_index]) {
 918                                 priv->wilc_gtk[key_index] = kmalloc(sizeof(struct wilc_wfi_key), GFP_KERNEL);
 919                                 priv->wilc_gtk[key_index]->key = NULL;
 920                                 priv->wilc_gtk[key_index]->seq = NULL;
 921                         }
 922                         if (!priv->wilc_ptk[key_index]) {
 923                                 priv->wilc_ptk[key_index] = kmalloc(sizeof(struct wilc_wfi_key), GFP_KERNEL);
 924                                 priv->wilc_ptk[key_index]->key = NULL;
 925                                 priv->wilc_ptk[key_index]->seq = NULL;
 926                         }
 927
 928
 929
 930                         if (!pairwise) {
 931                                 if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
 932                                         u8gmode = ENCRYPT_ENABLED | WPA | TKIP;
 933                                 else
 934                                         u8gmode = ENCRYPT_ENABLED | WPA2 | AES;
 935
 936                                 priv->wilc_groupkey = u8gmode;
 937
 938                                 if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {
 939                                         pu8TxMic = params->key + 24;
 940                                         pu8RxMic = params->key + 16;
 941                                         KeyLen = params->key_len - 16;
 942                                 }
 943                                 kfree(priv->wilc_gtk[key_index]->key);
 944
 945                                 priv->wilc_gtk[key_index]->key = kmalloc(params->key_len, GFP_KERNEL);
 946                                 memcpy(priv->wilc_gtk[key_index]->key, params->key, params->key_len);
 947                                 kfree(priv->wilc_gtk[key_index]->seq);
 948
 949                                 if ((params->seq_len) > 0) {
 950                                         priv->wilc_gtk[key_index]->seq = kmalloc(params->seq_len, GFP_KERNEL);
 951                                         memcpy(priv->wilc_gtk[key_index]->seq, params->seq, params->seq_len);
 952                                 }
 953
 954                                 priv->wilc_gtk[key_index]->cipher = params->cipher;
 955                                 priv->wilc_gtk[key_index]->key_len = params->key_len;
 956                                 priv->wilc_gtk[key_index]->seq_len = params->seq_len;
 957
 958                                 wilc_add_rx_gtk(vif, params->key, KeyLen,
 959                                                 key_index, params->seq_len,
 960                                                 params->seq, pu8RxMic,
 961                                                 pu8TxMic, AP_MODE, u8gmode);
 962
 963                         } else {
 964                                 if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
 965                                         u8pmode = ENCRYPT_ENABLED | WPA | TKIP;
 966                                 else
 967                                         u8pmode = priv->wilc_groupkey | AES;
 968
 969
 970                                 if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {
 971                                         pu8TxMic = params->key + 24;
 972                                         pu8RxMic = params->key + 16;
 973                                         KeyLen = params->key_len - 16;
 974                                 }
 975
 976                                 kfree(priv->wilc_ptk[key_index]->key);
 977
 978                                 priv->wilc_ptk[key_index]->key = kmalloc(params->key_len, GFP_KERNEL);
 979
 980                                 kfree(priv->wilc_ptk[key_index]->seq);
 981
 982                                 if ((params->seq_len) > 0)
 983                                         priv->wilc_ptk[key_index]->seq = kmalloc(params->seq_len, GFP_KERNEL);
 984
 985                                 memcpy(priv->wilc_ptk[key_index]->key, params->key, params->key_len);
 986
 987                                 if ((params->seq_len) > 0)
 988                                         memcpy(priv->wilc_ptk[key_index]->seq, params->seq, params->seq_len);
 989
 990                                 priv->wilc_ptk[key_index]->cipher = params->cipher;
 991                                 priv->wilc_ptk[key_index]->key_len = params->key_len;
 992                                 priv->wilc_ptk[key_index]->seq_len = params->seq_len;
 993
 994                                 wilc_add_ptk(vif, params->key, KeyLen,
 995                                              mac_addr, pu8RxMic, pu8TxMic,
 996                                              AP_MODE, u8pmode, key_index);
 997                         }
 998                         break;
 999                 }
1000
1001                 {
1002                         u8mode = 0;
1003                         if (!pairwise) {
1004                                 if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1005                                         pu8RxMic = params->key + 24;
1006                                         pu8TxMic = params->key + 16;
1007                                         KeyLen = params->key_len - 16;
1008                                 }
1009
1010                                 if (!g_gtk_keys_saved && netdev == wl->vif[0]->ndev) {
1011                                         g_add_gtk_key_params.key_idx = key_index;
1012                                         g_add_gtk_key_params.pairwise = pairwise;
1013                                         if (!mac_addr) {
1014                                                 g_add_gtk_key_params.mac_addr = NULL;
1015                                         } else {
1016                                                 g_add_gtk_key_params.mac_addr = kmalloc(ETH_ALEN, GFP_KERNEL);
1017                                                 memcpy(g_add_gtk_key_params.mac_addr, mac_addr, ETH_ALEN);
1018                                         }
1019                                         g_key_gtk_params.key_len = params->key_len;
1020                                         g_key_gtk_params.seq_len = params->seq_len;
1021                                         g_key_gtk_params.key =  kmalloc(params->key_len, GFP_KERNEL);
1022                                         memcpy(g_key_gtk_params.key, params->key, params->key_len);
1023                                         if (params->seq_len > 0) {
1024                                                 g_key_gtk_params.seq =  kmalloc(params->seq_len, GFP_KERNEL);
1025                                                 memcpy(g_key_gtk_params.seq, params->seq, params->seq_len);
1026                                         }
1027                                         g_key_gtk_params.cipher = params->cipher;
1028                                         g_gtk_keys_saved = true;
1029                                 }
1030
1031                                 wilc_add_rx_gtk(vif, params->key, KeyLen,
1032                                                 key_index, params->seq_len,
1033                                                 params->seq, pu8RxMic,
1034                                                 pu8TxMic, STATION_MODE,
1035                                                 u8mode);
1036                         } else {
1037                                 if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1038                                         pu8RxMic = params->key + 24;
1039                                         pu8TxMic = params->key + 16;
1040                                         KeyLen = params->key_len - 16;
1041                                 }
1042
1043                                 if (!g_ptk_keys_saved && netdev == wl->vif[0]->ndev) {
1044                                         g_add_ptk_key_params.key_idx = key_index;
1045                                         g_add_ptk_key_params.pairwise = pairwise;
1046                                         if (!mac_addr) {
1047                                                 g_add_ptk_key_params.mac_addr = NULL;
1048                                         } else {
1049                                                 g_add_ptk_key_params.mac_addr = kmalloc(ETH_ALEN, GFP_KERNEL);
1050                                                 memcpy(g_add_ptk_key_params.mac_addr, mac_addr, ETH_ALEN);
1051                                         }
1052                                         g_key_ptk_params.key_len = params->key_len;
1053                                         g_key_ptk_params.seq_len = params->seq_len;
1054                                         g_key_ptk_params.key =  kmalloc(params->key_len, GFP_KERNEL);
1055                                         memcpy(g_key_ptk_params.key, params->key, params->key_len);
1056                                         if (params->seq_len > 0) {
1057                                                 g_key_ptk_params.seq =  kmalloc(params->seq_len, GFP_KERNEL);
1058                                                 memcpy(g_key_ptk_params.seq, params->seq, params->seq_len);
1059                                         }
1060                                         g_key_ptk_params.cipher = params->cipher;
1061                                         g_ptk_keys_saved = true;
1062                                 }
1063
1064                                 wilc_add_ptk(vif, params->key, KeyLen,
1065                                              mac_addr, pu8RxMic, pu8TxMic,
1066                                              STATION_MODE, u8mode, key_index);
1067                         }
1068                 }
1069                 break;
1070
1071         default:
1072                 netdev_err(netdev, "Not supported cipher\n");
1073                 s32Error = -ENOTSUPP;
1074         }
1075
1076         return s32Error;
1077 }
1078
1079 static int del_key(struct wiphy *wiphy, struct net_device *netdev,
1080                    u8 key_index,
1081                    bool pairwise,
1082                    const u8 *mac_addr)
1083 {
1084         struct wilc_priv *priv;
1085         struct wilc *wl;
1086         struct wilc_vif *vif;
1087
1088         priv = wiphy_priv(wiphy);
1089         vif = netdev_priv(netdev);
1090         wl = vif->wilc;
1091
1092         if (netdev == wl->vif[0]->ndev) {
1093                 g_ptk_keys_saved = false;
1094                 g_gtk_keys_saved = false;
1095                 g_wep_keys_saved = false;
1096
1097                 kfree(g_key_wep_params.key);
1098                 g_key_wep_params.key = NULL;
1099
1100                 if ((priv->wilc_gtk[key_index]) != NULL) {
1101                         kfree(priv->wilc_gtk[key_index]->key);
1102                         priv->wilc_gtk[key_index]->key = NULL;
1103                         kfree(priv->wilc_gtk[key_index]->seq);
1104                         priv->wilc_gtk[key_index]->seq = NULL;
1105
1106                         kfree(priv->wilc_gtk[key_index]);
1107                         priv->wilc_gtk[key_index] = NULL;
1108                 }
1109
1110                 if ((priv->wilc_ptk[key_index]) != NULL) {
1111                         kfree(priv->wilc_ptk[key_index]->key);
1112                         priv->wilc_ptk[key_index]->key = NULL;
1113                         kfree(priv->wilc_ptk[key_index]->seq);
1114                         priv->wilc_ptk[key_index]->seq = NULL;
1115                         kfree(priv->wilc_ptk[key_index]);
1116                         priv->wilc_ptk[key_index] = NULL;
1117                 }
1118
1119                 kfree(g_key_ptk_params.key);
1120                 g_key_ptk_params.key = NULL;
1121                 kfree(g_key_ptk_params.seq);
1122                 g_key_ptk_params.seq = NULL;
1123
1124                 kfree(g_key_gtk_params.key);
1125                 g_key_gtk_params.key = NULL;
1126                 kfree(g_key_gtk_params.seq);
1127                 g_key_gtk_params.seq = NULL;
1128
1129         }
1130
1131         if (key_index >= 0 && key_index <= 3) {
1132                 if (priv->WILC_WFI_wep_key_len[key_index]) {
1133                         memset(priv->WILC_WFI_wep_key[key_index], 0,
1134                                priv->WILC_WFI_wep_key_len[key_index]);
1135                         priv->WILC_WFI_wep_key_len[key_index] = 0;
1136                         wilc_remove_wep_key(vif, key_index);
1137                 }
1138         } else {
1139                 wilc_remove_key(priv->hif_drv, mac_addr);
1140         }
1141
1142         return 0;
1143 }
1144
1145 static int get_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
1146                    bool pairwise,
1147                    const u8 *mac_addr, void *cookie, void (*callback)(void *cookie, struct key_params *))
1148 {
1149         struct wilc_priv *priv;
1150         struct  key_params key_params;
1151
1152         priv = wiphy_priv(wiphy);
1153
1154
1155         if (!pairwise) {
1156                 key_params.key = priv->wilc_gtk[key_index]->key;
1157                 key_params.cipher = priv->wilc_gtk[key_index]->cipher;
1158                 key_params.key_len = priv->wilc_gtk[key_index]->key_len;
1159                 key_params.seq = priv->wilc_gtk[key_index]->seq;
1160                 key_params.seq_len = priv->wilc_gtk[key_index]->seq_len;
1161         } else {
1162                 key_params.key = priv->wilc_ptk[key_index]->key;
1163                 key_params.cipher = priv->wilc_ptk[key_index]->cipher;
1164                 key_params.key_len = priv->wilc_ptk[key_index]->key_len;
1165                 key_params.seq = priv->wilc_ptk[key_index]->seq;
1166                 key_params.seq_len = priv->wilc_ptk[key_index]->seq_len;
1167         }
1168
1169         callback(cookie, &key_params);
1170
1171         return 0;
1172 }
1173
1174 static int set_default_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
1175                            bool unicast, bool multicast)
1176 {
1177         struct wilc_priv *priv;
1178         struct wilc_vif *vif;
1179
1180         priv = wiphy_priv(wiphy);
1181         vif = netdev_priv(priv->dev);
1182
1183         wilc_set_wep_default_keyid(vif, key_index);
1184
1185         return 0;
1186 }
1187
1188 static int get_station(struct wiphy *wiphy, struct net_device *dev,
1189                        const u8 *mac, struct station_info *sinfo)
1190 {
1191         struct wilc_priv *priv;
1192         struct wilc_vif *vif;
1193         u32 i = 0;
1194         u32 associatedsta = 0;
1195         u32 inactive_time = 0;
1196         priv = wiphy_priv(wiphy);
1197         vif = netdev_priv(dev);
1198
1199         if (vif->iftype == AP_MODE || vif->iftype == GO_MODE) {
1200                 for (i = 0; i < NUM_STA_ASSOCIATED; i++) {
1201                         if (!(memcmp(mac, priv->assoc_stainfo.au8Sta_AssociatedBss[i], ETH_ALEN))) {
1202                                 associatedsta = i;
1203                                 break;
1204                         }
1205                 }
1206
1207                 if (associatedsta == -1) {
1208                         netdev_err(dev, "sta required is not associated\n");
1209                         return -ENOENT;
1210                 }
1211
1212                 sinfo->filled |= BIT(NL80211_STA_INFO_INACTIVE_TIME);
1213
1214                 wilc_get_inactive_time(vif, mac, &inactive_time);
1215                 sinfo->inactive_time = 1000 * inactive_time;
1216         }
1217
1218         if (vif->iftype == STATION_MODE) {
1219                 struct rf_info strStatistics;
1220
1221                 wilc_get_statistics(vif, &strStatistics);
1222
1223                 sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL) |
1224                                                 BIT(NL80211_STA_INFO_RX_PACKETS) |
1225                                                 BIT(NL80211_STA_INFO_TX_PACKETS) |
1226                                                 BIT(NL80211_STA_INFO_TX_FAILED) |
1227                                                 BIT(NL80211_STA_INFO_TX_BITRATE);
1228
1229                 sinfo->signal = strStatistics.rssi;
1230                 sinfo->rx_packets = strStatistics.rx_cnt;
1231                 sinfo->tx_packets = strStatistics.tx_cnt + strStatistics.tx_fail_cnt;
1232                 sinfo->tx_failed = strStatistics.tx_fail_cnt;
1233                 sinfo->txrate.legacy = strStatistics.link_speed * 10;
1234
1235                 if ((strStatistics.link_speed > TCP_ACK_FILTER_LINK_SPEED_THRESH) &&
1236                     (strStatistics.link_speed != DEFAULT_LINK_SPEED))
1237                         wilc_enable_tcp_ack_filter(true);
1238                 else if (strStatistics.link_speed != DEFAULT_LINK_SPEED)
1239                         wilc_enable_tcp_ack_filter(false);
1240         }
1241         return 0;
1242 }
1243
1244 static int change_bss(struct wiphy *wiphy, struct net_device *dev,
1245                       struct bss_parameters *params)
1246 {
1247         return 0;
1248 }
1249
1250 static int set_wiphy_params(struct wiphy *wiphy, u32 changed)
1251 {
1252         s32 s32Error = 0;
1253         struct cfg_param_attr pstrCfgParamVal;
1254         struct wilc_priv *priv;
1255         struct wilc_vif *vif;
1256
1257         priv = wiphy_priv(wiphy);
1258         vif = netdev_priv(priv->dev);
1259
1260         pstrCfgParamVal.flag = 0;
1261
1262         if (changed & WIPHY_PARAM_RETRY_SHORT) {
1263                 pstrCfgParamVal.flag  |= RETRY_SHORT;
1264                 pstrCfgParamVal.short_retry_limit = priv->dev->ieee80211_ptr->wiphy->retry_short;
1265         }
1266         if (changed & WIPHY_PARAM_RETRY_LONG) {
1267                 pstrCfgParamVal.flag |= RETRY_LONG;
1268                 pstrCfgParamVal.long_retry_limit = priv->dev->ieee80211_ptr->wiphy->retry_long;
1269         }
1270         if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
1271                 pstrCfgParamVal.flag |= FRAG_THRESHOLD;
1272                 pstrCfgParamVal.frag_threshold = priv->dev->ieee80211_ptr->wiphy->frag_threshold;
1273         }
1274
1275         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1276                 pstrCfgParamVal.flag |= RTS_THRESHOLD;
1277                 pstrCfgParamVal.rts_threshold = priv->dev->ieee80211_ptr->wiphy->rts_threshold;
1278         }
1279
1280         s32Error = wilc_hif_set_cfg(vif, &pstrCfgParamVal);
1281         if (s32Error)
1282                 netdev_err(priv->dev, "Error in setting WIPHY PARAMS\n");
1283
1284         return s32Error;
1285 }
1286
1287 static int set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1288                      struct cfg80211_pmksa *pmksa)
1289 {
1290         u32 i;
1291         s32 s32Error = 0;
1292         u8 flag = 0;
1293         struct wilc_vif *vif;
1294         struct wilc_priv *priv = wiphy_priv(wiphy);
1295
1296         vif = netdev_priv(priv->dev);
1297
1298
1299         for (i = 0; i < priv->pmkid_list.numpmkid; i++) {
1300                 if (!memcmp(pmksa->bssid, priv->pmkid_list.pmkidlist[i].bssid,
1301                                  ETH_ALEN)) {
1302                         flag = PMKID_FOUND;
1303                         break;
1304                 }
1305         }
1306         if (i < WILC_MAX_NUM_PMKIDS) {
1307                 memcpy(priv->pmkid_list.pmkidlist[i].bssid, pmksa->bssid,
1308                             ETH_ALEN);
1309                 memcpy(priv->pmkid_list.pmkidlist[i].pmkid, pmksa->pmkid,
1310                             PMKID_LEN);
1311                 if (!(flag == PMKID_FOUND))
1312                         priv->pmkid_list.numpmkid++;
1313         } else {
1314                 netdev_err(netdev, "Invalid PMKID index\n");
1315                 s32Error = -EINVAL;
1316         }
1317
1318         if (!s32Error)
1319                 s32Error = wilc_set_pmkid_info(vif, &priv->pmkid_list);
1320
1321         return s32Error;
1322 }
1323
1324 static int del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1325                      struct cfg80211_pmksa *pmksa)
1326 {
1327         u32 i;
1328         s32 s32Error = 0;
1329
1330         struct wilc_priv *priv = wiphy_priv(wiphy);
1331
1332         for (i = 0; i < priv->pmkid_list.numpmkid; i++) {
1333                 if (!memcmp(pmksa->bssid, priv->pmkid_list.pmkidlist[i].bssid,
1334                                  ETH_ALEN)) {
1335                         memset(&priv->pmkid_list.pmkidlist[i], 0, sizeof(struct host_if_pmkid));
1336                         break;
1337                 }
1338         }
1339
1340         if (i < priv->pmkid_list.numpmkid && priv->pmkid_list.numpmkid > 0) {
1341                 for (; i < (priv->pmkid_list.numpmkid - 1); i++) {
1342                         memcpy(priv->pmkid_list.pmkidlist[i].bssid,
1343                                     priv->pmkid_list.pmkidlist[i + 1].bssid,
1344                                     ETH_ALEN);
1345                         memcpy(priv->pmkid_list.pmkidlist[i].pmkid,
1346                                     priv->pmkid_list.pmkidlist[i].pmkid,
1347                                     PMKID_LEN);
1348                 }
1349                 priv->pmkid_list.numpmkid--;
1350         } else {
1351                 s32Error = -EINVAL;
1352         }
1353
1354         return s32Error;
1355 }
1356
1357 static int flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1358 {
1359         struct wilc_priv *priv = wiphy_priv(wiphy);
1360
1361         memset(&priv->pmkid_list, 0, sizeof(struct host_if_pmkid_attr));
1362
1363         return 0;
1364 }
1365
1366 static void WILC_WFI_CfgParseRxAction(u8 *buf, u32 len)
1367 {
1368         u32 index = 0;
1369         u32 i = 0, j = 0;
1370
1371         u8 op_channel_attr_index = 0;
1372         u8 channel_list_attr_index = 0;
1373
1374         while (index < len) {
1375                 if (buf[index] == GO_INTENT_ATTR_ID)
1376                         buf[index + 3] = (buf[index + 3]  & 0x01) | (0x00 << 1);
1377
1378                 if (buf[index] ==  CHANLIST_ATTR_ID)
1379                         channel_list_attr_index = index;
1380                 else if (buf[index] ==  OPERCHAN_ATTR_ID)
1381                         op_channel_attr_index = index;
1382                 index += buf[index + 1] + 3;
1383         }
1384         if (wlan_channel != INVALID_CHANNEL) {
1385                 if (channel_list_attr_index) {
1386                         for (i = channel_list_attr_index + 3; i < ((channel_list_attr_index + 3) + buf[channel_list_attr_index + 1]); i++) {
1387                                 if (buf[i] == 0x51) {
1388                                         for (j = i + 2; j < ((i + 2) + buf[i + 1]); j++)
1389                                                 buf[j] = wlan_channel;
1390                                         break;
1391                                 }
1392                         }
1393                 }
1394
1395                 if (op_channel_attr_index) {
1396                         buf[op_channel_attr_index + 6] = 0x51;
1397                         buf[op_channel_attr_index + 7] = wlan_channel;
1398                 }
1399         }
1400 }
1401
1402 static void WILC_WFI_CfgParseTxAction(u8 *buf, u32 len, bool bOperChan, u8 iftype)
1403 {
1404         u32 index = 0;
1405         u32 i = 0, j = 0;
1406
1407         u8 op_channel_attr_index = 0;
1408         u8 channel_list_attr_index = 0;
1409
1410         while (index < len) {
1411                 if (buf[index] == GO_INTENT_ATTR_ID) {
1412                         buf[index + 3] = (buf[index + 3]  & 0x01) | (0x0f << 1);
1413
1414                         break;
1415                 }
1416
1417                 if (buf[index] ==  CHANLIST_ATTR_ID)
1418                         channel_list_attr_index = index;
1419                 else if (buf[index] ==  OPERCHAN_ATTR_ID)
1420                         op_channel_attr_index = index;
1421                 index += buf[index + 1] + 3;
1422         }
1423         if (wlan_channel != INVALID_CHANNEL && bOperChan) {
1424                 if (channel_list_attr_index) {
1425                         for (i = channel_list_attr_index + 3; i < ((channel_list_attr_index + 3) + buf[channel_list_attr_index + 1]); i++) {
1426                                 if (buf[i] == 0x51) {
1427                                         for (j = i + 2; j < ((i + 2) + buf[i + 1]); j++)
1428                                                 buf[j] = wlan_channel;
1429                                         break;
1430                                 }
1431                         }
1432                 }
1433
1434                 if (op_channel_attr_index) {
1435                         buf[op_channel_attr_index + 6] = 0x51;
1436                         buf[op_channel_attr_index + 7] = wlan_channel;
1437                 }
1438         }
1439 }
1440
1441 void WILC_WFI_p2p_rx(struct net_device *dev, u8 *buff, u32 size)
1442 {
1443         struct wilc_priv *priv;
1444         u32 header, pkt_offset;
1445         struct host_if_drv *pstrWFIDrv;
1446         u32 i = 0;
1447         s32 s32Freq;
1448
1449         priv = wiphy_priv(dev->ieee80211_ptr->wiphy);
1450         pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;
1451
1452         memcpy(&header, (buff - HOST_HDR_OFFSET), HOST_HDR_OFFSET);
1453
1454         pkt_offset = GET_PKT_OFFSET(header);
1455
1456         if (pkt_offset & IS_MANAGMEMENT_CALLBACK) {
1457                 if (buff[FRAME_TYPE_ID] == IEEE80211_STYPE_PROBE_RESP) {
1458                         cfg80211_mgmt_tx_status(priv->wdev, priv->u64tx_cookie, buff, size, true, GFP_KERNEL);
1459                         return;
1460                 } else {
1461                         if (pkt_offset & IS_MGMT_STATUS_SUCCES)
1462                                 cfg80211_mgmt_tx_status(priv->wdev, priv->u64tx_cookie, buff, size, true, GFP_KERNEL);
1463                         else
1464                                 cfg80211_mgmt_tx_status(priv->wdev, priv->u64tx_cookie, buff, size, false, GFP_KERNEL);
1465                         return;
1466                 }
1467         } else {
1468                 s32Freq = ieee80211_channel_to_frequency(curr_channel, NL80211_BAND_2GHZ);
1469
1470                 if (ieee80211_is_action(buff[FRAME_TYPE_ID])) {
1471                         if (priv->bCfgScanning && time_after_eq(jiffies, (unsigned long)pstrWFIDrv->p2p_timeout)) {
1472                                 netdev_dbg(dev, "Receiving action wrong ch\n");
1473                                 return;
1474                         }
1475                         if (buff[ACTION_CAT_ID] == PUB_ACTION_ATTR_ID) {
1476                                 switch (buff[ACTION_SUBTYPE_ID]) {
1477                                 case GAS_INTIAL_REQ:
1478                                         break;
1479
1480                                 case GAS_INTIAL_RSP:
1481                                         break;
1482
1483                                 case PUBLIC_ACT_VENDORSPEC:
1484                                         if (!memcmp(p2p_oui, &buff[ACTION_SUBTYPE_ID + 1], 4)) {
1485                                                 if ((buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP)) {
1486                                                         if (!wilc_ie) {
1487                                                                 for (i = P2P_PUB_ACTION_SUBTYPE; i < size; i++) {
1488                                                                         if (!memcmp(p2p_vendor_spec, &buff[i], 6)) {
1489                                                                                 p2p_recv_random = buff[i + 6];
1490                                                                                 wilc_ie = true;
1491                                                                                 break;
1492                                                                         }
1493                                                                 }
1494                                                         }
1495                                                 }
1496                                                 if (p2p_local_random > p2p_recv_random) {
1497                                                         if ((buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP
1498                                                               || buff[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_REQ || buff[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_RSP)) {
1499                                                                 for (i = P2P_PUB_ACTION_SUBTYPE + 2; i < size; i++) {
1500                                                                         if (buff[i] == P2PELEM_ATTR_ID && !(memcmp(p2p_oui, &buff[i + 2], 4))) {
1501                                                                                 WILC_WFI_CfgParseRxAction(&buff[i + 6], size - (i + 6));
1502                                                                                 break;
1503                                                                         }
1504                                                                 }
1505                                                         }
1506                                                 } else {
1507                                                         netdev_dbg(dev, "PEER WILL BE GO LocaRand=%02x RecvRand %02x\n", p2p_local_random, p2p_recv_random);
1508                                                 }
1509                                         }
1510
1511
1512                                         if ((buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buff[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP) && (wilc_ie))    {
1513                                                 cfg80211_rx_mgmt(priv->wdev, s32Freq, 0, buff, size - 7, 0);
1514                                                 return;
1515                                         }
1516                                         break;
1517
1518                                 default:
1519                                         netdev_dbg(dev, "NOT HANDLED PUBLIC ACTION FRAME TYPE:%x\n", buff[ACTION_SUBTYPE_ID]);
1520                                         break;
1521                                 }
1522                         }
1523                 }
1524
1525                 cfg80211_rx_mgmt(priv->wdev, s32Freq, 0, buff, size, 0);
1526         }
1527 }
1528
1529 static void WILC_WFI_mgmt_tx_complete(void *priv, int status)
1530 {
1531         struct p2p_mgmt_data *pv_data = priv;
1532
1533
1534         kfree(pv_data->buff);
1535         kfree(pv_data);
1536 }
1537
1538 static void WILC_WFI_RemainOnChannelReady(void *pUserVoid)
1539 {
1540         struct wilc_priv *priv;
1541
1542         priv = pUserVoid;
1543
1544         priv->bInP2PlistenState = true;
1545
1546         cfg80211_ready_on_channel(priv->wdev,
1547                                   priv->strRemainOnChanParams.u64ListenCookie,
1548                                   priv->strRemainOnChanParams.pstrListenChan,
1549                                   priv->strRemainOnChanParams.u32ListenDuration,
1550                                   GFP_KERNEL);
1551 }
1552
1553 static void WILC_WFI_RemainOnChannelExpired(void *pUserVoid, u32 u32SessionID)
1554 {
1555         struct wilc_priv *priv;
1556
1557         priv = pUserVoid;
1558
1559         if (u32SessionID == priv->strRemainOnChanParams.u32ListenSessionID) {
1560                 priv->bInP2PlistenState = false;
1561
1562                 cfg80211_remain_on_channel_expired(priv->wdev,
1563                                                    priv->strRemainOnChanParams.u64ListenCookie,
1564                                                    priv->strRemainOnChanParams.pstrListenChan,
1565                                                    GFP_KERNEL);
1566         }
1567 }
1568
1569 static int remain_on_channel(struct wiphy *wiphy,
1570                              struct wireless_dev *wdev,
1571                              struct ieee80211_channel *chan,
1572                              unsigned int duration, u64 *cookie)
1573 {
1574         s32 s32Error = 0;
1575         struct wilc_priv *priv;
1576         struct wilc_vif *vif;
1577
1578         priv = wiphy_priv(wiphy);
1579         vif = netdev_priv(priv->dev);
1580
1581         if (wdev->iftype == NL80211_IFTYPE_AP) {
1582                 netdev_dbg(vif->ndev, "Required while in AP mode\n");
1583                 return s32Error;
1584         }
1585
1586         curr_channel = chan->hw_value;
1587
1588         priv->strRemainOnChanParams.pstrListenChan = chan;
1589         priv->strRemainOnChanParams.u64ListenCookie = *cookie;
1590         priv->strRemainOnChanParams.u32ListenDuration = duration;
1591         priv->strRemainOnChanParams.u32ListenSessionID++;
1592
1593         s32Error = wilc_remain_on_channel(vif,
1594                                 priv->strRemainOnChanParams.u32ListenSessionID,
1595                                 duration, chan->hw_value,
1596                                 WILC_WFI_RemainOnChannelExpired,
1597                                 WILC_WFI_RemainOnChannelReady, (void *)priv);
1598
1599         return s32Error;
1600 }
1601
1602 static int cancel_remain_on_channel(struct wiphy *wiphy,
1603                                     struct wireless_dev *wdev,
1604                                     u64 cookie)
1605 {
1606         s32 s32Error = 0;
1607         struct wilc_priv *priv;
1608         struct wilc_vif *vif;
1609
1610         priv = wiphy_priv(wiphy);
1611         vif = netdev_priv(priv->dev);
1612
1613         s32Error = wilc_listen_state_expired(vif, priv->strRemainOnChanParams.u32ListenSessionID);
1614         return s32Error;
1615 }
1616
1617 static int mgmt_tx(struct wiphy *wiphy,
1618                    struct wireless_dev *wdev,
1619                    struct cfg80211_mgmt_tx_params *params,
1620                    u64 *cookie)
1621 {
1622         struct ieee80211_channel *chan = params->chan;
1623         unsigned int wait = params->wait;
1624         const u8 *buf = params->buf;
1625         size_t len = params->len;
1626         const struct ieee80211_mgmt *mgmt;
1627         struct p2p_mgmt_data *mgmt_tx;
1628         struct wilc_priv *priv;
1629         struct host_if_drv *pstrWFIDrv;
1630         u32 i;
1631         struct wilc_vif *vif;
1632         u32 buf_len = len + sizeof(p2p_vendor_spec) + sizeof(p2p_local_random);
1633
1634         vif = netdev_priv(wdev->netdev);
1635         priv = wiphy_priv(wiphy);
1636         pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;
1637
1638         *cookie = (unsigned long)buf;
1639         priv->u64tx_cookie = *cookie;
1640         mgmt = (const struct ieee80211_mgmt *) buf;
1641
1642         if (ieee80211_is_mgmt(mgmt->frame_control)) {
1643                 mgmt_tx = kmalloc(sizeof(struct p2p_mgmt_data), GFP_KERNEL);
1644                 if (!mgmt_tx)
1645                         return -EFAULT;
1646
1647                 mgmt_tx->buff = kmalloc(buf_len, GFP_KERNEL);
1648                 if (!mgmt_tx->buff) {
1649                         kfree(mgmt_tx);
1650                         return -ENOMEM;
1651                 }
1652
1653                 memcpy(mgmt_tx->buff, buf, len);
1654                 mgmt_tx->size = len;
1655
1656
1657                 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
1658                         wilc_set_mac_chnl_num(vif, chan->hw_value);
1659                         curr_channel = chan->hw_value;
1660                 } else if (ieee80211_is_action(mgmt->frame_control))   {
1661                         if (buf[ACTION_CAT_ID] == PUB_ACTION_ATTR_ID) {
1662                                 if (buf[ACTION_SUBTYPE_ID] != PUBLIC_ACT_VENDORSPEC ||
1663                                     buf[P2P_PUB_ACTION_SUBTYPE] != GO_NEG_CONF) {
1664                                         wilc_set_mac_chnl_num(vif,
1665                                                               chan->hw_value);
1666                                         curr_channel = chan->hw_value;
1667                                 }
1668                                 switch (buf[ACTION_SUBTYPE_ID]) {
1669                                 case GAS_INTIAL_REQ:
1670                                         break;
1671
1672                                 case GAS_INTIAL_RSP:
1673                                         break;
1674
1675                                 case PUBLIC_ACT_VENDORSPEC:
1676                                 {
1677                                         if (!memcmp(p2p_oui, &buf[ACTION_SUBTYPE_ID + 1], 4)) {
1678                                                 if ((buf[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP)) {
1679                                                         if (p2p_local_random == 1 && p2p_recv_random < p2p_local_random) {
1680                                                                 get_random_bytes(&p2p_local_random, 1);
1681                                                                 p2p_local_random++;
1682                                                         }
1683                                                 }
1684
1685                                                 if ((buf[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == GO_NEG_RSP
1686                                                       || buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_RSP)) {
1687                                                         if (p2p_local_random > p2p_recv_random) {
1688                                                                 for (i = P2P_PUB_ACTION_SUBTYPE + 2; i < len; i++) {
1689                                                                         if (buf[i] == P2PELEM_ATTR_ID && !(memcmp(p2p_oui, &buf[i + 2], 4))) {
1690                                                                                 if (buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_RSP)
1691                                                                                         WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), true, vif->iftype);
1692                                                                                 else
1693                                                                                         WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), false, vif->iftype);
1694                                                                                 break;
1695                                                                         }
1696                                                                 }
1697
1698                                                                 if (buf[P2P_PUB_ACTION_SUBTYPE] != P2P_INV_REQ && buf[P2P_PUB_ACTION_SUBTYPE] != P2P_INV_RSP) {
1699                                                                         memcpy(&mgmt_tx->buff[len], p2p_vendor_spec, sizeof(p2p_vendor_spec));
1700                                                                         mgmt_tx->buff[len + sizeof(p2p_vendor_spec)] = p2p_local_random;
1701                                                                         mgmt_tx->size = buf_len;
1702                                                                 }
1703                                                         }
1704                                                 }
1705
1706                                         } else {
1707                                                 netdev_dbg(vif->ndev, "Not a P2P public action frame\n");
1708                                         }
1709
1710                                         break;
1711                                 }
1712
1713                                 default:
1714                                 {
1715                                         netdev_dbg(vif->ndev, "NOT HANDLED PUBLIC ACTION FRAME TYPE:%x\n", buf[ACTION_SUBTYPE_ID]);
1716                                         break;
1717                                 }
1718                                 }
1719                         }
1720
1721                         pstrWFIDrv->p2p_timeout = (jiffies + msecs_to_jiffies(wait));
1722                 }
1723
1724                 wilc_wlan_txq_add_mgmt_pkt(wdev->netdev, mgmt_tx,
1725                                            mgmt_tx->buff, mgmt_tx->size,
1726                                            WILC_WFI_mgmt_tx_complete);
1727         }
1728         return 0;
1729 }
1730
1731 static int mgmt_tx_cancel_wait(struct wiphy *wiphy,
1732                                struct wireless_dev *wdev,
1733                                u64 cookie)
1734 {
1735         struct wilc_priv *priv;
1736         struct host_if_drv *pstrWFIDrv;
1737
1738         priv = wiphy_priv(wiphy);
1739         pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;
1740         pstrWFIDrv->p2p_timeout = jiffies;
1741
1742         if (!priv->bInP2PlistenState) {
1743                 cfg80211_remain_on_channel_expired(priv->wdev,
1744                                                    priv->strRemainOnChanParams.u64ListenCookie,
1745                                                    priv->strRemainOnChanParams.pstrListenChan,
1746                                                    GFP_KERNEL);
1747         }
1748
1749         return 0;
1750 }
1751
1752 void wilc_mgmt_frame_register(struct wiphy *wiphy, struct wireless_dev *wdev,
1753                               u16 frame_type, bool reg)
1754 {
1755         struct wilc_priv *priv;
1756         struct wilc_vif *vif;
1757         struct wilc *wl;
1758
1759         priv = wiphy_priv(wiphy);
1760         vif = netdev_priv(priv->wdev->netdev);
1761         wl = vif->wilc;
1762
1763         if (!frame_type)
1764                 return;
1765
1766         switch (frame_type) {
1767         case PROBE_REQ:
1768         {
1769                 vif->frame_reg[0].type = frame_type;
1770                 vif->frame_reg[0].reg = reg;
1771         }
1772         break;
1773
1774         case ACTION:
1775         {
1776                 vif->frame_reg[1].type = frame_type;
1777                 vif->frame_reg[1].reg = reg;
1778         }
1779         break;
1780
1781         default:
1782         {
1783                 break;
1784         }
1785         }
1786
1787         if (!wl->initialized)
1788                 return;
1789         wilc_frame_register(vif, frame_type, reg);
1790 }
1791
1792 static int set_cqm_rssi_config(struct wiphy *wiphy, struct net_device *dev,
1793                                s32 rssi_thold, u32 rssi_hyst)
1794 {
1795         return 0;
1796 }
1797
1798 static int dump_station(struct wiphy *wiphy, struct net_device *dev,
1799                         int idx, u8 *mac, struct station_info *sinfo)
1800 {
1801         struct wilc_priv *priv;
1802         struct wilc_vif *vif;
1803
1804         if (idx != 0)
1805                 return -ENOENT;
1806
1807         priv = wiphy_priv(wiphy);
1808         vif = netdev_priv(priv->dev);
1809
1810         sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
1811
1812         wilc_get_rssi(vif, &sinfo->signal);
1813
1814         memcpy(mac, priv->au8AssociatedBss, ETH_ALEN);
1815         return 0;
1816 }
1817
1818 static int set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1819                           bool enabled, int timeout)
1820 {
1821         struct wilc_priv *priv;
1822         struct wilc_vif *vif;
1823
1824         if (!wiphy)
1825                 return -ENOENT;
1826
1827         priv = wiphy_priv(wiphy);
1828         vif = netdev_priv(priv->dev);
1829         if (!priv->hif_drv)
1830                 return -EIO;
1831
1832         if (wilc_enable_ps)
1833                 wilc_set_power_mgmt(vif, enabled, timeout);
1834
1835
1836         return 0;
1837 }
1838
1839 static int change_virtual_intf(struct wiphy *wiphy, struct net_device *dev,
1840                                enum nl80211_iftype type, u32 *flags, struct vif_params *params)
1841 {
1842         struct wilc_priv *priv;
1843         struct wilc_vif *vif;
1844         struct wilc *wl;
1845
1846         vif = netdev_priv(dev);
1847         priv = wiphy_priv(wiphy);
1848         wl = vif->wilc;
1849         p2p_local_random = 0x01;
1850         p2p_recv_random = 0x00;
1851         wilc_ie = false;
1852         wilc_optaining_ip = false;
1853         del_timer(&wilc_during_ip_timer);
1854
1855         switch (type) {
1856         case NL80211_IFTYPE_STATION:
1857                 wilc_connecting = 0;
1858                 dev->ieee80211_ptr->iftype = type;
1859                 priv->wdev->iftype = type;
1860                 vif->monitor_flag = 0;
1861                 vif->iftype = STATION_MODE;
1862                 wilc_set_operation_mode(vif, STATION_MODE);
1863
1864                 memset(priv->assoc_stainfo.au8Sta_AssociatedBss, 0, MAX_NUM_STA * ETH_ALEN);
1865
1866                 wilc_enable_ps = true;
1867                 wilc_set_power_mgmt(vif, 1, 0);
1868                 break;
1869
1870         case NL80211_IFTYPE_P2P_CLIENT:
1871                 wilc_connecting = 0;
1872                 dev->ieee80211_ptr->iftype = type;
1873                 priv->wdev->iftype = type;
1874                 vif->monitor_flag = 0;
1875                 vif->iftype = CLIENT_MODE;
1876                 wilc_set_operation_mode(vif, STATION_MODE);
1877
1878                 wilc_enable_ps = false;
1879                 wilc_set_power_mgmt(vif, 0, 0);
1880                 break;
1881
1882         case NL80211_IFTYPE_AP:
1883                 wilc_enable_ps = false;
1884                 dev->ieee80211_ptr->iftype = type;
1885                 priv->wdev->iftype = type;
1886                 vif->iftype = AP_MODE;
1887
1888                 if (wl->initialized) {
1889                         wilc_set_wfi_drv_handler(vif, wilc_get_vif_idx(vif),
1890                                                  0);
1891                         wilc_set_operation_mode(vif, AP_MODE);
1892                         wilc_set_power_mgmt(vif, 0, 0);
1893                 }
1894                 break;
1895
1896         case NL80211_IFTYPE_P2P_GO:
1897                 wilc_optaining_ip = true;
1898                 mod_timer(&wilc_during_ip_timer,
1899                           jiffies + msecs_to_jiffies(during_ip_time));
1900                 wilc_set_operation_mode(vif, AP_MODE);
1901                 dev->ieee80211_ptr->iftype = type;
1902                 priv->wdev->iftype = type;
1903                 vif->iftype = GO_MODE;
1904
1905                 wilc_enable_ps = false;
1906                 wilc_set_power_mgmt(vif, 0, 0);
1907                 break;
1908
1909         default:
1910                 netdev_err(dev, "Unknown interface type= %d\n", type);
1911                 return -EINVAL;
1912         }
1913
1914         return 0;
1915 }
1916
1917 static int start_ap(struct wiphy *wiphy, struct net_device *dev,
1918                     struct cfg80211_ap_settings *settings)
1919 {
1920         struct cfg80211_beacon_data *beacon = &(settings->beacon);
1921         struct wilc_priv *priv;
1922         s32 s32Error = 0;
1923         struct wilc *wl;
1924         struct wilc_vif *vif;
1925
1926         priv = wiphy_priv(wiphy);
1927         vif = netdev_priv(dev);
1928         wl = vif->wilc;
1929
1930         s32Error = set_channel(wiphy, &settings->chandef);
1931
1932         if (s32Error != 0)
1933                 netdev_err(dev, "Error in setting channel\n");
1934
1935         wilc_wlan_set_bssid(dev, wl->vif[vif->idx]->src_addr, AP_MODE);
1936         wilc_set_power_mgmt(vif, 0, 0);
1937
1938         s32Error = wilc_add_beacon(vif, settings->beacon_interval,
1939                                    settings->dtim_period, beacon->head_len,
1940                                    (u8 *)beacon->head, beacon->tail_len,
1941                                    (u8 *)beacon->tail);
1942
1943         return s32Error;
1944 }
1945
1946 static int change_beacon(struct wiphy *wiphy, struct net_device *dev,
1947                          struct cfg80211_beacon_data *beacon)
1948 {
1949         struct wilc_priv *priv;
1950         struct wilc_vif *vif;
1951         s32 s32Error = 0;
1952
1953         priv = wiphy_priv(wiphy);
1954         vif = netdev_priv(priv->dev);
1955
1956         s32Error = wilc_add_beacon(vif, 0, 0, beacon->head_len,
1957                                    (u8 *)beacon->head, beacon->tail_len,
1958                                    (u8 *)beacon->tail);
1959
1960         return s32Error;
1961 }
1962
1963 static int stop_ap(struct wiphy *wiphy, struct net_device *dev)
1964 {
1965         s32 s32Error = 0;
1966         struct wilc_priv *priv;
1967         struct wilc_vif *vif;
1968         u8 NullBssid[ETH_ALEN] = {0};
1969
1970         if (!wiphy)
1971                 return -EFAULT;
1972
1973         priv = wiphy_priv(wiphy);
1974         vif = netdev_priv(priv->dev);
1975
1976         wilc_wlan_set_bssid(dev, NullBssid, AP_MODE);
1977
1978         s32Error = wilc_del_beacon(vif);
1979
1980         if (s32Error)
1981                 netdev_err(dev, "Host delete beacon fail\n");
1982
1983         return s32Error;
1984 }
1985
1986 static int add_station(struct wiphy *wiphy, struct net_device *dev,
1987                        const u8 *mac, struct station_parameters *params)
1988 {
1989         s32 s32Error = 0;
1990         struct wilc_priv *priv;
1991         struct add_sta_param strStaParams = { {0} };
1992         struct wilc_vif *vif;
1993
1994         if (!wiphy)
1995                 return -EFAULT;
1996
1997         priv = wiphy_priv(wiphy);
1998         vif = netdev_priv(dev);
1999
2000         if (vif->iftype == AP_MODE || vif->iftype == GO_MODE) {
2001                 memcpy(strStaParams.bssid, mac, ETH_ALEN);
2002                 memcpy(priv->assoc_stainfo.au8Sta_AssociatedBss[params->aid], mac, ETH_ALEN);
2003                 strStaParams.aid = params->aid;
2004                 strStaParams.rates_len = params->supported_rates_len;
2005                 strStaParams.rates = params->supported_rates;
2006
2007                 if (!params->ht_capa) {
2008                         strStaParams.ht_supported = false;
2009                 } else {
2010                         strStaParams.ht_supported = true;
2011                         strStaParams.ht_capa_info = params->ht_capa->cap_info;
2012                         strStaParams.ht_ampdu_params = params->ht_capa->ampdu_params_info;
2013                         memcpy(strStaParams.ht_supp_mcs_set,
2014                                &params->ht_capa->mcs,
2015                                WILC_SUPP_MCS_SET_SIZE);
2016                         strStaParams.ht_ext_params = params->ht_capa->extended_ht_cap_info;
2017                         strStaParams.ht_tx_bf_cap = params->ht_capa->tx_BF_cap_info;
2018                         strStaParams.ht_ante_sel = params->ht_capa->antenna_selection_info;
2019                 }
2020
2021                 strStaParams.flags_mask = params->sta_flags_mask;
2022                 strStaParams.flags_set = params->sta_flags_set;
2023
2024                 s32Error = wilc_add_station(vif, &strStaParams);
2025                 if (s32Error)
2026                         netdev_err(dev, "Host add station fail\n");
2027         }
2028
2029         return s32Error;
2030 }
2031
2032 static int del_station(struct wiphy *wiphy, struct net_device *dev,
2033                        struct station_del_parameters *params)
2034 {
2035         const u8 *mac = params->mac;
2036         s32 s32Error = 0;
2037         struct wilc_priv *priv;
2038         struct wilc_vif *vif;
2039
2040         if (!wiphy)
2041                 return -EFAULT;
2042
2043         priv = wiphy_priv(wiphy);
2044         vif = netdev_priv(dev);
2045
2046         if (vif->iftype == AP_MODE || vif->iftype == GO_MODE) {
2047                 if (!mac)
2048                         s32Error = wilc_del_allstation(vif,
2049                                      priv->assoc_stainfo.au8Sta_AssociatedBss);
2050
2051                 s32Error = wilc_del_station(vif, mac);
2052
2053                 if (s32Error)
2054                         netdev_err(dev, "Host delete station fail\n");
2055         }
2056         return s32Error;
2057 }
2058
2059 static int change_station(struct wiphy *wiphy, struct net_device *dev,
2060                           const u8 *mac, struct station_parameters *params)
2061 {
2062         s32 s32Error = 0;
2063         struct wilc_priv *priv;
2064         struct add_sta_param strStaParams = { {0} };
2065         struct wilc_vif *vif;
2066
2067         if (!wiphy)
2068                 return -EFAULT;
2069
2070         priv = wiphy_priv(wiphy);
2071         vif = netdev_priv(dev);
2072
2073         if (vif->iftype == AP_MODE || vif->iftype == GO_MODE) {
2074                 memcpy(strStaParams.bssid, mac, ETH_ALEN);
2075                 strStaParams.aid = params->aid;
2076                 strStaParams.rates_len = params->supported_rates_len;
2077                 strStaParams.rates = params->supported_rates;
2078
2079                 if (!params->ht_capa) {
2080                         strStaParams.ht_supported = false;
2081                 } else {
2082                         strStaParams.ht_supported = true;
2083                         strStaParams.ht_capa_info = params->ht_capa->cap_info;
2084                         strStaParams.ht_ampdu_params = params->ht_capa->ampdu_params_info;
2085                         memcpy(strStaParams.ht_supp_mcs_set,
2086                                &params->ht_capa->mcs,
2087                                WILC_SUPP_MCS_SET_SIZE);
2088                         strStaParams.ht_ext_params = params->ht_capa->extended_ht_cap_info;
2089                         strStaParams.ht_tx_bf_cap = params->ht_capa->tx_BF_cap_info;
2090                         strStaParams.ht_ante_sel = params->ht_capa->antenna_selection_info;
2091                 }
2092
2093                 strStaParams.flags_mask = params->sta_flags_mask;
2094                 strStaParams.flags_set = params->sta_flags_set;
2095
2096                 s32Error = wilc_edit_station(vif, &strStaParams);
2097                 if (s32Error)
2098                         netdev_err(dev, "Host edit station fail\n");
2099         }
2100         return s32Error;
2101 }
2102
2103 static struct wireless_dev *add_virtual_intf(struct wiphy *wiphy,
2104                                              const char *name,
2105                                              unsigned char name_assign_type,
2106                                              enum nl80211_iftype type,
2107                                              u32 *flags,
2108                                              struct vif_params *params)
2109 {
2110         struct wilc_vif *vif;
2111         struct wilc_priv *priv;
2112         struct net_device *new_ifc = NULL;
2113
2114         priv = wiphy_priv(wiphy);
2115         vif = netdev_priv(priv->wdev->netdev);
2116
2117
2118         if (type == NL80211_IFTYPE_MONITOR) {
2119                 new_ifc = WILC_WFI_init_mon_interface(name, vif->ndev);
2120                 if (new_ifc) {
2121                         vif = netdev_priv(priv->wdev->netdev);
2122                         vif->monitor_flag = 1;
2123                 }
2124         }
2125         return priv->wdev;
2126 }
2127
2128 static int del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
2129 {
2130         return 0;
2131 }
2132
2133 static int wilc_suspend(struct wiphy *wiphy, struct cfg80211_wowlan *wow)
2134 {
2135         struct wilc_priv *priv = wiphy_priv(wiphy);
2136         struct wilc_vif *vif = netdev_priv(priv->dev);
2137
2138         if (!wow && wilc_wlan_get_num_conn_ifcs(vif->wilc))
2139                 vif->wilc->suspend_event = true;
2140         else
2141                 vif->wilc->suspend_event = false;
2142
2143         return 0;
2144 }
2145
2146 static int wilc_resume(struct wiphy *wiphy)
2147 {
2148         struct wilc_priv *priv = wiphy_priv(wiphy);
2149         struct wilc_vif *vif = netdev_priv(priv->dev);
2150
2151         netdev_info(vif->ndev, "cfg resume\n");
2152         return 0;
2153 }
2154
2155 static void wilc_set_wakeup(struct wiphy *wiphy, bool enabled)
2156 {
2157         struct wilc_priv *priv = wiphy_priv(wiphy);
2158         struct wilc_vif *vif = netdev_priv(priv->dev);
2159
2160         netdev_info(vif->ndev, "cfg set wake up = %d\n", enabled);
2161 }
2162
2163 static int set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
2164                         enum nl80211_tx_power_setting type, int mbm)
2165 {
2166         int ret;
2167         s32 tx_power = MBM_TO_DBM(mbm);
2168         struct wilc_priv *priv = wiphy_priv(wiphy);
2169         struct wilc_vif *vif = netdev_priv(priv->dev);
2170
2171         if (tx_power < 0)
2172                 tx_power = 0;
2173         else if (tx_power > 18)
2174                 tx_power = 18;
2175         ret = wilc_set_tx_power(vif, tx_power);
2176         if (ret)
2177                 netdev_err(vif->ndev, "Failed to set tx power\n");
2178
2179         return ret;
2180 }
2181
2182 static int get_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
2183                         int *dbm)
2184 {
2185         int ret;
2186         struct wilc_priv *priv = wiphy_priv(wiphy);
2187         struct wilc_vif *vif = netdev_priv(priv->dev);
2188         struct wilc *wl;
2189
2190         wl = vif->wilc;
2191
2192         /* If firmware is not started, return. */
2193         if (!wl->initialized)
2194                 return -EIO;
2195
2196         ret = wilc_get_tx_power(vif, (u8 *)dbm);
2197         if (ret)
2198                 netdev_err(vif->ndev, "Failed to get tx power\n");
2199
2200         return ret;
2201 }
2202
2203 static struct cfg80211_ops wilc_cfg80211_ops = {
2204         .set_monitor_channel = set_channel,
2205         .scan = scan,
2206         .connect = connect,
2207         .disconnect = disconnect,
2208         .add_key = add_key,
2209         .del_key = del_key,
2210         .get_key = get_key,
2211         .set_default_key = set_default_key,
2212         .add_virtual_intf = add_virtual_intf,
2213         .del_virtual_intf = del_virtual_intf,
2214         .change_virtual_intf = change_virtual_intf,
2215
2216         .start_ap = start_ap,
2217         .change_beacon = change_beacon,
2218         .stop_ap = stop_ap,
2219         .add_station = add_station,
2220         .del_station = del_station,
2221         .change_station = change_station,
2222         .get_station = get_station,
2223         .dump_station = dump_station,
2224         .change_bss = change_bss,
2225         .set_wiphy_params = set_wiphy_params,
2226
2227         .set_pmksa = set_pmksa,
2228         .del_pmksa = del_pmksa,
2229         .flush_pmksa = flush_pmksa,
2230         .remain_on_channel = remain_on_channel,
2231         .cancel_remain_on_channel = cancel_remain_on_channel,
2232         .mgmt_tx_cancel_wait = mgmt_tx_cancel_wait,
2233         .mgmt_tx = mgmt_tx,
2234         .mgmt_frame_register = wilc_mgmt_frame_register,
2235         .set_power_mgmt = set_power_mgmt,
2236         .set_cqm_rssi_config = set_cqm_rssi_config,
2237
2238         .suspend = wilc_suspend,
2239         .resume = wilc_resume,
2240         .set_wakeup = wilc_set_wakeup,
2241         .set_tx_power = set_tx_power,
2242         .get_tx_power = get_tx_power,
2243
2244 };
2245
2246 static struct wireless_dev *WILC_WFI_CfgAlloc(void)
2247 {
2248         struct wireless_dev *wdev;
2249
2250         wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
2251         if (!wdev)
2252                 goto _fail_;
2253
2254         wdev->wiphy = wiphy_new(&wilc_cfg80211_ops, sizeof(struct wilc_priv));
2255         if (!wdev->wiphy)
2256                 goto _fail_mem_;
2257
2258         WILC_WFI_band_2ghz.ht_cap.ht_supported = 1;
2259         WILC_WFI_band_2ghz.ht_cap.cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
2260         WILC_WFI_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
2261         WILC_WFI_band_2ghz.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K;
2262         WILC_WFI_band_2ghz.ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
2263
2264         wdev->wiphy->bands[NL80211_BAND_2GHZ] = &WILC_WFI_band_2ghz;
2265
2266         return wdev;
2267
2268 _fail_mem_:
2269         kfree(wdev);
2270 _fail_:
2271         return NULL;
2272 }
2273
2274 struct wireless_dev *wilc_create_wiphy(struct net_device *net, struct device *dev)
2275 {
2276         struct wilc_priv *priv;
2277         struct wireless_dev *wdev;
2278         s32 s32Error = 0;
2279
2280         wdev = WILC_WFI_CfgAlloc();
2281         if (!wdev) {
2282                 netdev_err(net, "wiphy new allocate failed\n");
2283                 return NULL;
2284         }
2285
2286         priv = wdev_priv(wdev);
2287         priv->wdev = wdev;
2288         wdev->wiphy->max_scan_ssids = MAX_NUM_PROBED_SSID;
2289 #ifdef CONFIG_PM
2290         wdev->wiphy->wowlan = &wowlan_support;
2291 #endif
2292         wdev->wiphy->max_num_pmkids = WILC_MAX_NUM_PMKIDS;
2293         wdev->wiphy->max_scan_ie_len = 1000;
2294         wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2295         wdev->wiphy->cipher_suites = cipher_suites;
2296         wdev->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
2297         wdev->wiphy->mgmt_stypes = wilc_wfi_cfg80211_mgmt_types;
2298
2299         wdev->wiphy->max_remain_on_channel_duration = 500;
2300         wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_MONITOR) | BIT(NL80211_IFTYPE_P2P_GO) |
2301                 BIT(NL80211_IFTYPE_P2P_CLIENT);
2302         wdev->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
2303         wdev->iftype = NL80211_IFTYPE_STATION;
2304
2305         set_wiphy_dev(wdev->wiphy, dev);
2306
2307         s32Error = wiphy_register(wdev->wiphy);
2308         if (s32Error)
2309                 netdev_err(net, "Cannot register wiphy device\n");
2310
2311         priv->dev = net;
2312         return wdev;
2313 }
2314
2315 int wilc_init_host_int(struct net_device *net)
2316 {
2317         int s32Error = 0;
2318
2319         struct wilc_priv *priv;
2320
2321         priv = wdev_priv(net->ieee80211_ptr);
2322         if (op_ifcs == 0) {
2323                 setup_timer(&hAgingTimer, remove_network_from_shadow, 0);
2324                 setup_timer(&wilc_during_ip_timer, clear_duringIP, 0);
2325         }
2326         op_ifcs++;
2327
2328         priv->gbAutoRateAdjusted = false;
2329
2330         priv->bInP2PlistenState = false;
2331
2332         mutex_init(&priv->scan_req_lock);
2333         s32Error = wilc_init(net, &priv->hif_drv);
2334         if (s32Error)
2335                 netdev_err(net, "Error while initializing hostinterface\n");
2336
2337         return s32Error;
2338 }
2339
2340 int wilc_deinit_host_int(struct net_device *net)
2341 {
2342         int s32Error = 0;
2343         struct wilc_vif *vif;
2344         struct wilc_priv *priv;
2345
2346         priv = wdev_priv(net->ieee80211_ptr);
2347         vif = netdev_priv(priv->dev);
2348
2349         priv->gbAutoRateAdjusted = false;
2350
2351         priv->bInP2PlistenState = false;
2352
2353         op_ifcs--;
2354
2355         s32Error = wilc_deinit(vif);
2356
2357         clear_shadow_scan();
2358         if (op_ifcs == 0)
2359                 del_timer_sync(&wilc_during_ip_timer);
2360
2361         if (s32Error)
2362                 netdev_err(net, "Error while deintializing host interface\n");
2363
2364         return s32Error;
2365 }
2366
2367 void wilc_free_wiphy(struct net_device *net)
2368 {
2369         if (!net)
2370                 return;
2371
2372         if (!net->ieee80211_ptr)
2373                 return;
2374
2375         if (!net->ieee80211_ptr->wiphy)
2376                 return;
2377
2378         wiphy_unregister(net->ieee80211_ptr->wiphy);
2379
2380         wiphy_free(net->ieee80211_ptr->wiphy);
2381         kfree(net->ieee80211_ptr);
2382 }