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