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