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