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