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