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