drivers/net/wireless/microchip/wilc1000/cfg80211.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
   4  * All rights reserved.
   5  */
   6
   7 #include "cfg80211.h"
   8
   9 #define GO_NEG_REQ                      0x00
  10 #define GO_NEG_RSP                      0x01
  11 #define GO_NEG_CONF                     0x02
  12 #define P2P_INV_REQ                     0x03
  13 #define P2P_INV_RSP                     0x04
  14
  15 #define WILC_INVALID_CHANNEL            0
  16
  17 /* Operation at 2.4 GHz with channels 1-13 */
  18 #define WILC_WLAN_OPERATING_CLASS_2_4GHZ                0x51
  19
  20 static const struct ieee80211_txrx_stypes
  21         wilc_wfi_cfg80211_mgmt_types[NUM_NL80211_IFTYPES] = {
  22         [NL80211_IFTYPE_STATION] = {
  23                 .tx = 0xffff,
  24                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
  25                         BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
  26         },
  27         [NL80211_IFTYPE_AP] = {
  28                 .tx = 0xffff,
  29                 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
  30                         BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
  31                         BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
  32                         BIT(IEEE80211_STYPE_DISASSOC >> 4) |
  33                         BIT(IEEE80211_STYPE_AUTH >> 4) |
  34                         BIT(IEEE80211_STYPE_DEAUTH >> 4) |
  35                         BIT(IEEE80211_STYPE_ACTION >> 4)
  36         },
  37         [NL80211_IFTYPE_P2P_CLIENT] = {
  38                 .tx = 0xffff,
  39                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
  40                         BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
  41                         BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
  42                         BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
  43                         BIT(IEEE80211_STYPE_DISASSOC >> 4) |
  44                         BIT(IEEE80211_STYPE_AUTH >> 4) |
  45                         BIT(IEEE80211_STYPE_DEAUTH >> 4)
  46         }
  47 };
  48
  49 #ifdef CONFIG_PM
  50 static const struct wiphy_wowlan_support wowlan_support = {
  51         .flags = WIPHY_WOWLAN_ANY
  52 };
  53 #endif
  54
  55 struct wilc_p2p_mgmt_data {
  56         int size;
  57         u8 *buff;
  58 };
  59
  60 struct wilc_p2p_pub_act_frame {
  61         u8 category;
  62         u8 action;
  63         u8 oui[3];
  64         u8 oui_type;
  65         u8 oui_subtype;
  66         u8 dialog_token;
  67         u8 elem[];
  68 } __packed;
  69
  70 struct wilc_vendor_specific_ie {
  71         u8 tag_number;
  72         u8 tag_len;
  73         u8 oui[3];
  74         u8 oui_type;
  75         u8 attr[];
  76 } __packed;
  77
  78 struct wilc_attr_entry {
  79         u8  attr_type;
  80         __le16 attr_len;
  81         u8 val[];
  82 } __packed;
  83
  84 struct wilc_attr_oper_ch {
  85         u8 attr_type;
  86         __le16 attr_len;
  87         u8 country_code[IEEE80211_COUNTRY_STRING_LEN];
  88         u8 op_class;
  89         u8 op_channel;
  90 } __packed;
  91
  92 struct wilc_attr_ch_list {
  93         u8 attr_type;
  94         __le16 attr_len;
  95         u8 country_code[IEEE80211_COUNTRY_STRING_LEN];
  96         u8 elem[];
  97 } __packed;
  98
  99 struct wilc_ch_list_elem {
 100         u8 op_class;
 101         u8 no_of_channels;
 102         u8 ch_list[];
 103 } __packed;
 104
 105 static void cfg_scan_result(enum scan_event scan_event,
 106                             struct wilc_rcvd_net_info *info, void *user_void)
 107 {
 108         struct wilc_priv *priv = user_void;
 109
 110         if (!priv->cfg_scanning)
 111                 return;
 112
 113         if (scan_event == SCAN_EVENT_NETWORK_FOUND) {
 114                 s32 freq;
 115                 struct ieee80211_channel *channel;
 116                 struct cfg80211_bss *bss;
 117                 struct wiphy *wiphy = priv->dev->ieee80211_ptr->wiphy;
 118
 119                 if (!wiphy || !info)
 120                         return;
 121
 122                 freq = ieee80211_channel_to_frequency((s32)info->ch,
 123                                                       NL80211_BAND_2GHZ);
 124                 channel = ieee80211_get_channel(wiphy, freq);
 125                 if (!channel)
 126                         return;
 127
 128                 bss = cfg80211_inform_bss_frame(wiphy, channel, info->mgmt,
 129                                                 info->frame_len,
 130                                                 (s32)info->rssi * 100,
 131                                                 GFP_KERNEL);
 132                 cfg80211_put_bss(wiphy, bss);
 133         } else if (scan_event == SCAN_EVENT_DONE) {
 134                 mutex_lock(&priv->scan_req_lock);
 135
 136                 if (priv->scan_req) {
 137                         struct cfg80211_scan_info info = {
 138                                 .aborted = false,
 139                         };
 140
 141                         cfg80211_scan_done(priv->scan_req, &info);
 142                         priv->cfg_scanning = false;
 143                         priv->scan_req = NULL;
 144                 }
 145                 mutex_unlock(&priv->scan_req_lock);
 146         } else if (scan_event == SCAN_EVENT_ABORTED) {
 147                 mutex_lock(&priv->scan_req_lock);
 148
 149                 if (priv->scan_req) {
 150                         struct cfg80211_scan_info info = {
 151                                 .aborted = false,
 152                         };
 153
 154                         cfg80211_scan_done(priv->scan_req, &info);
 155                         priv->cfg_scanning = false;
 156                         priv->scan_req = NULL;
 157                 }
 158                 mutex_unlock(&priv->scan_req_lock);
 159         }
 160 }
 161
 162 static void cfg_connect_result(enum conn_event conn_disconn_evt, u8 mac_status,
 163                                void *priv_data)
 164 {
 165         struct wilc_priv *priv = priv_data;
 166         struct net_device *dev = priv->dev;
 167         struct wilc_vif *vif = netdev_priv(dev);
 168         struct wilc *wl = vif->wilc;
 169         struct host_if_drv *wfi_drv = priv->hif_drv;
 170         struct wilc_conn_info *conn_info = &wfi_drv->conn_info;
 171         struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
 172
 173         vif->connecting = false;
 174
 175         if (conn_disconn_evt == CONN_DISCONN_EVENT_CONN_RESP) {
 176                 u16 connect_status = conn_info->status;
 177
 178                 if (mac_status == WILC_MAC_STATUS_DISCONNECTED &&
 179                     connect_status == WLAN_STATUS_SUCCESS) {
 180                         connect_status = WLAN_STATUS_UNSPECIFIED_FAILURE;
 181                         wilc_wlan_set_bssid(priv->dev, NULL, WILC_STATION_MODE);
 182
 183                         if (vif->iftype != WILC_CLIENT_MODE)
 184                                 wl->sta_ch = WILC_INVALID_CHANNEL;
 185
 186                         netdev_err(dev, "Unspecified failure\n");
 187                 }
 188
 189                 if (connect_status == WLAN_STATUS_SUCCESS)
 190                         memcpy(priv->associated_bss, conn_info->bssid,
 191                                ETH_ALEN);
 192
 193                 cfg80211_ref_bss(wiphy, vif->bss);
 194                 cfg80211_connect_bss(dev, conn_info->bssid, vif->bss,
 195                                      conn_info->req_ies,
 196                                      conn_info->req_ies_len,
 197                                      conn_info->resp_ies,
 198                                      conn_info->resp_ies_len,
 199                                      connect_status, GFP_KERNEL,
 200                                      NL80211_TIMEOUT_UNSPECIFIED);
 201
 202                 vif->bss = NULL;
 203         } else if (conn_disconn_evt == CONN_DISCONN_EVENT_DISCONN_NOTIF) {
 204                 u16 reason = 0;
 205
 206                 eth_zero_addr(priv->associated_bss);
 207                 wilc_wlan_set_bssid(priv->dev, NULL, WILC_STATION_MODE);
 208
 209                 if (vif->iftype != WILC_CLIENT_MODE) {
 210                         wl->sta_ch = WILC_INVALID_CHANNEL;
 211                 } else {
 212                         if (wfi_drv->ifc_up)
 213                                 reason = 3;
 214                         else
 215                                 reason = 1;
 216                 }
 217
 218                 cfg80211_disconnected(dev, reason, NULL, 0, false, GFP_KERNEL);
 219         }
 220 }
 221
 222 struct wilc_vif *wilc_get_wl_to_vif(struct wilc *wl)
 223 {
 224         struct wilc_vif *vif;
 225
 226         vif = list_first_or_null_rcu(&wl->vif_list, typeof(*vif), list);
 227         if (!vif)
 228                 return ERR_PTR(-EINVAL);
 229
 230         return vif;
 231 }
 232
 233 static int set_channel(struct wiphy *wiphy,
 234                        struct cfg80211_chan_def *chandef)
 235 {
 236         struct wilc *wl = wiphy_priv(wiphy);
 237         struct wilc_vif *vif;
 238         u32 channelnum;
 239         int result;
 240         int srcu_idx;
 241
 242         srcu_idx = srcu_read_lock(&wl->srcu);
 243         vif = wilc_get_wl_to_vif(wl);
 244         if (IS_ERR(vif)) {
 245                 srcu_read_unlock(&wl->srcu, srcu_idx);
 246                 return PTR_ERR(vif);
 247         }
 248
 249         channelnum = ieee80211_frequency_to_channel(chandef->chan->center_freq);
 250
 251         wl->op_ch = channelnum;
 252         result = wilc_set_mac_chnl_num(vif, channelnum);
 253         if (result)
 254                 netdev_err(vif->ndev, "Error in setting channel\n");
 255
 256         srcu_read_unlock(&wl->srcu, srcu_idx);
 257         return result;
 258 }
 259
 260 static int scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
 261 {
 262         struct wilc_vif *vif = netdev_priv(request->wdev->netdev);
 263         struct wilc_priv *priv = &vif->priv;
 264         u32 i;
 265         int ret = 0;
 266         u8 scan_ch_list[WILC_MAX_NUM_SCANNED_CH];
 267         u8 scan_type;
 268
 269         if (request->n_channels > WILC_MAX_NUM_SCANNED_CH) {
 270                 netdev_err(vif->ndev, "Requested scanned channels over\n");
 271                 return -EINVAL;
 272         }
 273
 274         priv->scan_req = request;
 275         priv->cfg_scanning = true;
 276         for (i = 0; i < request->n_channels; i++) {
 277                 u16 freq = request->channels[i]->center_freq;
 278
 279                 scan_ch_list[i] = ieee80211_frequency_to_channel(freq);
 280         }
 281
 282         if (request->n_ssids)
 283                 scan_type = WILC_FW_ACTIVE_SCAN;
 284         else
 285                 scan_type = WILC_FW_PASSIVE_SCAN;
 286
 287         ret = wilc_scan(vif, WILC_FW_USER_SCAN, scan_type, scan_ch_list,
 288                         request->n_channels, cfg_scan_result, (void *)priv,
 289                         request);
 290
 291         if (ret) {
 292                 priv->scan_req = NULL;
 293                 priv->cfg_scanning = false;
 294         }
 295
 296         return ret;
 297 }
 298
 299 static int connect(struct wiphy *wiphy, struct net_device *dev,
 300                    struct cfg80211_connect_params *sme)
 301 {
 302         struct wilc_vif *vif = netdev_priv(dev);
 303         struct wilc_priv *priv = &vif->priv;
 304         struct host_if_drv *wfi_drv = priv->hif_drv;
 305         int ret;
 306         u32 i;
 307         u8 security = WILC_FW_SEC_NO;
 308         enum authtype auth_type = WILC_FW_AUTH_ANY;
 309         u32 cipher_group;
 310         struct cfg80211_bss *bss;
 311         void *join_params;
 312         u8 ch;
 313
 314         vif->connecting = true;
 315
 316         memset(priv->wep_key, 0, sizeof(priv->wep_key));
 317         memset(priv->wep_key_len, 0, sizeof(priv->wep_key_len));
 318
 319         cipher_group = sme->crypto.cipher_group;
 320         if (cipher_group != 0) {
 321                 if (cipher_group == WLAN_CIPHER_SUITE_WEP40) {
 322                         security = WILC_FW_SEC_WEP;
 323
 324                         priv->wep_key_len[sme->key_idx] = sme->key_len;
 325                         memcpy(priv->wep_key[sme->key_idx], sme->key,
 326                                sme->key_len);
 327
 328                         wilc_set_wep_default_keyid(vif, sme->key_idx);
 329                         wilc_add_wep_key_bss_sta(vif, sme->key, sme->key_len,
 330                                                  sme->key_idx);
 331                 } else if (cipher_group == WLAN_CIPHER_SUITE_WEP104) {
 332                         security = WILC_FW_SEC_WEP_EXTENDED;
 333
 334                         priv->wep_key_len[sme->key_idx] = sme->key_len;
 335                         memcpy(priv->wep_key[sme->key_idx], sme->key,
 336                                sme->key_len);
 337
 338                         wilc_set_wep_default_keyid(vif, sme->key_idx);
 339                         wilc_add_wep_key_bss_sta(vif, sme->key, sme->key_len,
 340                                                  sme->key_idx);
 341                 } else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2) {
 342                         if (cipher_group == WLAN_CIPHER_SUITE_TKIP)
 343                                 security = WILC_FW_SEC_WPA2_TKIP;
 344                         else
 345                                 security = WILC_FW_SEC_WPA2_AES;
 346                 } else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1) {
 347                         if (cipher_group == WLAN_CIPHER_SUITE_TKIP)
 348                                 security = WILC_FW_SEC_WPA_TKIP;
 349                         else
 350                                 security = WILC_FW_SEC_WPA_AES;
 351                 } else {
 352                         ret = -ENOTSUPP;
 353                         netdev_err(dev, "%s: Unsupported cipher\n",
 354                                    __func__);
 355                         goto out_error;
 356                 }
 357         }
 358
 359         if ((sme->crypto.wpa_versions & NL80211_WPA_VERSION_1) ||
 360             (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)) {
 361                 for (i = 0; i < sme->crypto.n_ciphers_pairwise; i++) {
 362                         u32 ciphers_pairwise = sme->crypto.ciphers_pairwise[i];
 363
 364                         if (ciphers_pairwise == WLAN_CIPHER_SUITE_TKIP)
 365                                 security |= WILC_FW_TKIP;
 366                         else
 367                                 security |= WILC_FW_AES;
 368                 }
 369         }
 370
 371         switch (sme->auth_type) {
 372         case NL80211_AUTHTYPE_OPEN_SYSTEM:
 373                 auth_type = WILC_FW_AUTH_OPEN_SYSTEM;
 374                 break;
 375
 376         case NL80211_AUTHTYPE_SHARED_KEY:
 377                 auth_type = WILC_FW_AUTH_SHARED_KEY;
 378                 break;
 379
 380         default:
 381                 break;
 382         }
 383
 384         if (sme->crypto.n_akm_suites) {
 385                 if (sme->crypto.akm_suites[0] == WLAN_AKM_SUITE_8021X)
 386                         auth_type = WILC_FW_AUTH_IEEE8021;
 387         }
 388
 389         if (wfi_drv->usr_scan_req.scan_result) {
 390                 netdev_err(vif->ndev, "%s: Scan in progress\n", __func__);
 391                 ret = -EBUSY;
 392                 goto out_error;
 393         }
 394
 395         bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid, sme->ssid,
 396                                sme->ssid_len, IEEE80211_BSS_TYPE_ANY,
 397                                IEEE80211_PRIVACY(sme->privacy));
 398         if (!bss) {
 399                 ret = -EINVAL;
 400                 goto out_error;
 401         }
 402
 403         if (ether_addr_equal_unaligned(vif->bssid, bss->bssid)) {
 404                 ret = -EALREADY;
 405                 goto out_put_bss;
 406         }
 407
 408         join_params = wilc_parse_join_bss_param(bss, &sme->crypto);
 409         if (!join_params) {
 410                 netdev_err(dev, "%s: failed to construct join param\n",
 411                            __func__);
 412                 ret = -EINVAL;
 413                 goto out_put_bss;
 414         }
 415
 416         ch = ieee80211_frequency_to_channel(bss->channel->center_freq);
 417         vif->wilc->op_ch = ch;
 418         if (vif->iftype != WILC_CLIENT_MODE)
 419                 vif->wilc->sta_ch = ch;
 420
 421         wilc_wlan_set_bssid(dev, bss->bssid, WILC_STATION_MODE);
 422
 423         wfi_drv->conn_info.security = security;
 424         wfi_drv->conn_info.auth_type = auth_type;
 425         wfi_drv->conn_info.ch = ch;
 426         wfi_drv->conn_info.conn_result = cfg_connect_result;
 427         wfi_drv->conn_info.arg = priv;
 428         wfi_drv->conn_info.param = join_params;
 429
 430         ret = wilc_set_join_req(vif, bss->bssid, sme->ie, sme->ie_len);
 431         if (ret) {
 432                 netdev_err(dev, "wilc_set_join_req(): Error\n");
 433                 ret = -ENOENT;
 434                 if (vif->iftype != WILC_CLIENT_MODE)
 435                         vif->wilc->sta_ch = WILC_INVALID_CHANNEL;
 436                 wilc_wlan_set_bssid(dev, NULL, WILC_STATION_MODE);
 437                 wfi_drv->conn_info.conn_result = NULL;
 438                 kfree(join_params);
 439                 goto out_put_bss;
 440         }
 441         kfree(join_params);
 442         vif->bss = bss;
 443         cfg80211_put_bss(wiphy, bss);
 444         return 0;
 445
 446 out_put_bss:
 447         cfg80211_put_bss(wiphy, bss);
 448
 449 out_error:
 450         vif->connecting = false;
 451         return ret;
 452 }
 453
 454 static int disconnect(struct wiphy *wiphy, struct net_device *dev,
 455                       u16 reason_code)
 456 {
 457         struct wilc_vif *vif = netdev_priv(dev);
 458         struct wilc_priv *priv = &vif->priv;
 459         struct wilc *wilc = vif->wilc;
 460         int ret;
 461
 462         vif->connecting = false;
 463
 464         if (!wilc)
 465                 return -EIO;
 466
 467         if (wilc->close) {
 468                 /* already disconnected done */
 469                 cfg80211_disconnected(dev, 0, NULL, 0, true, GFP_KERNEL);
 470                 return 0;
 471         }
 472
 473         if (vif->iftype != WILC_CLIENT_MODE)
 474                 wilc->sta_ch = WILC_INVALID_CHANNEL;
 475         wilc_wlan_set_bssid(priv->dev, NULL, WILC_STATION_MODE);
 476
 477         priv->hif_drv->p2p_timeout = 0;
 478
 479         ret = wilc_disconnect(vif);
 480         if (ret != 0) {
 481                 netdev_err(priv->dev, "Error in disconnecting\n");
 482                 ret = -EINVAL;
 483         }
 484
 485         vif->bss = NULL;
 486
 487         return ret;
 488 }
 489
 490 static inline void wilc_wfi_cfg_copy_wep_info(struct wilc_priv *priv,
 491                                               u8 key_index,
 492                                               struct key_params *params)
 493 {
 494         priv->wep_key_len[key_index] = params->key_len;
 495         memcpy(priv->wep_key[key_index], params->key, params->key_len);
 496 }
 497
 498 static int wilc_wfi_cfg_allocate_wpa_entry(struct wilc_priv *priv, u8 idx)
 499 {
 500         if (!priv->wilc_gtk[idx]) {
 501                 priv->wilc_gtk[idx] = kzalloc(sizeof(*priv->wilc_gtk[idx]),
 502                                               GFP_KERNEL);
 503                 if (!priv->wilc_gtk[idx])
 504                         return -ENOMEM;
 505         }
 506
 507         if (!priv->wilc_ptk[idx]) {
 508                 priv->wilc_ptk[idx] = kzalloc(sizeof(*priv->wilc_ptk[idx]),
 509                                               GFP_KERNEL);
 510                 if (!priv->wilc_ptk[idx])
 511                         return -ENOMEM;
 512         }
 513
 514         return 0;
 515 }
 516
 517 static int wilc_wfi_cfg_copy_wpa_info(struct wilc_wfi_key *key_info,
 518                                       struct key_params *params)
 519 {
 520         kfree(key_info->key);
 521
 522         key_info->key = kmemdup(params->key, params->key_len, GFP_KERNEL);
 523         if (!key_info->key)
 524                 return -ENOMEM;
 525
 526         kfree(key_info->seq);
 527
 528         if (params->seq_len > 0) {
 529                 key_info->seq = kmemdup(params->seq, params->seq_len,
 530                                         GFP_KERNEL);
 531                 if (!key_info->seq)
 532                         return -ENOMEM;
 533         }
 534
 535         key_info->cipher = params->cipher;
 536         key_info->key_len = params->key_len;
 537         key_info->seq_len = params->seq_len;
 538
 539         return 0;
 540 }
 541
 542 static int add_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
 543                    bool pairwise, const u8 *mac_addr, struct key_params *params)
 544
 545 {
 546         int ret = 0, keylen = params->key_len;
 547         const u8 *rx_mic = NULL;
 548         const u8 *tx_mic = NULL;
 549         u8 mode = WILC_FW_SEC_NO;
 550         u8 op_mode;
 551         struct wilc_vif *vif = netdev_priv(netdev);
 552         struct wilc_priv *priv = &vif->priv;
 553
 554         switch (params->cipher) {
 555         case WLAN_CIPHER_SUITE_WEP40:
 556         case WLAN_CIPHER_SUITE_WEP104:
 557                 if (priv->wdev.iftype == NL80211_IFTYPE_AP) {
 558                         wilc_wfi_cfg_copy_wep_info(priv, key_index, params);
 559
 560                         if (params->cipher == WLAN_CIPHER_SUITE_WEP40)
 561                                 mode = WILC_FW_SEC_WEP;
 562                         else
 563                                 mode = WILC_FW_SEC_WEP_EXTENDED;
 564
 565                         ret = wilc_add_wep_key_bss_ap(vif, params->key,
 566                                                       params->key_len,
 567                                                       key_index, mode,
 568                                                       WILC_FW_AUTH_OPEN_SYSTEM);
 569                         break;
 570                 }
 571                 if (memcmp(params->key, priv->wep_key[key_index],
 572                            params->key_len)) {
 573                         wilc_wfi_cfg_copy_wep_info(priv, key_index, params);
 574
 575                         ret = wilc_add_wep_key_bss_sta(vif, params->key,
 576                                                        params->key_len,
 577                                                        key_index);
 578                 }
 579
 580                 break;
 581
 582         case WLAN_CIPHER_SUITE_TKIP:
 583         case WLAN_CIPHER_SUITE_CCMP:
 584                 if (priv->wdev.iftype == NL80211_IFTYPE_AP ||
 585                     priv->wdev.iftype == NL80211_IFTYPE_P2P_GO) {
 586                         struct wilc_wfi_key *key;
 587
 588                         ret = wilc_wfi_cfg_allocate_wpa_entry(priv, key_index);
 589                         if (ret)
 590                                 return -ENOMEM;
 591
 592                         if (params->key_len > 16 &&
 593                             params->cipher == WLAN_CIPHER_SUITE_TKIP) {
 594                                 tx_mic = params->key + 24;
 595                                 rx_mic = params->key + 16;
 596                                 keylen = params->key_len - 16;
 597                         }
 598
 599                         if (!pairwise) {
 600                                 if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
 601                                         mode = WILC_FW_SEC_WPA_TKIP;
 602                                 else
 603                                         mode = WILC_FW_SEC_WPA2_AES;
 604
 605                                 priv->wilc_groupkey = mode;
 606
 607                                 key = priv->wilc_gtk[key_index];
 608                         } else {
 609                                 if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
 610                                         mode = WILC_FW_SEC_WPA_TKIP;
 611                                 else
 612                                         mode = priv->wilc_groupkey | WILC_FW_AES;
 613
 614                                 key = priv->wilc_ptk[key_index];
 615                         }
 616                         ret = wilc_wfi_cfg_copy_wpa_info(key, params);
 617                         if (ret)
 618                                 return -ENOMEM;
 619
 620                         op_mode = WILC_AP_MODE;
 621                 } else {
 622                         if (params->key_len > 16 &&
 623                             params->cipher == WLAN_CIPHER_SUITE_TKIP) {
 624                                 rx_mic = params->key + 24;
 625                                 tx_mic = params->key + 16;
 626                                 keylen = params->key_len - 16;
 627                         }
 628
 629                         op_mode = WILC_STATION_MODE;
 630                 }
 631
 632                 if (!pairwise)
 633                         ret = wilc_add_rx_gtk(vif, params->key, keylen,
 634                                               key_index, params->seq_len,
 635                                               params->seq, rx_mic, tx_mic,
 636                                               op_mode, mode);
 637                 else
 638                         ret = wilc_add_ptk(vif, params->key, keylen, mac_addr,
 639                                            rx_mic, tx_mic, op_mode, mode,
 640                                            key_index);
 641
 642                 break;
 643
 644         default:
 645                 netdev_err(netdev, "%s: Unsupported cipher\n", __func__);
 646                 ret = -ENOTSUPP;
 647         }
 648
 649         return ret;
 650 }
 651
 652 static int del_key(struct wiphy *wiphy, struct net_device *netdev,
 653                    u8 key_index,
 654                    bool pairwise,
 655                    const u8 *mac_addr)
 656 {
 657         struct wilc_vif *vif = netdev_priv(netdev);
 658         struct wilc_priv *priv = &vif->priv;
 659
 660         if (priv->wilc_gtk[key_index]) {
 661                 kfree(priv->wilc_gtk[key_index]->key);
 662                 priv->wilc_gtk[key_index]->key = NULL;
 663                 kfree(priv->wilc_gtk[key_index]->seq);
 664                 priv->wilc_gtk[key_index]->seq = NULL;
 665
 666                 kfree(priv->wilc_gtk[key_index]);
 667                 priv->wilc_gtk[key_index] = NULL;
 668         }
 669
 670         if (priv->wilc_ptk[key_index]) {
 671                 kfree(priv->wilc_ptk[key_index]->key);
 672                 priv->wilc_ptk[key_index]->key = NULL;
 673                 kfree(priv->wilc_ptk[key_index]->seq);
 674                 priv->wilc_ptk[key_index]->seq = NULL;
 675                 kfree(priv->wilc_ptk[key_index]);
 676                 priv->wilc_ptk[key_index] = NULL;
 677         }
 678
 679         if (key_index <= 3 && priv->wep_key_len[key_index]) {
 680                 memset(priv->wep_key[key_index], 0,
 681                        priv->wep_key_len[key_index]);
 682                 priv->wep_key_len[key_index] = 0;
 683                 wilc_remove_wep_key(vif, key_index);
 684         }
 685
 686         return 0;
 687 }
 688
 689 static int get_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
 690                    bool pairwise, const u8 *mac_addr, void *cookie,
 691                    void (*callback)(void *cookie, struct key_params *))
 692 {
 693         struct wilc_vif *vif = netdev_priv(netdev);
 694         struct wilc_priv *priv = &vif->priv;
 695         struct  key_params key_params;
 696
 697         if (!pairwise) {
 698                 key_params.key = priv->wilc_gtk[key_index]->key;
 699                 key_params.cipher = priv->wilc_gtk[key_index]->cipher;
 700                 key_params.key_len = priv->wilc_gtk[key_index]->key_len;
 701                 key_params.seq = priv->wilc_gtk[key_index]->seq;
 702                 key_params.seq_len = priv->wilc_gtk[key_index]->seq_len;
 703         } else {
 704                 key_params.key = priv->wilc_ptk[key_index]->key;
 705                 key_params.cipher = priv->wilc_ptk[key_index]->cipher;
 706                 key_params.key_len = priv->wilc_ptk[key_index]->key_len;
 707                 key_params.seq = priv->wilc_ptk[key_index]->seq;
 708                 key_params.seq_len = priv->wilc_ptk[key_index]->seq_len;
 709         }
 710
 711         callback(cookie, &key_params);
 712
 713         return 0;
 714 }
 715
 716 static int set_default_key(struct wiphy *wiphy, struct net_device *netdev,
 717                            u8 key_index, bool unicast, bool multicast)
 718 {
 719         struct wilc_vif *vif = netdev_priv(netdev);
 720
 721         wilc_set_wep_default_keyid(vif, key_index);
 722
 723         return 0;
 724 }
 725
 726 static int get_station(struct wiphy *wiphy, struct net_device *dev,
 727                        const u8 *mac, struct station_info *sinfo)
 728 {
 729         struct wilc_vif *vif = netdev_priv(dev);
 730         struct wilc_priv *priv = &vif->priv;
 731         struct wilc *wilc = vif->wilc;
 732         u32 i = 0;
 733         u32 associatedsta = ~0;
 734         u32 inactive_time = 0;
 735
 736         if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) {
 737                 for (i = 0; i < NUM_STA_ASSOCIATED; i++) {
 738                         if (!(memcmp(mac,
 739                                      priv->assoc_stainfo.sta_associated_bss[i],
 740                                      ETH_ALEN))) {
 741                                 associatedsta = i;
 742                                 break;
 743                         }
 744                 }
 745
 746                 if (associatedsta == ~0) {
 747                         netdev_err(dev, "sta required is not associated\n");
 748                         return -ENOENT;
 749                 }
 750
 751                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME);
 752
 753                 wilc_get_inactive_time(vif, mac, &inactive_time);
 754                 sinfo->inactive_time = 1000 * inactive_time;
 755         } else if (vif->iftype == WILC_STATION_MODE) {
 756                 struct rf_info stats;
 757
 758                 if (!wilc->initialized)
 759                         return -EBUSY;
 760
 761                 wilc_get_statistics(vif, &stats);
 762
 763                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL) |
 764                                  BIT_ULL(NL80211_STA_INFO_RX_PACKETS) |
 765                                  BIT_ULL(NL80211_STA_INFO_TX_PACKETS) |
 766                                  BIT_ULL(NL80211_STA_INFO_TX_FAILED) |
 767                                  BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
 768
 769                 sinfo->signal = stats.rssi;
 770                 sinfo->rx_packets = stats.rx_cnt;
 771                 sinfo->tx_packets = stats.tx_cnt + stats.tx_fail_cnt;
 772                 sinfo->tx_failed = stats.tx_fail_cnt;
 773                 sinfo->txrate.legacy = stats.link_speed * 10;
 774
 775                 if (stats.link_speed > TCP_ACK_FILTER_LINK_SPEED_THRESH &&
 776                     stats.link_speed != DEFAULT_LINK_SPEED)
 777                         wilc_enable_tcp_ack_filter(vif, true);
 778                 else if (stats.link_speed != DEFAULT_LINK_SPEED)
 779                         wilc_enable_tcp_ack_filter(vif, false);
 780         }
 781         return 0;
 782 }
 783
 784 static int change_bss(struct wiphy *wiphy, struct net_device *dev,
 785                       struct bss_parameters *params)
 786 {
 787         return 0;
 788 }
 789
 790 static int set_wiphy_params(struct wiphy *wiphy, u32 changed)
 791 {
 792         int ret = -EINVAL;
 793         struct cfg_param_attr cfg_param_val;
 794         struct wilc *wl = wiphy_priv(wiphy);
 795         struct wilc_vif *vif;
 796         struct wilc_priv *priv;
 797         int srcu_idx;
 798
 799         srcu_idx = srcu_read_lock(&wl->srcu);
 800         vif = wilc_get_wl_to_vif(wl);
 801         if (IS_ERR(vif))
 802                 goto out;
 803
 804         priv = &vif->priv;
 805         cfg_param_val.flag = 0;
 806
 807         if (changed & WIPHY_PARAM_RETRY_SHORT) {
 808                 netdev_dbg(vif->ndev,
 809                            "Setting WIPHY_PARAM_RETRY_SHORT %d\n",
 810                            wiphy->retry_short);
 811                 cfg_param_val.flag  |= WILC_CFG_PARAM_RETRY_SHORT;
 812                 cfg_param_val.short_retry_limit = wiphy->retry_short;
 813         }
 814         if (changed & WIPHY_PARAM_RETRY_LONG) {
 815                 netdev_dbg(vif->ndev,
 816                            "Setting WIPHY_PARAM_RETRY_LONG %d\n",
 817                            wiphy->retry_long);
 818                 cfg_param_val.flag |= WILC_CFG_PARAM_RETRY_LONG;
 819                 cfg_param_val.long_retry_limit = wiphy->retry_long;
 820         }
 821         if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
 822                 if (wiphy->frag_threshold > 255 &&
 823                     wiphy->frag_threshold < 7937) {
 824                         netdev_dbg(vif->ndev,
 825                                    "Setting WIPHY_PARAM_FRAG_THRESHOLD %d\n",
 826                                    wiphy->frag_threshold);
 827                         cfg_param_val.flag |= WILC_CFG_PARAM_FRAG_THRESHOLD;
 828                         cfg_param_val.frag_threshold = wiphy->frag_threshold;
 829                 } else {
 830                         netdev_err(vif->ndev,
 831                                    "Fragmentation threshold out of range\n");
 832                         goto out;
 833                 }
 834         }
 835
 836         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
 837                 if (wiphy->rts_threshold > 255) {
 838                         netdev_dbg(vif->ndev,
 839                                    "Setting WIPHY_PARAM_RTS_THRESHOLD %d\n",
 840                                    wiphy->rts_threshold);
 841                         cfg_param_val.flag |= WILC_CFG_PARAM_RTS_THRESHOLD;
 842                         cfg_param_val.rts_threshold = wiphy->rts_threshold;
 843                 } else {
 844                         netdev_err(vif->ndev, "RTS threshold out of range\n");
 845                         goto out;
 846                 }
 847         }
 848
 849         ret = wilc_hif_set_cfg(vif, &cfg_param_val);
 850         if (ret)
 851                 netdev_err(priv->dev, "Error in setting WIPHY PARAMS\n");
 852
 853 out:
 854         srcu_read_unlock(&wl->srcu, srcu_idx);
 855         return ret;
 856 }
 857
 858 static int set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
 859                      struct cfg80211_pmksa *pmksa)
 860 {
 861         struct wilc_vif *vif = netdev_priv(netdev);
 862         struct wilc_priv *priv = &vif->priv;
 863         u32 i;
 864         int ret = 0;
 865         u8 flag = 0;
 866
 867         for (i = 0; i < priv->pmkid_list.numpmkid; i++) {
 868                 if (!memcmp(pmksa->bssid, priv->pmkid_list.pmkidlist[i].bssid,
 869                             ETH_ALEN)) {
 870                         flag = PMKID_FOUND;
 871                         break;
 872                 }
 873         }
 874         if (i < WILC_MAX_NUM_PMKIDS) {
 875                 memcpy(priv->pmkid_list.pmkidlist[i].bssid, pmksa->bssid,
 876                        ETH_ALEN);
 877                 memcpy(priv->pmkid_list.pmkidlist[i].pmkid, pmksa->pmkid,
 878                        WLAN_PMKID_LEN);
 879                 if (!(flag == PMKID_FOUND))
 880                         priv->pmkid_list.numpmkid++;
 881         } else {
 882                 netdev_err(netdev, "Invalid PMKID index\n");
 883                 ret = -EINVAL;
 884         }
 885
 886         if (!ret)
 887                 ret = wilc_set_pmkid_info(vif, &priv->pmkid_list);
 888
 889         return ret;
 890 }
 891
 892 static int del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
 893                      struct cfg80211_pmksa *pmksa)
 894 {
 895         u32 i;
 896         struct wilc_vif *vif = netdev_priv(netdev);
 897         struct wilc_priv *priv = &vif->priv;
 898
 899         for (i = 0; i < priv->pmkid_list.numpmkid; i++) {
 900                 if (!memcmp(pmksa->bssid, priv->pmkid_list.pmkidlist[i].bssid,
 901                             ETH_ALEN)) {
 902                         memset(&priv->pmkid_list.pmkidlist[i], 0,
 903                                sizeof(struct wilc_pmkid));
 904                         break;
 905                 }
 906         }
 907
 908         if (i == priv->pmkid_list.numpmkid)
 909                 return -EINVAL;
 910
 911         for (; i < (priv->pmkid_list.numpmkid - 1); i++) {
 912                 memcpy(priv->pmkid_list.pmkidlist[i].bssid,
 913                        priv->pmkid_list.pmkidlist[i + 1].bssid,
 914                        ETH_ALEN);
 915                 memcpy(priv->pmkid_list.pmkidlist[i].pmkid,
 916                        priv->pmkid_list.pmkidlist[i + 1].pmkid,
 917                        WLAN_PMKID_LEN);
 918         }
 919         priv->pmkid_list.numpmkid--;
 920
 921         return 0;
 922 }
 923
 924 static int flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
 925 {
 926         struct wilc_vif *vif = netdev_priv(netdev);
 927
 928         memset(&vif->priv.pmkid_list, 0, sizeof(struct wilc_pmkid_attr));
 929
 930         return 0;
 931 }
 932
 933 static inline void wilc_wfi_cfg_parse_ch_attr(u8 *buf, u32 len, u8 sta_ch)
 934 {
 935         struct wilc_attr_entry *e;
 936         struct wilc_attr_ch_list *ch_list;
 937         struct wilc_attr_oper_ch *op_ch;
 938         u32 index = 0;
 939         u8 ch_list_idx = 0;
 940         u8 op_ch_idx = 0;
 941
 942         if (sta_ch == WILC_INVALID_CHANNEL)
 943                 return;
 944
 945         while (index + sizeof(*e) <= len) {
 946                 e = (struct wilc_attr_entry *)&buf[index];
 947                 if (e->attr_type == IEEE80211_P2P_ATTR_CHANNEL_LIST)
 948                         ch_list_idx = index;
 949                 else if (e->attr_type == IEEE80211_P2P_ATTR_OPER_CHANNEL)
 950                         op_ch_idx = index;
 951                 if (ch_list_idx && op_ch_idx)
 952                         break;
 953                 index += le16_to_cpu(e->attr_len) + sizeof(*e);
 954         }
 955
 956         if (ch_list_idx) {
 957                 u16 attr_size;
 958                 struct wilc_ch_list_elem *e;
 959                 int i;
 960
 961                 ch_list = (struct wilc_attr_ch_list *)&buf[ch_list_idx];
 962                 attr_size = le16_to_cpu(ch_list->attr_len);
 963                 for (i = 0; i < attr_size;) {
 964                         e = (struct wilc_ch_list_elem *)(ch_list->elem + i);
 965                         if (e->op_class == WILC_WLAN_OPERATING_CLASS_2_4GHZ) {
 966                                 memset(e->ch_list, sta_ch, e->no_of_channels);
 967                                 break;
 968                         }
 969                         i += e->no_of_channels;
 970                 }
 971         }
 972
 973         if (op_ch_idx) {
 974                 op_ch = (struct wilc_attr_oper_ch *)&buf[op_ch_idx];
 975                 op_ch->op_class = WILC_WLAN_OPERATING_CLASS_2_4GHZ;
 976                 op_ch->op_channel = sta_ch;
 977         }
 978 }
 979
 980 void wilc_wfi_p2p_rx(struct wilc_vif *vif, u8 *buff, u32 size)
 981 {
 982         struct wilc *wl = vif->wilc;
 983         struct wilc_priv *priv = &vif->priv;
 984         struct host_if_drv *wfi_drv = priv->hif_drv;
 985         struct ieee80211_mgmt *mgmt;
 986         struct wilc_vendor_specific_ie *p;
 987         struct wilc_p2p_pub_act_frame *d;
 988         int ie_offset = offsetof(struct ieee80211_mgmt, u) + sizeof(*d);
 989         const u8 *vendor_ie;
 990         u32 header, pkt_offset;
 991         s32 freq;
 992
 993         header = get_unaligned_le32(buff - HOST_HDR_OFFSET);
 994         pkt_offset = FIELD_GET(WILC_PKT_HDR_OFFSET_FIELD, header);
 995
 996         if (pkt_offset & IS_MANAGMEMENT_CALLBACK) {
 997                 bool ack = false;
 998                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)buff;
 999
1000                 if (ieee80211_is_probe_resp(hdr->frame_control) ||
1001                     pkt_offset & IS_MGMT_STATUS_SUCCES)
1002                         ack = true;
1003
1004                 cfg80211_mgmt_tx_status(&priv->wdev, priv->tx_cookie, buff,
1005                                         size, ack, GFP_KERNEL);
1006                 return;
1007         }
1008
1009         freq = ieee80211_channel_to_frequency(wl->op_ch, NL80211_BAND_2GHZ);
1010
1011         mgmt = (struct ieee80211_mgmt *)buff;
1012         if (!ieee80211_is_action(mgmt->frame_control))
1013                 goto out_rx_mgmt;
1014
1015         if (priv->cfg_scanning &&
1016             time_after_eq(jiffies, (unsigned long)wfi_drv->p2p_timeout)) {
1017                 netdev_dbg(vif->ndev, "Receiving action wrong ch\n");
1018                 return;
1019         }
1020
1021         if (!ieee80211_is_public_action((struct ieee80211_hdr *)buff, size))
1022                 goto out_rx_mgmt;
1023
1024         d = (struct wilc_p2p_pub_act_frame *)(&mgmt->u.action);
1025         if (d->oui_subtype != GO_NEG_REQ && d->oui_subtype != GO_NEG_RSP &&
1026             d->oui_subtype != P2P_INV_REQ && d->oui_subtype != P2P_INV_RSP)
1027                 goto out_rx_mgmt;
1028
1029         vendor_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1030                                             buff + ie_offset, size - ie_offset);
1031         if (!vendor_ie)
1032                 goto out_rx_mgmt;
1033
1034         p = (struct wilc_vendor_specific_ie *)vendor_ie;
1035         wilc_wfi_cfg_parse_ch_attr(p->attr, p->tag_len - 4, vif->wilc->sta_ch);
1036
1037 out_rx_mgmt:
1038         cfg80211_rx_mgmt(&priv->wdev, freq, 0, buff, size, 0);
1039 }
1040
1041 static void wilc_wfi_mgmt_tx_complete(void *priv, int status)
1042 {
1043         struct wilc_p2p_mgmt_data *pv_data = priv;
1044
1045         kfree(pv_data->buff);
1046         kfree(pv_data);
1047 }
1048
1049 static void wilc_wfi_remain_on_channel_expired(void *data, u64 cookie)
1050 {
1051         struct wilc_vif *vif = data;
1052         struct wilc_priv *priv = &vif->priv;
1053         struct wilc_wfi_p2p_listen_params *params = &priv->remain_on_ch_params;
1054
1055         if (cookie != params->listen_cookie)
1056                 return;
1057
1058         priv->p2p_listen_state = false;
1059
1060         cfg80211_remain_on_channel_expired(&priv->wdev, params->listen_cookie,
1061                                            params->listen_ch, GFP_KERNEL);
1062 }
1063
1064 static int remain_on_channel(struct wiphy *wiphy,
1065                              struct wireless_dev *wdev,
1066                              struct ieee80211_channel *chan,
1067                              unsigned int duration, u64 *cookie)
1068 {
1069         int ret = 0;
1070         struct wilc_vif *vif = netdev_priv(wdev->netdev);
1071         struct wilc_priv *priv = &vif->priv;
1072         u64 id;
1073
1074         if (wdev->iftype == NL80211_IFTYPE_AP) {
1075                 netdev_dbg(vif->ndev, "Required while in AP mode\n");
1076                 return ret;
1077         }
1078
1079         id = ++priv->inc_roc_cookie;
1080         if (id == 0)
1081                 id = ++priv->inc_roc_cookie;
1082
1083         ret = wilc_remain_on_channel(vif, id, duration, chan->hw_value,
1084                                      wilc_wfi_remain_on_channel_expired,
1085                                      (void *)vif);
1086         if (ret)
1087                 return ret;
1088
1089         vif->wilc->op_ch = chan->hw_value;
1090
1091         priv->remain_on_ch_params.listen_ch = chan;
1092         priv->remain_on_ch_params.listen_cookie = id;
1093         *cookie = id;
1094         priv->p2p_listen_state = true;
1095         priv->remain_on_ch_params.listen_duration = duration;
1096
1097         cfg80211_ready_on_channel(wdev, *cookie, chan, duration, GFP_KERNEL);
1098         mod_timer(&vif->hif_drv->remain_on_ch_timer,
1099                   jiffies + msecs_to_jiffies(duration + 1000));
1100
1101         return ret;
1102 }
1103
1104 static int cancel_remain_on_channel(struct wiphy *wiphy,
1105                                     struct wireless_dev *wdev,
1106                                     u64 cookie)
1107 {
1108         struct wilc_vif *vif = netdev_priv(wdev->netdev);
1109         struct wilc_priv *priv = &vif->priv;
1110
1111         if (cookie != priv->remain_on_ch_params.listen_cookie)
1112                 return -ENOENT;
1113
1114         return wilc_listen_state_expired(vif, cookie);
1115 }
1116
1117 static int mgmt_tx(struct wiphy *wiphy,
1118                    struct wireless_dev *wdev,
1119                    struct cfg80211_mgmt_tx_params *params,
1120                    u64 *cookie)
1121 {
1122         struct ieee80211_channel *chan = params->chan;
1123         unsigned int wait = params->wait;
1124         const u8 *buf = params->buf;
1125         size_t len = params->len;
1126         const struct ieee80211_mgmt *mgmt;
1127         struct wilc_p2p_mgmt_data *mgmt_tx;
1128         struct wilc_vif *vif = netdev_priv(wdev->netdev);
1129         struct wilc_priv *priv = &vif->priv;
1130         struct host_if_drv *wfi_drv = priv->hif_drv;
1131         struct wilc_vendor_specific_ie *p;
1132         struct wilc_p2p_pub_act_frame *d;
1133         int ie_offset = offsetof(struct ieee80211_mgmt, u) + sizeof(*d);
1134         const u8 *vendor_ie;
1135         int ret = 0;
1136
1137         *cookie = prandom_u32();
1138         priv->tx_cookie = *cookie;
1139         mgmt = (const struct ieee80211_mgmt *)buf;
1140
1141         if (!ieee80211_is_mgmt(mgmt->frame_control))
1142                 goto out;
1143
1144         mgmt_tx = kmalloc(sizeof(*mgmt_tx), GFP_KERNEL);
1145         if (!mgmt_tx) {
1146                 ret = -ENOMEM;
1147                 goto out;
1148         }
1149
1150         mgmt_tx->buff = kmemdup(buf, len, GFP_KERNEL);
1151         if (!mgmt_tx->buff) {
1152                 ret = -ENOMEM;
1153                 kfree(mgmt_tx);
1154                 goto out;
1155         }
1156
1157         mgmt_tx->size = len;
1158
1159         if (ieee80211_is_probe_resp(mgmt->frame_control)) {
1160                 wilc_set_mac_chnl_num(vif, chan->hw_value);
1161                 vif->wilc->op_ch = chan->hw_value;
1162                 goto out_txq_add_pkt;
1163         }
1164
1165         if (!ieee80211_is_public_action((struct ieee80211_hdr *)buf, len))
1166                 goto out_set_timeout;
1167
1168         d = (struct wilc_p2p_pub_act_frame *)(&mgmt->u.action);
1169         if (d->oui_type != WLAN_OUI_TYPE_WFA_P2P ||
1170             d->oui_subtype != GO_NEG_CONF) {
1171                 wilc_set_mac_chnl_num(vif, chan->hw_value);
1172                 vif->wilc->op_ch = chan->hw_value;
1173         }
1174
1175         if (d->oui_subtype != P2P_INV_REQ && d->oui_subtype != P2P_INV_RSP)
1176                 goto out_set_timeout;
1177
1178         vendor_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1179                                             mgmt_tx->buff + ie_offset,
1180                                             len - ie_offset);
1181         if (!vendor_ie)
1182                 goto out_set_timeout;
1183
1184         p = (struct wilc_vendor_specific_ie *)vendor_ie;
1185         wilc_wfi_cfg_parse_ch_attr(p->attr, p->tag_len - 4, vif->wilc->sta_ch);
1186
1187 out_set_timeout:
1188         wfi_drv->p2p_timeout = (jiffies + msecs_to_jiffies(wait));
1189
1190 out_txq_add_pkt:
1191
1192         wilc_wlan_txq_add_mgmt_pkt(wdev->netdev, mgmt_tx,
1193                                    mgmt_tx->buff, mgmt_tx->size,
1194                                    wilc_wfi_mgmt_tx_complete);
1195
1196 out:
1197
1198         return ret;
1199 }
1200
1201 static int mgmt_tx_cancel_wait(struct wiphy *wiphy,
1202                                struct wireless_dev *wdev,
1203                                u64 cookie)
1204 {
1205         struct wilc_vif *vif = netdev_priv(wdev->netdev);
1206         struct wilc_priv *priv = &vif->priv;
1207         struct host_if_drv *wfi_drv = priv->hif_drv;
1208
1209         wfi_drv->p2p_timeout = jiffies;
1210
1211         if (!priv->p2p_listen_state) {
1212                 struct wilc_wfi_p2p_listen_params *params;
1213
1214                 params = &priv->remain_on_ch_params;
1215
1216                 cfg80211_remain_on_channel_expired(wdev,
1217                                                    params->listen_cookie,
1218                                                    params->listen_ch,
1219                                                    GFP_KERNEL);
1220         }
1221
1222         return 0;
1223 }
1224
1225 void wilc_update_mgmt_frame_registrations(struct wiphy *wiphy,
1226                                           struct wireless_dev *wdev,
1227                                           struct mgmt_frame_regs *upd)
1228 {
1229         struct wilc *wl = wiphy_priv(wiphy);
1230         struct wilc_vif *vif = netdev_priv(wdev->netdev);
1231         u32 presp_bit = BIT(IEEE80211_STYPE_PROBE_REQ >> 4);
1232         u32 action_bit = BIT(IEEE80211_STYPE_ACTION >> 4);
1233
1234         if (wl->initialized) {
1235                 bool prev = vif->mgmt_reg_stypes & presp_bit;
1236                 bool now = upd->interface_stypes & presp_bit;
1237
1238                 if (now != prev)
1239                         wilc_frame_register(vif, IEEE80211_STYPE_PROBE_REQ, now);
1240
1241                 prev = vif->mgmt_reg_stypes & action_bit;
1242                 now = upd->interface_stypes & action_bit;
1243
1244                 if (now != prev)
1245                         wilc_frame_register(vif, IEEE80211_STYPE_ACTION, now);
1246         }
1247
1248         vif->mgmt_reg_stypes =
1249                 upd->interface_stypes & (presp_bit | action_bit);
1250 }
1251
1252 static int set_cqm_rssi_config(struct wiphy *wiphy, struct net_device *dev,
1253                                s32 rssi_thold, u32 rssi_hyst)
1254 {
1255         return 0;
1256 }
1257
1258 static int dump_station(struct wiphy *wiphy, struct net_device *dev,
1259                         int idx, u8 *mac, struct station_info *sinfo)
1260 {
1261         struct wilc_vif *vif = netdev_priv(dev);
1262         int ret;
1263
1264         if (idx != 0)
1265                 return -ENOENT;
1266
1267         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
1268
1269         ret = wilc_get_rssi(vif, &sinfo->signal);
1270         if (ret)
1271                 return ret;
1272
1273         memcpy(mac, vif->priv.associated_bss, ETH_ALEN);
1274         return 0;
1275 }
1276
1277 static int set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1278                           bool enabled, int timeout)
1279 {
1280         struct wilc_vif *vif = netdev_priv(dev);
1281         struct wilc_priv *priv = &vif->priv;
1282
1283         if (!priv->hif_drv)
1284                 return -EIO;
1285
1286         wilc_set_power_mgmt(vif, enabled, timeout);
1287
1288         return 0;
1289 }
1290
1291 static int change_virtual_intf(struct wiphy *wiphy, struct net_device *dev,
1292                                enum nl80211_iftype type,
1293                                struct vif_params *params)
1294 {
1295         struct wilc *wl = wiphy_priv(wiphy);
1296         struct wilc_vif *vif = netdev_priv(dev);
1297         struct wilc_priv *priv = &vif->priv;
1298
1299         switch (type) {
1300         case NL80211_IFTYPE_STATION:
1301                 vif->connecting = false;
1302                 dev->ieee80211_ptr->iftype = type;
1303                 priv->wdev.iftype = type;
1304                 vif->monitor_flag = 0;
1305                 if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE)
1306                         wilc_wfi_deinit_mon_interface(wl, true);
1307                 vif->iftype = WILC_STATION_MODE;
1308
1309                 if (wl->initialized)
1310                         wilc_set_operation_mode(vif, wilc_get_vif_idx(vif),
1311                                                 WILC_STATION_MODE, vif->idx);
1312
1313                 memset(priv->assoc_stainfo.sta_associated_bss, 0,
1314                        WILC_MAX_NUM_STA * ETH_ALEN);
1315                 break;
1316
1317         case NL80211_IFTYPE_P2P_CLIENT:
1318                 vif->connecting = false;
1319                 dev->ieee80211_ptr->iftype = type;
1320                 priv->wdev.iftype = type;
1321                 vif->monitor_flag = 0;
1322                 vif->iftype = WILC_CLIENT_MODE;
1323
1324                 if (wl->initialized)
1325                         wilc_set_operation_mode(vif, wilc_get_vif_idx(vif),
1326                                                 WILC_STATION_MODE, vif->idx);
1327                 break;
1328
1329         case NL80211_IFTYPE_AP:
1330                 dev->ieee80211_ptr->iftype = type;
1331                 priv->wdev.iftype = type;
1332                 vif->iftype = WILC_AP_MODE;
1333
1334                 if (wl->initialized)
1335                         wilc_set_operation_mode(vif, wilc_get_vif_idx(vif),
1336                                                 WILC_AP_MODE, vif->idx);
1337                 break;
1338
1339         case NL80211_IFTYPE_P2P_GO:
1340                 dev->ieee80211_ptr->iftype = type;
1341                 priv->wdev.iftype = type;
1342                 vif->iftype = WILC_GO_MODE;
1343
1344                 if (wl->initialized)
1345                         wilc_set_operation_mode(vif, wilc_get_vif_idx(vif),
1346                                                 WILC_AP_MODE, vif->idx);
1347                 break;
1348
1349         default:
1350                 netdev_err(dev, "Unknown interface type= %d\n", type);
1351                 return -EINVAL;
1352         }
1353
1354         return 0;
1355 }
1356
1357 static int start_ap(struct wiphy *wiphy, struct net_device *dev,
1358                     struct cfg80211_ap_settings *settings)
1359 {
1360         struct wilc_vif *vif = netdev_priv(dev);
1361         int ret;
1362
1363         ret = set_channel(wiphy, &settings->chandef);
1364         if (ret != 0)
1365                 netdev_err(dev, "Error in setting channel\n");
1366
1367         wilc_wlan_set_bssid(dev, dev->dev_addr, WILC_AP_MODE);
1368
1369         return wilc_add_beacon(vif, settings->beacon_interval,
1370                                    settings->dtim_period, &settings->beacon);
1371 }
1372
1373 static int change_beacon(struct wiphy *wiphy, struct net_device *dev,
1374                          struct cfg80211_beacon_data *beacon)
1375 {
1376         struct wilc_vif *vif = netdev_priv(dev);
1377
1378         return wilc_add_beacon(vif, 0, 0, beacon);
1379 }
1380
1381 static int stop_ap(struct wiphy *wiphy, struct net_device *dev)
1382 {
1383         int ret;
1384         struct wilc_vif *vif = netdev_priv(dev);
1385
1386         wilc_wlan_set_bssid(dev, NULL, WILC_AP_MODE);
1387
1388         ret = wilc_del_beacon(vif);
1389
1390         if (ret)
1391                 netdev_err(dev, "Host delete beacon fail\n");
1392
1393         return ret;
1394 }
1395
1396 static int add_station(struct wiphy *wiphy, struct net_device *dev,
1397                        const u8 *mac, struct station_parameters *params)
1398 {
1399         int ret = 0;
1400         struct wilc_vif *vif = netdev_priv(dev);
1401         struct wilc_priv *priv = &vif->priv;
1402
1403         if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) {
1404                 memcpy(priv->assoc_stainfo.sta_associated_bss[params->aid], mac,
1405                        ETH_ALEN);
1406
1407                 ret = wilc_add_station(vif, mac, params);
1408                 if (ret)
1409                         netdev_err(dev, "Host add station fail\n");
1410         }
1411
1412         return ret;
1413 }
1414
1415 static int del_station(struct wiphy *wiphy, struct net_device *dev,
1416                        struct station_del_parameters *params)
1417 {
1418         const u8 *mac = params->mac;
1419         int ret = 0;
1420         struct wilc_vif *vif = netdev_priv(dev);
1421         struct wilc_priv *priv = &vif->priv;
1422         struct sta_info *info;
1423
1424         if (!(vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE))
1425                 return ret;
1426
1427         info = &priv->assoc_stainfo;
1428
1429         if (!mac)
1430                 ret = wilc_del_allstation(vif, info->sta_associated_bss);
1431
1432         ret = wilc_del_station(vif, mac);
1433         if (ret)
1434                 netdev_err(dev, "Host delete station fail\n");
1435         return ret;
1436 }
1437
1438 static int change_station(struct wiphy *wiphy, struct net_device *dev,
1439                           const u8 *mac, struct station_parameters *params)
1440 {
1441         int ret = 0;
1442         struct wilc_vif *vif = netdev_priv(dev);
1443
1444         if (vif->iftype == WILC_AP_MODE || vif->iftype == WILC_GO_MODE) {
1445                 ret = wilc_edit_station(vif, mac, params);
1446                 if (ret)
1447                         netdev_err(dev, "Host edit station fail\n");
1448         }
1449         return ret;
1450 }
1451
1452 static struct wilc_vif *wilc_get_vif_from_type(struct wilc *wl, int type)
1453 {
1454         struct wilc_vif *vif;
1455
1456         list_for_each_entry_rcu(vif, &wl->vif_list, list) {
1457                 if (vif->iftype == type)
1458                         return vif;
1459         }
1460
1461         return NULL;
1462 }
1463
1464 static struct wireless_dev *add_virtual_intf(struct wiphy *wiphy,
1465                                              const char *name,
1466                                              unsigned char name_assign_type,
1467                                              enum nl80211_iftype type,
1468                                              struct vif_params *params)
1469 {
1470         struct wilc *wl = wiphy_priv(wiphy);
1471         struct wilc_vif *vif;
1472         struct wireless_dev *wdev;
1473         int iftype;
1474
1475         if (type == NL80211_IFTYPE_MONITOR) {
1476                 struct net_device *ndev;
1477                 int srcu_idx;
1478
1479                 srcu_idx = srcu_read_lock(&wl->srcu);
1480                 vif = wilc_get_vif_from_type(wl, WILC_AP_MODE);
1481                 if (!vif) {
1482                         vif = wilc_get_vif_from_type(wl, WILC_GO_MODE);
1483                         if (!vif) {
1484                                 srcu_read_unlock(&wl->srcu, srcu_idx);
1485                                 goto validate_interface;
1486                         }
1487                 }
1488
1489                 if (vif->monitor_flag) {
1490                         srcu_read_unlock(&wl->srcu, srcu_idx);
1491                         goto validate_interface;
1492                 }
1493
1494                 ndev = wilc_wfi_init_mon_interface(wl, name, vif->ndev);
1495                 if (ndev) {
1496                         vif->monitor_flag = 1;
1497                 } else {
1498                         srcu_read_unlock(&wl->srcu, srcu_idx);
1499                         return ERR_PTR(-EINVAL);
1500                 }
1501
1502                 wdev = &vif->priv.wdev;
1503                 srcu_read_unlock(&wl->srcu, srcu_idx);
1504                 return wdev;
1505         }
1506
1507 validate_interface:
1508         mutex_lock(&wl->vif_mutex);
1509         if (wl->vif_num == WILC_NUM_CONCURRENT_IFC) {
1510                 pr_err("Reached maximum number of interface\n");
1511                 mutex_unlock(&wl->vif_mutex);
1512                 return ERR_PTR(-EINVAL);
1513         }
1514         mutex_unlock(&wl->vif_mutex);
1515
1516         switch (type) {
1517         case NL80211_IFTYPE_STATION:
1518                 iftype = WILC_STATION_MODE;
1519                 break;
1520         case NL80211_IFTYPE_AP:
1521                 iftype = WILC_AP_MODE;
1522                 break;
1523         default:
1524                 return ERR_PTR(-EOPNOTSUPP);
1525         }
1526
1527         vif = wilc_netdev_ifc_init(wl, name, iftype, type, true);
1528         if (IS_ERR(vif))
1529                 return ERR_CAST(vif);
1530
1531         return &vif->priv.wdev;
1532 }
1533
1534 static int del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
1535 {
1536         struct wilc *wl = wiphy_priv(wiphy);
1537         struct wilc_vif *vif;
1538
1539         if (wdev->iftype == NL80211_IFTYPE_AP ||
1540             wdev->iftype == NL80211_IFTYPE_P2P_GO)
1541                 wilc_wfi_deinit_mon_interface(wl, true);
1542         vif = netdev_priv(wdev->netdev);
1543         cfg80211_stop_iface(wiphy, wdev, GFP_KERNEL);
1544         cfg80211_unregister_netdevice(vif->ndev);
1545         vif->monitor_flag = 0;
1546
1547         wilc_set_operation_mode(vif, 0, 0, 0);
1548         mutex_lock(&wl->vif_mutex);
1549         list_del_rcu(&vif->list);
1550         wl->vif_num--;
1551         mutex_unlock(&wl->vif_mutex);
1552         synchronize_srcu(&wl->srcu);
1553         return 0;
1554 }
1555
1556 static int wilc_suspend(struct wiphy *wiphy, struct cfg80211_wowlan *wow)
1557 {
1558         struct wilc *wl = wiphy_priv(wiphy);
1559
1560         if (!wow && wilc_wlan_get_num_conn_ifcs(wl))
1561                 wl->suspend_event = true;
1562         else
1563                 wl->suspend_event = false;
1564
1565         return 0;
1566 }
1567
1568 static int wilc_resume(struct wiphy *wiphy)
1569 {
1570         return 0;
1571 }
1572
1573 static void wilc_set_wakeup(struct wiphy *wiphy, bool enabled)
1574 {
1575         struct wilc *wl = wiphy_priv(wiphy);
1576         struct wilc_vif *vif;
1577         int srcu_idx;
1578
1579         srcu_idx = srcu_read_lock(&wl->srcu);
1580         vif = wilc_get_wl_to_vif(wl);
1581         if (IS_ERR(vif)) {
1582                 srcu_read_unlock(&wl->srcu, srcu_idx);
1583                 return;
1584         }
1585
1586         netdev_info(vif->ndev, "cfg set wake up = %d\n", enabled);
1587         wilc_set_wowlan_trigger(vif, enabled);
1588         srcu_read_unlock(&wl->srcu, srcu_idx);
1589 }
1590
1591 static int set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
1592                         enum nl80211_tx_power_setting type, int mbm)
1593 {
1594         int ret;
1595         int srcu_idx;
1596         s32 tx_power = MBM_TO_DBM(mbm);
1597         struct wilc *wl = wiphy_priv(wiphy);
1598         struct wilc_vif *vif;
1599
1600         if (!wl->initialized)
1601                 return -EIO;
1602
1603         srcu_idx = srcu_read_lock(&wl->srcu);
1604         vif = wilc_get_wl_to_vif(wl);
1605         if (IS_ERR(vif)) {
1606                 srcu_read_unlock(&wl->srcu, srcu_idx);
1607                 return -EINVAL;
1608         }
1609
1610         netdev_info(vif->ndev, "Setting tx power %d\n", tx_power);
1611         if (tx_power < 0)
1612                 tx_power = 0;
1613         else if (tx_power > 18)
1614                 tx_power = 18;
1615         ret = wilc_set_tx_power(vif, tx_power);
1616         if (ret)
1617                 netdev_err(vif->ndev, "Failed to set tx power\n");
1618         srcu_read_unlock(&wl->srcu, srcu_idx);
1619
1620         return ret;
1621 }
1622
1623 static int get_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
1624                         int *dbm)
1625 {
1626         int ret;
1627         struct wilc_vif *vif = netdev_priv(wdev->netdev);
1628         struct wilc *wl = vif->wilc;
1629
1630         /* If firmware is not started, return. */
1631         if (!wl->initialized)
1632                 return -EIO;
1633
1634         ret = wilc_get_tx_power(vif, (u8 *)dbm);
1635         if (ret)
1636                 netdev_err(vif->ndev, "Failed to get tx power\n");
1637
1638         return ret;
1639 }
1640
1641 static const struct cfg80211_ops wilc_cfg80211_ops = {
1642         .set_monitor_channel = set_channel,
1643         .scan = scan,
1644         .connect = connect,
1645         .disconnect = disconnect,
1646         .add_key = add_key,
1647         .del_key = del_key,
1648         .get_key = get_key,
1649         .set_default_key = set_default_key,
1650         .add_virtual_intf = add_virtual_intf,
1651         .del_virtual_intf = del_virtual_intf,
1652         .change_virtual_intf = change_virtual_intf,
1653
1654         .start_ap = start_ap,
1655         .change_beacon = change_beacon,
1656         .stop_ap = stop_ap,
1657         .add_station = add_station,
1658         .del_station = del_station,
1659         .change_station = change_station,
1660         .get_station = get_station,
1661         .dump_station = dump_station,
1662         .change_bss = change_bss,
1663         .set_wiphy_params = set_wiphy_params,
1664
1665         .set_pmksa = set_pmksa,
1666         .del_pmksa = del_pmksa,
1667         .flush_pmksa = flush_pmksa,
1668         .remain_on_channel = remain_on_channel,
1669         .cancel_remain_on_channel = cancel_remain_on_channel,
1670         .mgmt_tx_cancel_wait = mgmt_tx_cancel_wait,
1671         .mgmt_tx = mgmt_tx,
1672         .update_mgmt_frame_registrations = wilc_update_mgmt_frame_registrations,
1673         .set_power_mgmt = set_power_mgmt,
1674         .set_cqm_rssi_config = set_cqm_rssi_config,
1675
1676         .suspend = wilc_suspend,
1677         .resume = wilc_resume,
1678         .set_wakeup = wilc_set_wakeup,
1679         .set_tx_power = set_tx_power,
1680         .get_tx_power = get_tx_power,
1681
1682 };
1683
1684 static void wlan_init_locks(struct wilc *wl)
1685 {
1686         mutex_init(&wl->hif_cs);
1687         mutex_init(&wl->rxq_cs);
1688         mutex_init(&wl->cfg_cmd_lock);
1689         mutex_init(&wl->vif_mutex);
1690         mutex_init(&wl->deinit_lock);
1691
1692         spin_lock_init(&wl->txq_spinlock);
1693         mutex_init(&wl->txq_add_to_head_cs);
1694
1695         init_completion(&wl->txq_event);
1696         init_completion(&wl->cfg_event);
1697         init_completion(&wl->sync_event);
1698         init_completion(&wl->txq_thread_started);
1699         init_srcu_struct(&wl->srcu);
1700 }
1701
1702 void wlan_deinit_locks(struct wilc *wilc)
1703 {
1704         mutex_destroy(&wilc->hif_cs);
1705         mutex_destroy(&wilc->rxq_cs);
1706         mutex_destroy(&wilc->cfg_cmd_lock);
1707         mutex_destroy(&wilc->txq_add_to_head_cs);
1708         mutex_destroy(&wilc->vif_mutex);
1709         mutex_destroy(&wilc->deinit_lock);
1710         cleanup_srcu_struct(&wilc->srcu);
1711 }
1712
1713 int wilc_cfg80211_init(struct wilc **wilc, struct device *dev, int io_type,
1714                        const struct wilc_hif_func *ops)
1715 {
1716         struct wilc *wl;
1717         struct wilc_vif *vif;
1718         int ret, i;
1719
1720         wl = wilc_create_wiphy(dev);
1721         if (!wl)
1722                 return -EINVAL;
1723
1724         wlan_init_locks(wl);
1725
1726         ret = wilc_wlan_cfg_init(wl);
1727         if (ret)
1728                 goto free_wl;
1729
1730         *wilc = wl;
1731         wl->io_type = io_type;
1732         wl->hif_func = ops;
1733
1734         for (i = 0; i < NQUEUES; i++)
1735                 INIT_LIST_HEAD(&wl->txq[i].txq_head.list);
1736
1737         INIT_LIST_HEAD(&wl->rxq_head.list);
1738         INIT_LIST_HEAD(&wl->vif_list);
1739
1740         vif = wilc_netdev_ifc_init(wl, "wlan%d", WILC_STATION_MODE,
1741                                    NL80211_IFTYPE_STATION, false);
1742         if (IS_ERR(vif)) {
1743                 ret = PTR_ERR(vif);
1744                 goto free_cfg;
1745         }
1746
1747         return 0;
1748
1749 free_cfg:
1750         wilc_wlan_cfg_deinit(wl);
1751
1752 free_wl:
1753         wlan_deinit_locks(wl);
1754         wiphy_unregister(wl->wiphy);
1755         wiphy_free(wl->wiphy);
1756         return ret;
1757 }
1758 EXPORT_SYMBOL_GPL(wilc_cfg80211_init);
1759
1760 struct wilc *wilc_create_wiphy(struct device *dev)
1761 {
1762         struct wiphy *wiphy;
1763         struct wilc *wl;
1764         int ret;
1765
1766         wiphy = wiphy_new(&wilc_cfg80211_ops, sizeof(*wl));
1767         if (!wiphy)
1768                 return NULL;
1769
1770         wl = wiphy_priv(wiphy);
1771
1772         memcpy(wl->bitrates, wilc_bitrates, sizeof(wilc_bitrates));
1773         memcpy(wl->channels, wilc_2ghz_channels, sizeof(wilc_2ghz_channels));
1774         wl->band.bitrates = wl->bitrates;
1775         wl->band.n_bitrates = ARRAY_SIZE(wl->bitrates);
1776         wl->band.channels = wl->channels;
1777         wl->band.n_channels = ARRAY_SIZE(wilc_2ghz_channels);
1778
1779         wl->band.ht_cap.ht_supported = 1;
1780         wl->band.ht_cap.cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
1781         wl->band.ht_cap.mcs.rx_mask[0] = 0xff;
1782         wl->band.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K;
1783         wl->band.ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
1784
1785         wiphy->bands[NL80211_BAND_2GHZ] = &wl->band;
1786
1787         wiphy->max_scan_ssids = WILC_MAX_NUM_PROBED_SSID;
1788 #ifdef CONFIG_PM
1789         wiphy->wowlan = &wowlan_support;
1790 #endif
1791         wiphy->max_num_pmkids = WILC_MAX_NUM_PMKIDS;
1792         wiphy->max_scan_ie_len = 1000;
1793         wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
1794         memcpy(wl->cipher_suites, wilc_cipher_suites,
1795                sizeof(wilc_cipher_suites));
1796         wiphy->cipher_suites = wl->cipher_suites;
1797         wiphy->n_cipher_suites = ARRAY_SIZE(wilc_cipher_suites);
1798         wiphy->mgmt_stypes = wilc_wfi_cfg80211_mgmt_types;
1799
1800         wiphy->max_remain_on_channel_duration = 500;
1801         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1802                                 BIT(NL80211_IFTYPE_AP) |
1803                                 BIT(NL80211_IFTYPE_MONITOR) |
1804                                 BIT(NL80211_IFTYPE_P2P_GO) |
1805                                 BIT(NL80211_IFTYPE_P2P_CLIENT);
1806         wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
1807
1808         set_wiphy_dev(wiphy, dev);
1809         wl->wiphy = wiphy;
1810         ret = wiphy_register(wiphy);
1811         if (ret) {
1812                 wiphy_free(wiphy);
1813                 return NULL;
1814         }
1815         return wl;
1816 }
1817
1818 int wilc_init_host_int(struct net_device *net)
1819 {
1820         int ret;
1821         struct wilc_vif *vif = netdev_priv(net);
1822         struct wilc_priv *priv = &vif->priv;
1823
1824         priv->p2p_listen_state = false;
1825
1826         mutex_init(&priv->scan_req_lock);
1827         ret = wilc_init(net, &priv->hif_drv);
1828         if (ret)
1829                 netdev_err(net, "Error while initializing hostinterface\n");
1830
1831         return ret;
1832 }
1833
1834 void wilc_deinit_host_int(struct net_device *net)
1835 {
1836         int ret;
1837         struct wilc_vif *vif = netdev_priv(net);
1838         struct wilc_priv *priv = &vif->priv;
1839
1840         priv->p2p_listen_state = false;
1841
1842         flush_workqueue(vif->wilc->hif_workqueue);
1843         mutex_destroy(&priv->scan_req_lock);
1844         ret = wilc_deinit(vif);
1845
1846         if (ret)
1847                 netdev_err(net, "Error while deinitializing host interface\n");
1848 }
1849