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