Pileus Git - ~andy/linux/blob - drivers/net/wireless/ath/ath6kl/cfg80211.c

   1 /*
   2  * Copyright (c) 2004-2011 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "core.h"
  18 #include "cfg80211.h"
  19 #include "debug.h"
  20
  21 #define RATETAB_ENT(_rate, _rateid, _flags) {   \
  22         .bitrate    = (_rate),                  \
  23         .flags      = (_flags),                 \
  24         .hw_value   = (_rateid),                \
  25 }
  26
  27 #define CHAN2G(_channel, _freq, _flags) {   \
  28         .band           = IEEE80211_BAND_2GHZ,  \
  29         .hw_value       = (_channel),           \
  30         .center_freq    = (_freq),              \
  31         .flags          = (_flags),             \
  32         .max_antenna_gain   = 0,                \
  33         .max_power      = 30,                   \
  34 }
  35
  36 #define CHAN5G(_channel, _flags) {                  \
  37         .band           = IEEE80211_BAND_5GHZ,      \
  38         .hw_value       = (_channel),               \
  39         .center_freq    = 5000 + (5 * (_channel)),  \
  40         .flags          = (_flags),                 \
  41         .max_antenna_gain   = 0,                    \
  42         .max_power      = 30,                       \
  43 }
  44
  45 static struct ieee80211_rate ath6kl_rates[] = {
  46         RATETAB_ENT(10, 0x1, 0),
  47         RATETAB_ENT(20, 0x2, 0),
  48         RATETAB_ENT(55, 0x4, 0),
  49         RATETAB_ENT(110, 0x8, 0),
  50         RATETAB_ENT(60, 0x10, 0),
  51         RATETAB_ENT(90, 0x20, 0),
  52         RATETAB_ENT(120, 0x40, 0),
  53         RATETAB_ENT(180, 0x80, 0),
  54         RATETAB_ENT(240, 0x100, 0),
  55         RATETAB_ENT(360, 0x200, 0),
  56         RATETAB_ENT(480, 0x400, 0),
  57         RATETAB_ENT(540, 0x800, 0),
  58 };
  59
  60 #define ath6kl_a_rates     (ath6kl_rates + 4)
  61 #define ath6kl_a_rates_size    8
  62 #define ath6kl_g_rates     (ath6kl_rates + 0)
  63 #define ath6kl_g_rates_size    12
  64
  65 static struct ieee80211_channel ath6kl_2ghz_channels[] = {
  66         CHAN2G(1, 2412, 0),
  67         CHAN2G(2, 2417, 0),
  68         CHAN2G(3, 2422, 0),
  69         CHAN2G(4, 2427, 0),
  70         CHAN2G(5, 2432, 0),
  71         CHAN2G(6, 2437, 0),
  72         CHAN2G(7, 2442, 0),
  73         CHAN2G(8, 2447, 0),
  74         CHAN2G(9, 2452, 0),
  75         CHAN2G(10, 2457, 0),
  76         CHAN2G(11, 2462, 0),
  77         CHAN2G(12, 2467, 0),
  78         CHAN2G(13, 2472, 0),
  79         CHAN2G(14, 2484, 0),
  80 };
  81
  82 static struct ieee80211_channel ath6kl_5ghz_a_channels[] = {
  83         CHAN5G(34, 0), CHAN5G(36, 0),
  84         CHAN5G(38, 0), CHAN5G(40, 0),
  85         CHAN5G(42, 0), CHAN5G(44, 0),
  86         CHAN5G(46, 0), CHAN5G(48, 0),
  87         CHAN5G(52, 0), CHAN5G(56, 0),
  88         CHAN5G(60, 0), CHAN5G(64, 0),
  89         CHAN5G(100, 0), CHAN5G(104, 0),
  90         CHAN5G(108, 0), CHAN5G(112, 0),
  91         CHAN5G(116, 0), CHAN5G(120, 0),
  92         CHAN5G(124, 0), CHAN5G(128, 0),
  93         CHAN5G(132, 0), CHAN5G(136, 0),
  94         CHAN5G(140, 0), CHAN5G(149, 0),
  95         CHAN5G(153, 0), CHAN5G(157, 0),
  96         CHAN5G(161, 0), CHAN5G(165, 0),
  97         CHAN5G(184, 0), CHAN5G(188, 0),
  98         CHAN5G(192, 0), CHAN5G(196, 0),
  99         CHAN5G(200, 0), CHAN5G(204, 0),
 100         CHAN5G(208, 0), CHAN5G(212, 0),
 101         CHAN5G(216, 0),
 102 };
 103
 104 static struct ieee80211_supported_band ath6kl_band_2ghz = {
 105         .n_channels = ARRAY_SIZE(ath6kl_2ghz_channels),
 106         .channels = ath6kl_2ghz_channels,
 107         .n_bitrates = ath6kl_g_rates_size,
 108         .bitrates = ath6kl_g_rates,
 109 };
 110
 111 static struct ieee80211_supported_band ath6kl_band_5ghz = {
 112         .n_channels = ARRAY_SIZE(ath6kl_5ghz_a_channels),
 113         .channels = ath6kl_5ghz_a_channels,
 114         .n_bitrates = ath6kl_a_rates_size,
 115         .bitrates = ath6kl_a_rates,
 116 };
 117
 118 static int ath6kl_set_wpa_version(struct ath6kl *ar,
 119                                   enum nl80211_wpa_versions wpa_version)
 120 {
 121         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version);
 122
 123         if (!wpa_version) {
 124                 ar->auth_mode = NONE_AUTH;
 125         } else if (wpa_version & NL80211_WPA_VERSION_2) {
 126                 ar->auth_mode = WPA2_AUTH;
 127         } else if (wpa_version & NL80211_WPA_VERSION_1) {
 128                 ar->auth_mode = WPA_AUTH;
 129         } else {
 130                 ath6kl_err("%s: %u not supported\n", __func__, wpa_version);
 131                 return -ENOTSUPP;
 132         }
 133
 134         return 0;
 135 }
 136
 137 static int ath6kl_set_auth_type(struct ath6kl *ar,
 138                                 enum nl80211_auth_type auth_type)
 139 {
 140
 141         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type);
 142
 143         switch (auth_type) {
 144         case NL80211_AUTHTYPE_OPEN_SYSTEM:
 145                 ar->dot11_auth_mode = OPEN_AUTH;
 146                 break;
 147         case NL80211_AUTHTYPE_SHARED_KEY:
 148                 ar->dot11_auth_mode = SHARED_AUTH;
 149                 break;
 150         case NL80211_AUTHTYPE_NETWORK_EAP:
 151                 ar->dot11_auth_mode = LEAP_AUTH;
 152                 break;
 153
 154         case NL80211_AUTHTYPE_AUTOMATIC:
 155                 ar->dot11_auth_mode = OPEN_AUTH;
 156                 ar->auto_auth_stage = AUTH_OPEN_IN_PROGRESS;
 157                 break;
 158
 159         default:
 160                 ath6kl_err("%s: 0x%x not spported\n", __func__, auth_type);
 161                 return -ENOTSUPP;
 162         }
 163
 164         return 0;
 165 }
 166
 167 static int ath6kl_set_cipher(struct ath6kl *ar, u32 cipher, bool ucast)
 168 {
 169         u8 *ar_cipher = ucast ? &ar->prwise_crypto : &ar->grp_crypto;
 170         u8 *ar_cipher_len = ucast ? &ar->prwise_crypto_len : &ar->grp_crpto_len;
 171
 172         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n",
 173                    __func__, cipher, ucast);
 174
 175         switch (cipher) {
 176         case 0:
 177                 /* our own hack to use value 0 as no crypto used */
 178                 *ar_cipher = NONE_CRYPT;
 179                 *ar_cipher_len = 0;
 180                 break;
 181         case WLAN_CIPHER_SUITE_WEP40:
 182                 *ar_cipher = WEP_CRYPT;
 183                 *ar_cipher_len = 5;
 184                 break;
 185         case WLAN_CIPHER_SUITE_WEP104:
 186                 *ar_cipher = WEP_CRYPT;
 187                 *ar_cipher_len = 13;
 188                 break;
 189         case WLAN_CIPHER_SUITE_TKIP:
 190                 *ar_cipher = TKIP_CRYPT;
 191                 *ar_cipher_len = 0;
 192                 break;
 193         case WLAN_CIPHER_SUITE_CCMP:
 194                 *ar_cipher = AES_CRYPT;
 195                 *ar_cipher_len = 0;
 196                 break;
 197         default:
 198                 ath6kl_err("cipher 0x%x not supported\n", cipher);
 199                 return -ENOTSUPP;
 200         }
 201
 202         return 0;
 203 }
 204
 205 static void ath6kl_set_key_mgmt(struct ath6kl *ar, u32 key_mgmt)
 206 {
 207         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt);
 208
 209         if (key_mgmt == WLAN_AKM_SUITE_PSK) {
 210                 if (ar->auth_mode == WPA_AUTH)
 211                         ar->auth_mode = WPA_PSK_AUTH;
 212                 else if (ar->auth_mode == WPA2_AUTH)
 213                         ar->auth_mode = WPA2_PSK_AUTH;
 214         } else if (key_mgmt != WLAN_AKM_SUITE_8021X) {
 215                 ar->auth_mode = NONE_AUTH;
 216         }
 217 }
 218
 219 static bool ath6kl_cfg80211_ready(struct ath6kl *ar)
 220 {
 221         if (!test_bit(WMI_READY, &ar->flag)) {
 222                 ath6kl_err("wmi is not ready\n");
 223                 return false;
 224         }
 225
 226         if (!test_bit(WLAN_ENABLED, &ar->flag)) {
 227                 ath6kl_err("wlan disabled\n");
 228                 return false;
 229         }
 230
 231         return true;
 232 }
 233
 234 static int ath6kl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
 235                                    struct cfg80211_connect_params *sme)
 236 {
 237         struct ath6kl *ar = ath6kl_priv(dev);
 238         int status;
 239
 240         ar->sme_state = SME_CONNECTING;
 241
 242         if (!ath6kl_cfg80211_ready(ar))
 243                 return -EIO;
 244
 245         if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
 246                 ath6kl_err("destroy in progress\n");
 247                 return -EBUSY;
 248         }
 249
 250         if (test_bit(SKIP_SCAN, &ar->flag) &&
 251             ((sme->channel && sme->channel->center_freq == 0) ||
 252              (sme->bssid && is_zero_ether_addr(sme->bssid)))) {
 253                 ath6kl_err("SkipScan: channel or bssid invalid\n");
 254                 return -EINVAL;
 255         }
 256
 257         if (down_interruptible(&ar->sem)) {
 258                 ath6kl_err("busy, couldn't get access\n");
 259                 return -ERESTARTSYS;
 260         }
 261
 262         if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
 263                 ath6kl_err("busy, destroy in progress\n");
 264                 up(&ar->sem);
 265                 return -EBUSY;
 266         }
 267
 268         if (ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)]) {
 269                 /*
 270                  * sleep until the command queue drains
 271                  */
 272                 wait_event_interruptible_timeout(ar->event_wq,
 273                         ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)] == 0,
 274                         WMI_TIMEOUT);
 275                 if (signal_pending(current)) {
 276                         ath6kl_err("cmd queue drain timeout\n");
 277                         up(&ar->sem);
 278                         return -EINTR;
 279                 }
 280         }
 281
 282         if (test_bit(CONNECTED, &ar->flag) &&
 283             ar->ssid_len == sme->ssid_len &&
 284             !memcmp(ar->ssid, sme->ssid, ar->ssid_len)) {
 285                 ar->reconnect_flag = true;
 286                 status = ath6kl_wmi_reconnect_cmd(ar->wmi, ar->req_bssid,
 287                                                   ar->ch_hint);
 288
 289                 up(&ar->sem);
 290                 if (status) {
 291                         ath6kl_err("wmi_reconnect_cmd failed\n");
 292                         return -EIO;
 293                 }
 294                 return 0;
 295         } else if (ar->ssid_len == sme->ssid_len &&
 296                    !memcmp(ar->ssid, sme->ssid, ar->ssid_len)) {
 297                 ath6kl_disconnect(ar);
 298         }
 299
 300         memset(ar->ssid, 0, sizeof(ar->ssid));
 301         ar->ssid_len = sme->ssid_len;
 302         memcpy(ar->ssid, sme->ssid, sme->ssid_len);
 303
 304         if (sme->channel)
 305                 ar->ch_hint = sme->channel->center_freq;
 306
 307         memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
 308         if (sme->bssid && !is_broadcast_ether_addr(sme->bssid))
 309                 memcpy(ar->req_bssid, sme->bssid, sizeof(ar->req_bssid));
 310
 311         ath6kl_set_wpa_version(ar, sme->crypto.wpa_versions);
 312
 313         status = ath6kl_set_auth_type(ar, sme->auth_type);
 314         if (status) {
 315                 up(&ar->sem);
 316                 return status;
 317         }
 318
 319         if (sme->crypto.n_ciphers_pairwise)
 320                 ath6kl_set_cipher(ar, sme->crypto.ciphers_pairwise[0], true);
 321         else
 322                 ath6kl_set_cipher(ar, 0, true);
 323
 324         ath6kl_set_cipher(ar, sme->crypto.cipher_group, false);
 325
 326         if (sme->crypto.n_akm_suites)
 327                 ath6kl_set_key_mgmt(ar, sme->crypto.akm_suites[0]);
 328
 329         if ((sme->key_len) &&
 330             (ar->auth_mode == NONE_AUTH) && (ar->prwise_crypto == WEP_CRYPT)) {
 331                 struct ath6kl_key *key = NULL;
 332
 333                 if (sme->key_idx < WMI_MIN_KEY_INDEX ||
 334                     sme->key_idx > WMI_MAX_KEY_INDEX) {
 335                         ath6kl_err("key index %d out of bounds\n",
 336                                    sme->key_idx);
 337                         up(&ar->sem);
 338                         return -ENOENT;
 339                 }
 340
 341                 key = &ar->keys[sme->key_idx];
 342                 key->key_len = sme->key_len;
 343                 memcpy(key->key, sme->key, key->key_len);
 344                 key->cipher = ar->prwise_crypto;
 345                 ar->def_txkey_index = sme->key_idx;
 346
 347                 ath6kl_wmi_addkey_cmd(ar->wmi, sme->key_idx,
 348                                       ar->prwise_crypto,
 349                                       GROUP_USAGE | TX_USAGE,
 350                                       key->key_len,
 351                                       NULL,
 352                                       key->key, KEY_OP_INIT_VAL, NULL,
 353                                       NO_SYNC_WMIFLAG);
 354         }
 355
 356         if (!ar->usr_bss_filter) {
 357                 if (ath6kl_wmi_bssfilter_cmd(ar->wmi, ALL_BSS_FILTER, 0) != 0) {
 358                         ath6kl_err("couldn't set bss filtering\n");
 359                         up(&ar->sem);
 360                         return -EIO;
 361                 }
 362         }
 363
 364         ar->nw_type = ar->next_mode;
 365
 366         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 367                    "%s: connect called with authmode %d dot11 auth %d"
 368                    " PW crypto %d PW crypto len %d GRP crypto %d"
 369                    " GRP crypto len %d channel hint %u\n",
 370                    __func__,
 371                    ar->auth_mode, ar->dot11_auth_mode, ar->prwise_crypto,
 372                    ar->prwise_crypto_len, ar->grp_crypto,
 373                    ar->grp_crpto_len, ar->ch_hint);
 374
 375         ar->reconnect_flag = 0;
 376         status = ath6kl_wmi_connect_cmd(ar->wmi, ar->nw_type,
 377                                         ar->dot11_auth_mode, ar->auth_mode,
 378                                         ar->prwise_crypto,
 379                                         ar->prwise_crypto_len,
 380                                         ar->grp_crypto, ar->grp_crpto_len,
 381                                         ar->ssid_len, ar->ssid,
 382                                         ar->req_bssid, ar->ch_hint,
 383                                         ar->connect_ctrl_flags);
 384
 385         up(&ar->sem);
 386
 387         if (status == -EINVAL) {
 388                 memset(ar->ssid, 0, sizeof(ar->ssid));
 389                 ar->ssid_len = 0;
 390                 ath6kl_err("invalid request\n");
 391                 return -ENOENT;
 392         } else if (status) {
 393                 ath6kl_err("ath6kl_wmi_connect_cmd failed\n");
 394                 return -EIO;
 395         }
 396
 397         if ((!(ar->connect_ctrl_flags & CONNECT_DO_WPA_OFFLOAD)) &&
 398             ((ar->auth_mode == WPA_PSK_AUTH)
 399              || (ar->auth_mode == WPA2_PSK_AUTH))) {
 400                 mod_timer(&ar->disconnect_timer,
 401                           jiffies + msecs_to_jiffies(DISCON_TIMER_INTVAL));
 402         }
 403
 404         ar->connect_ctrl_flags &= ~CONNECT_DO_WPA_OFFLOAD;
 405         set_bit(CONNECT_PEND, &ar->flag);
 406
 407         return 0;
 408 }
 409
 410 void ath6kl_cfg80211_connect_event(struct ath6kl *ar, u16 channel,
 411                                    u8 *bssid, u16 listen_intvl,
 412                                    u16 beacon_intvl,
 413                                    enum network_type nw_type,
 414                                    u8 beacon_ie_len, u8 assoc_req_len,
 415                                    u8 assoc_resp_len, u8 *assoc_info)
 416 {
 417         u16 size = 0;
 418         u16 capability = 0;
 419         struct cfg80211_bss *bss = NULL;
 420         struct ieee80211_mgmt *mgmt = NULL;
 421         struct ieee80211_channel *ibss_ch = NULL;
 422         s32 signal = 50 * 100;
 423         u8 ie_buf_len = 0;
 424         unsigned char ie_buf[256];
 425         unsigned char *ptr_ie_buf = ie_buf;
 426         unsigned char *ieeemgmtbuf = NULL;
 427         u8 source_mac[ETH_ALEN];
 428         u16 capa_mask;
 429         u16 capa_val;
 430
 431         /* capinfo + listen interval */
 432         u8 assoc_req_ie_offset = sizeof(u16) + sizeof(u16);
 433
 434         /* capinfo + status code +  associd */
 435         u8 assoc_resp_ie_offset = sizeof(u16) + sizeof(u16) + sizeof(u16);
 436
 437         u8 *assoc_req_ie = assoc_info + beacon_ie_len + assoc_req_ie_offset;
 438         u8 *assoc_resp_ie = assoc_info + beacon_ie_len + assoc_req_len +
 439             assoc_resp_ie_offset;
 440
 441         assoc_req_len -= assoc_req_ie_offset;
 442         assoc_resp_len -= assoc_resp_ie_offset;
 443
 444         ar->auto_auth_stage = AUTH_IDLE;
 445
 446         if (nw_type & ADHOC_NETWORK) {
 447                 if (ar->wdev->iftype != NL80211_IFTYPE_ADHOC) {
 448                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 449                                    "%s: ath6k not in ibss mode\n", __func__);
 450                         return;
 451                 }
 452         }
 453
 454         if (nw_type & INFRA_NETWORK) {
 455                 if (ar->wdev->iftype != NL80211_IFTYPE_STATION) {
 456                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 457                                    "%s: ath6k not in station mode\n", __func__);
 458                         return;
 459                 }
 460         }
 461
 462         if (nw_type & ADHOC_NETWORK) {
 463                 capa_mask = WLAN_CAPABILITY_IBSS;
 464                 capa_val = WLAN_CAPABILITY_IBSS;
 465         } else {
 466                 capa_mask = WLAN_CAPABILITY_ESS;
 467                 capa_val = WLAN_CAPABILITY_ESS;
 468         }
 469
 470         /* Before informing the join/connect event, make sure that
 471          * bss entry is present in scan list, if it not present
 472          * construct and insert into scan list, otherwise that
 473          * event will be dropped on the way by cfg80211, due to
 474          * this keys will not be plumbed in case of WEP and
 475          * application will not be aware of join/connect status. */
 476         bss = cfg80211_get_bss(ar->wdev->wiphy, NULL, bssid,
 477                                ar->wdev->ssid, ar->wdev->ssid_len,
 478                                capa_mask, capa_val);
 479
 480         /*
 481          * Earlier we were updating the cfg about bss by making a beacon frame
 482          * only if the entry for bss is not there. This can have some issue if
 483          * ROAM event is generated and a heavy traffic is ongoing. The ROAM
 484          * event is handled through a work queue and by the time it really gets
 485          * handled, BSS would have been aged out. So it is better to update the
 486          * cfg about BSS irrespective of its entry being present right now or
 487          * not.
 488          */
 489
 490         if (nw_type & ADHOC_NETWORK) {
 491                 /* construct 802.11 mgmt beacon */
 492                 if (ptr_ie_buf) {
 493                         *ptr_ie_buf++ = WLAN_EID_SSID;
 494                         *ptr_ie_buf++ = ar->ssid_len;
 495                         memcpy(ptr_ie_buf, ar->ssid, ar->ssid_len);
 496                         ptr_ie_buf += ar->ssid_len;
 497
 498                         *ptr_ie_buf++ = WLAN_EID_IBSS_PARAMS;
 499                         *ptr_ie_buf++ = 2;      /* length */
 500                         *ptr_ie_buf++ = 0;      /* ATIM window */
 501                         *ptr_ie_buf++ = 0;      /* ATIM window */
 502
 503                         /* TODO: update ibss params and include supported rates,
 504                          * DS param set, extened support rates, wmm. */
 505
 506                         ie_buf_len = ptr_ie_buf - ie_buf;
 507                 }
 508
 509                 capability |= WLAN_CAPABILITY_IBSS;
 510
 511                 if (ar->prwise_crypto == WEP_CRYPT)
 512                         capability |= WLAN_CAPABILITY_PRIVACY;
 513
 514                 memcpy(source_mac, ar->net_dev->dev_addr, ETH_ALEN);
 515                 ptr_ie_buf = ie_buf;
 516         } else {
 517                 capability = *(u16 *) (&assoc_info[beacon_ie_len]);
 518                 memcpy(source_mac, bssid, ETH_ALEN);
 519                 ptr_ie_buf = assoc_req_ie;
 520                 ie_buf_len = assoc_req_len;
 521         }
 522
 523         size = offsetof(struct ieee80211_mgmt, u)
 524         + sizeof(mgmt->u.beacon)
 525         + ie_buf_len;
 526
 527         ieeemgmtbuf = kzalloc(size, GFP_ATOMIC);
 528         if (!ieeemgmtbuf) {
 529                 ath6kl_err("ieee mgmt buf alloc error\n");
 530                 cfg80211_put_bss(bss);
 531                 return;
 532         }
 533
 534         mgmt = (struct ieee80211_mgmt *)ieeemgmtbuf;
 535         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 536                                           IEEE80211_STYPE_BEACON);
 537         memset(mgmt->da, 0xff, ETH_ALEN);       /* broadcast addr */
 538         memcpy(mgmt->sa, source_mac, ETH_ALEN);
 539         memcpy(mgmt->bssid, bssid, ETH_ALEN);
 540         mgmt->u.beacon.beacon_int = cpu_to_le16(beacon_intvl);
 541         mgmt->u.beacon.capab_info = cpu_to_le16(capability);
 542         memcpy(mgmt->u.beacon.variable, ptr_ie_buf, ie_buf_len);
 543
 544         ibss_ch = ieee80211_get_channel(ar->wdev->wiphy, (int)channel);
 545
 546         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 547                    "%s: inform bss with bssid %pM channel %d beacon_intvl %d capability 0x%x\n",
 548                    __func__, mgmt->bssid, ibss_ch->hw_value,
 549                    beacon_intvl, capability);
 550
 551         bss = cfg80211_inform_bss_frame(ar->wdev->wiphy,
 552                                         ibss_ch, mgmt,
 553                                         size, signal, GFP_KERNEL);
 554         kfree(ieeemgmtbuf);
 555         cfg80211_put_bss(bss);
 556
 557         if (nw_type & ADHOC_NETWORK) {
 558                 cfg80211_ibss_joined(ar->net_dev, bssid, GFP_KERNEL);
 559                 return;
 560         }
 561
 562         if (!test_bit(CONNECTED, &ar->flag)) {
 563                 /* inform connect result to cfg80211 */
 564                 ar->sme_state = SME_DISCONNECTED;
 565                 cfg80211_connect_result(ar->net_dev, bssid,
 566                                         assoc_req_ie, assoc_req_len,
 567                                         assoc_resp_ie, assoc_resp_len,
 568                                         WLAN_STATUS_SUCCESS, GFP_KERNEL);
 569         } else {
 570                 /* inform roam event to cfg80211 */
 571                 cfg80211_roamed(ar->net_dev, ibss_ch, bssid,
 572                                 assoc_req_ie, assoc_req_len,
 573                                 assoc_resp_ie, assoc_resp_len, GFP_KERNEL);
 574         }
 575 }
 576
 577 static int ath6kl_cfg80211_disconnect(struct wiphy *wiphy,
 578                                       struct net_device *dev, u16 reason_code)
 579 {
 580         struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(dev);
 581
 582         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: reason=%u\n", __func__,
 583                    reason_code);
 584
 585         if (!ath6kl_cfg80211_ready(ar))
 586                 return -EIO;
 587
 588         if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
 589                 ath6kl_err("busy, destroy in progress\n");
 590                 return -EBUSY;
 591         }
 592
 593         if (down_interruptible(&ar->sem)) {
 594                 ath6kl_err("busy, couldn't get access\n");
 595                 return -ERESTARTSYS;
 596         }
 597
 598         ar->reconnect_flag = 0;
 599         ath6kl_disconnect(ar);
 600         memset(ar->ssid, 0, sizeof(ar->ssid));
 601         ar->ssid_len = 0;
 602
 603         if (!test_bit(SKIP_SCAN, &ar->flag))
 604                 memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
 605
 606         up(&ar->sem);
 607
 608         return 0;
 609 }
 610
 611 void ath6kl_cfg80211_disconnect_event(struct ath6kl *ar, u8 reason,
 612                                       u8 *bssid, u8 assoc_resp_len,
 613                                       u8 *assoc_info, u16 proto_reason)
 614 {
 615         struct ath6kl_key *key = NULL;
 616         u16 status;
 617
 618         if (ar->scan_req) {
 619                 cfg80211_scan_done(ar->scan_req, true);
 620                 ar->scan_req = NULL;
 621         }
 622
 623         if (ar->nw_type & ADHOC_NETWORK) {
 624                 if (ar->wdev->iftype != NL80211_IFTYPE_ADHOC) {
 625                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 626                                    "%s: ath6k not in ibss mode\n", __func__);
 627                         return;
 628                 }
 629                 memset(bssid, 0, ETH_ALEN);
 630                 cfg80211_ibss_joined(ar->net_dev, bssid, GFP_KERNEL);
 631                 return;
 632         }
 633
 634         if (ar->nw_type & INFRA_NETWORK) {
 635                 if (ar->wdev->iftype != NL80211_IFTYPE_STATION) {
 636                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 637                                    "%s: ath6k not in station mode\n", __func__);
 638                         return;
 639                 }
 640         }
 641
 642         if (!test_bit(CONNECT_PEND, &ar->flag)) {
 643                 if (reason != DISCONNECT_CMD)
 644                         ath6kl_wmi_disconnect_cmd(ar->wmi);
 645
 646                 return;
 647         }
 648
 649         if (reason == NO_NETWORK_AVAIL) {
 650                 /* connect cmd failed */
 651                 ath6kl_wmi_disconnect_cmd(ar->wmi);
 652                 return;
 653         }
 654
 655         if (reason != DISCONNECT_CMD)
 656                 return;
 657
 658         if (!ar->auto_auth_stage) {
 659                 clear_bit(CONNECT_PEND, &ar->flag);
 660
 661                 if (ar->sme_state == SME_CONNECTING) {
 662                         cfg80211_connect_result(ar->net_dev,
 663                                                 bssid, NULL, 0,
 664                                                 NULL, 0,
 665                                                 WLAN_STATUS_UNSPECIFIED_FAILURE,
 666                                                 GFP_KERNEL);
 667                 } else {
 668                         cfg80211_disconnected(ar->net_dev, reason,
 669                                               NULL, 0, GFP_KERNEL);
 670                 }
 671
 672                 ar->sme_state = SME_DISCONNECTED;
 673                 return;
 674         }
 675
 676         if (ar->dot11_auth_mode != OPEN_AUTH)
 677                 return;
 678
 679         /*
 680          * If the current auth algorithm is open, try shared and
 681          * make autoAuthStage idle. We do not make it leap for now
 682          * being.
 683          */
 684         key = &ar->keys[ar->def_txkey_index];
 685         if (down_interruptible(&ar->sem)) {
 686                 ath6kl_err("busy, couldn't get access\n");
 687                 return;
 688         }
 689
 690         ar->dot11_auth_mode = SHARED_AUTH;
 691         ar->auto_auth_stage = AUTH_IDLE;
 692
 693         ath6kl_wmi_addkey_cmd(ar->wmi,
 694                               ar->def_txkey_index,
 695                               ar->prwise_crypto,
 696                               GROUP_USAGE | TX_USAGE,
 697                               key->key_len, NULL,
 698                               key->key,
 699                               KEY_OP_INIT_VAL, NULL,
 700                               NO_SYNC_WMIFLAG);
 701
 702         status = ath6kl_wmi_connect_cmd(ar->wmi,
 703                                         ar->nw_type,
 704                                         ar->dot11_auth_mode,
 705                                         ar->auth_mode,
 706                                         ar->prwise_crypto,
 707                                         ar->prwise_crypto_len,
 708                                         ar->grp_crypto,
 709                                         ar->grp_crpto_len,
 710                                         ar->ssid_len,
 711                                         ar->ssid,
 712                                         ar->req_bssid,
 713                                         ar->ch_hint,
 714                                         ar->connect_ctrl_flags);
 715         up(&ar->sem);
 716 }
 717
 718 static inline bool is_ch_11a(u16 ch)
 719 {
 720         return (!((ch >= 2412) && (ch <= 2484)));
 721 }
 722
 723 /* struct ath6kl_node_table::nt_nodelock is locked when calling this */
 724 static void ath6kl_cfg80211_scan_node(void *arg, struct bss *ni)
 725 {
 726         struct wiphy *wiphy = (struct wiphy *)arg;
 727         u16 size;
 728         unsigned char *ieeemgmtbuf = NULL;
 729         struct ieee80211_mgmt *mgmt;
 730         struct ieee80211_channel *channel;
 731         struct ieee80211_supported_band *band;
 732         struct ath6kl_common_ie *cie;
 733         s32 signal;
 734         int freq;
 735
 736         cie = &ni->ni_cie;
 737
 738         if (is_ch_11a(cie->ie_chan))
 739                 band = wiphy->bands[IEEE80211_BAND_5GHZ]; /* 11a */
 740         else if ((cie->ie_erp) || (cie->ie_xrates))
 741                 band = wiphy->bands[IEEE80211_BAND_2GHZ]; /* 11g */
 742         else
 743                 band = wiphy->bands[IEEE80211_BAND_2GHZ]; /* 11b */
 744
 745         size = ni->ni_framelen + offsetof(struct ieee80211_mgmt, u);
 746         ieeemgmtbuf = kmalloc(size, GFP_ATOMIC);
 747         if (!ieeemgmtbuf) {
 748                 ath6kl_err("ieee mgmt buf alloc error\n");
 749                 return;
 750         }
 751
 752         /*
 753          * TODO: Update target to include 802.11 mac header while sending
 754          * bss info. Target removes 802.11 mac header while sending the bss
 755          * info to host, cfg80211 needs it, for time being just filling the
 756          * da, sa and bssid fields alone.
 757          */
 758         mgmt = (struct ieee80211_mgmt *)ieeemgmtbuf;
 759         memset(mgmt->da, 0xff, ETH_ALEN);       /*broadcast addr */
 760         memcpy(mgmt->sa, ni->ni_macaddr, ETH_ALEN);
 761         memcpy(mgmt->bssid, ni->ni_macaddr, ETH_ALEN);
 762         memcpy(ieeemgmtbuf + offsetof(struct ieee80211_mgmt, u),
 763                ni->ni_buf, ni->ni_framelen);
 764
 765         freq = cie->ie_chan;
 766         channel = ieee80211_get_channel(wiphy, freq);
 767         signal = ni->ni_snr * 100;
 768
 769         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 770                    "%s: bssid %pM ch %d freq %d size %d\n", __func__,
 771                    mgmt->bssid, channel->hw_value, freq, size);
 772         cfg80211_inform_bss_frame(wiphy, channel, mgmt,
 773                                   size, signal, GFP_ATOMIC);
 774
 775         kfree(ieeemgmtbuf);
 776 }
 777
 778 static int ath6kl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
 779                                 struct cfg80211_scan_request *request)
 780 {
 781         struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
 782         int ret = 0;
 783
 784         if (!ath6kl_cfg80211_ready(ar))
 785                 return -EIO;
 786
 787         if (!ar->usr_bss_filter) {
 788                 if (ath6kl_wmi_bssfilter_cmd(ar->wmi,
 789                                              (test_bit(CONNECTED, &ar->flag) ?
 790                                              ALL_BUT_BSS_FILTER :
 791                                              ALL_BSS_FILTER), 0) != 0) {
 792                         ath6kl_err("couldn't set bss filtering\n");
 793                         return -EIO;
 794                 }
 795         }
 796
 797         if (request->n_ssids && request->ssids[0].ssid_len) {
 798                 u8 i;
 799
 800                 if (request->n_ssids > (MAX_PROBED_SSID_INDEX - 1))
 801                         request->n_ssids = MAX_PROBED_SSID_INDEX - 1;
 802
 803                 for (i = 0; i < request->n_ssids; i++)
 804                         ath6kl_wmi_probedssid_cmd(ar->wmi, i + 1,
 805                                                   SPECIFIC_SSID_FLAG,
 806                                                   request->ssids[i].ssid_len,
 807                                                   request->ssids[i].ssid);
 808         }
 809
 810         if (ath6kl_wmi_startscan_cmd(ar->wmi, WMI_LONG_SCAN, 0,
 811                                      false, 0, 0, 0, NULL) != 0) {
 812                 ath6kl_err("wmi_startscan_cmd failed\n");
 813                 ret = -EIO;
 814         }
 815
 816         ar->scan_req = request;
 817
 818         return ret;
 819 }
 820
 821 void ath6kl_cfg80211_scan_complete_event(struct ath6kl *ar, int status)
 822 {
 823         int i;
 824
 825         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: status %d\n", __func__, status);
 826
 827         if (!ar->scan_req)
 828                 return;
 829
 830         if ((status == -ECANCELED) || (status == -EBUSY)) {
 831                 cfg80211_scan_done(ar->scan_req, true);
 832                 goto out;
 833         }
 834
 835         /* Translate data to cfg80211 mgmt format */
 836         wlan_iterate_nodes(&ar->scan_table, ath6kl_cfg80211_scan_node,
 837                            ar->wdev->wiphy);
 838
 839         cfg80211_scan_done(ar->scan_req, false);
 840
 841         if (ar->scan_req->n_ssids && ar->scan_req->ssids[0].ssid_len) {
 842                 for (i = 0; i < ar->scan_req->n_ssids; i++) {
 843                         ath6kl_wmi_probedssid_cmd(ar->wmi, i + 1,
 844                                                   DISABLE_SSID_FLAG,
 845                                                   0, NULL);
 846                 }
 847         }
 848
 849 out:
 850         ar->scan_req = NULL;
 851 }
 852
 853 static int ath6kl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
 854                                    u8 key_index, bool pairwise,
 855                                    const u8 *mac_addr,
 856                                    struct key_params *params)
 857 {
 858         struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
 859         struct ath6kl_key *key = NULL;
 860         u8 key_usage;
 861         u8 key_type;
 862         int status = 0;
 863
 864         if (!ath6kl_cfg80211_ready(ar))
 865                 return -EIO;
 866
 867         if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
 868                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 869                            "%s: key index %d out of bounds\n", __func__,
 870                            key_index);
 871                 return -ENOENT;
 872         }
 873
 874         key = &ar->keys[key_index];
 875         memset(key, 0, sizeof(struct ath6kl_key));
 876
 877         if (pairwise)
 878                 key_usage = PAIRWISE_USAGE;
 879         else
 880                 key_usage = GROUP_USAGE;
 881
 882         if (params) {
 883                 if (params->key_len > WLAN_MAX_KEY_LEN ||
 884                     params->seq_len > sizeof(key->seq))
 885                         return -EINVAL;
 886
 887                 key->key_len = params->key_len;
 888                 memcpy(key->key, params->key, key->key_len);
 889                 key->seq_len = params->seq_len;
 890                 memcpy(key->seq, params->seq, key->seq_len);
 891                 key->cipher = params->cipher;
 892         }
 893
 894         switch (key->cipher) {
 895         case WLAN_CIPHER_SUITE_WEP40:
 896         case WLAN_CIPHER_SUITE_WEP104:
 897                 key_type = WEP_CRYPT;
 898                 break;
 899
 900         case WLAN_CIPHER_SUITE_TKIP:
 901                 key_type = TKIP_CRYPT;
 902                 break;
 903
 904         case WLAN_CIPHER_SUITE_CCMP:
 905                 key_type = AES_CRYPT;
 906                 break;
 907
 908         default:
 909                 return -ENOTSUPP;
 910         }
 911
 912         if (((ar->auth_mode == WPA_PSK_AUTH)
 913              || (ar->auth_mode == WPA2_PSK_AUTH))
 914             && (key_usage & GROUP_USAGE))
 915                 del_timer(&ar->disconnect_timer);
 916
 917         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 918                    "%s: index %d, key_len %d, key_type 0x%x, key_usage 0x%x, seq_len %d\n",
 919                    __func__, key_index, key->key_len, key_type,
 920                    key_usage, key->seq_len);
 921
 922         ar->def_txkey_index = key_index;
 923         status = ath6kl_wmi_addkey_cmd(ar->wmi, ar->def_txkey_index,
 924                                        key_type, key_usage, key->key_len,
 925                                        key->seq, key->key, KEY_OP_INIT_VAL,
 926                                        (u8 *) mac_addr, SYNC_BOTH_WMIFLAG);
 927
 928         if (status)
 929                 return -EIO;
 930
 931         return 0;
 932 }
 933
 934 static int ath6kl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
 935                                    u8 key_index, bool pairwise,
 936                                    const u8 *mac_addr)
 937 {
 938         struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
 939
 940         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
 941
 942         if (!ath6kl_cfg80211_ready(ar))
 943                 return -EIO;
 944
 945         if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
 946                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 947                            "%s: key index %d out of bounds\n", __func__,
 948                            key_index);
 949                 return -ENOENT;
 950         }
 951
 952         if (!ar->keys[key_index].key_len) {
 953                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 954                            "%s: index %d is empty\n", __func__, key_index);
 955                 return 0;
 956         }
 957
 958         ar->keys[key_index].key_len = 0;
 959
 960         return ath6kl_wmi_deletekey_cmd(ar->wmi, key_index);
 961 }
 962
 963 static int ath6kl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
 964                                    u8 key_index, bool pairwise,
 965                                    const u8 *mac_addr, void *cookie,
 966                                    void (*callback) (void *cookie,
 967                                                      struct key_params *))
 968 {
 969         struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
 970         struct ath6kl_key *key = NULL;
 971         struct key_params params;
 972
 973         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
 974
 975         if (!ath6kl_cfg80211_ready(ar))
 976                 return -EIO;
 977
 978         if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
 979                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 980                            "%s: key index %d out of bounds\n", __func__,
 981                            key_index);
 982                 return -ENOENT;
 983         }
 984
 985         key = &ar->keys[key_index];
 986         memset(&params, 0, sizeof(params));
 987         params.cipher = key->cipher;
 988         params.key_len = key->key_len;
 989         params.seq_len = key->seq_len;
 990         params.seq = key->seq;
 991         params.key = key->key;
 992
 993         callback(cookie, &params);
 994
 995         return key->key_len ? 0 : -ENOENT;
 996 }
 997
 998 static int ath6kl_cfg80211_set_default_key(struct wiphy *wiphy,
 999                                            struct net_device *ndev,
1000                                            u8 key_index, bool unicast,
1001                                            bool multicast)
1002 {
1003         struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
1004         struct ath6kl_key *key = NULL;
1005         int status = 0;
1006         u8 key_usage;
1007
1008         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1009
1010         if (!ath6kl_cfg80211_ready(ar))
1011                 return -EIO;
1012
1013         if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
1014                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1015                            "%s: key index %d out of bounds\n",
1016                            __func__, key_index);
1017                 return -ENOENT;
1018         }
1019
1020         if (!ar->keys[key_index].key_len) {
1021                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: invalid key index %d\n",
1022                            __func__, key_index);
1023                 return -EINVAL;
1024         }
1025
1026         ar->def_txkey_index = key_index;
1027         key = &ar->keys[ar->def_txkey_index];
1028         key_usage = GROUP_USAGE;
1029         if (ar->prwise_crypto == WEP_CRYPT)
1030                 key_usage |= TX_USAGE;
1031
1032         status = ath6kl_wmi_addkey_cmd(ar->wmi, ar->def_txkey_index,
1033                                        ar->prwise_crypto, key_usage,
1034                                        key->key_len, key->seq, key->key,
1035                                        KEY_OP_INIT_VAL, NULL,
1036                                        SYNC_BOTH_WMIFLAG);
1037         if (status)
1038                 return -EIO;
1039
1040         return 0;
1041 }
1042
1043 void ath6kl_cfg80211_tkip_micerr_event(struct ath6kl *ar, u8 keyid,
1044                                        bool ismcast)
1045 {
1046         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1047                    "%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast);
1048
1049         cfg80211_michael_mic_failure(ar->net_dev, ar->bssid,
1050                                      (ismcast ? NL80211_KEYTYPE_GROUP :
1051                                       NL80211_KEYTYPE_PAIRWISE), keyid, NULL,
1052                                      GFP_KERNEL);
1053 }
1054
1055 static int ath6kl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1056 {
1057         struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1058         int ret;
1059
1060         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: changed 0x%x\n", __func__,
1061                    changed);
1062
1063         if (!ath6kl_cfg80211_ready(ar))
1064                 return -EIO;
1065
1066         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1067                 ret = ath6kl_wmi_set_rts_cmd(ar->wmi, wiphy->rts_threshold);
1068                 if (ret != 0) {
1069                         ath6kl_err("ath6kl_wmi_set_rts_cmd failed\n");
1070                         return -EIO;
1071                 }
1072         }
1073
1074         return 0;
1075 }
1076
1077 /*
1078  * The type nl80211_tx_power_setting replaces the following
1079  * data type from 2.6.36 onwards
1080 */
1081 static int ath6kl_cfg80211_set_txpower(struct wiphy *wiphy,
1082                                        enum nl80211_tx_power_setting type,
1083                                        int dbm)
1084 {
1085         struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1086         u8 ath6kl_dbm;
1087
1088         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x, dbm %d\n", __func__,
1089                    type, dbm);
1090
1091         if (!ath6kl_cfg80211_ready(ar))
1092                 return -EIO;
1093
1094         switch (type) {
1095         case NL80211_TX_POWER_AUTOMATIC:
1096                 return 0;
1097         case NL80211_TX_POWER_LIMITED:
1098                 ar->tx_pwr = ath6kl_dbm = dbm;
1099                 break;
1100         default:
1101                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x not supported\n",
1102                            __func__, type);
1103                 return -EOPNOTSUPP;
1104         }
1105
1106         ath6kl_wmi_set_tx_pwr_cmd(ar->wmi, ath6kl_dbm);
1107
1108         return 0;
1109 }
1110
1111 static int ath6kl_cfg80211_get_txpower(struct wiphy *wiphy, int *dbm)
1112 {
1113         struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1114
1115         if (!ath6kl_cfg80211_ready(ar))
1116                 return -EIO;
1117
1118         if (test_bit(CONNECTED, &ar->flag)) {
1119                 ar->tx_pwr = 0;
1120
1121                 if (ath6kl_wmi_get_tx_pwr_cmd(ar->wmi) != 0) {
1122                         ath6kl_err("ath6kl_wmi_get_tx_pwr_cmd failed\n");
1123                         return -EIO;
1124                 }
1125
1126                 wait_event_interruptible_timeout(ar->event_wq, ar->tx_pwr != 0,
1127                                                  5 * HZ);
1128
1129                 if (signal_pending(current)) {
1130                         ath6kl_err("target did not respond\n");
1131                         return -EINTR;
1132                 }
1133         }
1134
1135         *dbm = ar->tx_pwr;
1136         return 0;
1137 }
1138
1139 static int ath6kl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
1140                                           struct net_device *dev,
1141                                           bool pmgmt, int timeout)
1142 {
1143         struct ath6kl *ar = ath6kl_priv(dev);
1144         struct wmi_power_mode_cmd mode;
1145
1146         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: pmgmt %d, timeout %d\n",
1147                    __func__, pmgmt, timeout);
1148
1149         if (!ath6kl_cfg80211_ready(ar))
1150                 return -EIO;
1151
1152         if (pmgmt) {
1153                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: max perf\n", __func__);
1154                 mode.pwr_mode = REC_POWER;
1155         } else {
1156                 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\n", __func__);
1157                 mode.pwr_mode = MAX_PERF_POWER;
1158         }
1159
1160         if (ath6kl_wmi_powermode_cmd(ar->wmi, mode.pwr_mode) != 0) {
1161                 ath6kl_err("wmi_powermode_cmd failed\n");
1162                 return -EIO;
1163         }
1164
1165         return 0;
1166 }
1167
1168 static int ath6kl_cfg80211_change_iface(struct wiphy *wiphy,
1169                                         struct net_device *ndev,
1170                                         enum nl80211_iftype type, u32 *flags,
1171                                         struct vif_params *params)
1172 {
1173         struct ath6kl *ar = ath6kl_priv(ndev);
1174         struct wireless_dev *wdev = ar->wdev;
1175
1176         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type %u\n", __func__, type);
1177
1178         if (!ath6kl_cfg80211_ready(ar))
1179                 return -EIO;
1180
1181         switch (type) {
1182         case NL80211_IFTYPE_STATION:
1183                 ar->next_mode = INFRA_NETWORK;
1184                 break;
1185         case NL80211_IFTYPE_ADHOC:
1186                 ar->next_mode = ADHOC_NETWORK;
1187                 break;
1188         default:
1189                 ath6kl_err("invalid interface type %u\n", type);
1190                 return -EOPNOTSUPP;
1191         }
1192
1193         wdev->iftype = type;
1194
1195         return 0;
1196 }
1197
1198 static int ath6kl_cfg80211_join_ibss(struct wiphy *wiphy,
1199                                      struct net_device *dev,
1200                                      struct cfg80211_ibss_params *ibss_param)
1201 {
1202         struct ath6kl *ar = ath6kl_priv(dev);
1203         int status;
1204
1205         if (!ath6kl_cfg80211_ready(ar))
1206                 return -EIO;
1207
1208         ar->ssid_len = ibss_param->ssid_len;
1209         memcpy(ar->ssid, ibss_param->ssid, ar->ssid_len);
1210
1211         if (ibss_param->channel)
1212                 ar->ch_hint = ibss_param->channel->center_freq;
1213
1214         if (ibss_param->channel_fixed) {
1215                 /*
1216                  * TODO: channel_fixed: The channel should be fixed, do not
1217                  * search for IBSSs to join on other channels. Target
1218                  * firmware does not support this feature, needs to be
1219                  * updated.
1220                  */
1221                 return -EOPNOTSUPP;
1222         }
1223
1224         memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
1225         if (ibss_param->bssid && !is_broadcast_ether_addr(ibss_param->bssid))
1226                 memcpy(ar->req_bssid, ibss_param->bssid, sizeof(ar->req_bssid));
1227
1228         ath6kl_set_wpa_version(ar, 0);
1229
1230         status = ath6kl_set_auth_type(ar, NL80211_AUTHTYPE_OPEN_SYSTEM);
1231         if (status)
1232                 return status;
1233
1234         if (ibss_param->privacy) {
1235                 ath6kl_set_cipher(ar, WLAN_CIPHER_SUITE_WEP40, true);
1236                 ath6kl_set_cipher(ar, WLAN_CIPHER_SUITE_WEP40, false);
1237         } else {
1238                 ath6kl_set_cipher(ar, 0, true);
1239                 ath6kl_set_cipher(ar, 0, false);
1240         }
1241
1242         ar->nw_type = ar->next_mode;
1243
1244         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1245                    "%s: connect called with authmode %d dot11 auth %d"
1246                    " PW crypto %d PW crypto len %d GRP crypto %d"
1247                    " GRP crypto len %d channel hint %u\n",
1248                    __func__,
1249                    ar->auth_mode, ar->dot11_auth_mode, ar->prwise_crypto,
1250                    ar->prwise_crypto_len, ar->grp_crypto,
1251                    ar->grp_crpto_len, ar->ch_hint);
1252
1253         status = ath6kl_wmi_connect_cmd(ar->wmi, ar->nw_type,
1254                                         ar->dot11_auth_mode, ar->auth_mode,
1255                                         ar->prwise_crypto,
1256                                         ar->prwise_crypto_len,
1257                                         ar->grp_crypto, ar->grp_crpto_len,
1258                                         ar->ssid_len, ar->ssid,
1259                                         ar->req_bssid, ar->ch_hint,
1260                                         ar->connect_ctrl_flags);
1261         set_bit(CONNECT_PEND, &ar->flag);
1262
1263         return 0;
1264 }
1265
1266 static int ath6kl_cfg80211_leave_ibss(struct wiphy *wiphy,
1267                                       struct net_device *dev)
1268 {
1269         struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(dev);
1270
1271         if (!ath6kl_cfg80211_ready(ar))
1272                 return -EIO;
1273
1274         ath6kl_disconnect(ar);
1275         memset(ar->ssid, 0, sizeof(ar->ssid));
1276         ar->ssid_len = 0;
1277
1278         return 0;
1279 }
1280
1281 static const u32 cipher_suites[] = {
1282         WLAN_CIPHER_SUITE_WEP40,
1283         WLAN_CIPHER_SUITE_WEP104,
1284         WLAN_CIPHER_SUITE_TKIP,
1285         WLAN_CIPHER_SUITE_CCMP,
1286 };
1287
1288 static bool is_rate_legacy(s32 rate)
1289 {
1290         static const s32 legacy[] = { 1000, 2000, 5500, 11000,
1291                 6000, 9000, 12000, 18000, 24000,
1292                 36000, 48000, 54000
1293         };
1294         u8 i;
1295
1296         for (i = 0; i < ARRAY_SIZE(legacy); i++)
1297                 if (rate == legacy[i])
1298                         return true;
1299
1300         return false;
1301 }
1302
1303 static bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi)
1304 {
1305         static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000,
1306                 52000, 58500, 65000, 72200
1307         };
1308         u8 i;
1309
1310         for (i = 0; i < ARRAY_SIZE(ht20); i++) {
1311                 if (rate == ht20[i]) {
1312                         if (i == ARRAY_SIZE(ht20) - 1)
1313                                 /* last rate uses sgi */
1314                                 *sgi = true;
1315                         else
1316                                 *sgi = false;
1317
1318                         *mcs = i;
1319                         return true;
1320                 }
1321         }
1322         return false;
1323 }
1324
1325 static bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi)
1326 {
1327         static const s32 ht40[] = { 13500, 27000, 40500, 54000,
1328                 81000, 108000, 121500, 135000,
1329                 150000
1330         };
1331         u8 i;
1332
1333         for (i = 0; i < ARRAY_SIZE(ht40); i++) {
1334                 if (rate == ht40[i]) {
1335                         if (i == ARRAY_SIZE(ht40) - 1)
1336                                 /* last rate uses sgi */
1337                                 *sgi = true;
1338                         else
1339                                 *sgi = false;
1340
1341                         *mcs = i;
1342                         return true;
1343                 }
1344         }
1345
1346         return false;
1347 }
1348
1349 static int ath6kl_get_station(struct wiphy *wiphy, struct net_device *dev,
1350                               u8 *mac, struct station_info *sinfo)
1351 {
1352         struct ath6kl *ar = ath6kl_priv(dev);
1353         long left;
1354         bool sgi;
1355         s32 rate;
1356         int ret;
1357         u8 mcs;
1358
1359         if (memcmp(mac, ar->bssid, ETH_ALEN) != 0)
1360                 return -ENOENT;
1361
1362         if (down_interruptible(&ar->sem))
1363                 return -EBUSY;
1364
1365         set_bit(STATS_UPDATE_PEND, &ar->flag);
1366
1367         ret = ath6kl_wmi_get_stats_cmd(ar->wmi);
1368
1369         if (ret != 0) {
1370                 up(&ar->sem);
1371                 return -EIO;
1372         }
1373
1374         left = wait_event_interruptible_timeout(ar->event_wq,
1375                                                 !test_bit(STATS_UPDATE_PEND,
1376                                                           &ar->flag),
1377                                                 WMI_TIMEOUT);
1378
1379         up(&ar->sem);
1380
1381         if (left == 0)
1382                 return -ETIMEDOUT;
1383         else if (left < 0)
1384                 return left;
1385
1386         if (ar->target_stats.rx_byte) {
1387                 sinfo->rx_bytes = ar->target_stats.rx_byte;
1388                 sinfo->filled |= STATION_INFO_RX_BYTES;
1389                 sinfo->rx_packets = ar->target_stats.rx_pkt;
1390                 sinfo->filled |= STATION_INFO_RX_PACKETS;
1391         }
1392
1393         if (ar->target_stats.tx_byte) {
1394                 sinfo->tx_bytes = ar->target_stats.tx_byte;
1395                 sinfo->filled |= STATION_INFO_TX_BYTES;
1396                 sinfo->tx_packets = ar->target_stats.tx_pkt;
1397                 sinfo->filled |= STATION_INFO_TX_PACKETS;
1398         }
1399
1400         sinfo->signal = ar->target_stats.cs_rssi;
1401         sinfo->filled |= STATION_INFO_SIGNAL;
1402
1403         rate = ar->target_stats.tx_ucast_rate;
1404
1405         if (is_rate_legacy(rate)) {
1406                 sinfo->txrate.legacy = rate / 100;
1407         } else if (is_rate_ht20(rate, &mcs, &sgi)) {
1408                 if (sgi) {
1409                         sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1410                         sinfo->txrate.mcs = mcs - 1;
1411                 } else {
1412                         sinfo->txrate.mcs = mcs;
1413                 }
1414
1415                 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1416         } else if (is_rate_ht40(rate, &mcs, &sgi)) {
1417                 if (sgi) {
1418                         sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1419                         sinfo->txrate.mcs = mcs - 1;
1420                 } else {
1421                         sinfo->txrate.mcs = mcs;
1422                 }
1423
1424                 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
1425                 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1426         } else {
1427                 ath6kl_warn("invalid rate: %d\n", rate);
1428                 return 0;
1429         }
1430
1431         sinfo->filled |= STATION_INFO_TX_BITRATE;
1432
1433         return 0;
1434 }
1435
1436 static int ath6kl_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1437                             struct cfg80211_pmksa *pmksa)
1438 {
1439         struct ath6kl *ar = ath6kl_priv(netdev);
1440         return ath6kl_wmi_setpmkid_cmd(ar->wmi, pmksa->bssid,
1441                                        pmksa->pmkid, true);
1442 }
1443
1444 static int ath6kl_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1445                             struct cfg80211_pmksa *pmksa)
1446 {
1447         struct ath6kl *ar = ath6kl_priv(netdev);
1448         return ath6kl_wmi_setpmkid_cmd(ar->wmi, pmksa->bssid,
1449                                        pmksa->pmkid, false);
1450 }
1451
1452 static int ath6kl_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1453 {
1454         struct ath6kl *ar = ath6kl_priv(netdev);
1455         if (test_bit(CONNECTED, &ar->flag))
1456                 return ath6kl_wmi_setpmkid_cmd(ar->wmi, ar->bssid, NULL, false);
1457         return 0;
1458 }
1459
1460 static struct cfg80211_ops ath6kl_cfg80211_ops = {
1461         .change_virtual_intf = ath6kl_cfg80211_change_iface,
1462         .scan = ath6kl_cfg80211_scan,
1463         .connect = ath6kl_cfg80211_connect,
1464         .disconnect = ath6kl_cfg80211_disconnect,
1465         .add_key = ath6kl_cfg80211_add_key,
1466         .get_key = ath6kl_cfg80211_get_key,
1467         .del_key = ath6kl_cfg80211_del_key,
1468         .set_default_key = ath6kl_cfg80211_set_default_key,
1469         .set_wiphy_params = ath6kl_cfg80211_set_wiphy_params,
1470         .set_tx_power = ath6kl_cfg80211_set_txpower,
1471         .get_tx_power = ath6kl_cfg80211_get_txpower,
1472         .set_power_mgmt = ath6kl_cfg80211_set_power_mgmt,
1473         .join_ibss = ath6kl_cfg80211_join_ibss,
1474         .leave_ibss = ath6kl_cfg80211_leave_ibss,
1475         .get_station = ath6kl_get_station,
1476         .set_pmksa = ath6kl_set_pmksa,
1477         .del_pmksa = ath6kl_del_pmksa,
1478         .flush_pmksa = ath6kl_flush_pmksa,
1479 };
1480
1481 struct wireless_dev *ath6kl_cfg80211_init(struct device *dev)
1482 {
1483         int ret = 0;
1484         struct wireless_dev *wdev;
1485
1486         wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
1487         if (!wdev) {
1488                 ath6kl_err("couldn't allocate wireless device\n");
1489                 return NULL;
1490         }
1491
1492         /* create a new wiphy for use with cfg80211 */
1493         wdev->wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl));
1494         if (!wdev->wiphy) {
1495                 ath6kl_err("couldn't allocate wiphy device\n");
1496                 kfree(wdev);
1497                 return NULL;
1498         }
1499
1500         /* set device pointer for wiphy */
1501         set_wiphy_dev(wdev->wiphy, dev);
1502
1503         wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1504             BIT(NL80211_IFTYPE_ADHOC);
1505         /* max num of ssids that can be probed during scanning */
1506         wdev->wiphy->max_scan_ssids = MAX_PROBED_SSID_INDEX;
1507         wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz;
1508         wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz;
1509         wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
1510
1511         wdev->wiphy->cipher_suites = cipher_suites;
1512         wdev->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
1513
1514         ret = wiphy_register(wdev->wiphy);
1515         if (ret < 0) {
1516                 ath6kl_err("couldn't register wiphy device\n");
1517                 wiphy_free(wdev->wiphy);
1518                 kfree(wdev);
1519                 return NULL;
1520         }
1521
1522         return wdev;
1523 }
1524
1525 void ath6kl_cfg80211_deinit(struct ath6kl *ar)
1526 {
1527         struct wireless_dev *wdev = ar->wdev;
1528
1529         if (ar->scan_req) {
1530                 cfg80211_scan_done(ar->scan_req, true);
1531                 ar->scan_req = NULL;
1532         }
1533
1534         if (!wdev)
1535                 return;
1536
1537         wiphy_unregister(wdev->wiphy);
1538         wiphy_free(wdev->wiphy);
1539         kfree(wdev);
1540 }