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

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