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