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