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