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