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         ath6kl_wmi_enable_sched_scan_cmd(ar->wmi, vif->fw_vif_idx, false);
 155
 156         return true;
 157 }
 158
 159 static void ath6kl_cfg80211_sscan_disable(struct ath6kl_vif *vif)
 160 {
 161         struct ath6kl *ar = vif->ar;
 162         bool stopped;
 163
 164         stopped = __ath6kl_cfg80211_sscan_stop(vif);
 165
 166         if (!stopped)
 167                 return;
 168
 169         cfg80211_sched_scan_stopped(ar->wiphy);
 170 }
 171
 172 static int ath6kl_set_wpa_version(struct ath6kl_vif *vif,
 173                                   enum nl80211_wpa_versions wpa_version)
 174 {
 175         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version);
 176
 177         if (!wpa_version) {
 178                 vif->auth_mode = NONE_AUTH;
 179         } else if (wpa_version & NL80211_WPA_VERSION_2) {
 180                 vif->auth_mode = WPA2_AUTH;
 181         } else if (wpa_version & NL80211_WPA_VERSION_1) {
 182                 vif->auth_mode = WPA_AUTH;
 183         } else {
 184                 ath6kl_err("%s: %u not supported\n", __func__, wpa_version);
 185                 return -ENOTSUPP;
 186         }
 187
 188         return 0;
 189 }
 190
 191 static int ath6kl_set_auth_type(struct ath6kl_vif *vif,
 192                                 enum nl80211_auth_type auth_type)
 193 {
 194         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type);
 195
 196         switch (auth_type) {
 197         case NL80211_AUTHTYPE_OPEN_SYSTEM:
 198                 vif->dot11_auth_mode = OPEN_AUTH;
 199                 break;
 200         case NL80211_AUTHTYPE_SHARED_KEY:
 201                 vif->dot11_auth_mode = SHARED_AUTH;
 202                 break;
 203         case NL80211_AUTHTYPE_NETWORK_EAP:
 204                 vif->dot11_auth_mode = LEAP_AUTH;
 205                 break;
 206
 207         case NL80211_AUTHTYPE_AUTOMATIC:
 208                 vif->dot11_auth_mode = OPEN_AUTH | SHARED_AUTH;
 209                 break;
 210
 211         default:
 212                 ath6kl_err("%s: 0x%x not supported\n", __func__, auth_type);
 213                 return -ENOTSUPP;
 214         }
 215
 216         return 0;
 217 }
 218
 219 static int ath6kl_set_cipher(struct ath6kl_vif *vif, u32 cipher, bool ucast)
 220 {
 221         u8 *ar_cipher = ucast ? &vif->prwise_crypto : &vif->grp_crypto;
 222         u8 *ar_cipher_len = ucast ? &vif->prwise_crypto_len :
 223                 &vif->grp_crypto_len;
 224
 225         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n",
 226                    __func__, cipher, ucast);
 227
 228         switch (cipher) {
 229         case 0:
 230                 /* our own hack to use value 0 as no crypto used */
 231                 *ar_cipher = NONE_CRYPT;
 232                 *ar_cipher_len = 0;
 233                 break;
 234         case WLAN_CIPHER_SUITE_WEP40:
 235                 *ar_cipher = WEP_CRYPT;
 236                 *ar_cipher_len = 5;
 237                 break;
 238         case WLAN_CIPHER_SUITE_WEP104:
 239                 *ar_cipher = WEP_CRYPT;
 240                 *ar_cipher_len = 13;
 241                 break;
 242         case WLAN_CIPHER_SUITE_TKIP:
 243                 *ar_cipher = TKIP_CRYPT;
 244                 *ar_cipher_len = 0;
 245                 break;
 246         case WLAN_CIPHER_SUITE_CCMP:
 247                 *ar_cipher = AES_CRYPT;
 248                 *ar_cipher_len = 0;
 249                 break;
 250         case WLAN_CIPHER_SUITE_SMS4:
 251                 *ar_cipher = WAPI_CRYPT;
 252                 *ar_cipher_len = 0;
 253                 break;
 254         default:
 255                 ath6kl_err("cipher 0x%x not supported\n", cipher);
 256                 return -ENOTSUPP;
 257         }
 258
 259         return 0;
 260 }
 261
 262 static void ath6kl_set_key_mgmt(struct ath6kl_vif *vif, u32 key_mgmt)
 263 {
 264         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt);
 265
 266         if (key_mgmt == WLAN_AKM_SUITE_PSK) {
 267                 if (vif->auth_mode == WPA_AUTH)
 268                         vif->auth_mode = WPA_PSK_AUTH;
 269                 else if (vif->auth_mode == WPA2_AUTH)
 270                         vif->auth_mode = WPA2_PSK_AUTH;
 271         } else if (key_mgmt == 0x00409600) {
 272                 if (vif->auth_mode == WPA_AUTH)
 273                         vif->auth_mode = WPA_AUTH_CCKM;
 274                 else if (vif->auth_mode == WPA2_AUTH)
 275                         vif->auth_mode = WPA2_AUTH_CCKM;
 276         } else if (key_mgmt != WLAN_AKM_SUITE_8021X) {
 277                 vif->auth_mode = NONE_AUTH;
 278         }
 279 }
 280
 281 static bool ath6kl_cfg80211_ready(struct ath6kl_vif *vif)
 282 {
 283         struct ath6kl *ar = vif->ar;
 284
 285         if (!test_bit(WMI_READY, &ar->flag)) {
 286                 ath6kl_err("wmi is not ready\n");
 287                 return false;
 288         }
 289
 290         if (!test_bit(WLAN_ENABLED, &vif->flags)) {
 291                 ath6kl_err("wlan disabled\n");
 292                 return false;
 293         }
 294
 295         return true;
 296 }
 297
 298 static bool ath6kl_is_wpa_ie(const u8 *pos)
 299 {
 300         return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
 301                 pos[2] == 0x00 && pos[3] == 0x50 &&
 302                 pos[4] == 0xf2 && pos[5] == 0x01;
 303 }
 304
 305 static bool ath6kl_is_rsn_ie(const u8 *pos)
 306 {
 307         return pos[0] == WLAN_EID_RSN;
 308 }
 309
 310 static bool ath6kl_is_wps_ie(const u8 *pos)
 311 {
 312         return (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
 313                 pos[1] >= 4 &&
 314                 pos[2] == 0x00 && pos[3] == 0x50 && pos[4] == 0xf2 &&
 315                 pos[5] == 0x04);
 316 }
 317
 318 static int ath6kl_set_assoc_req_ies(struct ath6kl_vif *vif, const u8 *ies,
 319                                     size_t ies_len)
 320 {
 321         struct ath6kl *ar = vif->ar;
 322         const u8 *pos;
 323         u8 *buf = NULL;
 324         size_t len = 0;
 325         int ret;
 326
 327         /*
 328          * Clear previously set flag
 329          */
 330
 331         ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
 332
 333         /*
 334          * Filter out RSN/WPA IE(s)
 335          */
 336
 337         if (ies && ies_len) {
 338                 buf = kmalloc(ies_len, GFP_KERNEL);
 339                 if (buf == NULL)
 340                         return -ENOMEM;
 341                 pos = ies;
 342
 343                 while (pos + 1 < ies + ies_len) {
 344                         if (pos + 2 + pos[1] > ies + ies_len)
 345                                 break;
 346                         if (!(ath6kl_is_wpa_ie(pos) || ath6kl_is_rsn_ie(pos))) {
 347                                 memcpy(buf + len, pos, 2 + pos[1]);
 348                                 len += 2 + pos[1];
 349                         }
 350
 351                         if (ath6kl_is_wps_ie(pos))
 352                                 ar->connect_ctrl_flags |= CONNECT_WPS_FLAG;
 353
 354                         pos += 2 + pos[1];
 355                 }
 356         }
 357
 358         ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
 359                                        WMI_FRAME_ASSOC_REQ, buf, len);
 360         kfree(buf);
 361         return ret;
 362 }
 363
 364 static int ath6kl_nliftype_to_drv_iftype(enum nl80211_iftype type, u8 *nw_type)
 365 {
 366         switch (type) {
 367         case NL80211_IFTYPE_STATION:
 368                 *nw_type = INFRA_NETWORK;
 369                 break;
 370         case NL80211_IFTYPE_ADHOC:
 371                 *nw_type = ADHOC_NETWORK;
 372                 break;
 373         case NL80211_IFTYPE_AP:
 374                 *nw_type = AP_NETWORK;
 375                 break;
 376         case NL80211_IFTYPE_P2P_CLIENT:
 377                 *nw_type = INFRA_NETWORK;
 378                 break;
 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: max perf\n", __func__);
1456                 mode.pwr_mode = REC_POWER;
1457         } else {
1458                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\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         return ath6kl_hif_suspend(ar, wow);
2511 }
2512
2513 static int __ath6kl_cfg80211_resume(struct wiphy *wiphy)
2514 {
2515         struct ath6kl *ar = wiphy_priv(wiphy);
2516
2517         return ath6kl_hif_resume(ar);
2518 }
2519
2520 /*
2521  * FIXME: WOW suspend mode is selected if the host sdio controller supports
2522  * both sdio irq wake up and keep power. The target pulls sdio data line to
2523  * wake up the host when WOW pattern matches. This causes sdio irq handler
2524  * is being called in the host side which internally hits ath6kl's RX path.
2525  *
2526  * Since sdio interrupt is not disabled, RX path executes even before
2527  * the host executes the actual resume operation from PM module.
2528  *
2529  * In the current scenario, WOW resume should happen before start processing
2530  * any data from the target. So It's required to perform WOW resume in RX path.
2531  * Ideally we should perform WOW resume only in the actual platform
2532  * resume path. This area needs bit rework to avoid WOW resume in RX path.
2533  *
2534  * ath6kl_check_wow_status() is called from ath6kl_rx().
2535  */
2536 void ath6kl_check_wow_status(struct ath6kl *ar)
2537 {
2538         if (ar->state == ATH6KL_STATE_SUSPENDING)
2539                 return;
2540
2541         if (ar->state == ATH6KL_STATE_WOW)
2542                 ath6kl_cfg80211_resume(ar);
2543 }
2544
2545 #else
2546
2547 void ath6kl_check_wow_status(struct ath6kl *ar)
2548 {
2549 }
2550 #endif
2551
2552 static int ath6kl_set_htcap(struct ath6kl_vif *vif, enum ieee80211_band band,
2553                             bool ht_enable)
2554 {
2555         struct ath6kl_htcap *htcap = &vif->htcap[band];
2556
2557         if (htcap->ht_enable == ht_enable)
2558                 return 0;
2559
2560         if (ht_enable) {
2561                 /* Set default ht capabilities */
2562                 htcap->ht_enable = true;
2563                 htcap->cap_info = (band == IEEE80211_BAND_2GHZ) ?
2564                                    ath6kl_g_htcap : ath6kl_a_htcap;
2565                 htcap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K;
2566         } else /* Disable ht */
2567                 memset(htcap, 0, sizeof(*htcap));
2568
2569         return ath6kl_wmi_set_htcap_cmd(vif->ar->wmi, vif->fw_vif_idx,
2570                                         band, htcap);
2571 }
2572
2573 static int ath6kl_restore_htcap(struct ath6kl_vif *vif)
2574 {
2575         struct wiphy *wiphy = vif->ar->wiphy;
2576         int band, ret = 0;
2577
2578         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2579                 if (!wiphy->bands[band])
2580                         continue;
2581
2582                 ret = ath6kl_set_htcap(vif, band,
2583                                 wiphy->bands[band]->ht_cap.ht_supported);
2584                 if (ret)
2585                         return ret;
2586         }
2587
2588         return ret;
2589 }
2590
2591 static bool ath6kl_is_p2p_ie(const u8 *pos)
2592 {
2593         return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
2594                 pos[2] == 0x50 && pos[3] == 0x6f &&
2595                 pos[4] == 0x9a && pos[5] == 0x09;
2596 }
2597
2598 static int ath6kl_set_ap_probe_resp_ies(struct ath6kl_vif *vif,
2599                                         const u8 *ies, size_t ies_len)
2600 {
2601         struct ath6kl *ar = vif->ar;
2602         const u8 *pos;
2603         u8 *buf = NULL;
2604         size_t len = 0;
2605         int ret;
2606
2607         /*
2608          * Filter out P2P IE(s) since they will be included depending on
2609          * the Probe Request frame in ath6kl_send_go_probe_resp().
2610          */
2611
2612         if (ies && ies_len) {
2613                 buf = kmalloc(ies_len, GFP_KERNEL);
2614                 if (buf == NULL)
2615                         return -ENOMEM;
2616                 pos = ies;
2617                 while (pos + 1 < ies + ies_len) {
2618                         if (pos + 2 + pos[1] > ies + ies_len)
2619                                 break;
2620                         if (!ath6kl_is_p2p_ie(pos)) {
2621                                 memcpy(buf + len, pos, 2 + pos[1]);
2622                                 len += 2 + pos[1];
2623                         }
2624                         pos += 2 + pos[1];
2625                 }
2626         }
2627
2628         ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2629                                        WMI_FRAME_PROBE_RESP, buf, len);
2630         kfree(buf);
2631         return ret;
2632 }
2633
2634 static int ath6kl_set_ies(struct ath6kl_vif *vif,
2635                           struct cfg80211_beacon_data *info)
2636 {
2637         struct ath6kl *ar = vif->ar;
2638         int res;
2639
2640         /* this also clears IE in fw if it's not set */
2641         res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2642                                        WMI_FRAME_BEACON,
2643                                        info->beacon_ies,
2644                                        info->beacon_ies_len);
2645         if (res)
2646                 return res;
2647
2648         /* this also clears IE in fw if it's not set */
2649         res = ath6kl_set_ap_probe_resp_ies(vif, info->proberesp_ies,
2650                                            info->proberesp_ies_len);
2651         if (res)
2652                 return res;
2653
2654         /* this also clears IE in fw if it's not set */
2655         res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2656                                        WMI_FRAME_ASSOC_RESP,
2657                                        info->assocresp_ies,
2658                                        info->assocresp_ies_len);
2659         if (res)
2660                 return res;
2661
2662         return 0;
2663 }
2664
2665 void ath6kl_cfg80211_sta_bmiss_enhance(struct ath6kl_vif *vif, bool enable)
2666 {
2667         int err;
2668
2669         if (WARN_ON(!test_bit(WMI_READY, &vif->ar->flag)))
2670                 return;
2671
2672         if (vif->nw_type != INFRA_NETWORK)
2673                 return;
2674
2675         if (!test_bit(ATH6KL_FW_CAPABILITY_BMISS_ENHANCE,
2676                       vif->ar->fw_capabilities))
2677                 return;
2678
2679         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s fw bmiss enhance\n",
2680                    enable ? "enable" : "disable");
2681
2682         err = ath6kl_wmi_sta_bmiss_enhance_cmd(vif->ar->wmi,
2683                                                vif->fw_vif_idx, enable);
2684         if (err)
2685                 ath6kl_err("failed to %s enhanced bmiss detection: %d\n",
2686                            enable ? "enable" : "disable", err);
2687 }
2688
2689 static int ath6kl_get_rsn_capab(struct cfg80211_beacon_data *beacon,
2690                                 u8 *rsn_capab)
2691 {
2692         const u8 *rsn_ie;
2693         size_t rsn_ie_len;
2694         u16 cnt;
2695
2696         if (!beacon->tail)
2697                 return -EINVAL;
2698
2699         rsn_ie = cfg80211_find_ie(WLAN_EID_RSN, beacon->tail, beacon->tail_len);
2700         if (!rsn_ie)
2701                 return -EINVAL;
2702
2703         rsn_ie_len = *(rsn_ie + 1);
2704         /* skip element id and length */
2705         rsn_ie += 2;
2706
2707         /* skip version */
2708         if (rsn_ie_len < 2)
2709                 return -EINVAL;
2710         rsn_ie +=  2;
2711         rsn_ie_len -= 2;
2712
2713         /* skip group cipher suite */
2714         if (rsn_ie_len < 4)
2715                 return 0;
2716         rsn_ie +=  4;
2717         rsn_ie_len -= 4;
2718
2719         /* skip pairwise cipher suite */
2720         if (rsn_ie_len < 2)
2721                 return 0;
2722         cnt = get_unaligned_le16(rsn_ie);
2723         rsn_ie += (2 + cnt * 4);
2724         rsn_ie_len -= (2 + cnt * 4);
2725
2726         /* skip akm suite */
2727         if (rsn_ie_len < 2)
2728                 return 0;
2729         cnt = get_unaligned_le16(rsn_ie);
2730         rsn_ie += (2 + cnt * 4);
2731         rsn_ie_len -= (2 + cnt * 4);
2732
2733         if (rsn_ie_len < 2)
2734                 return 0;
2735
2736         memcpy(rsn_capab, rsn_ie, 2);
2737
2738         return 0;
2739 }
2740
2741 static int ath6kl_start_ap(struct wiphy *wiphy, struct net_device *dev,
2742                            struct cfg80211_ap_settings *info)
2743 {
2744         struct ath6kl *ar = ath6kl_priv(dev);
2745         struct ath6kl_vif *vif = netdev_priv(dev);
2746         struct ieee80211_mgmt *mgmt;
2747         bool hidden = false;
2748         u8 *ies;
2749         int ies_len;
2750         struct wmi_connect_cmd p;
2751         int res;
2752         int i, ret;
2753         u16 rsn_capab = 0;
2754
2755         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s:\n", __func__);
2756
2757         if (!ath6kl_cfg80211_ready(vif))
2758                 return -EIO;
2759
2760         if (vif->next_mode != AP_NETWORK)
2761                 return -EOPNOTSUPP;
2762
2763         res = ath6kl_set_ies(vif, &info->beacon);
2764
2765         ar->ap_mode_bkey.valid = false;
2766
2767         /* TODO:
2768          * info->interval
2769          */
2770
2771         ret = ath6kl_wmi_ap_set_dtim_cmd(ar->wmi, vif->fw_vif_idx,
2772                                          info->dtim_period);
2773
2774         /* ignore error, just print a warning and continue normally */
2775         if (ret)
2776                 ath6kl_warn("Failed to set dtim_period in beacon: %d\n", ret);
2777
2778         if (info->beacon.head == NULL)
2779                 return -EINVAL;
2780         mgmt = (struct ieee80211_mgmt *) info->beacon.head;
2781         ies = mgmt->u.beacon.variable;
2782         if (ies > info->beacon.head + info->beacon.head_len)
2783                 return -EINVAL;
2784         ies_len = info->beacon.head + info->beacon.head_len - ies;
2785
2786         if (info->ssid == NULL)
2787                 return -EINVAL;
2788         memcpy(vif->ssid, info->ssid, info->ssid_len);
2789         vif->ssid_len = info->ssid_len;
2790         if (info->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE)
2791                 hidden = true;
2792
2793         res = ath6kl_wmi_ap_hidden_ssid(ar->wmi, vif->fw_vif_idx, hidden);
2794         if (res)
2795                 return res;
2796
2797         ret = ath6kl_set_auth_type(vif, info->auth_type);
2798         if (ret)
2799                 return ret;
2800
2801         memset(&p, 0, sizeof(p));
2802
2803         for (i = 0; i < info->crypto.n_akm_suites; i++) {
2804                 switch (info->crypto.akm_suites[i]) {
2805                 case WLAN_AKM_SUITE_8021X:
2806                         if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2807                                 p.auth_mode |= WPA_AUTH;
2808                         if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2809                                 p.auth_mode |= WPA2_AUTH;
2810                         break;
2811                 case WLAN_AKM_SUITE_PSK:
2812                         if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2813                                 p.auth_mode |= WPA_PSK_AUTH;
2814                         if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2815                                 p.auth_mode |= WPA2_PSK_AUTH;
2816                         break;
2817                 }
2818         }
2819         if (p.auth_mode == 0)
2820                 p.auth_mode = NONE_AUTH;
2821         vif->auth_mode = p.auth_mode;
2822
2823         for (i = 0; i < info->crypto.n_ciphers_pairwise; i++) {
2824                 switch (info->crypto.ciphers_pairwise[i]) {
2825                 case WLAN_CIPHER_SUITE_WEP40:
2826                 case WLAN_CIPHER_SUITE_WEP104:
2827                         p.prwise_crypto_type |= WEP_CRYPT;
2828                         break;
2829                 case WLAN_CIPHER_SUITE_TKIP:
2830                         p.prwise_crypto_type |= TKIP_CRYPT;
2831                         break;
2832                 case WLAN_CIPHER_SUITE_CCMP:
2833                         p.prwise_crypto_type |= AES_CRYPT;
2834                         break;
2835                 case WLAN_CIPHER_SUITE_SMS4:
2836                         p.prwise_crypto_type |= WAPI_CRYPT;
2837                         break;
2838                 }
2839         }
2840         if (p.prwise_crypto_type == 0) {
2841                 p.prwise_crypto_type = NONE_CRYPT;
2842                 ath6kl_set_cipher(vif, 0, true);
2843         } else if (info->crypto.n_ciphers_pairwise == 1)
2844                 ath6kl_set_cipher(vif, info->crypto.ciphers_pairwise[0], true);
2845
2846         switch (info->crypto.cipher_group) {
2847         case WLAN_CIPHER_SUITE_WEP40:
2848         case WLAN_CIPHER_SUITE_WEP104:
2849                 p.grp_crypto_type = WEP_CRYPT;
2850                 break;
2851         case WLAN_CIPHER_SUITE_TKIP:
2852                 p.grp_crypto_type = TKIP_CRYPT;
2853                 break;
2854         case WLAN_CIPHER_SUITE_CCMP:
2855                 p.grp_crypto_type = AES_CRYPT;
2856                 break;
2857         case WLAN_CIPHER_SUITE_SMS4:
2858                 p.grp_crypto_type = WAPI_CRYPT;
2859                 break;
2860         default:
2861                 p.grp_crypto_type = NONE_CRYPT;
2862                 break;
2863         }
2864         ath6kl_set_cipher(vif, info->crypto.cipher_group, false);
2865
2866         p.nw_type = AP_NETWORK;
2867         vif->nw_type = vif->next_mode;
2868
2869         p.ssid_len = vif->ssid_len;
2870         memcpy(p.ssid, vif->ssid, vif->ssid_len);
2871         p.dot11_auth_mode = vif->dot11_auth_mode;
2872         p.ch = cpu_to_le16(info->channel->center_freq);
2873
2874         /* Enable uAPSD support by default */
2875         res = ath6kl_wmi_ap_set_apsd(ar->wmi, vif->fw_vif_idx, true);
2876         if (res < 0)
2877                 return res;
2878
2879         if (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) {
2880                 p.nw_subtype = SUBTYPE_P2PGO;
2881         } else {
2882                 /*
2883                  * Due to firmware limitation, it is not possible to
2884                  * do P2P mgmt operations in AP mode
2885                  */
2886                 p.nw_subtype = SUBTYPE_NONE;
2887         }
2888
2889         if (info->inactivity_timeout) {
2890                 res = ath6kl_wmi_set_inact_period(ar->wmi, vif->fw_vif_idx,
2891                                                   info->inactivity_timeout);
2892                 if (res < 0)
2893                         return res;
2894         }
2895
2896         if (ath6kl_set_htcap(vif, info->channel->band,
2897                              info->channel_type != NL80211_CHAN_NO_HT))
2898                 return -EIO;
2899
2900         /*
2901          * Get the PTKSA replay counter in the RSN IE. Supplicant
2902          * will use the RSN IE in M3 message and firmware has to
2903          * advertise the same in beacon/probe response. Send
2904          * the complete RSN IE capability field to firmware
2905          */
2906         if (!ath6kl_get_rsn_capab(&info->beacon, (u8 *) &rsn_capab) &&
2907             test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
2908                      ar->fw_capabilities)) {
2909                 res = ath6kl_wmi_set_ie_cmd(ar->wmi, vif->fw_vif_idx,
2910                                             WLAN_EID_RSN, WMI_RSN_IE_CAPB,
2911                                             (const u8 *) &rsn_capab,
2912                                             sizeof(rsn_capab));
2913                 vif->rsn_capab = rsn_capab;
2914                 if (res < 0)
2915                         return res;
2916         }
2917
2918         memcpy(&vif->profile, &p, sizeof(p));
2919         res = ath6kl_wmi_ap_profile_commit(ar->wmi, vif->fw_vif_idx, &p);
2920         if (res < 0)
2921                 return res;
2922
2923         return 0;
2924 }
2925
2926 static int ath6kl_change_beacon(struct wiphy *wiphy, struct net_device *dev,
2927                                 struct cfg80211_beacon_data *beacon)
2928 {
2929         struct ath6kl_vif *vif = netdev_priv(dev);
2930
2931         if (!ath6kl_cfg80211_ready(vif))
2932                 return -EIO;
2933
2934         if (vif->next_mode != AP_NETWORK)
2935                 return -EOPNOTSUPP;
2936
2937         return ath6kl_set_ies(vif, beacon);
2938 }
2939
2940 static int ath6kl_stop_ap(struct wiphy *wiphy, struct net_device *dev)
2941 {
2942         struct ath6kl *ar = ath6kl_priv(dev);
2943         struct ath6kl_vif *vif = netdev_priv(dev);
2944
2945         if (vif->nw_type != AP_NETWORK)
2946                 return -EOPNOTSUPP;
2947         if (!test_bit(CONNECTED, &vif->flags))
2948                 return -ENOTCONN;
2949
2950         ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
2951         clear_bit(CONNECTED, &vif->flags);
2952
2953         /* Restore ht setting in firmware */
2954         return ath6kl_restore_htcap(vif);
2955 }
2956
2957 static const u8 bcast_addr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2958
2959 static int ath6kl_del_station(struct wiphy *wiphy, struct net_device *dev,
2960                               u8 *mac)
2961 {
2962         struct ath6kl *ar = ath6kl_priv(dev);
2963         struct ath6kl_vif *vif = netdev_priv(dev);
2964         const u8 *addr = mac ? mac : bcast_addr;
2965
2966         return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx, WMI_AP_DEAUTH,
2967                                       addr, WLAN_REASON_PREV_AUTH_NOT_VALID);
2968 }
2969
2970 static int ath6kl_change_station(struct wiphy *wiphy, struct net_device *dev,
2971                                  u8 *mac, struct station_parameters *params)
2972 {
2973         struct ath6kl *ar = ath6kl_priv(dev);
2974         struct ath6kl_vif *vif = netdev_priv(dev);
2975
2976         if (vif->nw_type != AP_NETWORK)
2977                 return -EOPNOTSUPP;
2978
2979         /* Use this only for authorizing/unauthorizing a station */
2980         if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
2981                 return -EOPNOTSUPP;
2982
2983         if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
2984                 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
2985                                               WMI_AP_MLME_AUTHORIZE, mac, 0);
2986         return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
2987                                       WMI_AP_MLME_UNAUTHORIZE, mac, 0);
2988 }
2989
2990 static int ath6kl_remain_on_channel(struct wiphy *wiphy,
2991                                     struct wireless_dev *wdev,
2992                                     struct ieee80211_channel *chan,
2993                                     enum nl80211_channel_type channel_type,
2994                                     unsigned int duration,
2995                                     u64 *cookie)
2996 {
2997         struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
2998         struct ath6kl *ar = ath6kl_priv(vif->ndev);
2999         u32 id;
3000
3001         /* TODO: if already pending or ongoing remain-on-channel,
3002          * return -EBUSY */
3003         id = ++vif->last_roc_id;
3004         if (id == 0) {
3005                 /* Do not use 0 as the cookie value */
3006                 id = ++vif->last_roc_id;
3007         }
3008         *cookie = id;
3009
3010         return ath6kl_wmi_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx,
3011                                              chan->center_freq, duration);
3012 }
3013
3014 static int ath6kl_cancel_remain_on_channel(struct wiphy *wiphy,
3015                                            struct wireless_dev *wdev,
3016                                            u64 cookie)
3017 {
3018         struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3019         struct ath6kl *ar = ath6kl_priv(vif->ndev);
3020
3021         if (cookie != vif->last_roc_id)
3022                 return -ENOENT;
3023         vif->last_cancel_roc_id = cookie;
3024
3025         return ath6kl_wmi_cancel_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx);
3026 }
3027
3028 static int ath6kl_send_go_probe_resp(struct ath6kl_vif *vif,
3029                                      const u8 *buf, size_t len,
3030                                      unsigned int freq)
3031 {
3032         struct ath6kl *ar = vif->ar;
3033         const u8 *pos;
3034         u8 *p2p;
3035         int p2p_len;
3036         int ret;
3037         const struct ieee80211_mgmt *mgmt;
3038
3039         mgmt = (const struct ieee80211_mgmt *) buf;
3040
3041         /* Include P2P IE(s) from the frame generated in user space. */
3042
3043         p2p = kmalloc(len, GFP_KERNEL);
3044         if (p2p == NULL)
3045                 return -ENOMEM;
3046         p2p_len = 0;
3047
3048         pos = mgmt->u.probe_resp.variable;
3049         while (pos + 1 < buf + len) {
3050                 if (pos + 2 + pos[1] > buf + len)
3051                         break;
3052                 if (ath6kl_is_p2p_ie(pos)) {
3053                         memcpy(p2p + p2p_len, pos, 2 + pos[1]);
3054                         p2p_len += 2 + pos[1];
3055                 }
3056                 pos += 2 + pos[1];
3057         }
3058
3059         ret = ath6kl_wmi_send_probe_response_cmd(ar->wmi, vif->fw_vif_idx, freq,
3060                                                  mgmt->da, p2p, p2p_len);
3061         kfree(p2p);
3062         return ret;
3063 }
3064
3065 static bool ath6kl_mgmt_powersave_ap(struct ath6kl_vif *vif,
3066                                      u32 id,
3067                                      u32 freq,
3068                                      u32 wait,
3069                                      const u8 *buf,
3070                                      size_t len,
3071                                      bool *more_data,
3072                                      bool no_cck)
3073 {
3074         struct ieee80211_mgmt *mgmt;
3075         struct ath6kl_sta *conn;
3076         bool is_psq_empty = false;
3077         struct ath6kl_mgmt_buff *mgmt_buf;
3078         size_t mgmt_buf_size;
3079         struct ath6kl *ar = vif->ar;
3080
3081         mgmt = (struct ieee80211_mgmt *) buf;
3082         if (is_multicast_ether_addr(mgmt->da))
3083                 return false;
3084
3085         conn = ath6kl_find_sta(vif, mgmt->da);
3086         if (!conn)
3087                 return false;
3088
3089         if (conn->sta_flags & STA_PS_SLEEP) {
3090                 if (!(conn->sta_flags & STA_PS_POLLED)) {
3091                         /* Queue the frames if the STA is sleeping */
3092                         mgmt_buf_size = len + sizeof(struct ath6kl_mgmt_buff);
3093                         mgmt_buf = kmalloc(mgmt_buf_size, GFP_KERNEL);
3094                         if (!mgmt_buf)
3095                                 return false;
3096
3097                         INIT_LIST_HEAD(&mgmt_buf->list);
3098                         mgmt_buf->id = id;
3099                         mgmt_buf->freq = freq;
3100                         mgmt_buf->wait = wait;
3101                         mgmt_buf->len = len;
3102                         mgmt_buf->no_cck = no_cck;
3103                         memcpy(mgmt_buf->buf, buf, len);
3104                         spin_lock_bh(&conn->psq_lock);
3105                         is_psq_empty = skb_queue_empty(&conn->psq) &&
3106                                         (conn->mgmt_psq_len == 0);
3107                         list_add_tail(&mgmt_buf->list, &conn->mgmt_psq);
3108                         conn->mgmt_psq_len++;
3109                         spin_unlock_bh(&conn->psq_lock);
3110
3111                         /*
3112                          * If this is the first pkt getting queued
3113                          * for this STA, update the PVB for this
3114                          * STA.
3115                          */
3116                         if (is_psq_empty)
3117                                 ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx,
3118                                                        conn->aid, 1);
3119                         return true;
3120                 }
3121
3122                 /*
3123                  * This tx is because of a PsPoll.
3124                  * Determine if MoreData bit has to be set.
3125                  */
3126                 spin_lock_bh(&conn->psq_lock);
3127                 if (!skb_queue_empty(&conn->psq) || (conn->mgmt_psq_len != 0))
3128                         *more_data = true;
3129                 spin_unlock_bh(&conn->psq_lock);
3130         }
3131
3132         return false;
3133 }
3134
3135 /* Check if SSID length is greater than DIRECT- */
3136 static bool ath6kl_is_p2p_go_ssid(const u8 *buf, size_t len)
3137 {
3138         const struct ieee80211_mgmt *mgmt;
3139         mgmt = (const struct ieee80211_mgmt *) buf;
3140
3141         /* variable[1] contains the SSID tag length */
3142         if (buf + len >= &mgmt->u.probe_resp.variable[1] &&
3143             (mgmt->u.probe_resp.variable[1] > P2P_WILDCARD_SSID_LEN)) {
3144                 return true;
3145         }
3146
3147         return false;
3148 }
3149
3150 static int ath6kl_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
3151                           struct ieee80211_channel *chan, bool offchan,
3152                           enum nl80211_channel_type channel_type,
3153                           bool channel_type_valid, unsigned int wait,
3154                           const u8 *buf, size_t len, bool no_cck,
3155                           bool dont_wait_for_ack, u64 *cookie)
3156 {
3157         struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3158         struct ath6kl *ar = ath6kl_priv(vif->ndev);
3159         u32 id;
3160         const struct ieee80211_mgmt *mgmt;
3161         bool more_data, queued;
3162
3163         mgmt = (const struct ieee80211_mgmt *) buf;
3164         if (vif->nw_type == AP_NETWORK && test_bit(CONNECTED, &vif->flags) &&
3165             ieee80211_is_probe_resp(mgmt->frame_control) &&
3166             ath6kl_is_p2p_go_ssid(buf, len)) {
3167                 /*
3168                  * Send Probe Response frame in GO mode using a separate WMI
3169                  * command to allow the target to fill in the generic IEs.
3170                  */
3171                 *cookie = 0; /* TX status not supported */
3172                 return ath6kl_send_go_probe_resp(vif, buf, len,
3173                                                  chan->center_freq);
3174         }
3175
3176         id = vif->send_action_id++;
3177         if (id == 0) {
3178                 /*
3179                  * 0 is a reserved value in the WMI command and shall not be
3180                  * used for the command.
3181                  */
3182                 id = vif->send_action_id++;
3183         }
3184
3185         *cookie = id;
3186
3187         /* AP mode Power saving processing */
3188         if (vif->nw_type == AP_NETWORK) {
3189                 queued = ath6kl_mgmt_powersave_ap(vif,
3190                                         id, chan->center_freq,
3191                                         wait, buf,
3192                                         len, &more_data, no_cck);
3193                 if (queued)
3194                         return 0;
3195         }
3196
3197         return ath6kl_wmi_send_mgmt_cmd(ar->wmi, vif->fw_vif_idx, id,
3198                                         chan->center_freq, wait,
3199                                         buf, len, no_cck);
3200 }
3201
3202 static void ath6kl_mgmt_frame_register(struct wiphy *wiphy,
3203                                        struct wireless_dev *wdev,
3204                                        u16 frame_type, bool reg)
3205 {
3206         struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3207
3208         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: frame_type=0x%x reg=%d\n",
3209                    __func__, frame_type, reg);
3210         if (frame_type == IEEE80211_STYPE_PROBE_REQ) {
3211                 /*
3212                  * Note: This notification callback is not allowed to sleep, so
3213                  * we cannot send WMI_PROBE_REQ_REPORT_CMD here. Instead, we
3214                  * hardcode target to report Probe Request frames all the time.
3215                  */
3216                 vif->probe_req_report = reg;
3217         }
3218 }
3219
3220 static int ath6kl_cfg80211_sscan_start(struct wiphy *wiphy,
3221                         struct net_device *dev,
3222                         struct cfg80211_sched_scan_request *request)
3223 {
3224         struct ath6kl *ar = ath6kl_priv(dev);
3225         struct ath6kl_vif *vif = netdev_priv(dev);
3226         u16 interval;
3227         int ret, rssi_thold;
3228
3229         if (ar->state != ATH6KL_STATE_ON)
3230                 return -EIO;
3231
3232         if (vif->sme_state != SME_DISCONNECTED)
3233                 return -EBUSY;
3234
3235         ath6kl_cfg80211_scan_complete_event(vif, true);
3236
3237         ret = ath6kl_set_probed_ssids(ar, vif, request->ssids,
3238                                       request->n_ssids,
3239                                       request->match_sets,
3240                                       request->n_match_sets);
3241         if (ret < 0)
3242                 return ret;
3243
3244         if (!request->n_match_sets) {
3245                 ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
3246                                                ALL_BSS_FILTER, 0);
3247                 if (ret < 0)
3248                         return ret;
3249         } else {
3250                  ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
3251                                                 MATCHED_SSID_FILTER, 0);
3252                 if (ret < 0)
3253                         return ret;
3254         }
3255
3256         if (test_bit(ATH6KL_FW_CAPABILITY_RSSI_SCAN_THOLD,
3257                      ar->fw_capabilities)) {
3258                 if (request->rssi_thold <= NL80211_SCAN_RSSI_THOLD_OFF)
3259                         rssi_thold = 0;
3260                 else if (request->rssi_thold < -127)
3261                         rssi_thold = -127;
3262                 else
3263                         rssi_thold = request->rssi_thold;
3264
3265                 ret = ath6kl_wmi_set_rssi_filter_cmd(ar->wmi, vif->fw_vif_idx,
3266                                                      rssi_thold);
3267                 if (ret) {
3268                         ath6kl_err("failed to set RSSI threshold for scan\n");
3269                         return ret;
3270                 }
3271         }
3272
3273         /* fw uses seconds, also make sure that it's >0 */
3274         interval = max_t(u16, 1, request->interval / 1000);
3275
3276         ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
3277                                   interval, interval,
3278                                   vif->bg_scan_period, 0, 0, 0, 3, 0, 0, 0);
3279
3280         /* this also clears IE in fw if it's not set */
3281         ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
3282                                        WMI_FRAME_PROBE_REQ,
3283                                        request->ie, request->ie_len);
3284         if (ret) {
3285                 ath6kl_warn("Failed to set probe request IE for scheduled scan: %d\n",
3286                             ret);
3287                 return ret;
3288         }
3289
3290         ret = ath6kl_wmi_enable_sched_scan_cmd(ar->wmi, vif->fw_vif_idx, true);
3291         if (ret)
3292                 return ret;
3293
3294         set_bit(SCHED_SCANNING, &vif->flags);
3295
3296         return 0;
3297 }
3298
3299 static int ath6kl_cfg80211_sscan_stop(struct wiphy *wiphy,
3300                                       struct net_device *dev)
3301 {
3302         struct ath6kl_vif *vif = netdev_priv(dev);
3303         bool stopped;
3304
3305         stopped = __ath6kl_cfg80211_sscan_stop(vif);
3306
3307         if (!stopped)
3308                 return -EIO;
3309
3310         return 0;
3311 }
3312
3313 static int ath6kl_cfg80211_set_bitrate(struct wiphy *wiphy,
3314                                        struct net_device *dev,
3315                                        const u8 *addr,
3316                                        const struct cfg80211_bitrate_mask *mask)
3317 {
3318         struct ath6kl *ar = ath6kl_priv(dev);
3319         struct ath6kl_vif *vif = netdev_priv(dev);
3320
3321         return ath6kl_wmi_set_bitrate_mask(ar->wmi, vif->fw_vif_idx,
3322                                            mask);
3323 }
3324
3325 static int ath6kl_cfg80211_set_txe_config(struct wiphy *wiphy,
3326                                           struct net_device *dev,
3327                                           u32 rate, u32 pkts, u32 intvl)
3328 {
3329         struct ath6kl *ar = ath6kl_priv(dev);
3330         struct ath6kl_vif *vif = netdev_priv(dev);
3331
3332         if (vif->nw_type != INFRA_NETWORK ||
3333             !test_bit(ATH6KL_FW_CAPABILITY_TX_ERR_NOTIFY, ar->fw_capabilities))
3334                 return -EOPNOTSUPP;
3335
3336         if (vif->sme_state != SME_CONNECTED)
3337                 return -ENOTCONN;
3338
3339         /* save this since the firmware won't report the interval */
3340         vif->txe_intvl = intvl;
3341
3342         return ath6kl_wmi_set_txe_notify(ar->wmi, vif->fw_vif_idx,
3343                                          rate, pkts, intvl);
3344 }
3345
3346 static const struct ieee80211_txrx_stypes
3347 ath6kl_mgmt_stypes[NUM_NL80211_IFTYPES] = {
3348         [NL80211_IFTYPE_STATION] = {
3349                 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3350                 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3351                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3352                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3353         },
3354         [NL80211_IFTYPE_AP] = {
3355                 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3356                 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3357                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3358                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3359         },
3360         [NL80211_IFTYPE_P2P_CLIENT] = {
3361                 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3362                 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3363                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3364                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3365         },
3366         [NL80211_IFTYPE_P2P_GO] = {
3367                 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3368                 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3369                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3370                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3371         },
3372 };
3373
3374 static struct cfg80211_ops ath6kl_cfg80211_ops = {
3375         .add_virtual_intf = ath6kl_cfg80211_add_iface,
3376         .del_virtual_intf = ath6kl_cfg80211_del_iface,
3377         .change_virtual_intf = ath6kl_cfg80211_change_iface,
3378         .scan = ath6kl_cfg80211_scan,
3379         .connect = ath6kl_cfg80211_connect,
3380         .disconnect = ath6kl_cfg80211_disconnect,
3381         .add_key = ath6kl_cfg80211_add_key,
3382         .get_key = ath6kl_cfg80211_get_key,
3383         .del_key = ath6kl_cfg80211_del_key,
3384         .set_default_key = ath6kl_cfg80211_set_default_key,
3385         .set_wiphy_params = ath6kl_cfg80211_set_wiphy_params,
3386         .set_tx_power = ath6kl_cfg80211_set_txpower,
3387         .get_tx_power = ath6kl_cfg80211_get_txpower,
3388         .set_power_mgmt = ath6kl_cfg80211_set_power_mgmt,
3389         .join_ibss = ath6kl_cfg80211_join_ibss,
3390         .leave_ibss = ath6kl_cfg80211_leave_ibss,
3391         .get_station = ath6kl_get_station,
3392         .set_pmksa = ath6kl_set_pmksa,
3393         .del_pmksa = ath6kl_del_pmksa,
3394         .flush_pmksa = ath6kl_flush_pmksa,
3395         CFG80211_TESTMODE_CMD(ath6kl_tm_cmd)
3396 #ifdef CONFIG_PM
3397         .suspend = __ath6kl_cfg80211_suspend,
3398         .resume = __ath6kl_cfg80211_resume,
3399 #endif
3400         .start_ap = ath6kl_start_ap,
3401         .change_beacon = ath6kl_change_beacon,
3402         .stop_ap = ath6kl_stop_ap,
3403         .del_station = ath6kl_del_station,
3404         .change_station = ath6kl_change_station,
3405         .remain_on_channel = ath6kl_remain_on_channel,
3406         .cancel_remain_on_channel = ath6kl_cancel_remain_on_channel,
3407         .mgmt_tx = ath6kl_mgmt_tx,
3408         .mgmt_frame_register = ath6kl_mgmt_frame_register,
3409         .sched_scan_start = ath6kl_cfg80211_sscan_start,
3410         .sched_scan_stop = ath6kl_cfg80211_sscan_stop,
3411         .set_bitrate_mask = ath6kl_cfg80211_set_bitrate,
3412         .set_cqm_txe_config = ath6kl_cfg80211_set_txe_config,
3413 };
3414
3415 void ath6kl_cfg80211_stop(struct ath6kl_vif *vif)
3416 {
3417         ath6kl_cfg80211_sscan_disable(vif);
3418
3419         switch (vif->sme_state) {
3420         case SME_DISCONNECTED:
3421                 break;
3422         case SME_CONNECTING:
3423                 cfg80211_connect_result(vif->ndev, vif->bssid, NULL, 0,
3424                                         NULL, 0,
3425                                         WLAN_STATUS_UNSPECIFIED_FAILURE,
3426                                         GFP_KERNEL);
3427                 break;
3428         case SME_CONNECTED:
3429                 cfg80211_disconnected(vif->ndev, 0, NULL, 0, GFP_KERNEL);
3430                 break;
3431         }
3432
3433         if (test_bit(CONNECTED, &vif->flags) ||
3434             test_bit(CONNECT_PEND, &vif->flags))
3435                 ath6kl_wmi_disconnect_cmd(vif->ar->wmi, vif->fw_vif_idx);
3436
3437         vif->sme_state = SME_DISCONNECTED;
3438         clear_bit(CONNECTED, &vif->flags);
3439         clear_bit(CONNECT_PEND, &vif->flags);
3440
3441         /* disable scanning */
3442         if (ath6kl_wmi_scanparams_cmd(vif->ar->wmi, vif->fw_vif_idx, 0xFFFF,
3443                                       0, 0, 0, 0, 0, 0, 0, 0, 0) != 0)
3444                 ath6kl_warn("failed to disable scan during stop\n");
3445
3446         ath6kl_cfg80211_scan_complete_event(vif, true);
3447 }
3448
3449 void ath6kl_cfg80211_stop_all(struct ath6kl *ar)
3450 {
3451         struct ath6kl_vif *vif;
3452
3453         vif = ath6kl_vif_first(ar);
3454         if (!vif) {
3455                 /* save the current power mode before enabling power save */
3456                 ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
3457
3458                 if (ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER) != 0)
3459                         ath6kl_warn("ath6kl_deep_sleep_enable: wmi_powermode_cmd failed\n");
3460                 return;
3461         }
3462
3463         /*
3464          * FIXME: we should take ar->list_lock to protect changes in the
3465          * vif_list, but that's not trivial to do as ath6kl_cfg80211_stop()
3466          * sleeps.
3467          */
3468         list_for_each_entry(vif, &ar->vif_list, list)
3469                 ath6kl_cfg80211_stop(vif);
3470 }
3471
3472 static int ath6kl_cfg80211_reg_notify(struct wiphy *wiphy,
3473                                       struct regulatory_request *request)
3474 {
3475         struct ath6kl *ar = wiphy_priv(wiphy);
3476         u32 rates[IEEE80211_NUM_BANDS];
3477         int ret, i;
3478
3479         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
3480                    "cfg reg_notify %c%c%s%s initiator %d\n",
3481                    request->alpha2[0], request->alpha2[1],
3482                    request->intersect ? " intersect" : "",
3483                    request->processed ? " processed" : "",
3484                    request->initiator);
3485
3486         ret = ath6kl_wmi_set_regdomain_cmd(ar->wmi, request->alpha2);
3487         if (ret) {
3488                 ath6kl_err("failed to set regdomain: %d\n", ret);
3489                 return ret;
3490         }
3491
3492         /*
3493          * Firmware will apply the regdomain change only after a scan is
3494          * issued and it will send a WMI_REGDOMAIN_EVENTID when it has been
3495          * changed.
3496          */
3497
3498         for (i = 0; i < IEEE80211_NUM_BANDS; i++)
3499                 if (wiphy->bands[i])
3500                         rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
3501
3502
3503         ret = ath6kl_wmi_beginscan_cmd(ar->wmi, 0, WMI_LONG_SCAN, false,
3504                                        false, 0, ATH6KL_FG_SCAN_INTERVAL,
3505                                        0, NULL, false, rates);
3506         if (ret) {
3507                 ath6kl_err("failed to start scan for a regdomain change: %d\n",
3508                            ret);
3509                 return ret;
3510         }
3511
3512         return 0;
3513 }
3514
3515 static int ath6kl_cfg80211_vif_init(struct ath6kl_vif *vif)
3516 {
3517         vif->aggr_cntxt = aggr_init(vif);
3518         if (!vif->aggr_cntxt) {
3519                 ath6kl_err("failed to initialize aggr\n");
3520                 return -ENOMEM;
3521         }
3522
3523         setup_timer(&vif->disconnect_timer, disconnect_timer_handler,
3524                     (unsigned long) vif->ndev);
3525         setup_timer(&vif->sched_scan_timer, ath6kl_wmi_sscan_timer,
3526                     (unsigned long) vif);
3527
3528         set_bit(WMM_ENABLED, &vif->flags);
3529         spin_lock_init(&vif->if_lock);
3530
3531         INIT_LIST_HEAD(&vif->mc_filter);
3532
3533         return 0;
3534 }
3535
3536 void ath6kl_cfg80211_vif_cleanup(struct ath6kl_vif *vif)
3537 {
3538         struct ath6kl *ar = vif->ar;
3539         struct ath6kl_mc_filter *mc_filter, *tmp;
3540
3541         aggr_module_destroy(vif->aggr_cntxt);
3542
3543         ar->avail_idx_map |= BIT(vif->fw_vif_idx);
3544
3545         if (vif->nw_type == ADHOC_NETWORK)
3546                 ar->ibss_if_active = false;
3547
3548         list_for_each_entry_safe(mc_filter, tmp, &vif->mc_filter, list) {
3549                 list_del(&mc_filter->list);
3550                 kfree(mc_filter);
3551         }
3552
3553         unregister_netdevice(vif->ndev);
3554
3555         ar->num_vif--;
3556 }
3557
3558 struct wireless_dev *ath6kl_interface_add(struct ath6kl *ar, const char *name,
3559                                           enum nl80211_iftype type,
3560                                           u8 fw_vif_idx, u8 nw_type)
3561 {
3562         struct net_device *ndev;
3563         struct ath6kl_vif *vif;
3564
3565         ndev = alloc_netdev(sizeof(*vif), name, ether_setup);
3566         if (!ndev)
3567                 return NULL;
3568
3569         vif = netdev_priv(ndev);
3570         ndev->ieee80211_ptr = &vif->wdev;
3571         vif->wdev.wiphy = ar->wiphy;
3572         vif->ar = ar;
3573         vif->ndev = ndev;
3574         SET_NETDEV_DEV(ndev, wiphy_dev(vif->wdev.wiphy));
3575         vif->wdev.netdev = ndev;
3576         vif->wdev.iftype = type;
3577         vif->fw_vif_idx = fw_vif_idx;
3578         vif->nw_type = nw_type;
3579         vif->next_mode = nw_type;
3580         vif->listen_intvl_t = ATH6KL_DEFAULT_LISTEN_INTVAL;
3581         vif->bmiss_time_t = ATH6KL_DEFAULT_BMISS_TIME;
3582         vif->bg_scan_period = 0;
3583         vif->htcap[IEEE80211_BAND_2GHZ].ht_enable = true;
3584         vif->htcap[IEEE80211_BAND_5GHZ].ht_enable = true;
3585
3586         memcpy(ndev->dev_addr, ar->mac_addr, ETH_ALEN);
3587         if (fw_vif_idx != 0) {
3588                 ndev->dev_addr[0] = (ndev->dev_addr[0] ^ (1 << fw_vif_idx)) |
3589                                      0x2;
3590                 if (test_bit(ATH6KL_FW_CAPABILITY_CUSTOM_MAC_ADDR,
3591                              ar->fw_capabilities))
3592                         ndev->dev_addr[4] ^= 0x80;
3593         }
3594
3595         init_netdev(ndev);
3596
3597         ath6kl_init_control_info(vif);
3598
3599         if (ath6kl_cfg80211_vif_init(vif))
3600                 goto err;
3601
3602         if (register_netdevice(ndev))
3603                 goto err;
3604
3605         ar->avail_idx_map &= ~BIT(fw_vif_idx);
3606         vif->sme_state = SME_DISCONNECTED;
3607         set_bit(WLAN_ENABLED, &vif->flags);
3608         ar->wlan_pwr_state = WLAN_POWER_STATE_ON;
3609         set_bit(NETDEV_REGISTERED, &vif->flags);
3610
3611         if (type == NL80211_IFTYPE_ADHOC)
3612                 ar->ibss_if_active = true;
3613
3614         spin_lock_bh(&ar->list_lock);
3615         list_add_tail(&vif->list, &ar->vif_list);
3616         spin_unlock_bh(&ar->list_lock);
3617
3618         return &vif->wdev;
3619
3620 err:
3621         aggr_module_destroy(vif->aggr_cntxt);
3622         free_netdev(ndev);
3623         return NULL;
3624 }
3625
3626 int ath6kl_cfg80211_init(struct ath6kl *ar)
3627 {
3628         struct wiphy *wiphy = ar->wiphy;
3629         bool band_2gig = false, band_5gig = false, ht = false;
3630         int ret;
3631
3632         wiphy->mgmt_stypes = ath6kl_mgmt_stypes;
3633
3634         wiphy->max_remain_on_channel_duration = 5000;
3635
3636         /* set device pointer for wiphy */
3637         set_wiphy_dev(wiphy, ar->dev);
3638
3639         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3640                                  BIT(NL80211_IFTYPE_ADHOC) |
3641                                  BIT(NL80211_IFTYPE_AP);
3642         if (ar->p2p) {
3643                 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_GO) |
3644                                           BIT(NL80211_IFTYPE_P2P_CLIENT);
3645         }
3646
3647         if (config_enabled(CONFIG_ATH6KL_REGDOMAIN) &&
3648             test_bit(ATH6KL_FW_CAPABILITY_REGDOMAIN, ar->fw_capabilities))
3649                 wiphy->reg_notifier = ath6kl_cfg80211_reg_notify;
3650
3651         /* max num of ssids that can be probed during scanning */
3652         wiphy->max_scan_ssids = MAX_PROBED_SSIDS;
3653
3654         /* max num of ssids that can be matched after scan */
3655         if (test_bit(ATH6KL_FW_CAPABILITY_SCHED_SCAN_MATCH_LIST,
3656                      ar->fw_capabilities))
3657                 wiphy->max_match_sets = MAX_PROBED_SSIDS;
3658
3659         wiphy->max_scan_ie_len = 1000; /* FIX: what is correct limit? */
3660         switch (ar->hw.cap) {
3661         case WMI_11AN_CAP:
3662                 ht = true;
3663         case WMI_11A_CAP:
3664                 band_5gig = true;
3665                 break;
3666         case WMI_11GN_CAP:
3667                 ht = true;
3668         case WMI_11G_CAP:
3669                 band_2gig = true;
3670                 break;
3671         case WMI_11AGN_CAP:
3672                 ht = true;
3673         case WMI_11AG_CAP:
3674                 band_2gig = true;
3675                 band_5gig = true;
3676                 break;
3677         default:
3678                 ath6kl_err("invalid phy capability!\n");
3679                 return -EINVAL;
3680         }
3681
3682         /*
3683          * Even if the fw has HT support, advertise HT cap only when
3684          * the firmware has support to override RSN capability, otherwise
3685          * 4-way handshake would fail.
3686          */
3687         if (!(ht &&
3688               test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
3689                        ar->fw_capabilities))) {
3690                 ath6kl_band_2ghz.ht_cap.cap = 0;
3691                 ath6kl_band_2ghz.ht_cap.ht_supported = false;
3692                 ath6kl_band_5ghz.ht_cap.cap = 0;
3693                 ath6kl_band_5ghz.ht_cap.ht_supported = false;
3694         }
3695
3696         if (ar->hw.flags & ATH6KL_HW_FLAG_64BIT_RATES) {
3697                 ath6kl_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3698                 ath6kl_band_5ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3699                 ath6kl_band_2ghz.ht_cap.mcs.rx_mask[1] = 0xff;
3700                 ath6kl_band_5ghz.ht_cap.mcs.rx_mask[1] = 0xff;
3701         } else {
3702                 ath6kl_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3703                 ath6kl_band_5ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3704         }
3705
3706         if (band_2gig)
3707                 wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz;
3708         if (band_5gig)
3709                 wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz;
3710
3711         wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
3712
3713         wiphy->cipher_suites = cipher_suites;
3714         wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3715
3716 #ifdef CONFIG_PM
3717         wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
3718                               WIPHY_WOWLAN_DISCONNECT |
3719                               WIPHY_WOWLAN_GTK_REKEY_FAILURE  |
3720                               WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
3721                               WIPHY_WOWLAN_EAP_IDENTITY_REQ   |
3722                               WIPHY_WOWLAN_4WAY_HANDSHAKE;
3723         wiphy->wowlan.n_patterns = WOW_MAX_FILTERS_PER_LIST;
3724         wiphy->wowlan.pattern_min_len = 1;
3725         wiphy->wowlan.pattern_max_len = WOW_PATTERN_SIZE;
3726 #endif
3727
3728         wiphy->max_sched_scan_ssids = MAX_PROBED_SSIDS;
3729
3730         ar->wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM |
3731                             WIPHY_FLAG_HAVE_AP_SME |
3732                             WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
3733                             WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
3734
3735         if (test_bit(ATH6KL_FW_CAPABILITY_SCHED_SCAN_V2, ar->fw_capabilities))
3736                 ar->wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
3737
3738         if (test_bit(ATH6KL_FW_CAPABILITY_INACTIVITY_TIMEOUT,
3739                      ar->fw_capabilities))
3740                 ar->wiphy->features |= NL80211_FEATURE_INACTIVITY_TIMER;
3741
3742         ar->wiphy->probe_resp_offload =
3743                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
3744                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
3745                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
3746
3747         ret = wiphy_register(wiphy);
3748         if (ret < 0) {
3749                 ath6kl_err("couldn't register wiphy device\n");
3750                 return ret;
3751         }
3752
3753         ar->wiphy_registered = true;
3754
3755         return 0;
3756 }
3757
3758 void ath6kl_cfg80211_cleanup(struct ath6kl *ar)
3759 {
3760         wiphy_unregister(ar->wiphy);
3761
3762         ar->wiphy_registered = false;
3763 }
3764
3765 struct ath6kl *ath6kl_cfg80211_create(void)
3766 {
3767         struct ath6kl *ar;
3768         struct wiphy *wiphy;
3769
3770         /* create a new wiphy for use with cfg80211 */
3771         wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl));
3772
3773         if (!wiphy) {
3774                 ath6kl_err("couldn't allocate wiphy device\n");
3775                 return NULL;
3776         }
3777
3778         ar = wiphy_priv(wiphy);
3779         ar->wiphy = wiphy;
3780
3781         return ar;
3782 }
3783
3784 /* Note: ar variable must not be accessed after calling this! */
3785 void ath6kl_cfg80211_destroy(struct ath6kl *ar)
3786 {
3787         int i;
3788
3789         for (i = 0; i < AP_MAX_NUM_STA; i++)
3790                 kfree(ar->sta_list[i].aggr_conn);
3791
3792         wiphy_free(ar->wiphy);
3793 }
3794