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

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