drivers/net/wireless/ath/ath6kl/cfg80211.c

   1 /*
   2  * Copyright (c) 2004-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include <linux/moduleparam.h>
  21 #include <linux/inetdevice.h>
  22 #include <linux/export.h>
  23
  24 #include "core.h"
  25 #include "cfg80211.h"
  26 #include "debug.h"
  27 #include "hif-ops.h"
  28 #include "testmode.h"
  29
  30 #define RATETAB_ENT(_rate, _rateid, _flags) {   \
  31         .bitrate    = (_rate),                  \
  32         .flags      = (_flags),                 \
  33         .hw_value   = (_rateid),                \
  34 }
  35
  36 #define CHAN2G(_channel, _freq, _flags) {   \
  37         .band           = IEEE80211_BAND_2GHZ,  \
  38         .hw_value       = (_channel),           \
  39         .center_freq    = (_freq),              \
  40         .flags          = (_flags),             \
  41         .max_antenna_gain   = 0,                \
  42         .max_power      = 30,                   \
  43 }
  44
  45 #define CHAN5G(_channel, _flags) {                  \
  46         .band           = IEEE80211_BAND_5GHZ,      \
  47         .hw_value       = (_channel),               \
  48         .center_freq    = 5000 + (5 * (_channel)),  \
  49         .flags          = (_flags),                 \
  50         .max_antenna_gain   = 0,                    \
  51         .max_power      = 30,                       \
  52 }
  53
  54 #define DEFAULT_BG_SCAN_PERIOD 60
  55
  56 static struct ieee80211_rate ath6kl_rates[] = {
  57         RATETAB_ENT(10, 0x1, 0),
  58         RATETAB_ENT(20, 0x2, 0),
  59         RATETAB_ENT(55, 0x4, 0),
  60         RATETAB_ENT(110, 0x8, 0),
  61         RATETAB_ENT(60, 0x10, 0),
  62         RATETAB_ENT(90, 0x20, 0),
  63         RATETAB_ENT(120, 0x40, 0),
  64         RATETAB_ENT(180, 0x80, 0),
  65         RATETAB_ENT(240, 0x100, 0),
  66         RATETAB_ENT(360, 0x200, 0),
  67         RATETAB_ENT(480, 0x400, 0),
  68         RATETAB_ENT(540, 0x800, 0),
  69 };
  70
  71 #define ath6kl_a_rates     (ath6kl_rates + 4)
  72 #define ath6kl_a_rates_size    8
  73 #define ath6kl_g_rates     (ath6kl_rates + 0)
  74 #define ath6kl_g_rates_size    12
  75
  76 #define ath6kl_g_htcap IEEE80211_HT_CAP_SGI_20
  77 #define ath6kl_a_htcap (IEEE80211_HT_CAP_SUP_WIDTH_20_40 | \
  78                         IEEE80211_HT_CAP_SGI_20          | \
  79                         IEEE80211_HT_CAP_SGI_40)
  80
  81 static struct ieee80211_channel ath6kl_2ghz_channels[] = {
  82         CHAN2G(1, 2412, 0),
  83         CHAN2G(2, 2417, 0),
  84         CHAN2G(3, 2422, 0),
  85         CHAN2G(4, 2427, 0),
  86         CHAN2G(5, 2432, 0),
  87         CHAN2G(6, 2437, 0),
  88         CHAN2G(7, 2442, 0),
  89         CHAN2G(8, 2447, 0),
  90         CHAN2G(9, 2452, 0),
  91         CHAN2G(10, 2457, 0),
  92         CHAN2G(11, 2462, 0),
  93         CHAN2G(12, 2467, 0),
  94         CHAN2G(13, 2472, 0),
  95         CHAN2G(14, 2484, 0),
  96 };
  97
  98 static struct ieee80211_channel ath6kl_5ghz_a_channels[] = {
  99         CHAN5G(34, 0), CHAN5G(36, 0),
 100         CHAN5G(38, 0), CHAN5G(40, 0),
 101         CHAN5G(42, 0), CHAN5G(44, 0),
 102         CHAN5G(46, 0), CHAN5G(48, 0),
 103         CHAN5G(52, 0), CHAN5G(56, 0),
 104         CHAN5G(60, 0), CHAN5G(64, 0),
 105         CHAN5G(100, 0), CHAN5G(104, 0),
 106         CHAN5G(108, 0), CHAN5G(112, 0),
 107         CHAN5G(116, 0), CHAN5G(120, 0),
 108         CHAN5G(124, 0), CHAN5G(128, 0),
 109         CHAN5G(132, 0), CHAN5G(136, 0),
 110         CHAN5G(140, 0), CHAN5G(149, 0),
 111         CHAN5G(153, 0), CHAN5G(157, 0),
 112         CHAN5G(161, 0), CHAN5G(165, 0),
 113         CHAN5G(184, 0), CHAN5G(188, 0),
 114         CHAN5G(192, 0), CHAN5G(196, 0),
 115         CHAN5G(200, 0), CHAN5G(204, 0),
 116         CHAN5G(208, 0), CHAN5G(212, 0),
 117         CHAN5G(216, 0),
 118 };
 119
 120 static struct ieee80211_supported_band ath6kl_band_2ghz = {
 121         .n_channels = ARRAY_SIZE(ath6kl_2ghz_channels),
 122         .channels = ath6kl_2ghz_channels,
 123         .n_bitrates = ath6kl_g_rates_size,
 124         .bitrates = ath6kl_g_rates,
 125         .ht_cap.cap = ath6kl_g_htcap,
 126         .ht_cap.ht_supported = true,
 127 };
 128
 129 static struct ieee80211_supported_band ath6kl_band_5ghz = {
 130         .n_channels = ARRAY_SIZE(ath6kl_5ghz_a_channels),
 131         .channels = ath6kl_5ghz_a_channels,
 132         .n_bitrates = ath6kl_a_rates_size,
 133         .bitrates = ath6kl_a_rates,
 134         .ht_cap.cap = ath6kl_a_htcap,
 135         .ht_cap.ht_supported = true,
 136 };
 137
 138 #define CCKM_KRK_CIPHER_SUITE 0x004096ff /* use for KRK */
 139
 140 /* returns true if scheduled scan was stopped */
 141 static bool __ath6kl_cfg80211_sscan_stop(struct ath6kl_vif *vif)
 142 {
 143         struct ath6kl *ar = vif->ar;
 144
 145         if (ar->state != ATH6KL_STATE_SCHED_SCAN)
 146                 return false;
 147
 148         del_timer_sync(&vif->sched_scan_timer);
 149
 150         ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
 151                                            ATH6KL_HOST_MODE_AWAKE);
 152
 153         ar->state = ATH6KL_STATE_ON;
 154
 155         return true;
 156 }
 157
 158 static void ath6kl_cfg80211_sscan_disable(struct ath6kl_vif *vif)
 159 {
 160         struct ath6kl *ar = vif->ar;
 161         bool stopped;
 162
 163         stopped = __ath6kl_cfg80211_sscan_stop(vif);
 164
 165         if (!stopped)
 166                 return;
 167
 168         cfg80211_sched_scan_stopped(ar->wiphy);
 169 }
 170
 171 static int ath6kl_set_wpa_version(struct ath6kl_vif *vif,
 172                                   enum nl80211_wpa_versions wpa_version)
 173 {
 174         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version);
 175
 176         if (!wpa_version) {
 177                 vif->auth_mode = NONE_AUTH;
 178         } else if (wpa_version & NL80211_WPA_VERSION_2) {
 179                 vif->auth_mode = WPA2_AUTH;
 180         } else if (wpa_version & NL80211_WPA_VERSION_1) {
 181                 vif->auth_mode = WPA_AUTH;
 182         } else {
 183                 ath6kl_err("%s: %u not supported\n", __func__, wpa_version);
 184                 return -ENOTSUPP;
 185         }
 186
 187         return 0;
 188 }
 189
 190 static int ath6kl_set_auth_type(struct ath6kl_vif *vif,
 191                                 enum nl80211_auth_type auth_type)
 192 {
 193         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type);
 194
 195         switch (auth_type) {
 196         case NL80211_AUTHTYPE_OPEN_SYSTEM:
 197                 vif->dot11_auth_mode = OPEN_AUTH;
 198                 break;
 199         case NL80211_AUTHTYPE_SHARED_KEY:
 200                 vif->dot11_auth_mode = SHARED_AUTH;
 201                 break;
 202         case NL80211_AUTHTYPE_NETWORK_EAP:
 203                 vif->dot11_auth_mode = LEAP_AUTH;
 204                 break;
 205
 206         case NL80211_AUTHTYPE_AUTOMATIC:
 207                 vif->dot11_auth_mode = OPEN_AUTH | SHARED_AUTH;
 208                 break;
 209
 210         default:
 211                 ath6kl_err("%s: 0x%x not supported\n", __func__, auth_type);
 212                 return -ENOTSUPP;
 213         }
 214
 215         return 0;
 216 }
 217
 218 static int ath6kl_set_cipher(struct ath6kl_vif *vif, u32 cipher, bool ucast)
 219 {
 220         u8 *ar_cipher = ucast ? &vif->prwise_crypto : &vif->grp_crypto;
 221         u8 *ar_cipher_len = ucast ? &vif->prwise_crypto_len :
 222                 &vif->grp_crypto_len;
 223
 224         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n",
 225                    __func__, cipher, ucast);
 226
 227         switch (cipher) {
 228         case 0:
 229                 /* our own hack to use value 0 as no crypto used */
 230                 *ar_cipher = NONE_CRYPT;
 231                 *ar_cipher_len = 0;
 232                 break;
 233         case WLAN_CIPHER_SUITE_WEP40:
 234                 *ar_cipher = WEP_CRYPT;
 235                 *ar_cipher_len = 5;
 236                 break;
 237         case WLAN_CIPHER_SUITE_WEP104:
 238                 *ar_cipher = WEP_CRYPT;
 239                 *ar_cipher_len = 13;
 240                 break;
 241         case WLAN_CIPHER_SUITE_TKIP:
 242                 *ar_cipher = TKIP_CRYPT;
 243                 *ar_cipher_len = 0;
 244                 break;
 245         case WLAN_CIPHER_SUITE_CCMP:
 246                 *ar_cipher = AES_CRYPT;
 247                 *ar_cipher_len = 0;
 248                 break;
 249         case WLAN_CIPHER_SUITE_SMS4:
 250                 *ar_cipher = WAPI_CRYPT;
 251                 *ar_cipher_len = 0;
 252                 break;
 253         default:
 254                 ath6kl_err("cipher 0x%x not supported\n", cipher);
 255                 return -ENOTSUPP;
 256         }
 257
 258         return 0;
 259 }
 260
 261 static void ath6kl_set_key_mgmt(struct ath6kl_vif *vif, u32 key_mgmt)
 262 {
 263         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt);
 264
 265         if (key_mgmt == WLAN_AKM_SUITE_PSK) {
 266                 if (vif->auth_mode == WPA_AUTH)
 267                         vif->auth_mode = WPA_PSK_AUTH;
 268                 else if (vif->auth_mode == WPA2_AUTH)
 269                         vif->auth_mode = WPA2_PSK_AUTH;
 270         } else if (key_mgmt == 0x00409600) {
 271                 if (vif->auth_mode == WPA_AUTH)
 272                         vif->auth_mode = WPA_AUTH_CCKM;
 273                 else if (vif->auth_mode == WPA2_AUTH)
 274                         vif->auth_mode = WPA2_AUTH_CCKM;
 275         } else if (key_mgmt != WLAN_AKM_SUITE_8021X) {
 276                 vif->auth_mode = NONE_AUTH;
 277         }
 278 }
 279
 280 static bool ath6kl_cfg80211_ready(struct ath6kl_vif *vif)
 281 {
 282         struct ath6kl *ar = vif->ar;
 283
 284         if (!test_bit(WMI_READY, &ar->flag)) {
 285                 ath6kl_err("wmi is not ready\n");
 286                 return false;
 287         }
 288
 289         if (!test_bit(WLAN_ENABLED, &vif->flags)) {
 290                 ath6kl_err("wlan disabled\n");
 291                 return false;
 292         }
 293
 294         return true;
 295 }
 296
 297 static bool ath6kl_is_wpa_ie(const u8 *pos)
 298 {
 299         return pos[0] == WLAN_EID_WPA && pos[1] >= 4 &&
 300                 pos[2] == 0x00 && pos[3] == 0x50 &&
 301                 pos[4] == 0xf2 && pos[5] == 0x01;
 302 }
 303
 304 static bool ath6kl_is_rsn_ie(const u8 *pos)
 305 {
 306         return pos[0] == WLAN_EID_RSN;
 307 }
 308
 309 static bool ath6kl_is_wps_ie(const u8 *pos)
 310 {
 311         return (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
 312                 pos[1] >= 4 &&
 313                 pos[2] == 0x00 && pos[3] == 0x50 && pos[4] == 0xf2 &&
 314                 pos[5] == 0x04);
 315 }
 316
 317 static int ath6kl_set_assoc_req_ies(struct ath6kl_vif *vif, const u8 *ies,
 318                                     size_t ies_len)
 319 {
 320         struct ath6kl *ar = vif->ar;
 321         const u8 *pos;
 322         u8 *buf = NULL;
 323         size_t len = 0;
 324         int ret;
 325
 326         /*
 327          * Clear previously set flag
 328          */
 329
 330         ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
 331
 332         /*
 333          * Filter out RSN/WPA IE(s)
 334          */
 335
 336         if (ies && ies_len) {
 337                 buf = kmalloc(ies_len, GFP_KERNEL);
 338                 if (buf == NULL)
 339                         return -ENOMEM;
 340                 pos = ies;
 341
 342                 while (pos + 1 < ies + ies_len) {
 343                         if (pos + 2 + pos[1] > ies + ies_len)
 344                                 break;
 345                         if (!(ath6kl_is_wpa_ie(pos) || ath6kl_is_rsn_ie(pos))) {
 346                                 memcpy(buf + len, pos, 2 + pos[1]);
 347                                 len += 2 + pos[1];
 348                         }
 349
 350                         if (ath6kl_is_wps_ie(pos))
 351                                 ar->connect_ctrl_flags |= CONNECT_WPS_FLAG;
 352
 353                         pos += 2 + pos[1];
 354                 }
 355         }
 356
 357         ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
 358                                        WMI_FRAME_ASSOC_REQ, buf, len);
 359         kfree(buf);
 360         return ret;
 361 }
 362
 363 static int ath6kl_nliftype_to_drv_iftype(enum nl80211_iftype type, u8 *nw_type)
 364 {
 365         switch (type) {
 366         case NL80211_IFTYPE_STATION:
 367                 *nw_type = INFRA_NETWORK;
 368                 break;
 369         case NL80211_IFTYPE_ADHOC:
 370                 *nw_type = ADHOC_NETWORK;
 371                 break;
 372         case NL80211_IFTYPE_AP:
 373                 *nw_type = AP_NETWORK;
 374                 break;
 375         case NL80211_IFTYPE_P2P_CLIENT:
 376                 *nw_type = INFRA_NETWORK;
 377                 break;
 378         case NL80211_IFTYPE_P2P_GO:
 379                 *nw_type = AP_NETWORK;
 380                 break;
 381         default:
 382                 ath6kl_err("invalid interface type %u\n", type);
 383                 return -ENOTSUPP;
 384         }
 385
 386         return 0;
 387 }
 388
 389 static bool ath6kl_is_valid_iftype(struct ath6kl *ar, enum nl80211_iftype type,
 390                                    u8 *if_idx, u8 *nw_type)
 391 {
 392         int i;
 393
 394         if (ath6kl_nliftype_to_drv_iftype(type, nw_type))
 395                 return false;
 396
 397         if (ar->ibss_if_active || ((type == NL80211_IFTYPE_ADHOC) &&
 398                                    ar->num_vif))
 399                 return false;
 400
 401         if (type == NL80211_IFTYPE_STATION ||
 402             type == NL80211_IFTYPE_AP || type == NL80211_IFTYPE_ADHOC) {
 403                 for (i = 0; i < ar->vif_max; i++) {
 404                         if ((ar->avail_idx_map >> i) & BIT(0)) {
 405                                 *if_idx = i;
 406                                 return true;
 407                         }
 408                 }
 409         }
 410
 411         if (type == NL80211_IFTYPE_P2P_CLIENT ||
 412             type == NL80211_IFTYPE_P2P_GO) {
 413                 for (i = ar->max_norm_iface; i < ar->vif_max; i++) {
 414                         if ((ar->avail_idx_map >> i) & BIT(0)) {
 415                                 *if_idx = i;
 416                                 return true;
 417                         }
 418                 }
 419         }
 420
 421         return false;
 422 }
 423
 424 static bool ath6kl_is_tx_pending(struct ath6kl *ar)
 425 {
 426         return ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)] == 0;
 427 }
 428
 429
 430 static int ath6kl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
 431                                    struct cfg80211_connect_params *sme)
 432 {
 433         struct ath6kl *ar = ath6kl_priv(dev);
 434         struct ath6kl_vif *vif = netdev_priv(dev);
 435         int status;
 436         u8 nw_subtype = (ar->p2p) ? SUBTYPE_P2PDEV : SUBTYPE_NONE;
 437         u16 interval;
 438
 439         ath6kl_cfg80211_sscan_disable(vif);
 440
 441         vif->sme_state = SME_CONNECTING;
 442
 443         if (!ath6kl_cfg80211_ready(vif))
 444                 return -EIO;
 445
 446         if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
 447                 ath6kl_err("destroy in progress\n");
 448                 return -EBUSY;
 449         }
 450
 451         if (test_bit(SKIP_SCAN, &ar->flag) &&
 452             ((sme->channel && sme->channel->center_freq == 0) ||
 453              (sme->bssid && is_zero_ether_addr(sme->bssid)))) {
 454                 ath6kl_err("SkipScan: channel or bssid invalid\n");
 455                 return -EINVAL;
 456         }
 457
 458         if (down_interruptible(&ar->sem)) {
 459                 ath6kl_err("busy, couldn't get access\n");
 460                 return -ERESTARTSYS;
 461         }
 462
 463         if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
 464                 ath6kl_err("busy, destroy in progress\n");
 465                 up(&ar->sem);
 466                 return -EBUSY;
 467         }
 468
 469         if (ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)]) {
 470                 /*
 471                  * sleep until the command queue drains
 472                  */
 473                 wait_event_interruptible_timeout(ar->event_wq,
 474                                                  ath6kl_is_tx_pending(ar),
 475                                                  WMI_TIMEOUT);
 476                 if (signal_pending(current)) {
 477                         ath6kl_err("cmd queue drain timeout\n");
 478                         up(&ar->sem);
 479                         return -EINTR;
 480                 }
 481         }
 482
 483         status = ath6kl_set_assoc_req_ies(vif, sme->ie, sme->ie_len);
 484         if (status) {
 485                 up(&ar->sem);
 486                 return status;
 487         }
 488
 489         if (sme->ie == NULL || sme->ie_len == 0)
 490                 ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
 491
 492         if (test_bit(CONNECTED, &vif->flags) &&
 493             vif->ssid_len == sme->ssid_len &&
 494             !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) {
 495                 vif->reconnect_flag = true;
 496                 status = ath6kl_wmi_reconnect_cmd(ar->wmi, vif->fw_vif_idx,
 497                                                   vif->req_bssid,
 498                                                   vif->ch_hint);
 499
 500                 up(&ar->sem);
 501                 if (status) {
 502                         ath6kl_err("wmi_reconnect_cmd failed\n");
 503                         return -EIO;
 504                 }
 505                 return 0;
 506         } else if (vif->ssid_len == sme->ssid_len &&
 507                    !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) {
 508                 ath6kl_disconnect(vif);
 509         }
 510
 511         memset(vif->ssid, 0, sizeof(vif->ssid));
 512         vif->ssid_len = sme->ssid_len;
 513         memcpy(vif->ssid, sme->ssid, sme->ssid_len);
 514
 515         if (sme->channel)
 516                 vif->ch_hint = sme->channel->center_freq;
 517
 518         memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
 519         if (sme->bssid && !is_broadcast_ether_addr(sme->bssid))
 520                 memcpy(vif->req_bssid, sme->bssid, sizeof(vif->req_bssid));
 521
 522         ath6kl_set_wpa_version(vif, sme->crypto.wpa_versions);
 523
 524         status = ath6kl_set_auth_type(vif, sme->auth_type);
 525         if (status) {
 526                 up(&ar->sem);
 527                 return status;
 528         }
 529
 530         if (sme->crypto.n_ciphers_pairwise)
 531                 ath6kl_set_cipher(vif, sme->crypto.ciphers_pairwise[0], true);
 532         else
 533                 ath6kl_set_cipher(vif, 0, true);
 534
 535         ath6kl_set_cipher(vif, sme->crypto.cipher_group, false);
 536
 537         if (sme->crypto.n_akm_suites)
 538                 ath6kl_set_key_mgmt(vif, sme->crypto.akm_suites[0]);
 539
 540         if ((sme->key_len) &&
 541             (vif->auth_mode == NONE_AUTH) &&
 542             (vif->prwise_crypto == WEP_CRYPT)) {
 543                 struct ath6kl_key *key = NULL;
 544
 545                 if (sme->key_idx > WMI_MAX_KEY_INDEX) {
 546                         ath6kl_err("key index %d out of bounds\n",
 547                                    sme->key_idx);
 548                         up(&ar->sem);
 549                         return -ENOENT;
 550                 }
 551
 552                 key = &vif->keys[sme->key_idx];
 553                 key->key_len = sme->key_len;
 554                 memcpy(key->key, sme->key, key->key_len);
 555                 key->cipher = vif->prwise_crypto;
 556                 vif->def_txkey_index = sme->key_idx;
 557
 558                 ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, sme->key_idx,
 559                                       vif->prwise_crypto,
 560                                       GROUP_USAGE | TX_USAGE,
 561                                       key->key_len,
 562                                       NULL, 0,
 563                                       key->key, KEY_OP_INIT_VAL, NULL,
 564                                       NO_SYNC_WMIFLAG);
 565         }
 566
 567         if (!ar->usr_bss_filter) {
 568                 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
 569                 if (ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
 570                                              ALL_BSS_FILTER, 0) != 0) {
 571                         ath6kl_err("couldn't set bss filtering\n");
 572                         up(&ar->sem);
 573                         return -EIO;
 574                 }
 575         }
 576
 577         vif->nw_type = vif->next_mode;
 578
 579         if (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT)
 580                 nw_subtype = SUBTYPE_P2PCLIENT;
 581
 582         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 583                    "%s: connect called with authmode %d dot11 auth %d"
 584                    " PW crypto %d PW crypto len %d GRP crypto %d"
 585                    " GRP crypto len %d channel hint %u\n",
 586                    __func__,
 587                    vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto,
 588                    vif->prwise_crypto_len, vif->grp_crypto,
 589                    vif->grp_crypto_len, vif->ch_hint);
 590
 591         vif->reconnect_flag = 0;
 592
 593         if (vif->nw_type == INFRA_NETWORK) {
 594                 interval = max_t(u16, vif->listen_intvl_t,
 595                                  ATH6KL_MAX_WOW_LISTEN_INTL);
 596                 status = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
 597                                                        interval,
 598                                                        0);
 599                 if (status) {
 600                         ath6kl_err("couldn't set listen intervel\n");
 601                         up(&ar->sem);
 602                         return status;
 603                 }
 604         }
 605
 606         status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type,
 607                                         vif->dot11_auth_mode, vif->auth_mode,
 608                                         vif->prwise_crypto,
 609                                         vif->prwise_crypto_len,
 610                                         vif->grp_crypto, vif->grp_crypto_len,
 611                                         vif->ssid_len, vif->ssid,
 612                                         vif->req_bssid, vif->ch_hint,
 613                                         ar->connect_ctrl_flags, nw_subtype);
 614
 615         /* disable background scan if period is 0 */
 616         if (sme->bg_scan_period == 0)
 617                 sme->bg_scan_period = 0xffff;
 618
 619         /* configure default value if not specified */
 620         if (sme->bg_scan_period == -1)
 621                 sme->bg_scan_period = DEFAULT_BG_SCAN_PERIOD;
 622
 623         ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx, 0, 0,
 624                                   sme->bg_scan_period, 0, 0, 0, 3, 0, 0, 0);
 625
 626         up(&ar->sem);
 627
 628         if (status == -EINVAL) {
 629                 memset(vif->ssid, 0, sizeof(vif->ssid));
 630                 vif->ssid_len = 0;
 631                 ath6kl_err("invalid request\n");
 632                 return -ENOENT;
 633         } else if (status) {
 634                 ath6kl_err("ath6kl_wmi_connect_cmd failed\n");
 635                 return -EIO;
 636         }
 637
 638         if ((!(ar->connect_ctrl_flags & CONNECT_DO_WPA_OFFLOAD)) &&
 639             ((vif->auth_mode == WPA_PSK_AUTH) ||
 640              (vif->auth_mode == WPA2_PSK_AUTH))) {
 641                 mod_timer(&vif->disconnect_timer,
 642                           jiffies + msecs_to_jiffies(DISCON_TIMER_INTVAL));
 643         }
 644
 645         ar->connect_ctrl_flags &= ~CONNECT_DO_WPA_OFFLOAD;
 646         set_bit(CONNECT_PEND, &vif->flags);
 647
 648         return 0;
 649 }
 650
 651 static struct cfg80211_bss *
 652 ath6kl_add_bss_if_needed(struct ath6kl_vif *vif,
 653                          enum network_type nw_type,
 654                          const u8 *bssid,
 655                          struct ieee80211_channel *chan,
 656                          const u8 *beacon_ie,
 657                          size_t beacon_ie_len)
 658 {
 659         struct ath6kl *ar = vif->ar;
 660         struct cfg80211_bss *bss;
 661         u16 cap_mask, cap_val;
 662         u8 *ie;
 663
 664         if (nw_type & ADHOC_NETWORK) {
 665                 cap_mask = WLAN_CAPABILITY_IBSS;
 666                 cap_val = WLAN_CAPABILITY_IBSS;
 667         } else {
 668                 cap_mask = WLAN_CAPABILITY_ESS;
 669                 cap_val = WLAN_CAPABILITY_ESS;
 670         }
 671
 672         bss = cfg80211_get_bss(ar->wiphy, chan, bssid,
 673                                vif->ssid, vif->ssid_len,
 674                                cap_mask, cap_val);
 675         if (bss == NULL) {
 676                 /*
 677                  * Since cfg80211 may not yet know about the BSS,
 678                  * generate a partial entry until the first BSS info
 679                  * event becomes available.
 680                  *
 681                  * Prepend SSID element since it is not included in the Beacon
 682                  * IEs from the target.
 683                  */
 684                 ie = kmalloc(2 + vif->ssid_len + beacon_ie_len, GFP_KERNEL);
 685                 if (ie == NULL)
 686                         return NULL;
 687                 ie[0] = WLAN_EID_SSID;
 688                 ie[1] = vif->ssid_len;
 689                 memcpy(ie + 2, vif->ssid, vif->ssid_len);
 690                 memcpy(ie + 2 + vif->ssid_len, beacon_ie, beacon_ie_len);
 691                 bss = cfg80211_inform_bss(ar->wiphy, chan,
 692                                           bssid, 0, cap_val, 100,
 693                                           ie, 2 + vif->ssid_len + beacon_ie_len,
 694                                           0, GFP_KERNEL);
 695                 if (bss)
 696                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 697                                    "added bss %pM to cfg80211\n", bssid);
 698                 kfree(ie);
 699         } else
 700                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "cfg80211 already has a bss\n");
 701
 702         return bss;
 703 }
 704
 705 void ath6kl_cfg80211_connect_event(struct ath6kl_vif *vif, u16 channel,
 706                                    u8 *bssid, u16 listen_intvl,
 707                                    u16 beacon_intvl,
 708                                    enum network_type nw_type,
 709                                    u8 beacon_ie_len, u8 assoc_req_len,
 710                                    u8 assoc_resp_len, u8 *assoc_info)
 711 {
 712         struct ieee80211_channel *chan;
 713         struct ath6kl *ar = vif->ar;
 714         struct cfg80211_bss *bss;
 715
 716         /* capinfo + listen interval */
 717         u8 assoc_req_ie_offset = sizeof(u16) + sizeof(u16);
 718
 719         /* capinfo + status code +  associd */
 720         u8 assoc_resp_ie_offset = sizeof(u16) + sizeof(u16) + sizeof(u16);
 721
 722         u8 *assoc_req_ie = assoc_info + beacon_ie_len + assoc_req_ie_offset;
 723         u8 *assoc_resp_ie = assoc_info + beacon_ie_len + assoc_req_len +
 724             assoc_resp_ie_offset;
 725
 726         assoc_req_len -= assoc_req_ie_offset;
 727         assoc_resp_len -= assoc_resp_ie_offset;
 728
 729         /*
 730          * Store Beacon interval here; DTIM period will be available only once
 731          * a Beacon frame from the AP is seen.
 732          */
 733         vif->assoc_bss_beacon_int = beacon_intvl;
 734         clear_bit(DTIM_PERIOD_AVAIL, &vif->flags);
 735
 736         if (nw_type & ADHOC_NETWORK) {
 737                 if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) {
 738                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 739                                    "%s: ath6k not in ibss mode\n", __func__);
 740                         return;
 741                 }
 742         }
 743
 744         if (nw_type & INFRA_NETWORK) {
 745                 if (vif->wdev.iftype != NL80211_IFTYPE_STATION &&
 746                     vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) {
 747                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 748                                    "%s: ath6k not in station mode\n", __func__);
 749                         return;
 750                 }
 751         }
 752
 753         chan = ieee80211_get_channel(ar->wiphy, (int) channel);
 754
 755         bss = ath6kl_add_bss_if_needed(vif, nw_type, bssid, chan,
 756                                        assoc_info, beacon_ie_len);
 757         if (!bss) {
 758                 ath6kl_err("could not add cfg80211 bss entry\n");
 759                 return;
 760         }
 761
 762         if (nw_type & ADHOC_NETWORK) {
 763                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "ad-hoc %s selected\n",
 764                            nw_type & ADHOC_CREATOR ? "creator" : "joiner");
 765                 cfg80211_ibss_joined(vif->ndev, bssid, GFP_KERNEL);
 766                 cfg80211_put_bss(bss);
 767                 return;
 768         }
 769
 770         if (vif->sme_state == SME_CONNECTING) {
 771                 /* inform connect result to cfg80211 */
 772                 vif->sme_state = SME_CONNECTED;
 773                 cfg80211_connect_result(vif->ndev, bssid,
 774                                         assoc_req_ie, assoc_req_len,
 775                                         assoc_resp_ie, assoc_resp_len,
 776                                         WLAN_STATUS_SUCCESS, GFP_KERNEL);
 777                 cfg80211_put_bss(bss);
 778         } else if (vif->sme_state == SME_CONNECTED) {
 779                 /* inform roam event to cfg80211 */
 780                 cfg80211_roamed_bss(vif->ndev, bss, assoc_req_ie, assoc_req_len,
 781                                     assoc_resp_ie, assoc_resp_len, GFP_KERNEL);
 782         }
 783 }
 784
 785 static int ath6kl_cfg80211_disconnect(struct wiphy *wiphy,
 786                                       struct net_device *dev, u16 reason_code)
 787 {
 788         struct ath6kl *ar = ath6kl_priv(dev);
 789         struct ath6kl_vif *vif = netdev_priv(dev);
 790
 791         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: reason=%u\n", __func__,
 792                    reason_code);
 793
 794         ath6kl_cfg80211_sscan_disable(vif);
 795
 796         if (!ath6kl_cfg80211_ready(vif))
 797                 return -EIO;
 798
 799         if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
 800                 ath6kl_err("busy, destroy in progress\n");
 801                 return -EBUSY;
 802         }
 803
 804         if (down_interruptible(&ar->sem)) {
 805                 ath6kl_err("busy, couldn't get access\n");
 806                 return -ERESTARTSYS;
 807         }
 808
 809         vif->reconnect_flag = 0;
 810         ath6kl_disconnect(vif);
 811         memset(vif->ssid, 0, sizeof(vif->ssid));
 812         vif->ssid_len = 0;
 813
 814         if (!test_bit(SKIP_SCAN, &ar->flag))
 815                 memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
 816
 817         up(&ar->sem);
 818
 819         vif->sme_state = SME_DISCONNECTED;
 820
 821         return 0;
 822 }
 823
 824 void ath6kl_cfg80211_disconnect_event(struct ath6kl_vif *vif, u8 reason,
 825                                       u8 *bssid, u8 assoc_resp_len,
 826                                       u8 *assoc_info, u16 proto_reason)
 827 {
 828         struct ath6kl *ar = vif->ar;
 829
 830         if (vif->scan_req) {
 831                 cfg80211_scan_done(vif->scan_req, true);
 832                 vif->scan_req = NULL;
 833         }
 834
 835         if (vif->nw_type & ADHOC_NETWORK) {
 836                 if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) {
 837                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 838                                    "%s: ath6k not in ibss mode\n", __func__);
 839                         return;
 840                 }
 841                 memset(bssid, 0, ETH_ALEN);
 842                 cfg80211_ibss_joined(vif->ndev, bssid, GFP_KERNEL);
 843                 return;
 844         }
 845
 846         if (vif->nw_type & INFRA_NETWORK) {
 847                 if (vif->wdev.iftype != NL80211_IFTYPE_STATION &&
 848                     vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) {
 849                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 850                                    "%s: ath6k not in station mode\n", __func__);
 851                         return;
 852                 }
 853         }
 854
 855         /*
 856          * Send a disconnect command to target when a disconnect event is
 857          * received with reason code other than 3 (DISCONNECT_CMD - disconnect
 858          * request from host) to make the firmware stop trying to connect even
 859          * after giving disconnect event. There will be one more disconnect
 860          * event for this disconnect command with reason code DISCONNECT_CMD
 861          * which will be notified to cfg80211.
 862          */
 863
 864         if (reason != DISCONNECT_CMD) {
 865                 ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
 866                 return;
 867         }
 868
 869         clear_bit(CONNECT_PEND, &vif->flags);
 870
 871         if (vif->sme_state == SME_CONNECTING) {
 872                 cfg80211_connect_result(vif->ndev,
 873                                         bssid, NULL, 0,
 874                                         NULL, 0,
 875                                         WLAN_STATUS_UNSPECIFIED_FAILURE,
 876                                         GFP_KERNEL);
 877         } else if (vif->sme_state == SME_CONNECTED) {
 878                 cfg80211_disconnected(vif->ndev, reason,
 879                                       NULL, 0, GFP_KERNEL);
 880         }
 881
 882         vif->sme_state = SME_DISCONNECTED;
 883 }
 884
 885 static int ath6kl_set_probed_ssids(struct ath6kl *ar,
 886                                    struct ath6kl_vif *vif,
 887                                    struct cfg80211_ssid *ssids, int n_ssids)
 888 {
 889         u8 i;
 890
 891         if (n_ssids > MAX_PROBED_SSID_INDEX)
 892                 return -EINVAL;
 893
 894         for (i = 0; i < n_ssids; i++) {
 895                 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, i,
 896                                           ssids[i].ssid_len ?
 897                                           SPECIFIC_SSID_FLAG : ANY_SSID_FLAG,
 898                                           ssids[i].ssid_len,
 899                                           ssids[i].ssid);
 900         }
 901
 902         /* Make sure no old entries are left behind */
 903         for (i = n_ssids; i < MAX_PROBED_SSID_INDEX; i++) {
 904                 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, i,
 905                                           DISABLE_SSID_FLAG, 0, NULL);
 906         }
 907
 908         return 0;
 909 }
 910
 911 static int ath6kl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
 912                                 struct cfg80211_scan_request *request)
 913 {
 914         struct ath6kl *ar = ath6kl_priv(ndev);
 915         struct ath6kl_vif *vif = netdev_priv(ndev);
 916         s8 n_channels = 0;
 917         u16 *channels = NULL;
 918         int ret = 0;
 919         u32 force_fg_scan = 0;
 920
 921         if (!ath6kl_cfg80211_ready(vif))
 922                 return -EIO;
 923
 924         ath6kl_cfg80211_sscan_disable(vif);
 925
 926         if (!ar->usr_bss_filter) {
 927                 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
 928                 ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
 929                                                ALL_BSS_FILTER, 0);
 930                 if (ret) {
 931                         ath6kl_err("couldn't set bss filtering\n");
 932                         return ret;
 933                 }
 934         }
 935
 936         ret = ath6kl_set_probed_ssids(ar, vif, request->ssids,
 937                                       request->n_ssids);
 938         if (ret < 0)
 939                 return ret;
 940
 941         /* this also clears IE in fw if it's not set */
 942         ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
 943                                        WMI_FRAME_PROBE_REQ,
 944                                        request->ie, request->ie_len);
 945         if (ret) {
 946                 ath6kl_err("failed to set Probe Request appie for scan");
 947                 return ret;
 948         }
 949
 950         /*
 951          * Scan only the requested channels if the request specifies a set of
 952          * channels. If the list is longer than the target supports, do not
 953          * configure the list and instead, scan all available channels.
 954          */
 955         if (request->n_channels > 0 &&
 956             request->n_channels <= WMI_MAX_CHANNELS) {
 957                 u8 i;
 958
 959                 n_channels = request->n_channels;
 960
 961                 channels = kzalloc(n_channels * sizeof(u16), GFP_KERNEL);
 962                 if (channels == NULL) {
 963                         ath6kl_warn("failed to set scan channels, scan all channels");
 964                         n_channels = 0;
 965                 }
 966
 967                 for (i = 0; i < n_channels; i++)
 968                         channels[i] = request->channels[i]->center_freq;
 969         }
 970
 971         if (test_bit(CONNECTED, &vif->flags))
 972                 force_fg_scan = 1;
 973
 974         vif->scan_req = request;
 975
 976         if (test_bit(ATH6KL_FW_CAPABILITY_STA_P2PDEV_DUPLEX,
 977                      ar->fw_capabilities)) {
 978                 /*
 979                  * If capable of doing P2P mgmt operations using
 980                  * station interface, send additional information like
 981                  * supported rates to advertise and xmit rates for
 982                  * probe requests
 983                  */
 984                 ret = ath6kl_wmi_beginscan_cmd(ar->wmi, vif->fw_vif_idx,
 985                                                 WMI_LONG_SCAN, force_fg_scan,
 986                                                 false, 0,
 987                                                 ATH6KL_FG_SCAN_INTERVAL,
 988                                                 n_channels, channels,
 989                                                 request->no_cck,
 990                                                 request->rates);
 991         } else {
 992                 ret = ath6kl_wmi_startscan_cmd(ar->wmi, vif->fw_vif_idx,
 993                                                 WMI_LONG_SCAN, force_fg_scan,
 994                                                 false, 0,
 995                                                 ATH6KL_FG_SCAN_INTERVAL,
 996                                                 n_channels, channels);
 997         }
 998         if (ret) {
 999                 ath6kl_err("wmi_startscan_cmd failed\n");
1000                 vif->scan_req = NULL;
1001         }
1002
1003         kfree(channels);
1004
1005         return ret;
1006 }
1007
1008 void ath6kl_cfg80211_scan_complete_event(struct ath6kl_vif *vif, bool aborted)
1009 {
1010         struct ath6kl *ar = vif->ar;
1011         int i;
1012
1013         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: status%s\n", __func__,
1014                    aborted ? " aborted" : "");
1015
1016         if (!vif->scan_req)
1017                 return;
1018
1019         if (aborted)
1020                 goto out;
1021
1022         if (vif->scan_req->n_ssids && vif->scan_req->ssids[0].ssid_len) {
1023                 for (i = 0; i < vif->scan_req->n_ssids; i++) {
1024                         ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx,
1025                                                   i + 1, DISABLE_SSID_FLAG,
1026                                                   0, NULL);
1027                 }
1028         }
1029
1030 out:
1031         cfg80211_scan_done(vif->scan_req, aborted);
1032         vif->scan_req = NULL;
1033 }
1034
1035 void ath6kl_cfg80211_ch_switch_notify(struct ath6kl_vif *vif, int freq,
1036                                       enum wmi_phy_mode mode)
1037 {
1038         enum nl80211_channel_type type;
1039
1040         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1041                    "channel switch notify nw_type %d freq %d mode %d\n",
1042                    vif->nw_type, freq, mode);
1043
1044         type = (mode == WMI_11G_HT20) ? NL80211_CHAN_HT20 : NL80211_CHAN_NO_HT;
1045
1046         cfg80211_ch_switch_notify(vif->ndev, freq, type);
1047 }
1048
1049 static int ath6kl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
1050                                    u8 key_index, bool pairwise,
1051                                    const u8 *mac_addr,
1052                                    struct key_params *params)
1053 {
1054         struct ath6kl *ar = ath6kl_priv(ndev);
1055         struct ath6kl_vif *vif = netdev_priv(ndev);
1056         struct ath6kl_key *key = NULL;
1057         int seq_len;
1058         u8 key_usage;
1059         u8 key_type;
1060
1061         if (!ath6kl_cfg80211_ready(vif))
1062                 return -EIO;
1063
1064         if (params->cipher == CCKM_KRK_CIPHER_SUITE) {
1065                 if (params->key_len != WMI_KRK_LEN)
1066                         return -EINVAL;
1067                 return ath6kl_wmi_add_krk_cmd(ar->wmi, vif->fw_vif_idx,
1068                                               params->key);
1069         }
1070
1071         if (key_index > WMI_MAX_KEY_INDEX) {
1072                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1073                            "%s: key index %d out of bounds\n", __func__,
1074                            key_index);
1075                 return -ENOENT;
1076         }
1077
1078         key = &vif->keys[key_index];
1079         memset(key, 0, sizeof(struct ath6kl_key));
1080
1081         if (pairwise)
1082                 key_usage = PAIRWISE_USAGE;
1083         else
1084                 key_usage = GROUP_USAGE;
1085
1086         seq_len = params->seq_len;
1087         if (params->cipher == WLAN_CIPHER_SUITE_SMS4 &&
1088             seq_len > ATH6KL_KEY_SEQ_LEN) {
1089                 /* Only first half of the WPI PN is configured */
1090                 seq_len = ATH6KL_KEY_SEQ_LEN;
1091         }
1092         if (params->key_len > WLAN_MAX_KEY_LEN ||
1093             seq_len > sizeof(key->seq))
1094                 return -EINVAL;
1095
1096         key->key_len = params->key_len;
1097         memcpy(key->key, params->key, key->key_len);
1098         key->seq_len = seq_len;
1099         memcpy(key->seq, params->seq, key->seq_len);
1100         key->cipher = params->cipher;
1101
1102         switch (key->cipher) {
1103         case WLAN_CIPHER_SUITE_WEP40:
1104         case WLAN_CIPHER_SUITE_WEP104:
1105                 key_type = WEP_CRYPT;
1106                 break;
1107
1108         case WLAN_CIPHER_SUITE_TKIP:
1109                 key_type = TKIP_CRYPT;
1110                 break;
1111
1112         case WLAN_CIPHER_SUITE_CCMP:
1113                 key_type = AES_CRYPT;
1114                 break;
1115         case WLAN_CIPHER_SUITE_SMS4:
1116                 key_type = WAPI_CRYPT;
1117                 break;
1118
1119         default:
1120                 return -ENOTSUPP;
1121         }
1122
1123         if (((vif->auth_mode == WPA_PSK_AUTH) ||
1124              (vif->auth_mode == WPA2_PSK_AUTH)) &&
1125             (key_usage & GROUP_USAGE))
1126                 del_timer(&vif->disconnect_timer);
1127
1128         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1129                    "%s: index %d, key_len %d, key_type 0x%x, key_usage 0x%x, seq_len %d\n",
1130                    __func__, key_index, key->key_len, key_type,
1131                    key_usage, key->seq_len);
1132
1133         if (vif->nw_type == AP_NETWORK && !pairwise &&
1134             (key_type == TKIP_CRYPT || key_type == AES_CRYPT ||
1135              key_type == WAPI_CRYPT)) {
1136                 ar->ap_mode_bkey.valid = true;
1137                 ar->ap_mode_bkey.key_index = key_index;
1138                 ar->ap_mode_bkey.key_type = key_type;
1139                 ar->ap_mode_bkey.key_len = key->key_len;
1140                 memcpy(ar->ap_mode_bkey.key, key->key, key->key_len);
1141                 if (!test_bit(CONNECTED, &vif->flags)) {
1142                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1143                                    "Delay initial group key configuration until AP mode has been started\n");
1144                         /*
1145                          * The key will be set in ath6kl_connect_ap_mode() once
1146                          * the connected event is received from the target.
1147                          */
1148                         return 0;
1149                 }
1150         }
1151
1152         if (vif->next_mode == AP_NETWORK && key_type == WEP_CRYPT &&
1153             !test_bit(CONNECTED, &vif->flags)) {
1154                 /*
1155                  * Store the key locally so that it can be re-configured after
1156                  * the AP mode has properly started
1157                  * (ath6kl_install_statioc_wep_keys).
1158                  */
1159                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1160                            "Delay WEP key configuration until AP mode has been started\n");
1161                 vif->wep_key_list[key_index].key_len = key->key_len;
1162                 memcpy(vif->wep_key_list[key_index].key, key->key,
1163                        key->key_len);
1164                 return 0;
1165         }
1166
1167         return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, key_index,
1168                                      key_type, key_usage, key->key_len,
1169                                      key->seq, key->seq_len, key->key,
1170                                      KEY_OP_INIT_VAL,
1171                                      (u8 *) mac_addr, SYNC_BOTH_WMIFLAG);
1172 }
1173
1174 static int ath6kl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
1175                                    u8 key_index, bool pairwise,
1176                                    const u8 *mac_addr)
1177 {
1178         struct ath6kl *ar = ath6kl_priv(ndev);
1179         struct ath6kl_vif *vif = netdev_priv(ndev);
1180
1181         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1182
1183         if (!ath6kl_cfg80211_ready(vif))
1184                 return -EIO;
1185
1186         if (key_index > WMI_MAX_KEY_INDEX) {
1187                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1188                            "%s: key index %d out of bounds\n", __func__,
1189                            key_index);
1190                 return -ENOENT;
1191         }
1192
1193         if (!vif->keys[key_index].key_len) {
1194                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1195                            "%s: index %d is empty\n", __func__, key_index);
1196                 return 0;
1197         }
1198
1199         vif->keys[key_index].key_len = 0;
1200
1201         return ath6kl_wmi_deletekey_cmd(ar->wmi, vif->fw_vif_idx, key_index);
1202 }
1203
1204 static int ath6kl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
1205                                    u8 key_index, bool pairwise,
1206                                    const u8 *mac_addr, void *cookie,
1207                                    void (*callback) (void *cookie,
1208                                                      struct key_params *))
1209 {
1210         struct ath6kl_vif *vif = netdev_priv(ndev);
1211         struct ath6kl_key *key = NULL;
1212         struct key_params params;
1213
1214         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1215
1216         if (!ath6kl_cfg80211_ready(vif))
1217                 return -EIO;
1218
1219         if (key_index > WMI_MAX_KEY_INDEX) {
1220                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1221                            "%s: key index %d out of bounds\n", __func__,
1222                            key_index);
1223                 return -ENOENT;
1224         }
1225
1226         key = &vif->keys[key_index];
1227         memset(&params, 0, sizeof(params));
1228         params.cipher = key->cipher;
1229         params.key_len = key->key_len;
1230         params.seq_len = key->seq_len;
1231         params.seq = key->seq;
1232         params.key = key->key;
1233
1234         callback(cookie, &params);
1235
1236         return key->key_len ? 0 : -ENOENT;
1237 }
1238
1239 static int ath6kl_cfg80211_set_default_key(struct wiphy *wiphy,
1240                                            struct net_device *ndev,
1241                                            u8 key_index, bool unicast,
1242                                            bool multicast)
1243 {
1244         struct ath6kl *ar = ath6kl_priv(ndev);
1245         struct ath6kl_vif *vif = netdev_priv(ndev);
1246         struct ath6kl_key *key = NULL;
1247         u8 key_usage;
1248         enum crypto_type key_type = NONE_CRYPT;
1249
1250         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1251
1252         if (!ath6kl_cfg80211_ready(vif))
1253                 return -EIO;
1254
1255         if (key_index > WMI_MAX_KEY_INDEX) {
1256                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1257                            "%s: key index %d out of bounds\n",
1258                            __func__, key_index);
1259                 return -ENOENT;
1260         }
1261
1262         if (!vif->keys[key_index].key_len) {
1263                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: invalid key index %d\n",
1264                            __func__, key_index);
1265                 return -EINVAL;
1266         }
1267
1268         vif->def_txkey_index = key_index;
1269         key = &vif->keys[vif->def_txkey_index];
1270         key_usage = GROUP_USAGE;
1271         if (vif->prwise_crypto == WEP_CRYPT)
1272                 key_usage |= TX_USAGE;
1273         if (unicast)
1274                 key_type = vif->prwise_crypto;
1275         if (multicast)
1276                 key_type = vif->grp_crypto;
1277
1278         if (vif->next_mode == AP_NETWORK && !test_bit(CONNECTED, &vif->flags))
1279                 return 0; /* Delay until AP mode has been started */
1280
1281         return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx,
1282                                      vif->def_txkey_index,
1283                                      key_type, key_usage,
1284                                      key->key_len, key->seq, key->seq_len,
1285                                      key->key,
1286                                      KEY_OP_INIT_VAL, NULL,
1287                                      SYNC_BOTH_WMIFLAG);
1288 }
1289
1290 void ath6kl_cfg80211_tkip_micerr_event(struct ath6kl_vif *vif, u8 keyid,
1291                                        bool ismcast)
1292 {
1293         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1294                    "%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast);
1295
1296         cfg80211_michael_mic_failure(vif->ndev, vif->bssid,
1297                                      (ismcast ? NL80211_KEYTYPE_GROUP :
1298                                       NL80211_KEYTYPE_PAIRWISE), keyid, NULL,
1299                                      GFP_KERNEL);
1300 }
1301
1302 static int ath6kl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1303 {
1304         struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1305         struct ath6kl_vif *vif;
1306         int ret;
1307
1308         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: changed 0x%x\n", __func__,
1309                    changed);
1310
1311         vif = ath6kl_vif_first(ar);
1312         if (!vif)
1313                 return -EIO;
1314
1315         if (!ath6kl_cfg80211_ready(vif))
1316                 return -EIO;
1317
1318         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1319                 ret = ath6kl_wmi_set_rts_cmd(ar->wmi, wiphy->rts_threshold);
1320                 if (ret != 0) {
1321                         ath6kl_err("ath6kl_wmi_set_rts_cmd failed\n");
1322                         return -EIO;
1323                 }
1324         }
1325
1326         return 0;
1327 }
1328
1329 /*
1330  * The type nl80211_tx_power_setting replaces the following
1331  * data type from 2.6.36 onwards
1332 */
1333 static int ath6kl_cfg80211_set_txpower(struct wiphy *wiphy,
1334                                        enum nl80211_tx_power_setting type,
1335                                        int mbm)
1336 {
1337         struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1338         struct ath6kl_vif *vif;
1339         int dbm = MBM_TO_DBM(mbm);
1340
1341         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x, dbm %d\n", __func__,
1342                    type, dbm);
1343
1344         vif = ath6kl_vif_first(ar);
1345         if (!vif)
1346                 return -EIO;
1347
1348         if (!ath6kl_cfg80211_ready(vif))
1349                 return -EIO;
1350
1351         switch (type) {
1352         case NL80211_TX_POWER_AUTOMATIC:
1353                 return 0;
1354         case NL80211_TX_POWER_LIMITED:
1355                 ar->tx_pwr = dbm;
1356                 break;
1357         default:
1358                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x not supported\n",
1359                            __func__, type);
1360                 return -EOPNOTSUPP;
1361         }
1362
1363         ath6kl_wmi_set_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx, dbm);
1364
1365         return 0;
1366 }
1367
1368 static int ath6kl_cfg80211_get_txpower(struct wiphy *wiphy, int *dbm)
1369 {
1370         struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1371         struct ath6kl_vif *vif;
1372
1373         vif = ath6kl_vif_first(ar);
1374         if (!vif)
1375                 return -EIO;
1376
1377         if (!ath6kl_cfg80211_ready(vif))
1378                 return -EIO;
1379
1380         if (test_bit(CONNECTED, &vif->flags)) {
1381                 ar->tx_pwr = 0;
1382
1383                 if (ath6kl_wmi_get_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx) != 0) {
1384                         ath6kl_err("ath6kl_wmi_get_tx_pwr_cmd failed\n");
1385                         return -EIO;
1386                 }
1387
1388                 wait_event_interruptible_timeout(ar->event_wq, ar->tx_pwr != 0,
1389                                                  5 * HZ);
1390
1391                 if (signal_pending(current)) {
1392                         ath6kl_err("target did not respond\n");
1393                         return -EINTR;
1394                 }
1395         }
1396
1397         *dbm = ar->tx_pwr;
1398         return 0;
1399 }
1400
1401 static int ath6kl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
1402                                           struct net_device *dev,
1403                                           bool pmgmt, int timeout)
1404 {
1405         struct ath6kl *ar = ath6kl_priv(dev);
1406         struct wmi_power_mode_cmd mode;
1407         struct ath6kl_vif *vif = netdev_priv(dev);
1408
1409         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: pmgmt %d, timeout %d\n",
1410                    __func__, pmgmt, timeout);
1411
1412         if (!ath6kl_cfg80211_ready(vif))
1413                 return -EIO;
1414
1415         if (pmgmt) {
1416                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: max perf\n", __func__);
1417                 mode.pwr_mode = REC_POWER;
1418         } else {
1419                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\n", __func__);
1420                 mode.pwr_mode = MAX_PERF_POWER;
1421         }
1422
1423         if (ath6kl_wmi_powermode_cmd(ar->wmi, vif->fw_vif_idx,
1424                                      mode.pwr_mode) != 0) {
1425                 ath6kl_err("wmi_powermode_cmd failed\n");
1426                 return -EIO;
1427         }
1428
1429         return 0;
1430 }
1431
1432 static struct net_device *ath6kl_cfg80211_add_iface(struct wiphy *wiphy,
1433                                                     char *name,
1434                                                     enum nl80211_iftype type,
1435                                                     u32 *flags,
1436                                                     struct vif_params *params)
1437 {
1438         struct ath6kl *ar = wiphy_priv(wiphy);
1439         struct net_device *ndev;
1440         u8 if_idx, nw_type;
1441
1442         if (ar->num_vif == ar->vif_max) {
1443                 ath6kl_err("Reached maximum number of supported vif\n");
1444                 return ERR_PTR(-EINVAL);
1445         }
1446
1447         if (!ath6kl_is_valid_iftype(ar, type, &if_idx, &nw_type)) {
1448                 ath6kl_err("Not a supported interface type\n");
1449                 return ERR_PTR(-EINVAL);
1450         }
1451
1452         ndev = ath6kl_interface_add(ar, name, type, if_idx, nw_type);
1453         if (!ndev)
1454                 return ERR_PTR(-ENOMEM);
1455
1456         ar->num_vif++;
1457
1458         return ndev;
1459 }
1460
1461 static int ath6kl_cfg80211_del_iface(struct wiphy *wiphy,
1462                                      struct net_device *ndev)
1463 {
1464         struct ath6kl *ar = wiphy_priv(wiphy);
1465         struct ath6kl_vif *vif = netdev_priv(ndev);
1466
1467         spin_lock_bh(&ar->list_lock);
1468         list_del(&vif->list);
1469         spin_unlock_bh(&ar->list_lock);
1470
1471         ath6kl_cleanup_vif(vif, test_bit(WMI_READY, &ar->flag));
1472
1473         ath6kl_cfg80211_vif_cleanup(vif);
1474
1475         return 0;
1476 }
1477
1478 static int ath6kl_cfg80211_change_iface(struct wiphy *wiphy,
1479                                         struct net_device *ndev,
1480                                         enum nl80211_iftype type, u32 *flags,
1481                                         struct vif_params *params)
1482 {
1483         struct ath6kl_vif *vif = netdev_priv(ndev);
1484         int i;
1485
1486         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type %u\n", __func__, type);
1487
1488         /*
1489          * Don't bring up p2p on an interface which is not initialized
1490          * for p2p operation where fw does not have capability to switch
1491          * dynamically between non-p2p and p2p type interface.
1492          */
1493         if (!test_bit(ATH6KL_FW_CAPABILITY_STA_P2PDEV_DUPLEX,
1494                       vif->ar->fw_capabilities) &&
1495             (type == NL80211_IFTYPE_P2P_CLIENT ||
1496              type == NL80211_IFTYPE_P2P_GO)) {
1497                 if (vif->ar->vif_max == 1) {
1498                         if (vif->fw_vif_idx != 0)
1499                                 return -EINVAL;
1500                         else
1501                                 goto set_iface_type;
1502                 }
1503
1504                 for (i = vif->ar->max_norm_iface; i < vif->ar->vif_max; i++) {
1505                         if (i == vif->fw_vif_idx)
1506                                 break;
1507                 }
1508
1509                 if (i == vif->ar->vif_max) {
1510                         ath6kl_err("Invalid interface to bring up P2P\n");
1511                         return -EINVAL;
1512                 }
1513         }
1514
1515 set_iface_type:
1516         switch (type) {
1517         case NL80211_IFTYPE_STATION:
1518                 vif->next_mode = INFRA_NETWORK;
1519                 break;
1520         case NL80211_IFTYPE_ADHOC:
1521                 vif->next_mode = ADHOC_NETWORK;
1522                 break;
1523         case NL80211_IFTYPE_AP:
1524                 vif->next_mode = AP_NETWORK;
1525                 break;
1526         case NL80211_IFTYPE_P2P_CLIENT:
1527                 vif->next_mode = INFRA_NETWORK;
1528                 break;
1529         case NL80211_IFTYPE_P2P_GO:
1530                 vif->next_mode = AP_NETWORK;
1531                 break;
1532         default:
1533                 ath6kl_err("invalid interface type %u\n", type);
1534                 return -EOPNOTSUPP;
1535         }
1536
1537         vif->wdev.iftype = type;
1538
1539         return 0;
1540 }
1541
1542 static int ath6kl_cfg80211_join_ibss(struct wiphy *wiphy,
1543                                      struct net_device *dev,
1544                                      struct cfg80211_ibss_params *ibss_param)
1545 {
1546         struct ath6kl *ar = ath6kl_priv(dev);
1547         struct ath6kl_vif *vif = netdev_priv(dev);
1548         int status;
1549
1550         if (!ath6kl_cfg80211_ready(vif))
1551                 return -EIO;
1552
1553         vif->ssid_len = ibss_param->ssid_len;
1554         memcpy(vif->ssid, ibss_param->ssid, vif->ssid_len);
1555
1556         if (ibss_param->channel)
1557                 vif->ch_hint = ibss_param->channel->center_freq;
1558
1559         if (ibss_param->channel_fixed) {
1560                 /*
1561                  * TODO: channel_fixed: The channel should be fixed, do not
1562                  * search for IBSSs to join on other channels. Target
1563                  * firmware does not support this feature, needs to be
1564                  * updated.
1565                  */
1566                 return -EOPNOTSUPP;
1567         }
1568
1569         memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
1570         if (ibss_param->bssid && !is_broadcast_ether_addr(ibss_param->bssid))
1571                 memcpy(vif->req_bssid, ibss_param->bssid,
1572                        sizeof(vif->req_bssid));
1573
1574         ath6kl_set_wpa_version(vif, 0);
1575
1576         status = ath6kl_set_auth_type(vif, NL80211_AUTHTYPE_OPEN_SYSTEM);
1577         if (status)
1578                 return status;
1579
1580         if (ibss_param->privacy) {
1581                 ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, true);
1582                 ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, false);
1583         } else {
1584                 ath6kl_set_cipher(vif, 0, true);
1585                 ath6kl_set_cipher(vif, 0, false);
1586         }
1587
1588         vif->nw_type = vif->next_mode;
1589
1590         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1591                    "%s: connect called with authmode %d dot11 auth %d"
1592                    " PW crypto %d PW crypto len %d GRP crypto %d"
1593                    " GRP crypto len %d channel hint %u\n",
1594                    __func__,
1595                    vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto,
1596                    vif->prwise_crypto_len, vif->grp_crypto,
1597                    vif->grp_crypto_len, vif->ch_hint);
1598
1599         status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type,
1600                                         vif->dot11_auth_mode, vif->auth_mode,
1601                                         vif->prwise_crypto,
1602                                         vif->prwise_crypto_len,
1603                                         vif->grp_crypto, vif->grp_crypto_len,
1604                                         vif->ssid_len, vif->ssid,
1605                                         vif->req_bssid, vif->ch_hint,
1606                                         ar->connect_ctrl_flags, SUBTYPE_NONE);
1607         set_bit(CONNECT_PEND, &vif->flags);
1608
1609         return 0;
1610 }
1611
1612 static int ath6kl_cfg80211_leave_ibss(struct wiphy *wiphy,
1613                                       struct net_device *dev)
1614 {
1615         struct ath6kl_vif *vif = netdev_priv(dev);
1616
1617         if (!ath6kl_cfg80211_ready(vif))
1618                 return -EIO;
1619
1620         ath6kl_disconnect(vif);
1621         memset(vif->ssid, 0, sizeof(vif->ssid));
1622         vif->ssid_len = 0;
1623
1624         return 0;
1625 }
1626
1627 static const u32 cipher_suites[] = {
1628         WLAN_CIPHER_SUITE_WEP40,
1629         WLAN_CIPHER_SUITE_WEP104,
1630         WLAN_CIPHER_SUITE_TKIP,
1631         WLAN_CIPHER_SUITE_CCMP,
1632         CCKM_KRK_CIPHER_SUITE,
1633         WLAN_CIPHER_SUITE_SMS4,
1634 };
1635
1636 static bool is_rate_legacy(s32 rate)
1637 {
1638         static const s32 legacy[] = { 1000, 2000, 5500, 11000,
1639                 6000, 9000, 12000, 18000, 24000,
1640                 36000, 48000, 54000
1641         };
1642         u8 i;
1643
1644         for (i = 0; i < ARRAY_SIZE(legacy); i++)
1645                 if (rate == legacy[i])
1646                         return true;
1647
1648         return false;
1649 }
1650
1651 static bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi)
1652 {
1653         static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000,
1654                 52000, 58500, 65000, 72200
1655         };
1656         u8 i;
1657
1658         for (i = 0; i < ARRAY_SIZE(ht20); i++) {
1659                 if (rate == ht20[i]) {
1660                         if (i == ARRAY_SIZE(ht20) - 1)
1661                                 /* last rate uses sgi */
1662                                 *sgi = true;
1663                         else
1664                                 *sgi = false;
1665
1666                         *mcs = i;
1667                         return true;
1668                 }
1669         }
1670         return false;
1671 }
1672
1673 static bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi)
1674 {
1675         static const s32 ht40[] = { 13500, 27000, 40500, 54000,
1676                 81000, 108000, 121500, 135000,
1677                 150000
1678         };
1679         u8 i;
1680
1681         for (i = 0; i < ARRAY_SIZE(ht40); i++) {
1682                 if (rate == ht40[i]) {
1683                         if (i == ARRAY_SIZE(ht40) - 1)
1684                                 /* last rate uses sgi */
1685                                 *sgi = true;
1686                         else
1687                                 *sgi = false;
1688
1689                         *mcs = i;
1690                         return true;
1691                 }
1692         }
1693
1694         return false;
1695 }
1696
1697 static int ath6kl_get_station(struct wiphy *wiphy, struct net_device *dev,
1698                               u8 *mac, struct station_info *sinfo)
1699 {
1700         struct ath6kl *ar = ath6kl_priv(dev);
1701         struct ath6kl_vif *vif = netdev_priv(dev);
1702         long left;
1703         bool sgi;
1704         s32 rate;
1705         int ret;
1706         u8 mcs;
1707
1708         if (memcmp(mac, vif->bssid, ETH_ALEN) != 0)
1709                 return -ENOENT;
1710
1711         if (down_interruptible(&ar->sem))
1712                 return -EBUSY;
1713
1714         set_bit(STATS_UPDATE_PEND, &vif->flags);
1715
1716         ret = ath6kl_wmi_get_stats_cmd(ar->wmi, vif->fw_vif_idx);
1717
1718         if (ret != 0) {
1719                 up(&ar->sem);
1720                 return -EIO;
1721         }
1722
1723         left = wait_event_interruptible_timeout(ar->event_wq,
1724                                                 !test_bit(STATS_UPDATE_PEND,
1725                                                           &vif->flags),
1726                                                 WMI_TIMEOUT);
1727
1728         up(&ar->sem);
1729
1730         if (left == 0)
1731                 return -ETIMEDOUT;
1732         else if (left < 0)
1733                 return left;
1734
1735         if (vif->target_stats.rx_byte) {
1736                 sinfo->rx_bytes = vif->target_stats.rx_byte;
1737                 sinfo->filled |= STATION_INFO_RX_BYTES;
1738                 sinfo->rx_packets = vif->target_stats.rx_pkt;
1739                 sinfo->filled |= STATION_INFO_RX_PACKETS;
1740         }
1741
1742         if (vif->target_stats.tx_byte) {
1743                 sinfo->tx_bytes = vif->target_stats.tx_byte;
1744                 sinfo->filled |= STATION_INFO_TX_BYTES;
1745                 sinfo->tx_packets = vif->target_stats.tx_pkt;
1746                 sinfo->filled |= STATION_INFO_TX_PACKETS;
1747         }
1748
1749         sinfo->signal = vif->target_stats.cs_rssi;
1750         sinfo->filled |= STATION_INFO_SIGNAL;
1751
1752         rate = vif->target_stats.tx_ucast_rate;
1753
1754         if (is_rate_legacy(rate)) {
1755                 sinfo->txrate.legacy = rate / 100;
1756         } else if (is_rate_ht20(rate, &mcs, &sgi)) {
1757                 if (sgi) {
1758                         sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1759                         sinfo->txrate.mcs = mcs - 1;
1760                 } else {
1761                         sinfo->txrate.mcs = mcs;
1762                 }
1763
1764                 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1765         } else if (is_rate_ht40(rate, &mcs, &sgi)) {
1766                 if (sgi) {
1767                         sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1768                         sinfo->txrate.mcs = mcs - 1;
1769                 } else {
1770                         sinfo->txrate.mcs = mcs;
1771                 }
1772
1773                 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
1774                 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1775         } else {
1776                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1777                            "invalid rate from stats: %d\n", rate);
1778                 ath6kl_debug_war(ar, ATH6KL_WAR_INVALID_RATE);
1779                 return 0;
1780         }
1781
1782         sinfo->filled |= STATION_INFO_TX_BITRATE;
1783
1784         if (test_bit(CONNECTED, &vif->flags) &&
1785             test_bit(DTIM_PERIOD_AVAIL, &vif->flags) &&
1786             vif->nw_type == INFRA_NETWORK) {
1787                 sinfo->filled |= STATION_INFO_BSS_PARAM;
1788                 sinfo->bss_param.flags = 0;
1789                 sinfo->bss_param.dtim_period = vif->assoc_bss_dtim_period;
1790                 sinfo->bss_param.beacon_interval = vif->assoc_bss_beacon_int;
1791         }
1792
1793         return 0;
1794 }
1795
1796 static int ath6kl_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1797                             struct cfg80211_pmksa *pmksa)
1798 {
1799         struct ath6kl *ar = ath6kl_priv(netdev);
1800         struct ath6kl_vif *vif = netdev_priv(netdev);
1801
1802         return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid,
1803                                        pmksa->pmkid, true);
1804 }
1805
1806 static int ath6kl_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1807                             struct cfg80211_pmksa *pmksa)
1808 {
1809         struct ath6kl *ar = ath6kl_priv(netdev);
1810         struct ath6kl_vif *vif = netdev_priv(netdev);
1811
1812         return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid,
1813                                        pmksa->pmkid, false);
1814 }
1815
1816 static int ath6kl_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1817 {
1818         struct ath6kl *ar = ath6kl_priv(netdev);
1819         struct ath6kl_vif *vif = netdev_priv(netdev);
1820
1821         if (test_bit(CONNECTED, &vif->flags))
1822                 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx,
1823                                                vif->bssid, NULL, false);
1824         return 0;
1825 }
1826
1827 static int ath6kl_wow_usr(struct ath6kl *ar, struct ath6kl_vif *vif,
1828                           struct cfg80211_wowlan *wow, u32 *filter)
1829 {
1830         int ret, pos;
1831         u8 mask[WOW_MASK_SIZE];
1832         u16 i;
1833
1834         /* Configure the patterns that we received from the user. */
1835         for (i = 0; i < wow->n_patterns; i++) {
1836
1837                 /*
1838                  * Convert given nl80211 specific mask value to equivalent
1839                  * driver specific mask value and send it to the chip along
1840                  * with patterns. For example, If the mask value defined in
1841                  * struct cfg80211_wowlan is 0xA (equivalent binary is 1010),
1842                  * then equivalent driver specific mask value is
1843                  * "0xFF 0x00 0xFF 0x00".
1844                  */
1845                 memset(&mask, 0, sizeof(mask));
1846                 for (pos = 0; pos < wow->patterns[i].pattern_len; pos++) {
1847                         if (wow->patterns[i].mask[pos / 8] & (0x1 << (pos % 8)))
1848                                 mask[pos] = 0xFF;
1849                 }
1850                 /*
1851                  * Note: Pattern's offset is not passed as part of wowlan
1852                  * parameter from CFG layer. So it's always passed as ZERO
1853                  * to the firmware. It means, given WOW patterns are always
1854                  * matched from the first byte of received pkt in the firmware.
1855                  */
1856                 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1857                                 vif->fw_vif_idx, WOW_LIST_ID,
1858                                 wow->patterns[i].pattern_len,
1859                                 0 /* pattern offset */,
1860                                 wow->patterns[i].pattern, mask);
1861                 if (ret)
1862                         return ret;
1863         }
1864
1865         if (wow->disconnect)
1866                 *filter |= WOW_FILTER_OPTION_NWK_DISASSOC;
1867
1868         if (wow->magic_pkt)
1869                 *filter |= WOW_FILTER_OPTION_MAGIC_PACKET;
1870
1871         if (wow->gtk_rekey_failure)
1872                 *filter |= WOW_FILTER_OPTION_GTK_ERROR;
1873
1874         if (wow->eap_identity_req)
1875                 *filter |= WOW_FILTER_OPTION_EAP_REQ;
1876
1877         if (wow->four_way_handshake)
1878                 *filter |= WOW_FILTER_OPTION_8021X_4WAYHS;
1879
1880         return 0;
1881 }
1882
1883 static int ath6kl_wow_ap(struct ath6kl *ar, struct ath6kl_vif *vif)
1884 {
1885         static const u8 unicst_pattern[] = { 0x00, 0x00, 0x00,
1886                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1887                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1888                 0x00, 0x08 };
1889         static const u8 unicst_mask[] = { 0x01, 0x00, 0x00,
1890                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1891                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1892                 0x00, 0x7f };
1893         u8 unicst_offset = 0;
1894         static const u8 arp_pattern[] = { 0x08, 0x06 };
1895         static const u8 arp_mask[] = { 0xff, 0xff };
1896         u8 arp_offset = 20;
1897         static const u8 discvr_pattern[] = { 0xe0, 0x00, 0x00, 0xf8 };
1898         static const u8 discvr_mask[] = { 0xf0, 0x00, 0x00, 0xf8 };
1899         u8 discvr_offset = 38;
1900         static const u8 dhcp_pattern[] = { 0xff, 0xff, 0xff, 0xff,
1901                 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1902                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
1903                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1904                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1905                 0x00, 0x00, 0x00, 0x00, 0x00, 0x43 /* port 67 */ };
1906         static const u8 dhcp_mask[] = { 0xff, 0xff, 0xff, 0xff,
1907                 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1908                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
1909                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1910                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1911                 0x00, 0x00, 0x00, 0x00, 0xff, 0xff /* port 67 */ };
1912         u8 dhcp_offset = 0;
1913         int ret;
1914
1915         /* Setup unicast IP, EAPOL-like and ARP pkt pattern */
1916         ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1917                         vif->fw_vif_idx, WOW_LIST_ID,
1918                         sizeof(unicst_pattern), unicst_offset,
1919                         unicst_pattern, unicst_mask);
1920         if (ret) {
1921                 ath6kl_err("failed to add WOW unicast IP pattern\n");
1922                 return ret;
1923         }
1924
1925         /* Setup all ARP pkt pattern */
1926         ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1927                         vif->fw_vif_idx, WOW_LIST_ID,
1928                         sizeof(arp_pattern), arp_offset,
1929                         arp_pattern, arp_mask);
1930         if (ret) {
1931                 ath6kl_err("failed to add WOW ARP pattern\n");
1932                 return ret;
1933         }
1934
1935         /*
1936          * Setup multicast pattern for mDNS 224.0.0.251,
1937          * SSDP 239.255.255.250 and LLMNR  224.0.0.252
1938          */
1939         ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1940                         vif->fw_vif_idx, WOW_LIST_ID,
1941                         sizeof(discvr_pattern), discvr_offset,
1942                         discvr_pattern, discvr_mask);
1943         if (ret) {
1944                 ath6kl_err("failed to add WOW mDNS/SSDP/LLMNR pattern\n");
1945                 return ret;
1946         }
1947
1948         /* Setup all DHCP broadcast pkt pattern */
1949         ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1950                         vif->fw_vif_idx, WOW_LIST_ID,
1951                         sizeof(dhcp_pattern), dhcp_offset,
1952                         dhcp_pattern, dhcp_mask);
1953         if (ret) {
1954                 ath6kl_err("failed to add WOW DHCP broadcast pattern\n");
1955                 return ret;
1956         }
1957
1958         return 0;
1959 }
1960
1961 static int ath6kl_wow_sta(struct ath6kl *ar, struct ath6kl_vif *vif)
1962 {
1963         struct net_device *ndev = vif->ndev;
1964         static const u8 discvr_pattern[] = { 0xe0, 0x00, 0x00, 0xf8 };
1965         static const u8 discvr_mask[] = { 0xf0, 0x00, 0x00, 0xf8 };
1966         u8 discvr_offset = 38;
1967         u8 mac_mask[ETH_ALEN];
1968         int ret;
1969
1970         /* Setup unicast pkt pattern */
1971         memset(mac_mask, 0xff, ETH_ALEN);
1972         ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1973                                 vif->fw_vif_idx, WOW_LIST_ID,
1974                                 ETH_ALEN, 0, ndev->dev_addr,
1975                                 mac_mask);
1976         if (ret) {
1977                 ath6kl_err("failed to add WOW unicast pattern\n");
1978                 return ret;
1979         }
1980
1981         /*
1982          * Setup multicast pattern for mDNS 224.0.0.251,
1983          * SSDP 239.255.255.250 and LLMNR 224.0.0.252
1984          */
1985         if ((ndev->flags & IFF_ALLMULTI) ||
1986             (ndev->flags & IFF_MULTICAST && netdev_mc_count(ndev) > 0)) {
1987                 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1988                                 vif->fw_vif_idx, WOW_LIST_ID,
1989                                 sizeof(discvr_pattern), discvr_offset,
1990                                 discvr_pattern, discvr_mask);
1991                 if (ret) {
1992                         ath6kl_err("failed to add WOW mDNS/SSDP/LLMNR pattern\n");
1993                         return ret;
1994                 }
1995         }
1996
1997         return 0;
1998 }
1999
2000 static int is_hsleep_mode_procsed(struct ath6kl_vif *vif)
2001 {
2002         return test_bit(HOST_SLEEP_MODE_CMD_PROCESSED, &vif->flags);
2003 }
2004
2005 static bool is_ctrl_ep_empty(struct ath6kl *ar)
2006 {
2007         return !ar->tx_pending[ar->ctrl_ep];
2008 }
2009
2010 static int ath6kl_cfg80211_host_sleep(struct ath6kl *ar, struct ath6kl_vif *vif)
2011 {
2012         int ret, left;
2013
2014         clear_bit(HOST_SLEEP_MODE_CMD_PROCESSED, &vif->flags);
2015
2016         ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2017                                                  ATH6KL_HOST_MODE_ASLEEP);
2018         if (ret)
2019                 return ret;
2020
2021         left = wait_event_interruptible_timeout(ar->event_wq,
2022                                                 is_hsleep_mode_procsed(vif),
2023                                                 WMI_TIMEOUT);
2024         if (left == 0) {
2025                 ath6kl_warn("timeout, didn't get host sleep cmd processed event\n");
2026                 ret = -ETIMEDOUT;
2027         } else if (left < 0) {
2028                 ath6kl_warn("error while waiting for host sleep cmd processed event %d\n",
2029                             left);
2030                 ret = left;
2031         }
2032
2033         if (ar->tx_pending[ar->ctrl_ep]) {
2034                 left = wait_event_interruptible_timeout(ar->event_wq,
2035                                                         is_ctrl_ep_empty(ar),
2036                                                         WMI_TIMEOUT);
2037                 if (left == 0) {
2038                         ath6kl_warn("clear wmi ctrl data timeout\n");
2039                         ret = -ETIMEDOUT;
2040                 } else if (left < 0) {
2041                         ath6kl_warn("clear wmi ctrl data failed: %d\n", left);
2042                         ret = left;
2043                 }
2044         }
2045
2046         return ret;
2047 }
2048
2049 static int ath6kl_wow_suspend(struct ath6kl *ar, struct cfg80211_wowlan *wow)
2050 {
2051         struct in_device *in_dev;
2052         struct in_ifaddr *ifa;
2053         struct ath6kl_vif *vif;
2054         int ret;
2055         u32 filter = 0;
2056         u16 i, bmiss_time;
2057         u8 index = 0;
2058         __be32 ips[MAX_IP_ADDRS];
2059
2060         /* The FW currently can't support multi-vif WoW properly. */
2061         if (ar->num_vif > 1)
2062                 return -EIO;
2063
2064         vif = ath6kl_vif_first(ar);
2065         if (!vif)
2066                 return -EIO;
2067
2068         if (!ath6kl_cfg80211_ready(vif))
2069                 return -EIO;
2070
2071         if (!test_bit(CONNECTED, &vif->flags))
2072                 return -ENOTCONN;
2073
2074         if (wow && (wow->n_patterns > WOW_MAX_FILTERS_PER_LIST))
2075                 return -EINVAL;
2076
2077         if (!test_bit(NETDEV_MCAST_ALL_ON, &vif->flags)) {
2078                 ret = ath6kl_wmi_mcast_filter_cmd(vif->ar->wmi,
2079                                                 vif->fw_vif_idx, false);
2080                 if (ret)
2081                         return ret;
2082         }
2083
2084         /* Clear existing WOW patterns */
2085         for (i = 0; i < WOW_MAX_FILTERS_PER_LIST; i++)
2086                 ath6kl_wmi_del_wow_pattern_cmd(ar->wmi, vif->fw_vif_idx,
2087                                                WOW_LIST_ID, i);
2088
2089         /*
2090          * Skip the default WOW pattern configuration
2091          * if the driver receives any WOW patterns from
2092          * the user.
2093          */
2094         if (wow)
2095                 ret = ath6kl_wow_usr(ar, vif, wow, &filter);
2096         else if (vif->nw_type == AP_NETWORK)
2097                 ret = ath6kl_wow_ap(ar, vif);
2098         else
2099                 ret = ath6kl_wow_sta(ar, vif);
2100
2101         if (ret)
2102                 return ret;
2103
2104         netif_stop_queue(vif->ndev);
2105
2106         if (vif->nw_type != AP_NETWORK) {
2107                 ret = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
2108                                                     ATH6KL_MAX_WOW_LISTEN_INTL,
2109                                                     0);
2110                 if (ret)
2111                         return ret;
2112
2113                 /* Set listen interval x 15 times as bmiss time */
2114                 bmiss_time = ATH6KL_MAX_WOW_LISTEN_INTL * 15;
2115                 if (bmiss_time > ATH6KL_MAX_BMISS_TIME)
2116                         bmiss_time = ATH6KL_MAX_BMISS_TIME;
2117
2118                 ret = ath6kl_wmi_bmisstime_cmd(ar->wmi, vif->fw_vif_idx,
2119                                                bmiss_time, 0);
2120                 if (ret)
2121                         return ret;
2122
2123                 ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2124                                                 0xFFFF, 0, 0xFFFF, 0, 0, 0,
2125                                                 0, 0, 0, 0);
2126                 if (ret)
2127                         return ret;
2128         }
2129
2130         ar->state = ATH6KL_STATE_SUSPENDING;
2131
2132         /* Setup own IP addr for ARP agent. */
2133         in_dev = __in_dev_get_rtnl(vif->ndev);
2134         if (!in_dev)
2135                 goto skip_arp;
2136
2137         ifa = in_dev->ifa_list;
2138         memset(&ips, 0, sizeof(ips));
2139
2140         /* Configure IP addr only if IP address count < MAX_IP_ADDRS */
2141         while (index < MAX_IP_ADDRS && ifa) {
2142                 ips[index] = ifa->ifa_local;
2143                 ifa = ifa->ifa_next;
2144                 index++;
2145         }
2146
2147         if (ifa) {
2148                 ath6kl_err("total IP addr count is exceeding fw limit\n");
2149                 return -EINVAL;
2150         }
2151
2152         ret = ath6kl_wmi_set_ip_cmd(ar->wmi, vif->fw_vif_idx, ips[0], ips[1]);
2153         if (ret) {
2154                 ath6kl_err("fail to setup ip for arp agent\n");
2155                 return ret;
2156         }
2157
2158 skip_arp:
2159         ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, vif->fw_vif_idx,
2160                                           ATH6KL_WOW_MODE_ENABLE,
2161                                           filter,
2162                                           WOW_HOST_REQ_DELAY);
2163         if (ret)
2164                 return ret;
2165
2166         ret = ath6kl_cfg80211_host_sleep(ar, vif);
2167         if (ret)
2168                 return ret;
2169
2170         return 0;
2171 }
2172
2173 static int ath6kl_wow_resume(struct ath6kl *ar)
2174 {
2175         struct ath6kl_vif *vif;
2176         int ret;
2177
2178         vif = ath6kl_vif_first(ar);
2179         if (!vif)
2180                 return -EIO;
2181
2182         ar->state = ATH6KL_STATE_RESUMING;
2183
2184         ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2185                                                  ATH6KL_HOST_MODE_AWAKE);
2186         if (ret) {
2187                 ath6kl_warn("Failed to configure host sleep mode for wow resume: %d\n",
2188                             ret);
2189                 ar->state = ATH6KL_STATE_WOW;
2190                 return ret;
2191         }
2192
2193         if (vif->nw_type != AP_NETWORK) {
2194                 ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2195                                                 0, 0, 0, 0, 0, 0, 3, 0, 0, 0);
2196                 if (ret)
2197                         return ret;
2198
2199                 ret = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
2200                                                     vif->listen_intvl_t, 0);
2201                 if (ret)
2202                         return ret;
2203
2204                 ret = ath6kl_wmi_bmisstime_cmd(ar->wmi, vif->fw_vif_idx,
2205                                                vif->bmiss_time_t, 0);
2206                 if (ret)
2207                         return ret;
2208         }
2209
2210         ar->state = ATH6KL_STATE_ON;
2211
2212         if (!test_bit(NETDEV_MCAST_ALL_OFF, &vif->flags)) {
2213                 ret = ath6kl_wmi_mcast_filter_cmd(vif->ar->wmi,
2214                                         vif->fw_vif_idx, true);
2215                 if (ret)
2216                         return ret;
2217         }
2218
2219         netif_wake_queue(vif->ndev);
2220
2221         return 0;
2222 }
2223
2224 static int ath6kl_cfg80211_deepsleep_suspend(struct ath6kl *ar)
2225 {
2226         struct ath6kl_vif *vif;
2227         int ret;
2228
2229         vif = ath6kl_vif_first(ar);
2230         if (!vif)
2231                 return -EIO;
2232
2233         if (!test_bit(WMI_READY, &ar->flag)) {
2234                 ath6kl_err("deepsleep failed as wmi is not ready\n");
2235                 return -EIO;
2236         }
2237
2238         ath6kl_cfg80211_stop_all(ar);
2239
2240         /* Save the current power mode before enabling power save */
2241         ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
2242
2243         ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER);
2244         if (ret)
2245                 return ret;
2246
2247         /* Disable WOW mode */
2248         ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, vif->fw_vif_idx,
2249                                           ATH6KL_WOW_MODE_DISABLE,
2250                                           0, 0);
2251         if (ret)
2252                 return ret;
2253
2254         /* Flush all non control pkts in TX path */
2255         ath6kl_tx_data_cleanup(ar);
2256
2257         ret = ath6kl_cfg80211_host_sleep(ar, vif);
2258         if (ret)
2259                 return ret;
2260
2261         return 0;
2262 }
2263
2264 static int ath6kl_cfg80211_deepsleep_resume(struct ath6kl *ar)
2265 {
2266         struct ath6kl_vif *vif;
2267         int ret;
2268
2269         vif = ath6kl_vif_first(ar);
2270
2271         if (!vif)
2272                 return -EIO;
2273
2274         if (ar->wmi->pwr_mode != ar->wmi->saved_pwr_mode) {
2275                 ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0,
2276                                                ar->wmi->saved_pwr_mode);
2277                 if (ret)
2278                         return ret;
2279         }
2280
2281         ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2282                                                  ATH6KL_HOST_MODE_AWAKE);
2283         if (ret)
2284                 return ret;
2285
2286         ar->state = ATH6KL_STATE_ON;
2287
2288         /* Reset scan parameter to default values */
2289         ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2290                                         0, 0, 0, 0, 0, 0, 3, 0, 0, 0);
2291         if (ret)
2292                 return ret;
2293
2294         return 0;
2295 }
2296
2297 int ath6kl_cfg80211_suspend(struct ath6kl *ar,
2298                             enum ath6kl_cfg_suspend_mode mode,
2299                             struct cfg80211_wowlan *wow)
2300 {
2301         struct ath6kl_vif *vif;
2302         enum ath6kl_state prev_state;
2303         int ret;
2304
2305         switch (mode) {
2306         case ATH6KL_CFG_SUSPEND_WOW:
2307
2308                 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode suspend\n");
2309
2310                 /* Flush all non control pkts in TX path */
2311                 ath6kl_tx_data_cleanup(ar);
2312
2313                 prev_state = ar->state;
2314
2315                 ret = ath6kl_wow_suspend(ar, wow);
2316                 if (ret) {
2317                         ar->state = prev_state;
2318                         return ret;
2319                 }
2320
2321                 ar->state = ATH6KL_STATE_WOW;
2322                 break;
2323
2324         case ATH6KL_CFG_SUSPEND_DEEPSLEEP:
2325
2326                 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "deep sleep suspend\n");
2327
2328                 ret = ath6kl_cfg80211_deepsleep_suspend(ar);
2329                 if (ret) {
2330                         ath6kl_err("deepsleep suspend failed: %d\n", ret);
2331                         return ret;
2332                 }
2333
2334                 ar->state = ATH6KL_STATE_DEEPSLEEP;
2335
2336                 break;
2337
2338         case ATH6KL_CFG_SUSPEND_CUTPOWER:
2339
2340                 ath6kl_cfg80211_stop_all(ar);
2341
2342                 if (ar->state == ATH6KL_STATE_OFF) {
2343                         ath6kl_dbg(ATH6KL_DBG_SUSPEND,
2344                                    "suspend hw off, no action for cutpower\n");
2345                         break;
2346                 }
2347
2348                 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "suspend cutting power\n");
2349
2350                 ret = ath6kl_init_hw_stop(ar);
2351                 if (ret) {
2352                         ath6kl_warn("failed to stop hw during suspend: %d\n",
2353                                     ret);
2354                 }
2355
2356                 ar->state = ATH6KL_STATE_CUTPOWER;
2357
2358                 break;
2359
2360         case ATH6KL_CFG_SUSPEND_SCHED_SCAN:
2361                 /*
2362                  * Nothing needed for schedule scan, firmware is already in
2363                  * wow mode and sleeping most of the time.
2364                  */
2365                 break;
2366
2367         default:
2368                 break;
2369         }
2370
2371         list_for_each_entry(vif, &ar->vif_list, list)
2372                 ath6kl_cfg80211_scan_complete_event(vif, true);
2373
2374         return 0;
2375 }
2376 EXPORT_SYMBOL(ath6kl_cfg80211_suspend);
2377
2378 int ath6kl_cfg80211_resume(struct ath6kl *ar)
2379 {
2380         int ret;
2381
2382         switch (ar->state) {
2383         case  ATH6KL_STATE_WOW:
2384                 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode resume\n");
2385
2386                 ret = ath6kl_wow_resume(ar);
2387                 if (ret) {
2388                         ath6kl_warn("wow mode resume failed: %d\n", ret);
2389                         return ret;
2390                 }
2391
2392                 break;
2393
2394         case ATH6KL_STATE_DEEPSLEEP:
2395                 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "deep sleep resume\n");
2396
2397                 ret = ath6kl_cfg80211_deepsleep_resume(ar);
2398                 if (ret) {
2399                         ath6kl_warn("deep sleep resume failed: %d\n", ret);
2400                         return ret;
2401                 }
2402                 break;
2403
2404         case ATH6KL_STATE_CUTPOWER:
2405                 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "resume restoring power\n");
2406
2407                 ret = ath6kl_init_hw_start(ar);
2408                 if (ret) {
2409                         ath6kl_warn("Failed to boot hw in resume: %d\n", ret);
2410                         return ret;
2411                 }
2412                 break;
2413
2414         case ATH6KL_STATE_SCHED_SCAN:
2415                 break;
2416
2417         default:
2418                 break;
2419         }
2420
2421         return 0;
2422 }
2423 EXPORT_SYMBOL(ath6kl_cfg80211_resume);
2424
2425 #ifdef CONFIG_PM
2426
2427 /* hif layer decides what suspend mode to use */
2428 static int __ath6kl_cfg80211_suspend(struct wiphy *wiphy,
2429                                  struct cfg80211_wowlan *wow)
2430 {
2431         struct ath6kl *ar = wiphy_priv(wiphy);
2432
2433         return ath6kl_hif_suspend(ar, wow);
2434 }
2435
2436 static int __ath6kl_cfg80211_resume(struct wiphy *wiphy)
2437 {
2438         struct ath6kl *ar = wiphy_priv(wiphy);
2439
2440         return ath6kl_hif_resume(ar);
2441 }
2442
2443 /*
2444  * FIXME: WOW suspend mode is selected if the host sdio controller supports
2445  * both sdio irq wake up and keep power. The target pulls sdio data line to
2446  * wake up the host when WOW pattern matches. This causes sdio irq handler
2447  * is being called in the host side which internally hits ath6kl's RX path.
2448  *
2449  * Since sdio interrupt is not disabled, RX path executes even before
2450  * the host executes the actual resume operation from PM module.
2451  *
2452  * In the current scenario, WOW resume should happen before start processing
2453  * any data from the target. So It's required to perform WOW resume in RX path.
2454  * Ideally we should perform WOW resume only in the actual platform
2455  * resume path. This area needs bit rework to avoid WOW resume in RX path.
2456  *
2457  * ath6kl_check_wow_status() is called from ath6kl_rx().
2458  */
2459 void ath6kl_check_wow_status(struct ath6kl *ar)
2460 {
2461         if (ar->state == ATH6KL_STATE_SUSPENDING)
2462                 return;
2463
2464         if (ar->state == ATH6KL_STATE_WOW)
2465                 ath6kl_cfg80211_resume(ar);
2466 }
2467
2468 #else
2469
2470 void ath6kl_check_wow_status(struct ath6kl *ar)
2471 {
2472 }
2473 #endif
2474
2475 static int ath6kl_set_htcap(struct ath6kl_vif *vif, enum ieee80211_band band,
2476                             bool ht_enable)
2477 {
2478         struct ath6kl_htcap *htcap = &vif->htcap;
2479
2480         if (htcap->ht_enable == ht_enable)
2481                 return 0;
2482
2483         if (ht_enable) {
2484                 /* Set default ht capabilities */
2485                 htcap->ht_enable = true;
2486                 htcap->cap_info = (band == IEEE80211_BAND_2GHZ) ?
2487                                    ath6kl_g_htcap : ath6kl_a_htcap;
2488                 htcap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K;
2489         } else /* Disable ht */
2490                 memset(htcap, 0, sizeof(*htcap));
2491
2492         return ath6kl_wmi_set_htcap_cmd(vif->ar->wmi, vif->fw_vif_idx,
2493                                         band, htcap);
2494 }
2495
2496 static int ath6kl_restore_htcap(struct ath6kl_vif *vif)
2497 {
2498         struct wiphy *wiphy = vif->ar->wiphy;
2499         int band, ret = 0;
2500
2501         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2502                 if (!wiphy->bands[band])
2503                         continue;
2504
2505                 ret = ath6kl_set_htcap(vif, band,
2506                                 wiphy->bands[band]->ht_cap.ht_supported);
2507                 if (ret)
2508                         return ret;
2509         }
2510
2511         return ret;
2512 }
2513
2514 static bool ath6kl_is_p2p_ie(const u8 *pos)
2515 {
2516         return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
2517                 pos[2] == 0x50 && pos[3] == 0x6f &&
2518                 pos[4] == 0x9a && pos[5] == 0x09;
2519 }
2520
2521 static int ath6kl_set_ap_probe_resp_ies(struct ath6kl_vif *vif,
2522                                         const u8 *ies, size_t ies_len)
2523 {
2524         struct ath6kl *ar = vif->ar;
2525         const u8 *pos;
2526         u8 *buf = NULL;
2527         size_t len = 0;
2528         int ret;
2529
2530         /*
2531          * Filter out P2P IE(s) since they will be included depending on
2532          * the Probe Request frame in ath6kl_send_go_probe_resp().
2533          */
2534
2535         if (ies && ies_len) {
2536                 buf = kmalloc(ies_len, GFP_KERNEL);
2537                 if (buf == NULL)
2538                         return -ENOMEM;
2539                 pos = ies;
2540                 while (pos + 1 < ies + ies_len) {
2541                         if (pos + 2 + pos[1] > ies + ies_len)
2542                                 break;
2543                         if (!ath6kl_is_p2p_ie(pos)) {
2544                                 memcpy(buf + len, pos, 2 + pos[1]);
2545                                 len += 2 + pos[1];
2546                         }
2547                         pos += 2 + pos[1];
2548                 }
2549         }
2550
2551         ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2552                                        WMI_FRAME_PROBE_RESP, buf, len);
2553         kfree(buf);
2554         return ret;
2555 }
2556
2557 static int ath6kl_set_ies(struct ath6kl_vif *vif,
2558                           struct cfg80211_beacon_data *info)
2559 {
2560         struct ath6kl *ar = vif->ar;
2561         int res;
2562
2563         /* this also clears IE in fw if it's not set */
2564         res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2565                                        WMI_FRAME_BEACON,
2566                                        info->beacon_ies,
2567                                        info->beacon_ies_len);
2568         if (res)
2569                 return res;
2570
2571         /* this also clears IE in fw if it's not set */
2572         res = ath6kl_set_ap_probe_resp_ies(vif, info->proberesp_ies,
2573                                            info->proberesp_ies_len);
2574         if (res)
2575                 return res;
2576
2577         /* this also clears IE in fw if it's not set */
2578         res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2579                                        WMI_FRAME_ASSOC_RESP,
2580                                        info->assocresp_ies,
2581                                        info->assocresp_ies_len);
2582         if (res)
2583                 return res;
2584
2585         return 0;
2586 }
2587
2588 static int ath6kl_set_channel(struct wiphy *wiphy, struct net_device *dev,
2589                               struct ieee80211_channel *chan,
2590                               enum nl80211_channel_type channel_type)
2591 {
2592         struct ath6kl_vif *vif;
2593
2594         /*
2595          * 'dev' could be NULL if a channel change is required for the hardware
2596          * device itself, instead of a particular VIF.
2597          *
2598          * FIXME: To be handled properly when monitor mode is supported.
2599          */
2600         if (!dev)
2601                 return -EBUSY;
2602
2603         vif = netdev_priv(dev);
2604
2605         if (!ath6kl_cfg80211_ready(vif))
2606                 return -EIO;
2607
2608         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: center_freq=%u hw_value=%u\n",
2609                    __func__, chan->center_freq, chan->hw_value);
2610         vif->next_chan = chan->center_freq;
2611         vif->next_ch_type = channel_type;
2612         vif->next_ch_band = chan->band;
2613
2614         return 0;
2615 }
2616
2617 static int ath6kl_get_rsn_capab(struct cfg80211_beacon_data *beacon,
2618                                 u8 *rsn_capab)
2619 {
2620         const u8 *rsn_ie;
2621         size_t rsn_ie_len;
2622         u16 cnt;
2623
2624         if (!beacon->tail)
2625                 return -EINVAL;
2626
2627         rsn_ie = cfg80211_find_ie(WLAN_EID_RSN, beacon->tail, beacon->tail_len);
2628         if (!rsn_ie)
2629                 return -EINVAL;
2630
2631         rsn_ie_len = *(rsn_ie + 1);
2632         /* skip element id and length */
2633         rsn_ie += 2;
2634
2635         /* skip version */
2636         if (rsn_ie_len < 2)
2637                 return -EINVAL;
2638         rsn_ie +=  2;
2639         rsn_ie_len -= 2;
2640
2641         /* skip group cipher suite */
2642         if (rsn_ie_len < 4)
2643                 return 0;
2644         rsn_ie +=  4;
2645         rsn_ie_len -= 4;
2646
2647         /* skip pairwise cipher suite */
2648         if (rsn_ie_len < 2)
2649                 return 0;
2650         cnt = get_unaligned_le16(rsn_ie);
2651         rsn_ie += (2 + cnt * 4);
2652         rsn_ie_len -= (2 + cnt * 4);
2653
2654         /* skip akm suite */
2655         if (rsn_ie_len < 2)
2656                 return 0;
2657         cnt = get_unaligned_le16(rsn_ie);
2658         rsn_ie += (2 + cnt * 4);
2659         rsn_ie_len -= (2 + cnt * 4);
2660
2661         if (rsn_ie_len < 2)
2662                 return 0;
2663
2664         memcpy(rsn_capab, rsn_ie, 2);
2665
2666         return 0;
2667 }
2668
2669 static int ath6kl_start_ap(struct wiphy *wiphy, struct net_device *dev,
2670                            struct cfg80211_ap_settings *info)
2671 {
2672         struct ath6kl *ar = ath6kl_priv(dev);
2673         struct ath6kl_vif *vif = netdev_priv(dev);
2674         struct ieee80211_mgmt *mgmt;
2675         bool hidden = false;
2676         u8 *ies;
2677         int ies_len;
2678         struct wmi_connect_cmd p;
2679         int res;
2680         int i, ret;
2681         u16 rsn_capab = 0;
2682
2683         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s:\n", __func__);
2684
2685         if (!ath6kl_cfg80211_ready(vif))
2686                 return -EIO;
2687
2688         if (vif->next_mode != AP_NETWORK)
2689                 return -EOPNOTSUPP;
2690
2691         res = ath6kl_set_ies(vif, &info->beacon);
2692
2693         ar->ap_mode_bkey.valid = false;
2694
2695         /* TODO:
2696          * info->interval
2697          * info->dtim_period
2698          */
2699
2700         if (info->beacon.head == NULL)
2701                 return -EINVAL;
2702         mgmt = (struct ieee80211_mgmt *) info->beacon.head;
2703         ies = mgmt->u.beacon.variable;
2704         if (ies > info->beacon.head + info->beacon.head_len)
2705                 return -EINVAL;
2706         ies_len = info->beacon.head + info->beacon.head_len - ies;
2707
2708         if (info->ssid == NULL)
2709                 return -EINVAL;
2710         memcpy(vif->ssid, info->ssid, info->ssid_len);
2711         vif->ssid_len = info->ssid_len;
2712         if (info->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE)
2713                 hidden = true;
2714
2715         res = ath6kl_wmi_ap_hidden_ssid(ar->wmi, vif->fw_vif_idx, hidden);
2716         if (res)
2717                 return res;
2718
2719         ret = ath6kl_set_auth_type(vif, info->auth_type);
2720         if (ret)
2721                 return ret;
2722
2723         memset(&p, 0, sizeof(p));
2724
2725         for (i = 0; i < info->crypto.n_akm_suites; i++) {
2726                 switch (info->crypto.akm_suites[i]) {
2727                 case WLAN_AKM_SUITE_8021X:
2728                         if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2729                                 p.auth_mode |= WPA_AUTH;
2730                         if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2731                                 p.auth_mode |= WPA2_AUTH;
2732                         break;
2733                 case WLAN_AKM_SUITE_PSK:
2734                         if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2735                                 p.auth_mode |= WPA_PSK_AUTH;
2736                         if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2737                                 p.auth_mode |= WPA2_PSK_AUTH;
2738                         break;
2739                 }
2740         }
2741         if (p.auth_mode == 0)
2742                 p.auth_mode = NONE_AUTH;
2743         vif->auth_mode = p.auth_mode;
2744
2745         for (i = 0; i < info->crypto.n_ciphers_pairwise; i++) {
2746                 switch (info->crypto.ciphers_pairwise[i]) {
2747                 case WLAN_CIPHER_SUITE_WEP40:
2748                 case WLAN_CIPHER_SUITE_WEP104:
2749                         p.prwise_crypto_type |= WEP_CRYPT;
2750                         break;
2751                 case WLAN_CIPHER_SUITE_TKIP:
2752                         p.prwise_crypto_type |= TKIP_CRYPT;
2753                         break;
2754                 case WLAN_CIPHER_SUITE_CCMP:
2755                         p.prwise_crypto_type |= AES_CRYPT;
2756                         break;
2757                 case WLAN_CIPHER_SUITE_SMS4:
2758                         p.prwise_crypto_type |= WAPI_CRYPT;
2759                         break;
2760                 }
2761         }
2762         if (p.prwise_crypto_type == 0) {
2763                 p.prwise_crypto_type = NONE_CRYPT;
2764                 ath6kl_set_cipher(vif, 0, true);
2765         } else if (info->crypto.n_ciphers_pairwise == 1)
2766                 ath6kl_set_cipher(vif, info->crypto.ciphers_pairwise[0], true);
2767
2768         switch (info->crypto.cipher_group) {
2769         case WLAN_CIPHER_SUITE_WEP40:
2770         case WLAN_CIPHER_SUITE_WEP104:
2771                 p.grp_crypto_type = WEP_CRYPT;
2772                 break;
2773         case WLAN_CIPHER_SUITE_TKIP:
2774                 p.grp_crypto_type = TKIP_CRYPT;
2775                 break;
2776         case WLAN_CIPHER_SUITE_CCMP:
2777                 p.grp_crypto_type = AES_CRYPT;
2778                 break;
2779         case WLAN_CIPHER_SUITE_SMS4:
2780                 p.grp_crypto_type = WAPI_CRYPT;
2781                 break;
2782         default:
2783                 p.grp_crypto_type = NONE_CRYPT;
2784                 break;
2785         }
2786         ath6kl_set_cipher(vif, info->crypto.cipher_group, false);
2787
2788         p.nw_type = AP_NETWORK;
2789         vif->nw_type = vif->next_mode;
2790
2791         p.ssid_len = vif->ssid_len;
2792         memcpy(p.ssid, vif->ssid, vif->ssid_len);
2793         p.dot11_auth_mode = vif->dot11_auth_mode;
2794         p.ch = cpu_to_le16(vif->next_chan);
2795
2796         /* Enable uAPSD support by default */
2797         res = ath6kl_wmi_ap_set_apsd(ar->wmi, vif->fw_vif_idx, true);
2798         if (res < 0)
2799                 return res;
2800
2801         if (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) {
2802                 p.nw_subtype = SUBTYPE_P2PGO;
2803         } else {
2804                 /*
2805                  * Due to firmware limitation, it is not possible to
2806                  * do P2P mgmt operations in AP mode
2807                  */
2808                 p.nw_subtype = SUBTYPE_NONE;
2809         }
2810
2811         if (info->inactivity_timeout) {
2812                 res = ath6kl_wmi_set_inact_period(ar->wmi, vif->fw_vif_idx,
2813                                                   info->inactivity_timeout);
2814                 if (res < 0)
2815                         return res;
2816         }
2817
2818         if (ath6kl_set_htcap(vif, vif->next_ch_band,
2819                              vif->next_ch_type != NL80211_CHAN_NO_HT))
2820                 return -EIO;
2821
2822         /*
2823          * Get the PTKSA replay counter in the RSN IE. Supplicant
2824          * will use the RSN IE in M3 message and firmware has to
2825          * advertise the same in beacon/probe response. Send
2826          * the complete RSN IE capability field to firmware
2827          */
2828         if (!ath6kl_get_rsn_capab(&info->beacon, (u8 *) &rsn_capab) &&
2829             test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
2830                      ar->fw_capabilities)) {
2831                 res = ath6kl_wmi_set_ie_cmd(ar->wmi, vif->fw_vif_idx,
2832                                             WLAN_EID_RSN, WMI_RSN_IE_CAPB,
2833                                             (const u8 *) &rsn_capab,
2834                                             sizeof(rsn_capab));
2835                 if (res < 0)
2836                         return res;
2837         }
2838
2839         memcpy(&vif->profile, &p, sizeof(p));
2840         res = ath6kl_wmi_ap_profile_commit(ar->wmi, vif->fw_vif_idx, &p);
2841         if (res < 0)
2842                 return res;
2843
2844         return 0;
2845 }
2846
2847 static int ath6kl_change_beacon(struct wiphy *wiphy, struct net_device *dev,
2848                                 struct cfg80211_beacon_data *beacon)
2849 {
2850         struct ath6kl_vif *vif = netdev_priv(dev);
2851
2852         if (!ath6kl_cfg80211_ready(vif))
2853                 return -EIO;
2854
2855         if (vif->next_mode != AP_NETWORK)
2856                 return -EOPNOTSUPP;
2857
2858         return ath6kl_set_ies(vif, beacon);
2859 }
2860
2861 static int ath6kl_stop_ap(struct wiphy *wiphy, struct net_device *dev)
2862 {
2863         struct ath6kl *ar = ath6kl_priv(dev);
2864         struct ath6kl_vif *vif = netdev_priv(dev);
2865
2866         if (vif->nw_type != AP_NETWORK)
2867                 return -EOPNOTSUPP;
2868         if (!test_bit(CONNECTED, &vif->flags))
2869                 return -ENOTCONN;
2870
2871         ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
2872         clear_bit(CONNECTED, &vif->flags);
2873
2874         /* Restore ht setting in firmware */
2875         return ath6kl_restore_htcap(vif);
2876 }
2877
2878 static const u8 bcast_addr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2879
2880 static int ath6kl_del_station(struct wiphy *wiphy, struct net_device *dev,
2881                               u8 *mac)
2882 {
2883         struct ath6kl *ar = ath6kl_priv(dev);
2884         struct ath6kl_vif *vif = netdev_priv(dev);
2885         const u8 *addr = mac ? mac : bcast_addr;
2886
2887         return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx, WMI_AP_DEAUTH,
2888                                       addr, WLAN_REASON_PREV_AUTH_NOT_VALID);
2889 }
2890
2891 static int ath6kl_change_station(struct wiphy *wiphy, struct net_device *dev,
2892                                  u8 *mac, struct station_parameters *params)
2893 {
2894         struct ath6kl *ar = ath6kl_priv(dev);
2895         struct ath6kl_vif *vif = netdev_priv(dev);
2896
2897         if (vif->nw_type != AP_NETWORK)
2898                 return -EOPNOTSUPP;
2899
2900         /* Use this only for authorizing/unauthorizing a station */
2901         if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
2902                 return -EOPNOTSUPP;
2903
2904         if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
2905                 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
2906                                               WMI_AP_MLME_AUTHORIZE, mac, 0);
2907         return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
2908                                       WMI_AP_MLME_UNAUTHORIZE, mac, 0);
2909 }
2910
2911 static int ath6kl_remain_on_channel(struct wiphy *wiphy,
2912                                     struct net_device *dev,
2913                                     struct ieee80211_channel *chan,
2914                                     enum nl80211_channel_type channel_type,
2915                                     unsigned int duration,
2916                                     u64 *cookie)
2917 {
2918         struct ath6kl *ar = ath6kl_priv(dev);
2919         struct ath6kl_vif *vif = netdev_priv(dev);
2920         u32 id;
2921
2922         /* TODO: if already pending or ongoing remain-on-channel,
2923          * return -EBUSY */
2924         id = ++vif->last_roc_id;
2925         if (id == 0) {
2926                 /* Do not use 0 as the cookie value */
2927                 id = ++vif->last_roc_id;
2928         }
2929         *cookie = id;
2930
2931         return ath6kl_wmi_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx,
2932                                              chan->center_freq, duration);
2933 }
2934
2935 static int ath6kl_cancel_remain_on_channel(struct wiphy *wiphy,
2936                                            struct net_device *dev,
2937                                            u64 cookie)
2938 {
2939         struct ath6kl *ar = ath6kl_priv(dev);
2940         struct ath6kl_vif *vif = netdev_priv(dev);
2941
2942         if (cookie != vif->last_roc_id)
2943                 return -ENOENT;
2944         vif->last_cancel_roc_id = cookie;
2945
2946         return ath6kl_wmi_cancel_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx);
2947 }
2948
2949 static int ath6kl_send_go_probe_resp(struct ath6kl_vif *vif,
2950                                      const u8 *buf, size_t len,
2951                                      unsigned int freq)
2952 {
2953         struct ath6kl *ar = vif->ar;
2954         const u8 *pos;
2955         u8 *p2p;
2956         int p2p_len;
2957         int ret;
2958         const struct ieee80211_mgmt *mgmt;
2959
2960         mgmt = (const struct ieee80211_mgmt *) buf;
2961
2962         /* Include P2P IE(s) from the frame generated in user space. */
2963
2964         p2p = kmalloc(len, GFP_KERNEL);
2965         if (p2p == NULL)
2966                 return -ENOMEM;
2967         p2p_len = 0;
2968
2969         pos = mgmt->u.probe_resp.variable;
2970         while (pos + 1 < buf + len) {
2971                 if (pos + 2 + pos[1] > buf + len)
2972                         break;
2973                 if (ath6kl_is_p2p_ie(pos)) {
2974                         memcpy(p2p + p2p_len, pos, 2 + pos[1]);
2975                         p2p_len += 2 + pos[1];
2976                 }
2977                 pos += 2 + pos[1];
2978         }
2979
2980         ret = ath6kl_wmi_send_probe_response_cmd(ar->wmi, vif->fw_vif_idx, freq,
2981                                                  mgmt->da, p2p, p2p_len);
2982         kfree(p2p);
2983         return ret;
2984 }
2985
2986 static bool ath6kl_mgmt_powersave_ap(struct ath6kl_vif *vif,
2987                                      u32 id,
2988                                      u32 freq,
2989                                      u32 wait,
2990                                      const u8 *buf,
2991                                      size_t len,
2992                                      bool *more_data,
2993                                      bool no_cck)
2994 {
2995         struct ieee80211_mgmt *mgmt;
2996         struct ath6kl_sta *conn;
2997         bool is_psq_empty = false;
2998         struct ath6kl_mgmt_buff *mgmt_buf;
2999         size_t mgmt_buf_size;
3000         struct ath6kl *ar = vif->ar;
3001
3002         mgmt = (struct ieee80211_mgmt *) buf;
3003         if (is_multicast_ether_addr(mgmt->da))
3004                 return false;
3005
3006         conn = ath6kl_find_sta(vif, mgmt->da);
3007         if (!conn)
3008                 return false;
3009
3010         if (conn->sta_flags & STA_PS_SLEEP) {
3011                 if (!(conn->sta_flags & STA_PS_POLLED)) {
3012                         /* Queue the frames if the STA is sleeping */
3013                         mgmt_buf_size = len + sizeof(struct ath6kl_mgmt_buff);
3014                         mgmt_buf = kmalloc(mgmt_buf_size, GFP_KERNEL);
3015                         if (!mgmt_buf)
3016                                 return false;
3017
3018                         INIT_LIST_HEAD(&mgmt_buf->list);
3019                         mgmt_buf->id = id;
3020                         mgmt_buf->freq = freq;
3021                         mgmt_buf->wait = wait;
3022                         mgmt_buf->len = len;
3023                         mgmt_buf->no_cck = no_cck;
3024                         memcpy(mgmt_buf->buf, buf, len);
3025                         spin_lock_bh(&conn->psq_lock);
3026                         is_psq_empty = skb_queue_empty(&conn->psq) &&
3027                                         (conn->mgmt_psq_len == 0);
3028                         list_add_tail(&mgmt_buf->list, &conn->mgmt_psq);
3029                         conn->mgmt_psq_len++;
3030                         spin_unlock_bh(&conn->psq_lock);
3031
3032                         /*
3033                          * If this is the first pkt getting queued
3034                          * for this STA, update the PVB for this
3035                          * STA.
3036                          */
3037                         if (is_psq_empty)
3038                                 ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx,
3039                                                        conn->aid, 1);
3040                         return true;
3041                 }
3042
3043                 /*
3044                  * This tx is because of a PsPoll.
3045                  * Determine if MoreData bit has to be set.
3046                  */
3047                 spin_lock_bh(&conn->psq_lock);
3048                 if (!skb_queue_empty(&conn->psq) || (conn->mgmt_psq_len != 0))
3049                         *more_data = true;
3050                 spin_unlock_bh(&conn->psq_lock);
3051         }
3052
3053         return false;
3054 }
3055
3056 /* Check if SSID length is greater than DIRECT- */
3057 static bool ath6kl_is_p2p_go_ssid(const u8 *buf, size_t len)
3058 {
3059         const struct ieee80211_mgmt *mgmt;
3060         mgmt = (const struct ieee80211_mgmt *) buf;
3061
3062         /* variable[1] contains the SSID tag length */
3063         if (buf + len >= &mgmt->u.probe_resp.variable[1] &&
3064             (mgmt->u.probe_resp.variable[1] > P2P_WILDCARD_SSID_LEN)) {
3065                 return true;
3066         }
3067
3068         return false;
3069 }
3070
3071 static int ath6kl_mgmt_tx(struct wiphy *wiphy, struct net_device *dev,
3072                           struct ieee80211_channel *chan, bool offchan,
3073                           enum nl80211_channel_type channel_type,
3074                           bool channel_type_valid, unsigned int wait,
3075                           const u8 *buf, size_t len, bool no_cck,
3076                           bool dont_wait_for_ack, u64 *cookie)
3077 {
3078         struct ath6kl *ar = ath6kl_priv(dev);
3079         struct ath6kl_vif *vif = netdev_priv(dev);
3080         u32 id;
3081         const struct ieee80211_mgmt *mgmt;
3082         bool more_data, queued;
3083
3084         mgmt = (const struct ieee80211_mgmt *) buf;
3085         if (vif->nw_type == AP_NETWORK && test_bit(CONNECTED, &vif->flags) &&
3086             ieee80211_is_probe_resp(mgmt->frame_control) &&
3087             ath6kl_is_p2p_go_ssid(buf, len)) {
3088                 /*
3089                  * Send Probe Response frame in GO mode using a separate WMI
3090                  * command to allow the target to fill in the generic IEs.
3091                  */
3092                 *cookie = 0; /* TX status not supported */
3093                 return ath6kl_send_go_probe_resp(vif, buf, len,
3094                                                  chan->center_freq);
3095         }
3096
3097         id = vif->send_action_id++;
3098         if (id == 0) {
3099                 /*
3100                  * 0 is a reserved value in the WMI command and shall not be
3101                  * used for the command.
3102                  */
3103                 id = vif->send_action_id++;
3104         }
3105
3106         *cookie = id;
3107
3108         /* AP mode Power saving processing */
3109         if (vif->nw_type == AP_NETWORK) {
3110                 queued = ath6kl_mgmt_powersave_ap(vif,
3111                                         id, chan->center_freq,
3112                                         wait, buf,
3113                                         len, &more_data, no_cck);
3114                 if (queued)
3115                         return 0;
3116         }
3117
3118         return ath6kl_wmi_send_mgmt_cmd(ar->wmi, vif->fw_vif_idx, id,
3119                                         chan->center_freq, wait,
3120                                         buf, len, no_cck);
3121 }
3122
3123 static void ath6kl_mgmt_frame_register(struct wiphy *wiphy,
3124                                        struct net_device *dev,
3125                                        u16 frame_type, bool reg)
3126 {
3127         struct ath6kl_vif *vif = netdev_priv(dev);
3128
3129         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: frame_type=0x%x reg=%d\n",
3130                    __func__, frame_type, reg);
3131         if (frame_type == IEEE80211_STYPE_PROBE_REQ) {
3132                 /*
3133                  * Note: This notification callback is not allowed to sleep, so
3134                  * we cannot send WMI_PROBE_REQ_REPORT_CMD here. Instead, we
3135                  * hardcode target to report Probe Request frames all the time.
3136                  */
3137                 vif->probe_req_report = reg;
3138         }
3139 }
3140
3141 static int ath6kl_cfg80211_sscan_start(struct wiphy *wiphy,
3142                         struct net_device *dev,
3143                         struct cfg80211_sched_scan_request *request)
3144 {
3145         struct ath6kl *ar = ath6kl_priv(dev);
3146         struct ath6kl_vif *vif = netdev_priv(dev);
3147         u16 interval;
3148         int ret;
3149
3150         if (ar->state != ATH6KL_STATE_ON)
3151                 return -EIO;
3152
3153         if (vif->sme_state != SME_DISCONNECTED)
3154                 return -EBUSY;
3155
3156         /* The FW currently can't support multi-vif WoW properly. */
3157         if (ar->num_vif > 1)
3158                 return -EIO;
3159
3160         ath6kl_cfg80211_scan_complete_event(vif, true);
3161
3162         ret = ath6kl_set_probed_ssids(ar, vif, request->ssids,
3163                                       request->n_ssids);
3164         if (ret < 0)
3165                 return ret;
3166
3167         /* fw uses seconds, also make sure that it's >0 */
3168         interval = max_t(u16, 1, request->interval / 1000);
3169
3170         ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
3171                                   interval, interval,
3172                                   vif->bg_scan_period, 0, 0, 0, 3, 0, 0, 0);
3173
3174         ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, vif->fw_vif_idx,
3175                                           ATH6KL_WOW_MODE_ENABLE,
3176                                           WOW_FILTER_SSID,
3177                                           WOW_HOST_REQ_DELAY);
3178         if (ret) {
3179                 ath6kl_warn("Failed to enable wow with ssid filter: %d\n", ret);
3180                 return ret;
3181         }
3182
3183         /* this also clears IE in fw if it's not set */
3184         ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
3185                                        WMI_FRAME_PROBE_REQ,
3186                                        request->ie, request->ie_len);
3187         if (ret) {
3188                 ath6kl_warn("Failed to set probe request IE for scheduled scan: %d",
3189                             ret);
3190                 return ret;
3191         }
3192
3193         ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
3194                                                  ATH6KL_HOST_MODE_ASLEEP);
3195         if (ret) {
3196                 ath6kl_warn("Failed to enable host sleep mode for sched scan: %d\n",
3197                             ret);
3198                 return ret;
3199         }
3200
3201         ar->state = ATH6KL_STATE_SCHED_SCAN;
3202
3203         return ret;
3204 }
3205
3206 static int ath6kl_cfg80211_sscan_stop(struct wiphy *wiphy,
3207                                       struct net_device *dev)
3208 {
3209         struct ath6kl_vif *vif = netdev_priv(dev);
3210         bool stopped;
3211
3212         stopped = __ath6kl_cfg80211_sscan_stop(vif);
3213
3214         if (!stopped)
3215                 return -EIO;
3216
3217         return 0;
3218 }
3219
3220 static const struct ieee80211_txrx_stypes
3221 ath6kl_mgmt_stypes[NUM_NL80211_IFTYPES] = {
3222         [NL80211_IFTYPE_STATION] = {
3223                 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3224                 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3225                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3226                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3227         },
3228         [NL80211_IFTYPE_AP] = {
3229                 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3230                 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3231                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3232                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3233         },
3234         [NL80211_IFTYPE_P2P_CLIENT] = {
3235                 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3236                 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3237                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3238                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3239         },
3240         [NL80211_IFTYPE_P2P_GO] = {
3241                 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3242                 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3243                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3244                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3245         },
3246 };
3247
3248 static struct cfg80211_ops ath6kl_cfg80211_ops = {
3249         .add_virtual_intf = ath6kl_cfg80211_add_iface,
3250         .del_virtual_intf = ath6kl_cfg80211_del_iface,
3251         .change_virtual_intf = ath6kl_cfg80211_change_iface,
3252         .scan = ath6kl_cfg80211_scan,
3253         .connect = ath6kl_cfg80211_connect,
3254         .disconnect = ath6kl_cfg80211_disconnect,
3255         .add_key = ath6kl_cfg80211_add_key,
3256         .get_key = ath6kl_cfg80211_get_key,
3257         .del_key = ath6kl_cfg80211_del_key,
3258         .set_default_key = ath6kl_cfg80211_set_default_key,
3259         .set_wiphy_params = ath6kl_cfg80211_set_wiphy_params,
3260         .set_tx_power = ath6kl_cfg80211_set_txpower,
3261         .get_tx_power = ath6kl_cfg80211_get_txpower,
3262         .set_power_mgmt = ath6kl_cfg80211_set_power_mgmt,
3263         .join_ibss = ath6kl_cfg80211_join_ibss,
3264         .leave_ibss = ath6kl_cfg80211_leave_ibss,
3265         .get_station = ath6kl_get_station,
3266         .set_pmksa = ath6kl_set_pmksa,
3267         .del_pmksa = ath6kl_del_pmksa,
3268         .flush_pmksa = ath6kl_flush_pmksa,
3269         CFG80211_TESTMODE_CMD(ath6kl_tm_cmd)
3270 #ifdef CONFIG_PM
3271         .suspend = __ath6kl_cfg80211_suspend,
3272         .resume = __ath6kl_cfg80211_resume,
3273 #endif
3274         .set_channel = ath6kl_set_channel,
3275         .start_ap = ath6kl_start_ap,
3276         .change_beacon = ath6kl_change_beacon,
3277         .stop_ap = ath6kl_stop_ap,
3278         .del_station = ath6kl_del_station,
3279         .change_station = ath6kl_change_station,
3280         .remain_on_channel = ath6kl_remain_on_channel,
3281         .cancel_remain_on_channel = ath6kl_cancel_remain_on_channel,
3282         .mgmt_tx = ath6kl_mgmt_tx,
3283         .mgmt_frame_register = ath6kl_mgmt_frame_register,
3284         .sched_scan_start = ath6kl_cfg80211_sscan_start,
3285         .sched_scan_stop = ath6kl_cfg80211_sscan_stop,
3286 };
3287
3288 void ath6kl_cfg80211_stop(struct ath6kl_vif *vif)
3289 {
3290         ath6kl_cfg80211_sscan_disable(vif);
3291
3292         switch (vif->sme_state) {
3293         case SME_DISCONNECTED:
3294                 break;
3295         case SME_CONNECTING:
3296                 cfg80211_connect_result(vif->ndev, vif->bssid, NULL, 0,
3297                                         NULL, 0,
3298                                         WLAN_STATUS_UNSPECIFIED_FAILURE,
3299                                         GFP_KERNEL);
3300                 break;
3301         case SME_CONNECTED:
3302                 cfg80211_disconnected(vif->ndev, 0, NULL, 0, GFP_KERNEL);
3303                 break;
3304         }
3305
3306         if (test_bit(CONNECTED, &vif->flags) ||
3307             test_bit(CONNECT_PEND, &vif->flags))
3308                 ath6kl_wmi_disconnect_cmd(vif->ar->wmi, vif->fw_vif_idx);
3309
3310         vif->sme_state = SME_DISCONNECTED;
3311         clear_bit(CONNECTED, &vif->flags);
3312         clear_bit(CONNECT_PEND, &vif->flags);
3313
3314         /* disable scanning */
3315         if (ath6kl_wmi_scanparams_cmd(vif->ar->wmi, vif->fw_vif_idx, 0xFFFF,
3316                                       0, 0, 0, 0, 0, 0, 0, 0, 0) != 0)
3317                 ath6kl_warn("failed to disable scan during stop\n");
3318
3319         ath6kl_cfg80211_scan_complete_event(vif, true);
3320 }
3321
3322 void ath6kl_cfg80211_stop_all(struct ath6kl *ar)
3323 {
3324         struct ath6kl_vif *vif;
3325
3326         vif = ath6kl_vif_first(ar);
3327         if (!vif) {
3328                 /* save the current power mode before enabling power save */
3329                 ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
3330
3331                 if (ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER) != 0)
3332                         ath6kl_warn("ath6kl_deep_sleep_enable: wmi_powermode_cmd failed\n");
3333                 return;
3334         }
3335
3336         /*
3337          * FIXME: we should take ar->list_lock to protect changes in the
3338          * vif_list, but that's not trivial to do as ath6kl_cfg80211_stop()
3339          * sleeps.
3340          */
3341         list_for_each_entry(vif, &ar->vif_list, list)
3342                 ath6kl_cfg80211_stop(vif);
3343 }
3344
3345 static int ath6kl_cfg80211_vif_init(struct ath6kl_vif *vif)
3346 {
3347         vif->aggr_cntxt = aggr_init(vif);
3348         if (!vif->aggr_cntxt) {
3349                 ath6kl_err("failed to initialize aggr\n");
3350                 return -ENOMEM;
3351         }
3352
3353         setup_timer(&vif->disconnect_timer, disconnect_timer_handler,
3354                     (unsigned long) vif->ndev);
3355         setup_timer(&vif->sched_scan_timer, ath6kl_wmi_sscan_timer,
3356                     (unsigned long) vif);
3357
3358         set_bit(WMM_ENABLED, &vif->flags);
3359         spin_lock_init(&vif->if_lock);
3360
3361         INIT_LIST_HEAD(&vif->mc_filter);
3362
3363         return 0;
3364 }
3365
3366 void ath6kl_cfg80211_vif_cleanup(struct ath6kl_vif *vif)
3367 {
3368         struct ath6kl *ar = vif->ar;
3369         struct ath6kl_mc_filter *mc_filter, *tmp;
3370
3371         aggr_module_destroy(vif->aggr_cntxt);
3372
3373         ar->avail_idx_map |= BIT(vif->fw_vif_idx);
3374
3375         if (vif->nw_type == ADHOC_NETWORK)
3376                 ar->ibss_if_active = false;
3377
3378         list_for_each_entry_safe(mc_filter, tmp, &vif->mc_filter, list) {
3379                 list_del(&mc_filter->list);
3380                 kfree(mc_filter);
3381         }
3382
3383         unregister_netdevice(vif->ndev);
3384
3385         ar->num_vif--;
3386 }
3387
3388 struct net_device *ath6kl_interface_add(struct ath6kl *ar, char *name,
3389                                         enum nl80211_iftype type, u8 fw_vif_idx,
3390                                         u8 nw_type)
3391 {
3392         struct net_device *ndev;
3393         struct ath6kl_vif *vif;
3394
3395         ndev = alloc_netdev(sizeof(*vif), name, ether_setup);
3396         if (!ndev)
3397                 return NULL;
3398
3399         vif = netdev_priv(ndev);
3400         ndev->ieee80211_ptr = &vif->wdev;
3401         vif->wdev.wiphy = ar->wiphy;
3402         vif->ar = ar;
3403         vif->ndev = ndev;
3404         SET_NETDEV_DEV(ndev, wiphy_dev(vif->wdev.wiphy));
3405         vif->wdev.netdev = ndev;
3406         vif->wdev.iftype = type;
3407         vif->fw_vif_idx = fw_vif_idx;
3408         vif->nw_type = nw_type;
3409         vif->next_mode = nw_type;
3410         vif->listen_intvl_t = ATH6KL_DEFAULT_LISTEN_INTVAL;
3411         vif->bmiss_time_t = ATH6KL_DEFAULT_BMISS_TIME;
3412         vif->bg_scan_period = 0;
3413         vif->htcap.ht_enable = true;
3414
3415         memcpy(ndev->dev_addr, ar->mac_addr, ETH_ALEN);
3416         if (fw_vif_idx != 0)
3417                 ndev->dev_addr[0] = (ndev->dev_addr[0] ^ (1 << fw_vif_idx)) |
3418                                      0x2;
3419
3420         init_netdev(ndev);
3421
3422         ath6kl_init_control_info(vif);
3423
3424         if (ath6kl_cfg80211_vif_init(vif))
3425                 goto err;
3426
3427         if (register_netdevice(ndev))
3428                 goto err;
3429
3430         ar->avail_idx_map &= ~BIT(fw_vif_idx);
3431         vif->sme_state = SME_DISCONNECTED;
3432         set_bit(WLAN_ENABLED, &vif->flags);
3433         ar->wlan_pwr_state = WLAN_POWER_STATE_ON;
3434         set_bit(NETDEV_REGISTERED, &vif->flags);
3435
3436         if (type == NL80211_IFTYPE_ADHOC)
3437                 ar->ibss_if_active = true;
3438
3439         spin_lock_bh(&ar->list_lock);
3440         list_add_tail(&vif->list, &ar->vif_list);
3441         spin_unlock_bh(&ar->list_lock);
3442
3443         return ndev;
3444
3445 err:
3446         aggr_module_destroy(vif->aggr_cntxt);
3447         free_netdev(ndev);
3448         return NULL;
3449 }
3450
3451 int ath6kl_cfg80211_init(struct ath6kl *ar)
3452 {
3453         struct wiphy *wiphy = ar->wiphy;
3454         bool band_2gig = false, band_5gig = false, ht = false;
3455         int ret;
3456
3457         wiphy->mgmt_stypes = ath6kl_mgmt_stypes;
3458
3459         wiphy->max_remain_on_channel_duration = 5000;
3460
3461         /* set device pointer for wiphy */
3462         set_wiphy_dev(wiphy, ar->dev);
3463
3464         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3465                                  BIT(NL80211_IFTYPE_ADHOC) |
3466                                  BIT(NL80211_IFTYPE_AP);
3467         if (ar->p2p) {
3468                 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_GO) |
3469                                           BIT(NL80211_IFTYPE_P2P_CLIENT);
3470         }
3471
3472         /* max num of ssids that can be probed during scanning */
3473         wiphy->max_scan_ssids = MAX_PROBED_SSID_INDEX;
3474         wiphy->max_scan_ie_len = 1000; /* FIX: what is correct limit? */
3475         switch (ar->hw.cap) {
3476         case WMI_11AN_CAP:
3477                 ht = true;
3478         case WMI_11A_CAP:
3479                 band_5gig = true;
3480                 break;
3481         case WMI_11GN_CAP:
3482                 ht = true;
3483         case WMI_11G_CAP:
3484                 band_2gig = true;
3485                 break;
3486         case WMI_11AGN_CAP:
3487                 ht = true;
3488         case WMI_11AG_CAP:
3489                 band_2gig = true;
3490                 band_5gig = true;
3491                 break;
3492         default:
3493                 ath6kl_err("invalid phy capability!\n");
3494                 return -EINVAL;
3495         }
3496
3497         /*
3498          * Even if the fw has HT support, advertise HT cap only when
3499          * the firmware has support to override RSN capability, otherwise
3500          * 4-way handshake would fail.
3501          */
3502         if (!(ht &&
3503               test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
3504                        ar->fw_capabilities))) {
3505                 ath6kl_band_2ghz.ht_cap.cap = 0;
3506                 ath6kl_band_2ghz.ht_cap.ht_supported = false;
3507                 ath6kl_band_5ghz.ht_cap.cap = 0;
3508                 ath6kl_band_5ghz.ht_cap.ht_supported = false;
3509         }
3510         if (band_2gig)
3511                 wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz;
3512         if (band_5gig)
3513                 wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz;
3514
3515         wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
3516
3517         wiphy->cipher_suites = cipher_suites;
3518         wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3519
3520         wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
3521                               WIPHY_WOWLAN_DISCONNECT |
3522                               WIPHY_WOWLAN_GTK_REKEY_FAILURE  |
3523                               WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
3524                               WIPHY_WOWLAN_EAP_IDENTITY_REQ   |
3525                               WIPHY_WOWLAN_4WAY_HANDSHAKE;
3526         wiphy->wowlan.n_patterns = WOW_MAX_FILTERS_PER_LIST;
3527         wiphy->wowlan.pattern_min_len = 1;
3528         wiphy->wowlan.pattern_max_len = WOW_PATTERN_SIZE;
3529
3530         wiphy->max_sched_scan_ssids = MAX_PROBED_SSID_INDEX;
3531
3532         ar->wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM |
3533                             WIPHY_FLAG_HAVE_AP_SME |
3534                             WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
3535                             WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
3536
3537         if (test_bit(ATH6KL_FW_CAPABILITY_SCHED_SCAN, ar->fw_capabilities))
3538                 ar->wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
3539
3540         if (test_bit(ATH6KL_FW_CAPABILITY_INACTIVITY_TIMEOUT,
3541                      ar->fw_capabilities))
3542                 ar->wiphy->features = NL80211_FEATURE_INACTIVITY_TIMER;
3543
3544         ar->wiphy->probe_resp_offload =
3545                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
3546                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
3547                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
3548
3549         ret = wiphy_register(wiphy);
3550         if (ret < 0) {
3551                 ath6kl_err("couldn't register wiphy device\n");
3552                 return ret;
3553         }
3554
3555         ar->wiphy_registered = true;
3556
3557         return 0;
3558 }
3559
3560 void ath6kl_cfg80211_cleanup(struct ath6kl *ar)
3561 {
3562         wiphy_unregister(ar->wiphy);
3563
3564         ar->wiphy_registered = false;
3565 }
3566
3567 struct ath6kl *ath6kl_cfg80211_create(void)
3568 {
3569         struct ath6kl *ar;
3570         struct wiphy *wiphy;
3571
3572         /* create a new wiphy for use with cfg80211 */
3573         wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl));
3574
3575         if (!wiphy) {
3576                 ath6kl_err("couldn't allocate wiphy device\n");
3577                 return NULL;
3578         }
3579
3580         ar = wiphy_priv(wiphy);
3581         ar->wiphy = wiphy;
3582
3583         return ar;
3584 }
3585
3586 /* Note: ar variable must not be accessed after calling this! */
3587 void ath6kl_cfg80211_destroy(struct ath6kl *ar)
3588 {
3589         int i;
3590
3591         for (i = 0; i < AP_MAX_NUM_STA; i++)
3592                 kfree(ar->sta_list[i].aggr_conn);
3593
3594         wiphy_free(ar->wiphy);
3595 }
3596