cfg80211.c revision be5abaafad8090a5051355b1d224bfbae0951fc2
1/* 2 * Copyright (c) 2004-2011 Atheros Communications Inc. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17#include "core.h" 18#include "cfg80211.h" 19#include "debug.h" 20#include "hif-ops.h" 21#include "testmode.h" 22 23static unsigned int ath6kl_p2p; 24static unsigned int multi_norm_if_support; 25 26module_param(ath6kl_p2p, uint, 0644); 27module_param(multi_norm_if_support, uint, 0644); 28 29#define RATETAB_ENT(_rate, _rateid, _flags) { \ 30 .bitrate = (_rate), \ 31 .flags = (_flags), \ 32 .hw_value = (_rateid), \ 33} 34 35#define CHAN2G(_channel, _freq, _flags) { \ 36 .band = IEEE80211_BAND_2GHZ, \ 37 .hw_value = (_channel), \ 38 .center_freq = (_freq), \ 39 .flags = (_flags), \ 40 .max_antenna_gain = 0, \ 41 .max_power = 30, \ 42} 43 44#define CHAN5G(_channel, _flags) { \ 45 .band = IEEE80211_BAND_5GHZ, \ 46 .hw_value = (_channel), \ 47 .center_freq = 5000 + (5 * (_channel)), \ 48 .flags = (_flags), \ 49 .max_antenna_gain = 0, \ 50 .max_power = 30, \ 51} 52 53static struct ieee80211_rate ath6kl_rates[] = { 54 RATETAB_ENT(10, 0x1, 0), 55 RATETAB_ENT(20, 0x2, 0), 56 RATETAB_ENT(55, 0x4, 0), 57 RATETAB_ENT(110, 0x8, 0), 58 RATETAB_ENT(60, 0x10, 0), 59 RATETAB_ENT(90, 0x20, 0), 60 RATETAB_ENT(120, 0x40, 0), 61 RATETAB_ENT(180, 0x80, 0), 62 RATETAB_ENT(240, 0x100, 0), 63 RATETAB_ENT(360, 0x200, 0), 64 RATETAB_ENT(480, 0x400, 0), 65 RATETAB_ENT(540, 0x800, 0), 66}; 67 68#define ath6kl_a_rates (ath6kl_rates + 4) 69#define ath6kl_a_rates_size 8 70#define ath6kl_g_rates (ath6kl_rates + 0) 71#define ath6kl_g_rates_size 12 72 73static struct ieee80211_channel ath6kl_2ghz_channels[] = { 74 CHAN2G(1, 2412, 0), 75 CHAN2G(2, 2417, 0), 76 CHAN2G(3, 2422, 0), 77 CHAN2G(4, 2427, 0), 78 CHAN2G(5, 2432, 0), 79 CHAN2G(6, 2437, 0), 80 CHAN2G(7, 2442, 0), 81 CHAN2G(8, 2447, 0), 82 CHAN2G(9, 2452, 0), 83 CHAN2G(10, 2457, 0), 84 CHAN2G(11, 2462, 0), 85 CHAN2G(12, 2467, 0), 86 CHAN2G(13, 2472, 0), 87 CHAN2G(14, 2484, 0), 88}; 89 90static struct ieee80211_channel ath6kl_5ghz_a_channels[] = { 91 CHAN5G(34, 0), CHAN5G(36, 0), 92 CHAN5G(38, 0), CHAN5G(40, 0), 93 CHAN5G(42, 0), CHAN5G(44, 0), 94 CHAN5G(46, 0), CHAN5G(48, 0), 95 CHAN5G(52, 0), CHAN5G(56, 0), 96 CHAN5G(60, 0), CHAN5G(64, 0), 97 CHAN5G(100, 0), CHAN5G(104, 0), 98 CHAN5G(108, 0), CHAN5G(112, 0), 99 CHAN5G(116, 0), CHAN5G(120, 0), 100 CHAN5G(124, 0), CHAN5G(128, 0), 101 CHAN5G(132, 0), CHAN5G(136, 0), 102 CHAN5G(140, 0), CHAN5G(149, 0), 103 CHAN5G(153, 0), CHAN5G(157, 0), 104 CHAN5G(161, 0), CHAN5G(165, 0), 105 CHAN5G(184, 0), CHAN5G(188, 0), 106 CHAN5G(192, 0), CHAN5G(196, 0), 107 CHAN5G(200, 0), CHAN5G(204, 0), 108 CHAN5G(208, 0), CHAN5G(212, 0), 109 CHAN5G(216, 0), 110}; 111 112static struct ieee80211_supported_band ath6kl_band_2ghz = { 113 .n_channels = ARRAY_SIZE(ath6kl_2ghz_channels), 114 .channels = ath6kl_2ghz_channels, 115 .n_bitrates = ath6kl_g_rates_size, 116 .bitrates = ath6kl_g_rates, 117}; 118 119static struct ieee80211_supported_band ath6kl_band_5ghz = { 120 .n_channels = ARRAY_SIZE(ath6kl_5ghz_a_channels), 121 .channels = ath6kl_5ghz_a_channels, 122 .n_bitrates = ath6kl_a_rates_size, 123 .bitrates = ath6kl_a_rates, 124}; 125 126#define CCKM_KRK_CIPHER_SUITE 0x004096ff /* use for KRK */ 127 128static int ath6kl_set_wpa_version(struct ath6kl_vif *vif, 129 enum nl80211_wpa_versions wpa_version) 130{ 131 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version); 132 133 if (!wpa_version) { 134 vif->auth_mode = NONE_AUTH; 135 } else if (wpa_version & NL80211_WPA_VERSION_2) { 136 vif->auth_mode = WPA2_AUTH; 137 } else if (wpa_version & NL80211_WPA_VERSION_1) { 138 vif->auth_mode = WPA_AUTH; 139 } else { 140 ath6kl_err("%s: %u not supported\n", __func__, wpa_version); 141 return -ENOTSUPP; 142 } 143 144 return 0; 145} 146 147static int ath6kl_set_auth_type(struct ath6kl_vif *vif, 148 enum nl80211_auth_type auth_type) 149{ 150 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type); 151 152 switch (auth_type) { 153 case NL80211_AUTHTYPE_OPEN_SYSTEM: 154 vif->dot11_auth_mode = OPEN_AUTH; 155 break; 156 case NL80211_AUTHTYPE_SHARED_KEY: 157 vif->dot11_auth_mode = SHARED_AUTH; 158 break; 159 case NL80211_AUTHTYPE_NETWORK_EAP: 160 vif->dot11_auth_mode = LEAP_AUTH; 161 break; 162 163 case NL80211_AUTHTYPE_AUTOMATIC: 164 vif->dot11_auth_mode = OPEN_AUTH | SHARED_AUTH; 165 break; 166 167 default: 168 ath6kl_err("%s: 0x%x not spported\n", __func__, auth_type); 169 return -ENOTSUPP; 170 } 171 172 return 0; 173} 174 175static int ath6kl_set_cipher(struct ath6kl_vif *vif, u32 cipher, bool ucast) 176{ 177 u8 *ar_cipher = ucast ? &vif->prwise_crypto : &vif->grp_crypto; 178 u8 *ar_cipher_len = ucast ? &vif->prwise_crypto_len : 179 &vif->grp_crypto_len; 180 181 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n", 182 __func__, cipher, ucast); 183 184 switch (cipher) { 185 case 0: 186 /* our own hack to use value 0 as no crypto used */ 187 *ar_cipher = NONE_CRYPT; 188 *ar_cipher_len = 0; 189 break; 190 case WLAN_CIPHER_SUITE_WEP40: 191 *ar_cipher = WEP_CRYPT; 192 *ar_cipher_len = 5; 193 break; 194 case WLAN_CIPHER_SUITE_WEP104: 195 *ar_cipher = WEP_CRYPT; 196 *ar_cipher_len = 13; 197 break; 198 case WLAN_CIPHER_SUITE_TKIP: 199 *ar_cipher = TKIP_CRYPT; 200 *ar_cipher_len = 0; 201 break; 202 case WLAN_CIPHER_SUITE_CCMP: 203 *ar_cipher = AES_CRYPT; 204 *ar_cipher_len = 0; 205 break; 206 case WLAN_CIPHER_SUITE_SMS4: 207 *ar_cipher = WAPI_CRYPT; 208 *ar_cipher_len = 0; 209 break; 210 default: 211 ath6kl_err("cipher 0x%x not supported\n", cipher); 212 return -ENOTSUPP; 213 } 214 215 return 0; 216} 217 218static void ath6kl_set_key_mgmt(struct ath6kl_vif *vif, u32 key_mgmt) 219{ 220 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt); 221 222 if (key_mgmt == WLAN_AKM_SUITE_PSK) { 223 if (vif->auth_mode == WPA_AUTH) 224 vif->auth_mode = WPA_PSK_AUTH; 225 else if (vif->auth_mode == WPA2_AUTH) 226 vif->auth_mode = WPA2_PSK_AUTH; 227 } else if (key_mgmt == 0x00409600) { 228 if (vif->auth_mode == WPA_AUTH) 229 vif->auth_mode = WPA_AUTH_CCKM; 230 else if (vif->auth_mode == WPA2_AUTH) 231 vif->auth_mode = WPA2_AUTH_CCKM; 232 } else if (key_mgmt != WLAN_AKM_SUITE_8021X) { 233 vif->auth_mode = NONE_AUTH; 234 } 235} 236 237static bool ath6kl_cfg80211_ready(struct ath6kl_vif *vif) 238{ 239 struct ath6kl *ar = vif->ar; 240 241 if (!test_bit(WMI_READY, &ar->flag)) { 242 ath6kl_err("wmi is not ready\n"); 243 return false; 244 } 245 246 if (!test_bit(WLAN_ENABLED, &vif->flags)) { 247 ath6kl_err("wlan disabled\n"); 248 return false; 249 } 250 251 return true; 252} 253 254static bool ath6kl_is_wpa_ie(const u8 *pos) 255{ 256 return pos[0] == WLAN_EID_WPA && pos[1] >= 4 && 257 pos[2] == 0x00 && pos[3] == 0x50 && 258 pos[4] == 0xf2 && pos[5] == 0x01; 259} 260 261static bool ath6kl_is_rsn_ie(const u8 *pos) 262{ 263 return pos[0] == WLAN_EID_RSN; 264} 265 266static bool ath6kl_is_wps_ie(const u8 *pos) 267{ 268 return (pos[0] == WLAN_EID_VENDOR_SPECIFIC && 269 pos[1] >= 4 && 270 pos[2] == 0x00 && pos[3] == 0x50 && pos[4] == 0xf2 && 271 pos[5] == 0x04); 272} 273 274static int ath6kl_set_assoc_req_ies(struct ath6kl_vif *vif, const u8 *ies, 275 size_t ies_len) 276{ 277 struct ath6kl *ar = vif->ar; 278 const u8 *pos; 279 u8 *buf = NULL; 280 size_t len = 0; 281 int ret; 282 283 /* 284 * Clear previously set flag 285 */ 286 287 ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG; 288 289 /* 290 * Filter out RSN/WPA IE(s) 291 */ 292 293 if (ies && ies_len) { 294 buf = kmalloc(ies_len, GFP_KERNEL); 295 if (buf == NULL) 296 return -ENOMEM; 297 pos = ies; 298 299 while (pos + 1 < ies + ies_len) { 300 if (pos + 2 + pos[1] > ies + ies_len) 301 break; 302 if (!(ath6kl_is_wpa_ie(pos) || ath6kl_is_rsn_ie(pos))) { 303 memcpy(buf + len, pos, 2 + pos[1]); 304 len += 2 + pos[1]; 305 } 306 307 if (ath6kl_is_wps_ie(pos)) 308 ar->connect_ctrl_flags |= CONNECT_WPS_FLAG; 309 310 pos += 2 + pos[1]; 311 } 312 } 313 314 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx, 315 WMI_FRAME_ASSOC_REQ, buf, len); 316 kfree(buf); 317 return ret; 318} 319 320static int ath6kl_nliftype_to_drv_iftype(enum nl80211_iftype type, u8 *nw_type) 321{ 322 switch (type) { 323 case NL80211_IFTYPE_STATION: 324 *nw_type = INFRA_NETWORK; 325 break; 326 case NL80211_IFTYPE_ADHOC: 327 *nw_type = ADHOC_NETWORK; 328 break; 329 case NL80211_IFTYPE_AP: 330 *nw_type = AP_NETWORK; 331 break; 332 case NL80211_IFTYPE_P2P_CLIENT: 333 *nw_type = INFRA_NETWORK; 334 break; 335 case NL80211_IFTYPE_P2P_GO: 336 *nw_type = AP_NETWORK; 337 break; 338 default: 339 ath6kl_err("invalid interface type %u\n", type); 340 return -ENOTSUPP; 341 } 342 343 return 0; 344} 345 346static bool ath6kl_is_valid_iftype(struct ath6kl *ar, enum nl80211_iftype type, 347 u8 *if_idx, u8 *nw_type) 348{ 349 int i; 350 351 if (ath6kl_nliftype_to_drv_iftype(type, nw_type)) 352 return false; 353 354 if (ar->ibss_if_active || ((type == NL80211_IFTYPE_ADHOC) && 355 ar->num_vif)) 356 return false; 357 358 if (type == NL80211_IFTYPE_STATION || 359 type == NL80211_IFTYPE_AP || type == NL80211_IFTYPE_ADHOC) { 360 for (i = 0; i < MAX_NUM_VIF; i++) { 361 if ((ar->avail_idx_map >> i) & BIT(0)) { 362 *if_idx = i; 363 return true; 364 } 365 } 366 } 367 368 if (type == NL80211_IFTYPE_P2P_CLIENT || 369 type == NL80211_IFTYPE_P2P_GO) { 370 for (i = ar->max_norm_iface; i < MAX_NUM_VIF; i++) { 371 if ((ar->avail_idx_map >> i) & BIT(0)) { 372 *if_idx = i; 373 return true; 374 } 375 } 376 } 377 378 return false; 379} 380 381static int ath6kl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev, 382 struct cfg80211_connect_params *sme) 383{ 384 struct ath6kl *ar = ath6kl_priv(dev); 385 struct ath6kl_vif *vif = netdev_priv(dev); 386 int status; 387 388 vif->sme_state = SME_CONNECTING; 389 390 if (!ath6kl_cfg80211_ready(vif)) 391 return -EIO; 392 393 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) { 394 ath6kl_err("destroy in progress\n"); 395 return -EBUSY; 396 } 397 398 if (test_bit(SKIP_SCAN, &ar->flag) && 399 ((sme->channel && sme->channel->center_freq == 0) || 400 (sme->bssid && is_zero_ether_addr(sme->bssid)))) { 401 ath6kl_err("SkipScan: channel or bssid invalid\n"); 402 return -EINVAL; 403 } 404 405 if (down_interruptible(&ar->sem)) { 406 ath6kl_err("busy, couldn't get access\n"); 407 return -ERESTARTSYS; 408 } 409 410 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) { 411 ath6kl_err("busy, destroy in progress\n"); 412 up(&ar->sem); 413 return -EBUSY; 414 } 415 416 if (ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)]) { 417 /* 418 * sleep until the command queue drains 419 */ 420 wait_event_interruptible_timeout(ar->event_wq, 421 ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)] == 0, 422 WMI_TIMEOUT); 423 if (signal_pending(current)) { 424 ath6kl_err("cmd queue drain timeout\n"); 425 up(&ar->sem); 426 return -EINTR; 427 } 428 } 429 430 if (sme->ie && (sme->ie_len > 0)) { 431 status = ath6kl_set_assoc_req_ies(vif, sme->ie, sme->ie_len); 432 if (status) 433 return status; 434 } 435 436 if (test_bit(CONNECTED, &vif->flags) && 437 vif->ssid_len == sme->ssid_len && 438 !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) { 439 vif->reconnect_flag = true; 440 status = ath6kl_wmi_reconnect_cmd(ar->wmi, vif->fw_vif_idx, 441 vif->req_bssid, 442 vif->ch_hint); 443 444 up(&ar->sem); 445 if (status) { 446 ath6kl_err("wmi_reconnect_cmd failed\n"); 447 return -EIO; 448 } 449 return 0; 450 } else if (vif->ssid_len == sme->ssid_len && 451 !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) { 452 ath6kl_disconnect(vif); 453 } 454 455 memset(vif->ssid, 0, sizeof(vif->ssid)); 456 vif->ssid_len = sme->ssid_len; 457 memcpy(vif->ssid, sme->ssid, sme->ssid_len); 458 459 if (sme->channel) 460 vif->ch_hint = sme->channel->center_freq; 461 462 memset(vif->req_bssid, 0, sizeof(vif->req_bssid)); 463 if (sme->bssid && !is_broadcast_ether_addr(sme->bssid)) 464 memcpy(vif->req_bssid, sme->bssid, sizeof(vif->req_bssid)); 465 466 ath6kl_set_wpa_version(vif, sme->crypto.wpa_versions); 467 468 status = ath6kl_set_auth_type(vif, sme->auth_type); 469 if (status) { 470 up(&ar->sem); 471 return status; 472 } 473 474 if (sme->crypto.n_ciphers_pairwise) 475 ath6kl_set_cipher(vif, sme->crypto.ciphers_pairwise[0], true); 476 else 477 ath6kl_set_cipher(vif, 0, true); 478 479 ath6kl_set_cipher(vif, sme->crypto.cipher_group, false); 480 481 if (sme->crypto.n_akm_suites) 482 ath6kl_set_key_mgmt(vif, sme->crypto.akm_suites[0]); 483 484 if ((sme->key_len) && 485 (vif->auth_mode == NONE_AUTH) && 486 (vif->prwise_crypto == WEP_CRYPT)) { 487 struct ath6kl_key *key = NULL; 488 489 if (sme->key_idx < WMI_MIN_KEY_INDEX || 490 sme->key_idx > WMI_MAX_KEY_INDEX) { 491 ath6kl_err("key index %d out of bounds\n", 492 sme->key_idx); 493 up(&ar->sem); 494 return -ENOENT; 495 } 496 497 key = &vif->keys[sme->key_idx]; 498 key->key_len = sme->key_len; 499 memcpy(key->key, sme->key, key->key_len); 500 key->cipher = vif->prwise_crypto; 501 vif->def_txkey_index = sme->key_idx; 502 503 ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, sme->key_idx, 504 vif->prwise_crypto, 505 GROUP_USAGE | TX_USAGE, 506 key->key_len, 507 NULL, 0, 508 key->key, KEY_OP_INIT_VAL, NULL, 509 NO_SYNC_WMIFLAG); 510 } 511 512 if (!ar->usr_bss_filter) { 513 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags); 514 if (ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx, 515 ALL_BSS_FILTER, 0) != 0) { 516 ath6kl_err("couldn't set bss filtering\n"); 517 up(&ar->sem); 518 return -EIO; 519 } 520 } 521 522 vif->nw_type = vif->next_mode; 523 524 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 525 "%s: connect called with authmode %d dot11 auth %d" 526 " PW crypto %d PW crypto len %d GRP crypto %d" 527 " GRP crypto len %d channel hint %u\n", 528 __func__, 529 vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto, 530 vif->prwise_crypto_len, vif->grp_crypto, 531 vif->grp_crypto_len, vif->ch_hint); 532 533 vif->reconnect_flag = 0; 534 status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type, 535 vif->dot11_auth_mode, vif->auth_mode, 536 vif->prwise_crypto, 537 vif->prwise_crypto_len, 538 vif->grp_crypto, vif->grp_crypto_len, 539 vif->ssid_len, vif->ssid, 540 vif->req_bssid, vif->ch_hint, 541 ar->connect_ctrl_flags); 542 543 up(&ar->sem); 544 545 if (status == -EINVAL) { 546 memset(vif->ssid, 0, sizeof(vif->ssid)); 547 vif->ssid_len = 0; 548 ath6kl_err("invalid request\n"); 549 return -ENOENT; 550 } else if (status) { 551 ath6kl_err("ath6kl_wmi_connect_cmd failed\n"); 552 return -EIO; 553 } 554 555 if ((!(ar->connect_ctrl_flags & CONNECT_DO_WPA_OFFLOAD)) && 556 ((vif->auth_mode == WPA_PSK_AUTH) 557 || (vif->auth_mode == WPA2_PSK_AUTH))) { 558 mod_timer(&vif->disconnect_timer, 559 jiffies + msecs_to_jiffies(DISCON_TIMER_INTVAL)); 560 } 561 562 ar->connect_ctrl_flags &= ~CONNECT_DO_WPA_OFFLOAD; 563 set_bit(CONNECT_PEND, &vif->flags); 564 565 return 0; 566} 567 568static int ath6kl_add_bss_if_needed(struct ath6kl_vif *vif, 569 enum network_type nw_type, 570 const u8 *bssid, 571 struct ieee80211_channel *chan, 572 const u8 *beacon_ie, size_t beacon_ie_len) 573{ 574 struct ath6kl *ar = vif->ar; 575 struct cfg80211_bss *bss; 576 u16 cap_mask, cap_val; 577 u8 *ie; 578 579 if (nw_type & ADHOC_NETWORK) { 580 cap_mask = WLAN_CAPABILITY_IBSS; 581 cap_val = WLAN_CAPABILITY_IBSS; 582 } else { 583 cap_mask = WLAN_CAPABILITY_ESS; 584 cap_val = WLAN_CAPABILITY_ESS; 585 } 586 587 bss = cfg80211_get_bss(ar->wiphy, chan, bssid, 588 vif->ssid, vif->ssid_len, 589 cap_mask, cap_val); 590 if (bss == NULL) { 591 /* 592 * Since cfg80211 may not yet know about the BSS, 593 * generate a partial entry until the first BSS info 594 * event becomes available. 595 * 596 * Prepend SSID element since it is not included in the Beacon 597 * IEs from the target. 598 */ 599 ie = kmalloc(2 + vif->ssid_len + beacon_ie_len, GFP_KERNEL); 600 if (ie == NULL) 601 return -ENOMEM; 602 ie[0] = WLAN_EID_SSID; 603 ie[1] = vif->ssid_len; 604 memcpy(ie + 2, vif->ssid, vif->ssid_len); 605 memcpy(ie + 2 + vif->ssid_len, beacon_ie, beacon_ie_len); 606 bss = cfg80211_inform_bss(ar->wiphy, chan, 607 bssid, 0, cap_val, 100, 608 ie, 2 + vif->ssid_len + beacon_ie_len, 609 0, GFP_KERNEL); 610 if (bss) 611 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "added bss %pM to " 612 "cfg80211\n", bssid); 613 kfree(ie); 614 } else 615 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "cfg80211 already has a bss " 616 "entry\n"); 617 618 if (bss == NULL) 619 return -ENOMEM; 620 621 cfg80211_put_bss(bss); 622 623 return 0; 624} 625 626void ath6kl_cfg80211_connect_event(struct ath6kl_vif *vif, u16 channel, 627 u8 *bssid, u16 listen_intvl, 628 u16 beacon_intvl, 629 enum network_type nw_type, 630 u8 beacon_ie_len, u8 assoc_req_len, 631 u8 assoc_resp_len, u8 *assoc_info) 632{ 633 struct ieee80211_channel *chan; 634 struct ath6kl *ar = vif->ar; 635 636 /* capinfo + listen interval */ 637 u8 assoc_req_ie_offset = sizeof(u16) + sizeof(u16); 638 639 /* capinfo + status code + associd */ 640 u8 assoc_resp_ie_offset = sizeof(u16) + sizeof(u16) + sizeof(u16); 641 642 u8 *assoc_req_ie = assoc_info + beacon_ie_len + assoc_req_ie_offset; 643 u8 *assoc_resp_ie = assoc_info + beacon_ie_len + assoc_req_len + 644 assoc_resp_ie_offset; 645 646 assoc_req_len -= assoc_req_ie_offset; 647 assoc_resp_len -= assoc_resp_ie_offset; 648 649 /* 650 * Store Beacon interval here; DTIM period will be available only once 651 * a Beacon frame from the AP is seen. 652 */ 653 vif->assoc_bss_beacon_int = beacon_intvl; 654 clear_bit(DTIM_PERIOD_AVAIL, &vif->flags); 655 656 if (nw_type & ADHOC_NETWORK) { 657 if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) { 658 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 659 "%s: ath6k not in ibss mode\n", __func__); 660 return; 661 } 662 } 663 664 if (nw_type & INFRA_NETWORK) { 665 if (vif->wdev.iftype != NL80211_IFTYPE_STATION && 666 vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) { 667 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 668 "%s: ath6k not in station mode\n", __func__); 669 return; 670 } 671 } 672 673 chan = ieee80211_get_channel(ar->wiphy, (int) channel); 674 675 if (ath6kl_add_bss_if_needed(vif, nw_type, bssid, chan, assoc_info, 676 beacon_ie_len) < 0) { 677 ath6kl_err("could not add cfg80211 bss entry\n"); 678 return; 679 } 680 681 if (nw_type & ADHOC_NETWORK) { 682 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "ad-hoc %s selected\n", 683 nw_type & ADHOC_CREATOR ? "creator" : "joiner"); 684 cfg80211_ibss_joined(vif->ndev, bssid, GFP_KERNEL); 685 return; 686 } 687 688 if (vif->sme_state == SME_CONNECTING) { 689 /* inform connect result to cfg80211 */ 690 vif->sme_state = SME_CONNECTED; 691 cfg80211_connect_result(vif->ndev, bssid, 692 assoc_req_ie, assoc_req_len, 693 assoc_resp_ie, assoc_resp_len, 694 WLAN_STATUS_SUCCESS, GFP_KERNEL); 695 } else if (vif->sme_state == SME_CONNECTED) { 696 /* inform roam event to cfg80211 */ 697 cfg80211_roamed(vif->ndev, chan, bssid, 698 assoc_req_ie, assoc_req_len, 699 assoc_resp_ie, assoc_resp_len, GFP_KERNEL); 700 } 701} 702 703static int ath6kl_cfg80211_disconnect(struct wiphy *wiphy, 704 struct net_device *dev, u16 reason_code) 705{ 706 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(dev); 707 struct ath6kl_vif *vif = netdev_priv(dev); 708 709 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: reason=%u\n", __func__, 710 reason_code); 711 712 if (!ath6kl_cfg80211_ready(vif)) 713 return -EIO; 714 715 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) { 716 ath6kl_err("busy, destroy in progress\n"); 717 return -EBUSY; 718 } 719 720 if (down_interruptible(&ar->sem)) { 721 ath6kl_err("busy, couldn't get access\n"); 722 return -ERESTARTSYS; 723 } 724 725 vif->reconnect_flag = 0; 726 ath6kl_disconnect(vif); 727 memset(vif->ssid, 0, sizeof(vif->ssid)); 728 vif->ssid_len = 0; 729 730 if (!test_bit(SKIP_SCAN, &ar->flag)) 731 memset(vif->req_bssid, 0, sizeof(vif->req_bssid)); 732 733 up(&ar->sem); 734 735 vif->sme_state = SME_DISCONNECTED; 736 737 return 0; 738} 739 740void ath6kl_cfg80211_disconnect_event(struct ath6kl_vif *vif, u8 reason, 741 u8 *bssid, u8 assoc_resp_len, 742 u8 *assoc_info, u16 proto_reason) 743{ 744 struct ath6kl *ar = vif->ar; 745 746 if (vif->scan_req) { 747 cfg80211_scan_done(vif->scan_req, true); 748 vif->scan_req = NULL; 749 } 750 751 if (vif->nw_type & ADHOC_NETWORK) { 752 if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) { 753 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 754 "%s: ath6k not in ibss mode\n", __func__); 755 return; 756 } 757 memset(bssid, 0, ETH_ALEN); 758 cfg80211_ibss_joined(vif->ndev, bssid, GFP_KERNEL); 759 return; 760 } 761 762 if (vif->nw_type & INFRA_NETWORK) { 763 if (vif->wdev.iftype != NL80211_IFTYPE_STATION && 764 vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) { 765 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 766 "%s: ath6k not in station mode\n", __func__); 767 return; 768 } 769 } 770 771 /* 772 * Send a disconnect command to target when a disconnect event is 773 * received with reason code other than 3 (DISCONNECT_CMD - disconnect 774 * request from host) to make the firmware stop trying to connect even 775 * after giving disconnect event. There will be one more disconnect 776 * event for this disconnect command with reason code DISCONNECT_CMD 777 * which will be notified to cfg80211. 778 */ 779 780 if (reason != DISCONNECT_CMD) { 781 ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx); 782 return; 783 } 784 785 clear_bit(CONNECT_PEND, &vif->flags); 786 787 if (vif->sme_state == SME_CONNECTING) { 788 cfg80211_connect_result(vif->ndev, 789 bssid, NULL, 0, 790 NULL, 0, 791 WLAN_STATUS_UNSPECIFIED_FAILURE, 792 GFP_KERNEL); 793 } else if (vif->sme_state == SME_CONNECTED) { 794 cfg80211_disconnected(vif->ndev, reason, 795 NULL, 0, GFP_KERNEL); 796 } 797 798 vif->sme_state = SME_DISCONNECTED; 799} 800 801static int ath6kl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev, 802 struct cfg80211_scan_request *request) 803{ 804 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev); 805 struct ath6kl_vif *vif = netdev_priv(ndev); 806 s8 n_channels = 0; 807 u16 *channels = NULL; 808 int ret = 0; 809 u32 force_fg_scan = 0; 810 811 if (!ath6kl_cfg80211_ready(vif)) 812 return -EIO; 813 814 if (!ar->usr_bss_filter) { 815 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags); 816 ret = ath6kl_wmi_bssfilter_cmd( 817 ar->wmi, vif->fw_vif_idx, 818 (test_bit(CONNECTED, &vif->flags) ? 819 ALL_BUT_BSS_FILTER : ALL_BSS_FILTER), 0); 820 if (ret) { 821 ath6kl_err("couldn't set bss filtering\n"); 822 return ret; 823 } 824 } 825 826 if (request->n_ssids && request->ssids[0].ssid_len) { 827 u8 i; 828 829 if (request->n_ssids > (MAX_PROBED_SSID_INDEX - 1)) 830 request->n_ssids = MAX_PROBED_SSID_INDEX - 1; 831 832 for (i = 0; i < request->n_ssids; i++) 833 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, 834 i + 1, SPECIFIC_SSID_FLAG, 835 request->ssids[i].ssid_len, 836 request->ssids[i].ssid); 837 } 838 839 if (request->ie) { 840 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx, 841 WMI_FRAME_PROBE_REQ, 842 request->ie, request->ie_len); 843 if (ret) { 844 ath6kl_err("failed to set Probe Request appie for " 845 "scan"); 846 return ret; 847 } 848 } 849 850 /* 851 * Scan only the requested channels if the request specifies a set of 852 * channels. If the list is longer than the target supports, do not 853 * configure the list and instead, scan all available channels. 854 */ 855 if (request->n_channels > 0 && 856 request->n_channels <= WMI_MAX_CHANNELS) { 857 u8 i; 858 859 n_channels = request->n_channels; 860 861 channels = kzalloc(n_channels * sizeof(u16), GFP_KERNEL); 862 if (channels == NULL) { 863 ath6kl_warn("failed to set scan channels, " 864 "scan all channels"); 865 n_channels = 0; 866 } 867 868 for (i = 0; i < n_channels; i++) 869 channels[i] = request->channels[i]->center_freq; 870 } 871 872 if (test_bit(CONNECTED, &vif->flags)) 873 force_fg_scan = 1; 874 875 ret = ath6kl_wmi_startscan_cmd(ar->wmi, vif->fw_vif_idx, WMI_LONG_SCAN, 876 force_fg_scan, false, 0, 0, n_channels, 877 channels); 878 if (ret) 879 ath6kl_err("wmi_startscan_cmd failed\n"); 880 else 881 vif->scan_req = request; 882 883 kfree(channels); 884 885 return ret; 886} 887 888void ath6kl_cfg80211_scan_complete_event(struct ath6kl_vif *vif, bool aborted) 889{ 890 struct ath6kl *ar = vif->ar; 891 int i; 892 893 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: status%s\n", __func__, 894 aborted ? " aborted" : ""); 895 896 if (!vif->scan_req) 897 return; 898 899 if (aborted) 900 goto out; 901 902 if (vif->scan_req->n_ssids && vif->scan_req->ssids[0].ssid_len) { 903 for (i = 0; i < vif->scan_req->n_ssids; i++) { 904 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, 905 i + 1, DISABLE_SSID_FLAG, 906 0, NULL); 907 } 908 } 909 910out: 911 cfg80211_scan_done(vif->scan_req, aborted); 912 vif->scan_req = NULL; 913} 914 915static int ath6kl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev, 916 u8 key_index, bool pairwise, 917 const u8 *mac_addr, 918 struct key_params *params) 919{ 920 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev); 921 struct ath6kl_vif *vif = netdev_priv(ndev); 922 struct ath6kl_key *key = NULL; 923 u8 key_usage; 924 u8 key_type; 925 926 if (!ath6kl_cfg80211_ready(vif)) 927 return -EIO; 928 929 if (params->cipher == CCKM_KRK_CIPHER_SUITE) { 930 if (params->key_len != WMI_KRK_LEN) 931 return -EINVAL; 932 return ath6kl_wmi_add_krk_cmd(ar->wmi, vif->fw_vif_idx, 933 params->key); 934 } 935 936 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) { 937 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 938 "%s: key index %d out of bounds\n", __func__, 939 key_index); 940 return -ENOENT; 941 } 942 943 key = &vif->keys[key_index]; 944 memset(key, 0, sizeof(struct ath6kl_key)); 945 946 if (pairwise) 947 key_usage = PAIRWISE_USAGE; 948 else 949 key_usage = GROUP_USAGE; 950 951 if (params) { 952 int seq_len = params->seq_len; 953 if (params->cipher == WLAN_CIPHER_SUITE_SMS4 && 954 seq_len > ATH6KL_KEY_SEQ_LEN) { 955 /* Only first half of the WPI PN is configured */ 956 seq_len = ATH6KL_KEY_SEQ_LEN; 957 } 958 if (params->key_len > WLAN_MAX_KEY_LEN || 959 seq_len > sizeof(key->seq)) 960 return -EINVAL; 961 962 key->key_len = params->key_len; 963 memcpy(key->key, params->key, key->key_len); 964 key->seq_len = seq_len; 965 memcpy(key->seq, params->seq, key->seq_len); 966 key->cipher = params->cipher; 967 } 968 969 switch (key->cipher) { 970 case WLAN_CIPHER_SUITE_WEP40: 971 case WLAN_CIPHER_SUITE_WEP104: 972 key_type = WEP_CRYPT; 973 break; 974 975 case WLAN_CIPHER_SUITE_TKIP: 976 key_type = TKIP_CRYPT; 977 break; 978 979 case WLAN_CIPHER_SUITE_CCMP: 980 key_type = AES_CRYPT; 981 break; 982 case WLAN_CIPHER_SUITE_SMS4: 983 key_type = WAPI_CRYPT; 984 break; 985 986 default: 987 return -ENOTSUPP; 988 } 989 990 if (((vif->auth_mode == WPA_PSK_AUTH) 991 || (vif->auth_mode == WPA2_PSK_AUTH)) 992 && (key_usage & GROUP_USAGE)) 993 del_timer(&vif->disconnect_timer); 994 995 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 996 "%s: index %d, key_len %d, key_type 0x%x, key_usage 0x%x, seq_len %d\n", 997 __func__, key_index, key->key_len, key_type, 998 key_usage, key->seq_len); 999 1000 if (vif->nw_type == AP_NETWORK && !pairwise && 1001 (key_type == TKIP_CRYPT || key_type == AES_CRYPT) && params) { 1002 ar->ap_mode_bkey.valid = true; 1003 ar->ap_mode_bkey.key_index = key_index; 1004 ar->ap_mode_bkey.key_type = key_type; 1005 ar->ap_mode_bkey.key_len = key->key_len; 1006 memcpy(ar->ap_mode_bkey.key, key->key, key->key_len); 1007 if (!test_bit(CONNECTED, &vif->flags)) { 1008 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "Delay initial group " 1009 "key configuration until AP mode has been " 1010 "started\n"); 1011 /* 1012 * The key will be set in ath6kl_connect_ap_mode() once 1013 * the connected event is received from the target. 1014 */ 1015 return 0; 1016 } 1017 } 1018 1019 if (vif->next_mode == AP_NETWORK && key_type == WEP_CRYPT && 1020 !test_bit(CONNECTED, &vif->flags)) { 1021 /* 1022 * Store the key locally so that it can be re-configured after 1023 * the AP mode has properly started 1024 * (ath6kl_install_statioc_wep_keys). 1025 */ 1026 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "Delay WEP key configuration " 1027 "until AP mode has been started\n"); 1028 vif->wep_key_list[key_index].key_len = key->key_len; 1029 memcpy(vif->wep_key_list[key_index].key, key->key, 1030 key->key_len); 1031 return 0; 1032 } 1033 1034 return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, key_index, 1035 key_type, key_usage, key->key_len, 1036 key->seq, key->seq_len, key->key, 1037 KEY_OP_INIT_VAL, 1038 (u8 *) mac_addr, SYNC_BOTH_WMIFLAG); 1039} 1040 1041static int ath6kl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev, 1042 u8 key_index, bool pairwise, 1043 const u8 *mac_addr) 1044{ 1045 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev); 1046 struct ath6kl_vif *vif = netdev_priv(ndev); 1047 1048 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index); 1049 1050 if (!ath6kl_cfg80211_ready(vif)) 1051 return -EIO; 1052 1053 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) { 1054 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 1055 "%s: key index %d out of bounds\n", __func__, 1056 key_index); 1057 return -ENOENT; 1058 } 1059 1060 if (!vif->keys[key_index].key_len) { 1061 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 1062 "%s: index %d is empty\n", __func__, key_index); 1063 return 0; 1064 } 1065 1066 vif->keys[key_index].key_len = 0; 1067 1068 return ath6kl_wmi_deletekey_cmd(ar->wmi, vif->fw_vif_idx, key_index); 1069} 1070 1071static int ath6kl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev, 1072 u8 key_index, bool pairwise, 1073 const u8 *mac_addr, void *cookie, 1074 void (*callback) (void *cookie, 1075 struct key_params *)) 1076{ 1077 struct ath6kl_vif *vif = netdev_priv(ndev); 1078 struct ath6kl_key *key = NULL; 1079 struct key_params params; 1080 1081 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index); 1082 1083 if (!ath6kl_cfg80211_ready(vif)) 1084 return -EIO; 1085 1086 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) { 1087 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 1088 "%s: key index %d out of bounds\n", __func__, 1089 key_index); 1090 return -ENOENT; 1091 } 1092 1093 key = &vif->keys[key_index]; 1094 memset(¶ms, 0, sizeof(params)); 1095 params.cipher = key->cipher; 1096 params.key_len = key->key_len; 1097 params.seq_len = key->seq_len; 1098 params.seq = key->seq; 1099 params.key = key->key; 1100 1101 callback(cookie, ¶ms); 1102 1103 return key->key_len ? 0 : -ENOENT; 1104} 1105 1106static int ath6kl_cfg80211_set_default_key(struct wiphy *wiphy, 1107 struct net_device *ndev, 1108 u8 key_index, bool unicast, 1109 bool multicast) 1110{ 1111 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev); 1112 struct ath6kl_vif *vif = netdev_priv(ndev); 1113 struct ath6kl_key *key = NULL; 1114 u8 key_usage; 1115 enum crypto_type key_type = NONE_CRYPT; 1116 1117 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index); 1118 1119 if (!ath6kl_cfg80211_ready(vif)) 1120 return -EIO; 1121 1122 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) { 1123 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 1124 "%s: key index %d out of bounds\n", 1125 __func__, key_index); 1126 return -ENOENT; 1127 } 1128 1129 if (!vif->keys[key_index].key_len) { 1130 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: invalid key index %d\n", 1131 __func__, key_index); 1132 return -EINVAL; 1133 } 1134 1135 vif->def_txkey_index = key_index; 1136 key = &vif->keys[vif->def_txkey_index]; 1137 key_usage = GROUP_USAGE; 1138 if (vif->prwise_crypto == WEP_CRYPT) 1139 key_usage |= TX_USAGE; 1140 if (unicast) 1141 key_type = vif->prwise_crypto; 1142 if (multicast) 1143 key_type = vif->grp_crypto; 1144 1145 if (vif->next_mode == AP_NETWORK && !test_bit(CONNECTED, &vif->flags)) 1146 return 0; /* Delay until AP mode has been started */ 1147 1148 return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, 1149 vif->def_txkey_index, 1150 key_type, key_usage, 1151 key->key_len, key->seq, key->seq_len, 1152 key->key, 1153 KEY_OP_INIT_VAL, NULL, 1154 SYNC_BOTH_WMIFLAG); 1155} 1156 1157void ath6kl_cfg80211_tkip_micerr_event(struct ath6kl_vif *vif, u8 keyid, 1158 bool ismcast) 1159{ 1160 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 1161 "%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast); 1162 1163 cfg80211_michael_mic_failure(vif->ndev, vif->bssid, 1164 (ismcast ? NL80211_KEYTYPE_GROUP : 1165 NL80211_KEYTYPE_PAIRWISE), keyid, NULL, 1166 GFP_KERNEL); 1167} 1168 1169static int ath6kl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed) 1170{ 1171 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy); 1172 struct ath6kl_vif *vif; 1173 int ret; 1174 1175 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: changed 0x%x\n", __func__, 1176 changed); 1177 1178 vif = ath6kl_vif_first(ar); 1179 if (!vif) 1180 return -EIO; 1181 1182 if (!ath6kl_cfg80211_ready(vif)) 1183 return -EIO; 1184 1185 if (changed & WIPHY_PARAM_RTS_THRESHOLD) { 1186 ret = ath6kl_wmi_set_rts_cmd(ar->wmi, wiphy->rts_threshold); 1187 if (ret != 0) { 1188 ath6kl_err("ath6kl_wmi_set_rts_cmd failed\n"); 1189 return -EIO; 1190 } 1191 } 1192 1193 return 0; 1194} 1195 1196/* 1197 * The type nl80211_tx_power_setting replaces the following 1198 * data type from 2.6.36 onwards 1199*/ 1200static int ath6kl_cfg80211_set_txpower(struct wiphy *wiphy, 1201 enum nl80211_tx_power_setting type, 1202 int dbm) 1203{ 1204 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy); 1205 struct ath6kl_vif *vif; 1206 u8 ath6kl_dbm; 1207 1208 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x, dbm %d\n", __func__, 1209 type, dbm); 1210 1211 vif = ath6kl_vif_first(ar); 1212 if (!vif) 1213 return -EIO; 1214 1215 if (!ath6kl_cfg80211_ready(vif)) 1216 return -EIO; 1217 1218 switch (type) { 1219 case NL80211_TX_POWER_AUTOMATIC: 1220 return 0; 1221 case NL80211_TX_POWER_LIMITED: 1222 ar->tx_pwr = ath6kl_dbm = dbm; 1223 break; 1224 default: 1225 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x not supported\n", 1226 __func__, type); 1227 return -EOPNOTSUPP; 1228 } 1229 1230 ath6kl_wmi_set_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx, ath6kl_dbm); 1231 1232 return 0; 1233} 1234 1235static int ath6kl_cfg80211_get_txpower(struct wiphy *wiphy, int *dbm) 1236{ 1237 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy); 1238 struct ath6kl_vif *vif; 1239 1240 vif = ath6kl_vif_first(ar); 1241 if (!vif) 1242 return -EIO; 1243 1244 if (!ath6kl_cfg80211_ready(vif)) 1245 return -EIO; 1246 1247 if (test_bit(CONNECTED, &vif->flags)) { 1248 ar->tx_pwr = 0; 1249 1250 if (ath6kl_wmi_get_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx) != 0) { 1251 ath6kl_err("ath6kl_wmi_get_tx_pwr_cmd failed\n"); 1252 return -EIO; 1253 } 1254 1255 wait_event_interruptible_timeout(ar->event_wq, ar->tx_pwr != 0, 1256 5 * HZ); 1257 1258 if (signal_pending(current)) { 1259 ath6kl_err("target did not respond\n"); 1260 return -EINTR; 1261 } 1262 } 1263 1264 *dbm = ar->tx_pwr; 1265 return 0; 1266} 1267 1268static int ath6kl_cfg80211_set_power_mgmt(struct wiphy *wiphy, 1269 struct net_device *dev, 1270 bool pmgmt, int timeout) 1271{ 1272 struct ath6kl *ar = ath6kl_priv(dev); 1273 struct wmi_power_mode_cmd mode; 1274 struct ath6kl_vif *vif = netdev_priv(dev); 1275 1276 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: pmgmt %d, timeout %d\n", 1277 __func__, pmgmt, timeout); 1278 1279 if (!ath6kl_cfg80211_ready(vif)) 1280 return -EIO; 1281 1282 if (pmgmt) { 1283 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: max perf\n", __func__); 1284 mode.pwr_mode = REC_POWER; 1285 } else { 1286 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\n", __func__); 1287 mode.pwr_mode = MAX_PERF_POWER; 1288 } 1289 1290 if (ath6kl_wmi_powermode_cmd(ar->wmi, vif->fw_vif_idx, 1291 mode.pwr_mode) != 0) { 1292 ath6kl_err("wmi_powermode_cmd failed\n"); 1293 return -EIO; 1294 } 1295 1296 return 0; 1297} 1298 1299static struct net_device *ath6kl_cfg80211_add_iface(struct wiphy *wiphy, 1300 char *name, 1301 enum nl80211_iftype type, 1302 u32 *flags, 1303 struct vif_params *params) 1304{ 1305 struct ath6kl *ar = wiphy_priv(wiphy); 1306 struct net_device *ndev; 1307 u8 if_idx, nw_type; 1308 1309 if (ar->num_vif == MAX_NUM_VIF) { 1310 ath6kl_err("Reached maximum number of supported vif\n"); 1311 return ERR_PTR(-EINVAL); 1312 } 1313 1314 if (!ath6kl_is_valid_iftype(ar, type, &if_idx, &nw_type)) { 1315 ath6kl_err("Not a supported interface type\n"); 1316 return ERR_PTR(-EINVAL); 1317 } 1318 1319 ndev = ath6kl_interface_add(ar, name, type, if_idx, nw_type); 1320 if (!ndev) 1321 return ERR_PTR(-ENOMEM); 1322 1323 ar->num_vif++; 1324 1325 return ndev; 1326} 1327 1328static int ath6kl_cfg80211_del_iface(struct wiphy *wiphy, 1329 struct net_device *ndev) 1330{ 1331 struct ath6kl *ar = wiphy_priv(wiphy); 1332 struct ath6kl_vif *vif = netdev_priv(ndev); 1333 1334 spin_lock_bh(&ar->list_lock); 1335 list_del(&vif->list); 1336 spin_unlock_bh(&ar->list_lock); 1337 1338 ath6kl_cleanup_vif(vif, test_bit(WMI_READY, &ar->flag)); 1339 1340 ath6kl_deinit_if_data(vif); 1341 1342 return 0; 1343} 1344 1345static int ath6kl_cfg80211_change_iface(struct wiphy *wiphy, 1346 struct net_device *ndev, 1347 enum nl80211_iftype type, u32 *flags, 1348 struct vif_params *params) 1349{ 1350 struct ath6kl_vif *vif = netdev_priv(ndev); 1351 1352 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type %u\n", __func__, type); 1353 1354 if (!ath6kl_cfg80211_ready(vif)) 1355 return -EIO; 1356 1357 switch (type) { 1358 case NL80211_IFTYPE_STATION: 1359 vif->next_mode = INFRA_NETWORK; 1360 break; 1361 case NL80211_IFTYPE_ADHOC: 1362 vif->next_mode = ADHOC_NETWORK; 1363 break; 1364 case NL80211_IFTYPE_AP: 1365 vif->next_mode = AP_NETWORK; 1366 break; 1367 case NL80211_IFTYPE_P2P_CLIENT: 1368 vif->next_mode = INFRA_NETWORK; 1369 break; 1370 case NL80211_IFTYPE_P2P_GO: 1371 vif->next_mode = AP_NETWORK; 1372 break; 1373 default: 1374 ath6kl_err("invalid interface type %u\n", type); 1375 return -EOPNOTSUPP; 1376 } 1377 1378 vif->wdev.iftype = type; 1379 1380 return 0; 1381} 1382 1383static int ath6kl_cfg80211_join_ibss(struct wiphy *wiphy, 1384 struct net_device *dev, 1385 struct cfg80211_ibss_params *ibss_param) 1386{ 1387 struct ath6kl *ar = ath6kl_priv(dev); 1388 struct ath6kl_vif *vif = netdev_priv(dev); 1389 int status; 1390 1391 if (!ath6kl_cfg80211_ready(vif)) 1392 return -EIO; 1393 1394 vif->ssid_len = ibss_param->ssid_len; 1395 memcpy(vif->ssid, ibss_param->ssid, vif->ssid_len); 1396 1397 if (ibss_param->channel) 1398 vif->ch_hint = ibss_param->channel->center_freq; 1399 1400 if (ibss_param->channel_fixed) { 1401 /* 1402 * TODO: channel_fixed: The channel should be fixed, do not 1403 * search for IBSSs to join on other channels. Target 1404 * firmware does not support this feature, needs to be 1405 * updated. 1406 */ 1407 return -EOPNOTSUPP; 1408 } 1409 1410 memset(vif->req_bssid, 0, sizeof(vif->req_bssid)); 1411 if (ibss_param->bssid && !is_broadcast_ether_addr(ibss_param->bssid)) 1412 memcpy(vif->req_bssid, ibss_param->bssid, 1413 sizeof(vif->req_bssid)); 1414 1415 ath6kl_set_wpa_version(vif, 0); 1416 1417 status = ath6kl_set_auth_type(vif, NL80211_AUTHTYPE_OPEN_SYSTEM); 1418 if (status) 1419 return status; 1420 1421 if (ibss_param->privacy) { 1422 ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, true); 1423 ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, false); 1424 } else { 1425 ath6kl_set_cipher(vif, 0, true); 1426 ath6kl_set_cipher(vif, 0, false); 1427 } 1428 1429 vif->nw_type = vif->next_mode; 1430 1431 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 1432 "%s: connect called with authmode %d dot11 auth %d" 1433 " PW crypto %d PW crypto len %d GRP crypto %d" 1434 " GRP crypto len %d channel hint %u\n", 1435 __func__, 1436 vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto, 1437 vif->prwise_crypto_len, vif->grp_crypto, 1438 vif->grp_crypto_len, vif->ch_hint); 1439 1440 status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type, 1441 vif->dot11_auth_mode, vif->auth_mode, 1442 vif->prwise_crypto, 1443 vif->prwise_crypto_len, 1444 vif->grp_crypto, vif->grp_crypto_len, 1445 vif->ssid_len, vif->ssid, 1446 vif->req_bssid, vif->ch_hint, 1447 ar->connect_ctrl_flags); 1448 set_bit(CONNECT_PEND, &vif->flags); 1449 1450 return 0; 1451} 1452 1453static int ath6kl_cfg80211_leave_ibss(struct wiphy *wiphy, 1454 struct net_device *dev) 1455{ 1456 struct ath6kl_vif *vif = netdev_priv(dev); 1457 1458 if (!ath6kl_cfg80211_ready(vif)) 1459 return -EIO; 1460 1461 ath6kl_disconnect(vif); 1462 memset(vif->ssid, 0, sizeof(vif->ssid)); 1463 vif->ssid_len = 0; 1464 1465 return 0; 1466} 1467 1468static const u32 cipher_suites[] = { 1469 WLAN_CIPHER_SUITE_WEP40, 1470 WLAN_CIPHER_SUITE_WEP104, 1471 WLAN_CIPHER_SUITE_TKIP, 1472 WLAN_CIPHER_SUITE_CCMP, 1473 CCKM_KRK_CIPHER_SUITE, 1474 WLAN_CIPHER_SUITE_SMS4, 1475}; 1476 1477static bool is_rate_legacy(s32 rate) 1478{ 1479 static const s32 legacy[] = { 1000, 2000, 5500, 11000, 1480 6000, 9000, 12000, 18000, 24000, 1481 36000, 48000, 54000 1482 }; 1483 u8 i; 1484 1485 for (i = 0; i < ARRAY_SIZE(legacy); i++) 1486 if (rate == legacy[i]) 1487 return true; 1488 1489 return false; 1490} 1491 1492static bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi) 1493{ 1494 static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000, 1495 52000, 58500, 65000, 72200 1496 }; 1497 u8 i; 1498 1499 for (i = 0; i < ARRAY_SIZE(ht20); i++) { 1500 if (rate == ht20[i]) { 1501 if (i == ARRAY_SIZE(ht20) - 1) 1502 /* last rate uses sgi */ 1503 *sgi = true; 1504 else 1505 *sgi = false; 1506 1507 *mcs = i; 1508 return true; 1509 } 1510 } 1511 return false; 1512} 1513 1514static bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi) 1515{ 1516 static const s32 ht40[] = { 13500, 27000, 40500, 54000, 1517 81000, 108000, 121500, 135000, 1518 150000 1519 }; 1520 u8 i; 1521 1522 for (i = 0; i < ARRAY_SIZE(ht40); i++) { 1523 if (rate == ht40[i]) { 1524 if (i == ARRAY_SIZE(ht40) - 1) 1525 /* last rate uses sgi */ 1526 *sgi = true; 1527 else 1528 *sgi = false; 1529 1530 *mcs = i; 1531 return true; 1532 } 1533 } 1534 1535 return false; 1536} 1537 1538static int ath6kl_get_station(struct wiphy *wiphy, struct net_device *dev, 1539 u8 *mac, struct station_info *sinfo) 1540{ 1541 struct ath6kl *ar = ath6kl_priv(dev); 1542 struct ath6kl_vif *vif = netdev_priv(dev); 1543 long left; 1544 bool sgi; 1545 s32 rate; 1546 int ret; 1547 u8 mcs; 1548 1549 if (memcmp(mac, vif->bssid, ETH_ALEN) != 0) 1550 return -ENOENT; 1551 1552 if (down_interruptible(&ar->sem)) 1553 return -EBUSY; 1554 1555 set_bit(STATS_UPDATE_PEND, &vif->flags); 1556 1557 ret = ath6kl_wmi_get_stats_cmd(ar->wmi, vif->fw_vif_idx); 1558 1559 if (ret != 0) { 1560 up(&ar->sem); 1561 return -EIO; 1562 } 1563 1564 left = wait_event_interruptible_timeout(ar->event_wq, 1565 !test_bit(STATS_UPDATE_PEND, 1566 &vif->flags), 1567 WMI_TIMEOUT); 1568 1569 up(&ar->sem); 1570 1571 if (left == 0) 1572 return -ETIMEDOUT; 1573 else if (left < 0) 1574 return left; 1575 1576 if (vif->target_stats.rx_byte) { 1577 sinfo->rx_bytes = vif->target_stats.rx_byte; 1578 sinfo->filled |= STATION_INFO_RX_BYTES; 1579 sinfo->rx_packets = vif->target_stats.rx_pkt; 1580 sinfo->filled |= STATION_INFO_RX_PACKETS; 1581 } 1582 1583 if (vif->target_stats.tx_byte) { 1584 sinfo->tx_bytes = vif->target_stats.tx_byte; 1585 sinfo->filled |= STATION_INFO_TX_BYTES; 1586 sinfo->tx_packets = vif->target_stats.tx_pkt; 1587 sinfo->filled |= STATION_INFO_TX_PACKETS; 1588 } 1589 1590 sinfo->signal = vif->target_stats.cs_rssi; 1591 sinfo->filled |= STATION_INFO_SIGNAL; 1592 1593 rate = vif->target_stats.tx_ucast_rate; 1594 1595 if (is_rate_legacy(rate)) { 1596 sinfo->txrate.legacy = rate / 100; 1597 } else if (is_rate_ht20(rate, &mcs, &sgi)) { 1598 if (sgi) { 1599 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 1600 sinfo->txrate.mcs = mcs - 1; 1601 } else { 1602 sinfo->txrate.mcs = mcs; 1603 } 1604 1605 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS; 1606 } else if (is_rate_ht40(rate, &mcs, &sgi)) { 1607 if (sgi) { 1608 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 1609 sinfo->txrate.mcs = mcs - 1; 1610 } else { 1611 sinfo->txrate.mcs = mcs; 1612 } 1613 1614 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH; 1615 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS; 1616 } else { 1617 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, 1618 "invalid rate from stats: %d\n", rate); 1619 ath6kl_debug_war(ar, ATH6KL_WAR_INVALID_RATE); 1620 return 0; 1621 } 1622 1623 sinfo->filled |= STATION_INFO_TX_BITRATE; 1624 1625 if (test_bit(CONNECTED, &vif->flags) && 1626 test_bit(DTIM_PERIOD_AVAIL, &vif->flags) && 1627 vif->nw_type == INFRA_NETWORK) { 1628 sinfo->filled |= STATION_INFO_BSS_PARAM; 1629 sinfo->bss_param.flags = 0; 1630 sinfo->bss_param.dtim_period = vif->assoc_bss_dtim_period; 1631 sinfo->bss_param.beacon_interval = vif->assoc_bss_beacon_int; 1632 } 1633 1634 return 0; 1635} 1636 1637static int ath6kl_set_pmksa(struct wiphy *wiphy, struct net_device *netdev, 1638 struct cfg80211_pmksa *pmksa) 1639{ 1640 struct ath6kl *ar = ath6kl_priv(netdev); 1641 struct ath6kl_vif *vif = netdev_priv(netdev); 1642 1643 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid, 1644 pmksa->pmkid, true); 1645} 1646 1647static int ath6kl_del_pmksa(struct wiphy *wiphy, struct net_device *netdev, 1648 struct cfg80211_pmksa *pmksa) 1649{ 1650 struct ath6kl *ar = ath6kl_priv(netdev); 1651 struct ath6kl_vif *vif = netdev_priv(netdev); 1652 1653 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid, 1654 pmksa->pmkid, false); 1655} 1656 1657static int ath6kl_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev) 1658{ 1659 struct ath6kl *ar = ath6kl_priv(netdev); 1660 struct ath6kl_vif *vif = netdev_priv(netdev); 1661 1662 if (test_bit(CONNECTED, &vif->flags)) 1663 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, 1664 vif->bssid, NULL, false); 1665 return 0; 1666} 1667 1668static int ath6kl_wow_suspend(struct ath6kl *ar, struct cfg80211_wowlan *wow) 1669{ 1670 struct ath6kl_vif *vif; 1671 int ret, pos, left; 1672 u32 filter = 0; 1673 u16 i; 1674 u8 mask[WOW_MASK_SIZE]; 1675 1676 vif = ath6kl_vif_first(ar); 1677 if (!vif) 1678 return -EIO; 1679 1680 if (!ath6kl_cfg80211_ready(vif)) 1681 return -EIO; 1682 1683 if (!test_bit(CONNECTED, &vif->flags)) 1684 return -EINVAL; 1685 1686 /* Clear existing WOW patterns */ 1687 for (i = 0; i < WOW_MAX_FILTERS_PER_LIST; i++) 1688 ath6kl_wmi_del_wow_pattern_cmd(ar->wmi, vif->fw_vif_idx, 1689 WOW_LIST_ID, i); 1690 /* Configure new WOW patterns */ 1691 for (i = 0; i < wow->n_patterns; i++) { 1692 1693 /* 1694 * Convert given nl80211 specific mask value to equivalent 1695 * driver specific mask value and send it to the chip along 1696 * with patterns. For example, If the mask value defined in 1697 * struct cfg80211_wowlan is 0xA (equivalent binary is 1010), 1698 * then equivalent driver specific mask value is 1699 * "0xFF 0x00 0xFF 0x00". 1700 */ 1701 memset(&mask, 0, sizeof(mask)); 1702 for (pos = 0; pos < wow->patterns[i].pattern_len; pos++) { 1703 if (wow->patterns[i].mask[pos / 8] & (0x1 << (pos % 8))) 1704 mask[pos] = 0xFF; 1705 } 1706 /* 1707 * Note: Pattern's offset is not passed as part of wowlan 1708 * parameter from CFG layer. So it's always passed as ZERO 1709 * to the firmware. It means, given WOW patterns are always 1710 * matched from the first byte of received pkt in the firmware. 1711 */ 1712 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi, 1713 vif->fw_vif_idx, WOW_LIST_ID, 1714 wow->patterns[i].pattern_len, 1715 0 /* pattern offset */, 1716 wow->patterns[i].pattern, mask); 1717 if (ret) 1718 return ret; 1719 } 1720 1721 if (wow->disconnect) 1722 filter |= WOW_FILTER_OPTION_NWK_DISASSOC; 1723 1724 if (wow->magic_pkt) 1725 filter |= WOW_FILTER_OPTION_MAGIC_PACKET; 1726 1727 if (wow->gtk_rekey_failure) 1728 filter |= WOW_FILTER_OPTION_GTK_ERROR; 1729 1730 if (wow->eap_identity_req) 1731 filter |= WOW_FILTER_OPTION_EAP_REQ; 1732 1733 if (wow->four_way_handshake) 1734 filter |= WOW_FILTER_OPTION_8021X_4WAYHS; 1735 1736 ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, vif->fw_vif_idx, 1737 ATH6KL_WOW_MODE_ENABLE, 1738 filter, 1739 WOW_HOST_REQ_DELAY); 1740 if (ret) 1741 return ret; 1742 1743 ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx, 1744 ATH6KL_HOST_MODE_ASLEEP); 1745 if (ret) 1746 return ret; 1747 1748 if (ar->tx_pending[ar->ctrl_ep]) { 1749 left = wait_event_interruptible_timeout(ar->event_wq, 1750 ar->tx_pending[ar->ctrl_ep] == 0, WMI_TIMEOUT); 1751 if (left == 0) { 1752 ath6kl_warn("clear wmi ctrl data timeout\n"); 1753 ret = -ETIMEDOUT; 1754 } else if (left < 0) { 1755 ath6kl_warn("clear wmi ctrl data failed: %d\n", left); 1756 ret = left; 1757 } 1758 } 1759 1760 return ret; 1761} 1762 1763static int ath6kl_wow_resume(struct ath6kl *ar) 1764{ 1765 struct ath6kl_vif *vif; 1766 int ret; 1767 1768 vif = ath6kl_vif_first(ar); 1769 if (!vif) 1770 return -EIO; 1771 1772 ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx, 1773 ATH6KL_HOST_MODE_AWAKE); 1774 return ret; 1775} 1776 1777int ath6kl_cfg80211_suspend(struct ath6kl *ar, 1778 enum ath6kl_cfg_suspend_mode mode, 1779 struct cfg80211_wowlan *wow) 1780{ 1781 int ret; 1782 1783 switch (mode) { 1784 case ATH6KL_CFG_SUSPEND_WOW: 1785 1786 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode suspend\n"); 1787 1788 /* Flush all non control pkts in TX path */ 1789 ath6kl_tx_data_cleanup(ar); 1790 1791 ret = ath6kl_wow_suspend(ar, wow); 1792 if (ret) { 1793 ath6kl_err("wow suspend failed: %d\n", ret); 1794 return ret; 1795 } 1796 ar->state = ATH6KL_STATE_WOW; 1797 break; 1798 1799 case ATH6KL_CFG_SUSPEND_DEEPSLEEP: 1800 1801 ath6kl_cfg80211_stop(ar); 1802 1803 /* save the current power mode before enabling power save */ 1804 ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode; 1805 1806 ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER); 1807 if (ret) { 1808 ath6kl_warn("wmi powermode command failed during suspend: %d\n", 1809 ret); 1810 } 1811 1812 ar->state = ATH6KL_STATE_DEEPSLEEP; 1813 1814 break; 1815 1816 case ATH6KL_CFG_SUSPEND_CUTPOWER: 1817 1818 ath6kl_cfg80211_stop(ar); 1819 1820 if (ar->state == ATH6KL_STATE_OFF) { 1821 ath6kl_dbg(ATH6KL_DBG_SUSPEND, 1822 "suspend hw off, no action for cutpower\n"); 1823 break; 1824 } 1825 1826 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "suspend cutting power\n"); 1827 1828 ret = ath6kl_init_hw_stop(ar); 1829 if (ret) { 1830 ath6kl_warn("failed to stop hw during suspend: %d\n", 1831 ret); 1832 } 1833 1834 ar->state = ATH6KL_STATE_CUTPOWER; 1835 1836 break; 1837 1838 default: 1839 break; 1840 } 1841 1842 return 0; 1843} 1844 1845int ath6kl_cfg80211_resume(struct ath6kl *ar) 1846{ 1847 int ret; 1848 1849 switch (ar->state) { 1850 case ATH6KL_STATE_WOW: 1851 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode resume\n"); 1852 1853 ret = ath6kl_wow_resume(ar); 1854 if (ret) { 1855 ath6kl_warn("wow mode resume failed: %d\n", ret); 1856 return ret; 1857 } 1858 1859 ar->state = ATH6KL_STATE_ON; 1860 break; 1861 1862 case ATH6KL_STATE_DEEPSLEEP: 1863 if (ar->wmi->pwr_mode != ar->wmi->saved_pwr_mode) { 1864 ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0, 1865 ar->wmi->saved_pwr_mode); 1866 if (ret) { 1867 ath6kl_warn("wmi powermode command failed during resume: %d\n", 1868 ret); 1869 } 1870 } 1871 1872 ar->state = ATH6KL_STATE_ON; 1873 1874 break; 1875 1876 case ATH6KL_STATE_CUTPOWER: 1877 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "resume restoring power\n"); 1878 1879 ret = ath6kl_init_hw_start(ar); 1880 if (ret) { 1881 ath6kl_warn("Failed to boot hw in resume: %d\n", ret); 1882 return ret; 1883 } 1884 break; 1885 1886 default: 1887 break; 1888 } 1889 1890 return 0; 1891} 1892 1893#ifdef CONFIG_PM 1894 1895/* hif layer decides what suspend mode to use */ 1896static int __ath6kl_cfg80211_suspend(struct wiphy *wiphy, 1897 struct cfg80211_wowlan *wow) 1898{ 1899 struct ath6kl *ar = wiphy_priv(wiphy); 1900 1901 return ath6kl_hif_suspend(ar, wow); 1902} 1903 1904static int __ath6kl_cfg80211_resume(struct wiphy *wiphy) 1905{ 1906 struct ath6kl *ar = wiphy_priv(wiphy); 1907 1908 return ath6kl_hif_resume(ar); 1909} 1910 1911/* 1912 * FIXME: WOW suspend mode is selected if the host sdio controller supports 1913 * both sdio irq wake up and keep power. The target pulls sdio data line to 1914 * wake up the host when WOW pattern matches. This causes sdio irq handler 1915 * is being called in the host side which internally hits ath6kl's RX path. 1916 * 1917 * Since sdio interrupt is not disabled, RX path executes even before 1918 * the host executes the actual resume operation from PM module. 1919 * 1920 * In the current scenario, WOW resume should happen before start processing 1921 * any data from the target. So It's required to perform WOW resume in RX path. 1922 * Ideally we should perform WOW resume only in the actual platform 1923 * resume path. This area needs bit rework to avoid WOW resume in RX path. 1924 * 1925 * ath6kl_check_wow_status() is called from ath6kl_rx(). 1926 */ 1927void ath6kl_check_wow_status(struct ath6kl *ar) 1928{ 1929 if (ar->state == ATH6KL_STATE_WOW) 1930 ath6kl_cfg80211_resume(ar); 1931} 1932 1933#else 1934 1935void ath6kl_check_wow_status(struct ath6kl *ar) 1936{ 1937} 1938#endif 1939 1940static int ath6kl_set_channel(struct wiphy *wiphy, struct net_device *dev, 1941 struct ieee80211_channel *chan, 1942 enum nl80211_channel_type channel_type) 1943{ 1944 struct ath6kl_vif *vif = netdev_priv(dev); 1945 1946 if (!ath6kl_cfg80211_ready(vif)) 1947 return -EIO; 1948 1949 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: center_freq=%u hw_value=%u\n", 1950 __func__, chan->center_freq, chan->hw_value); 1951 vif->next_chan = chan->center_freq; 1952 1953 return 0; 1954} 1955 1956static bool ath6kl_is_p2p_ie(const u8 *pos) 1957{ 1958 return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 && 1959 pos[2] == 0x50 && pos[3] == 0x6f && 1960 pos[4] == 0x9a && pos[5] == 0x09; 1961} 1962 1963static int ath6kl_set_ap_probe_resp_ies(struct ath6kl_vif *vif, 1964 const u8 *ies, size_t ies_len) 1965{ 1966 struct ath6kl *ar = vif->ar; 1967 const u8 *pos; 1968 u8 *buf = NULL; 1969 size_t len = 0; 1970 int ret; 1971 1972 /* 1973 * Filter out P2P IE(s) since they will be included depending on 1974 * the Probe Request frame in ath6kl_send_go_probe_resp(). 1975 */ 1976 1977 if (ies && ies_len) { 1978 buf = kmalloc(ies_len, GFP_KERNEL); 1979 if (buf == NULL) 1980 return -ENOMEM; 1981 pos = ies; 1982 while (pos + 1 < ies + ies_len) { 1983 if (pos + 2 + pos[1] > ies + ies_len) 1984 break; 1985 if (!ath6kl_is_p2p_ie(pos)) { 1986 memcpy(buf + len, pos, 2 + pos[1]); 1987 len += 2 + pos[1]; 1988 } 1989 pos += 2 + pos[1]; 1990 } 1991 } 1992 1993 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx, 1994 WMI_FRAME_PROBE_RESP, buf, len); 1995 kfree(buf); 1996 return ret; 1997} 1998 1999static int ath6kl_ap_beacon(struct wiphy *wiphy, struct net_device *dev, 2000 struct beacon_parameters *info, bool add) 2001{ 2002 struct ath6kl *ar = ath6kl_priv(dev); 2003 struct ath6kl_vif *vif = netdev_priv(dev); 2004 struct ieee80211_mgmt *mgmt; 2005 u8 *ies; 2006 int ies_len; 2007 struct wmi_connect_cmd p; 2008 int res; 2009 int i, ret; 2010 2011 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: add=%d\n", __func__, add); 2012 2013 if (!ath6kl_cfg80211_ready(vif)) 2014 return -EIO; 2015 2016 if (vif->next_mode != AP_NETWORK) 2017 return -EOPNOTSUPP; 2018 2019 if (info->beacon_ies) { 2020 res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx, 2021 WMI_FRAME_BEACON, 2022 info->beacon_ies, 2023 info->beacon_ies_len); 2024 if (res) 2025 return res; 2026 } 2027 if (info->proberesp_ies) { 2028 res = ath6kl_set_ap_probe_resp_ies(vif, info->proberesp_ies, 2029 info->proberesp_ies_len); 2030 if (res) 2031 return res; 2032 } 2033 if (info->assocresp_ies) { 2034 res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx, 2035 WMI_FRAME_ASSOC_RESP, 2036 info->assocresp_ies, 2037 info->assocresp_ies_len); 2038 if (res) 2039 return res; 2040 } 2041 2042 if (!add) 2043 return 0; 2044 2045 ar->ap_mode_bkey.valid = false; 2046 2047 /* TODO: 2048 * info->interval 2049 * info->dtim_period 2050 */ 2051 2052 if (info->head == NULL) 2053 return -EINVAL; 2054 mgmt = (struct ieee80211_mgmt *) info->head; 2055 ies = mgmt->u.beacon.variable; 2056 if (ies > info->head + info->head_len) 2057 return -EINVAL; 2058 ies_len = info->head + info->head_len - ies; 2059 2060 if (info->ssid == NULL) 2061 return -EINVAL; 2062 memcpy(vif->ssid, info->ssid, info->ssid_len); 2063 vif->ssid_len = info->ssid_len; 2064 if (info->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE) 2065 return -EOPNOTSUPP; /* TODO */ 2066 2067 ret = ath6kl_set_auth_type(vif, info->auth_type); 2068 if (ret) 2069 return ret; 2070 2071 memset(&p, 0, sizeof(p)); 2072 2073 for (i = 0; i < info->crypto.n_akm_suites; i++) { 2074 switch (info->crypto.akm_suites[i]) { 2075 case WLAN_AKM_SUITE_8021X: 2076 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1) 2077 p.auth_mode |= WPA_AUTH; 2078 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2) 2079 p.auth_mode |= WPA2_AUTH; 2080 break; 2081 case WLAN_AKM_SUITE_PSK: 2082 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1) 2083 p.auth_mode |= WPA_PSK_AUTH; 2084 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2) 2085 p.auth_mode |= WPA2_PSK_AUTH; 2086 break; 2087 } 2088 } 2089 if (p.auth_mode == 0) 2090 p.auth_mode = NONE_AUTH; 2091 vif->auth_mode = p.auth_mode; 2092 2093 for (i = 0; i < info->crypto.n_ciphers_pairwise; i++) { 2094 switch (info->crypto.ciphers_pairwise[i]) { 2095 case WLAN_CIPHER_SUITE_WEP40: 2096 case WLAN_CIPHER_SUITE_WEP104: 2097 p.prwise_crypto_type |= WEP_CRYPT; 2098 break; 2099 case WLAN_CIPHER_SUITE_TKIP: 2100 p.prwise_crypto_type |= TKIP_CRYPT; 2101 break; 2102 case WLAN_CIPHER_SUITE_CCMP: 2103 p.prwise_crypto_type |= AES_CRYPT; 2104 break; 2105 case WLAN_CIPHER_SUITE_SMS4: 2106 p.prwise_crypto_type |= WAPI_CRYPT; 2107 break; 2108 } 2109 } 2110 if (p.prwise_crypto_type == 0) { 2111 p.prwise_crypto_type = NONE_CRYPT; 2112 ath6kl_set_cipher(vif, 0, true); 2113 } else if (info->crypto.n_ciphers_pairwise == 1) 2114 ath6kl_set_cipher(vif, info->crypto.ciphers_pairwise[0], true); 2115 2116 switch (info->crypto.cipher_group) { 2117 case WLAN_CIPHER_SUITE_WEP40: 2118 case WLAN_CIPHER_SUITE_WEP104: 2119 p.grp_crypto_type = WEP_CRYPT; 2120 break; 2121 case WLAN_CIPHER_SUITE_TKIP: 2122 p.grp_crypto_type = TKIP_CRYPT; 2123 break; 2124 case WLAN_CIPHER_SUITE_CCMP: 2125 p.grp_crypto_type = AES_CRYPT; 2126 break; 2127 case WLAN_CIPHER_SUITE_SMS4: 2128 p.grp_crypto_type = WAPI_CRYPT; 2129 break; 2130 default: 2131 p.grp_crypto_type = NONE_CRYPT; 2132 break; 2133 } 2134 ath6kl_set_cipher(vif, info->crypto.cipher_group, false); 2135 2136 p.nw_type = AP_NETWORK; 2137 vif->nw_type = vif->next_mode; 2138 2139 p.ssid_len = vif->ssid_len; 2140 memcpy(p.ssid, vif->ssid, vif->ssid_len); 2141 p.dot11_auth_mode = vif->dot11_auth_mode; 2142 p.ch = cpu_to_le16(vif->next_chan); 2143 2144 res = ath6kl_wmi_ap_profile_commit(ar->wmi, vif->fw_vif_idx, &p); 2145 if (res < 0) 2146 return res; 2147 2148 return 0; 2149} 2150 2151static int ath6kl_add_beacon(struct wiphy *wiphy, struct net_device *dev, 2152 struct beacon_parameters *info) 2153{ 2154 return ath6kl_ap_beacon(wiphy, dev, info, true); 2155} 2156 2157static int ath6kl_set_beacon(struct wiphy *wiphy, struct net_device *dev, 2158 struct beacon_parameters *info) 2159{ 2160 return ath6kl_ap_beacon(wiphy, dev, info, false); 2161} 2162 2163static int ath6kl_del_beacon(struct wiphy *wiphy, struct net_device *dev) 2164{ 2165 struct ath6kl *ar = ath6kl_priv(dev); 2166 struct ath6kl_vif *vif = netdev_priv(dev); 2167 2168 if (vif->nw_type != AP_NETWORK) 2169 return -EOPNOTSUPP; 2170 if (!test_bit(CONNECTED, &vif->flags)) 2171 return -ENOTCONN; 2172 2173 ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx); 2174 clear_bit(CONNECTED, &vif->flags); 2175 2176 return 0; 2177} 2178 2179static int ath6kl_change_station(struct wiphy *wiphy, struct net_device *dev, 2180 u8 *mac, struct station_parameters *params) 2181{ 2182 struct ath6kl *ar = ath6kl_priv(dev); 2183 struct ath6kl_vif *vif = netdev_priv(dev); 2184 2185 if (vif->nw_type != AP_NETWORK) 2186 return -EOPNOTSUPP; 2187 2188 /* Use this only for authorizing/unauthorizing a station */ 2189 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED))) 2190 return -EOPNOTSUPP; 2191 2192 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED)) 2193 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx, 2194 WMI_AP_MLME_AUTHORIZE, mac, 0); 2195 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx, 2196 WMI_AP_MLME_UNAUTHORIZE, mac, 0); 2197} 2198 2199static int ath6kl_remain_on_channel(struct wiphy *wiphy, 2200 struct net_device *dev, 2201 struct ieee80211_channel *chan, 2202 enum nl80211_channel_type channel_type, 2203 unsigned int duration, 2204 u64 *cookie) 2205{ 2206 struct ath6kl *ar = ath6kl_priv(dev); 2207 struct ath6kl_vif *vif = netdev_priv(dev); 2208 u32 id; 2209 2210 /* TODO: if already pending or ongoing remain-on-channel, 2211 * return -EBUSY */ 2212 id = ++vif->last_roc_id; 2213 if (id == 0) { 2214 /* Do not use 0 as the cookie value */ 2215 id = ++vif->last_roc_id; 2216 } 2217 *cookie = id; 2218 2219 return ath6kl_wmi_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx, 2220 chan->center_freq, duration); 2221} 2222 2223static int ath6kl_cancel_remain_on_channel(struct wiphy *wiphy, 2224 struct net_device *dev, 2225 u64 cookie) 2226{ 2227 struct ath6kl *ar = ath6kl_priv(dev); 2228 struct ath6kl_vif *vif = netdev_priv(dev); 2229 2230 if (cookie != vif->last_roc_id) 2231 return -ENOENT; 2232 vif->last_cancel_roc_id = cookie; 2233 2234 return ath6kl_wmi_cancel_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx); 2235} 2236 2237static int ath6kl_send_go_probe_resp(struct ath6kl_vif *vif, 2238 const u8 *buf, size_t len, 2239 unsigned int freq) 2240{ 2241 struct ath6kl *ar = vif->ar; 2242 const u8 *pos; 2243 u8 *p2p; 2244 int p2p_len; 2245 int ret; 2246 const struct ieee80211_mgmt *mgmt; 2247 2248 mgmt = (const struct ieee80211_mgmt *) buf; 2249 2250 /* Include P2P IE(s) from the frame generated in user space. */ 2251 2252 p2p = kmalloc(len, GFP_KERNEL); 2253 if (p2p == NULL) 2254 return -ENOMEM; 2255 p2p_len = 0; 2256 2257 pos = mgmt->u.probe_resp.variable; 2258 while (pos + 1 < buf + len) { 2259 if (pos + 2 + pos[1] > buf + len) 2260 break; 2261 if (ath6kl_is_p2p_ie(pos)) { 2262 memcpy(p2p + p2p_len, pos, 2 + pos[1]); 2263 p2p_len += 2 + pos[1]; 2264 } 2265 pos += 2 + pos[1]; 2266 } 2267 2268 ret = ath6kl_wmi_send_probe_response_cmd(ar->wmi, vif->fw_vif_idx, freq, 2269 mgmt->da, p2p, p2p_len); 2270 kfree(p2p); 2271 return ret; 2272} 2273 2274static int ath6kl_mgmt_tx(struct wiphy *wiphy, struct net_device *dev, 2275 struct ieee80211_channel *chan, bool offchan, 2276 enum nl80211_channel_type channel_type, 2277 bool channel_type_valid, unsigned int wait, 2278 const u8 *buf, size_t len, bool no_cck, 2279 bool dont_wait_for_ack, u64 *cookie) 2280{ 2281 struct ath6kl *ar = ath6kl_priv(dev); 2282 struct ath6kl_vif *vif = netdev_priv(dev); 2283 u32 id; 2284 const struct ieee80211_mgmt *mgmt; 2285 2286 mgmt = (const struct ieee80211_mgmt *) buf; 2287 if (buf + len >= mgmt->u.probe_resp.variable && 2288 vif->nw_type == AP_NETWORK && test_bit(CONNECTED, &vif->flags) && 2289 ieee80211_is_probe_resp(mgmt->frame_control)) { 2290 /* 2291 * Send Probe Response frame in AP mode using a separate WMI 2292 * command to allow the target to fill in the generic IEs. 2293 */ 2294 *cookie = 0; /* TX status not supported */ 2295 return ath6kl_send_go_probe_resp(vif, buf, len, 2296 chan->center_freq); 2297 } 2298 2299 id = vif->send_action_id++; 2300 if (id == 0) { 2301 /* 2302 * 0 is a reserved value in the WMI command and shall not be 2303 * used for the command. 2304 */ 2305 id = vif->send_action_id++; 2306 } 2307 2308 *cookie = id; 2309 return ath6kl_wmi_send_action_cmd(ar->wmi, vif->fw_vif_idx, id, 2310 chan->center_freq, wait, 2311 buf, len); 2312} 2313 2314static void ath6kl_mgmt_frame_register(struct wiphy *wiphy, 2315 struct net_device *dev, 2316 u16 frame_type, bool reg) 2317{ 2318 struct ath6kl_vif *vif = netdev_priv(dev); 2319 2320 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: frame_type=0x%x reg=%d\n", 2321 __func__, frame_type, reg); 2322 if (frame_type == IEEE80211_STYPE_PROBE_REQ) { 2323 /* 2324 * Note: This notification callback is not allowed to sleep, so 2325 * we cannot send WMI_PROBE_REQ_REPORT_CMD here. Instead, we 2326 * hardcode target to report Probe Request frames all the time. 2327 */ 2328 vif->probe_req_report = reg; 2329 } 2330} 2331 2332static const struct ieee80211_txrx_stypes 2333ath6kl_mgmt_stypes[NUM_NL80211_IFTYPES] = { 2334 [NL80211_IFTYPE_STATION] = { 2335 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) | 2336 BIT(IEEE80211_STYPE_PROBE_RESP >> 4), 2337 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 2338 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 2339 }, 2340 [NL80211_IFTYPE_P2P_CLIENT] = { 2341 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) | 2342 BIT(IEEE80211_STYPE_PROBE_RESP >> 4), 2343 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 2344 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 2345 }, 2346 [NL80211_IFTYPE_P2P_GO] = { 2347 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) | 2348 BIT(IEEE80211_STYPE_PROBE_RESP >> 4), 2349 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 2350 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 2351 }, 2352}; 2353 2354static struct cfg80211_ops ath6kl_cfg80211_ops = { 2355 .add_virtual_intf = ath6kl_cfg80211_add_iface, 2356 .del_virtual_intf = ath6kl_cfg80211_del_iface, 2357 .change_virtual_intf = ath6kl_cfg80211_change_iface, 2358 .scan = ath6kl_cfg80211_scan, 2359 .connect = ath6kl_cfg80211_connect, 2360 .disconnect = ath6kl_cfg80211_disconnect, 2361 .add_key = ath6kl_cfg80211_add_key, 2362 .get_key = ath6kl_cfg80211_get_key, 2363 .del_key = ath6kl_cfg80211_del_key, 2364 .set_default_key = ath6kl_cfg80211_set_default_key, 2365 .set_wiphy_params = ath6kl_cfg80211_set_wiphy_params, 2366 .set_tx_power = ath6kl_cfg80211_set_txpower, 2367 .get_tx_power = ath6kl_cfg80211_get_txpower, 2368 .set_power_mgmt = ath6kl_cfg80211_set_power_mgmt, 2369 .join_ibss = ath6kl_cfg80211_join_ibss, 2370 .leave_ibss = ath6kl_cfg80211_leave_ibss, 2371 .get_station = ath6kl_get_station, 2372 .set_pmksa = ath6kl_set_pmksa, 2373 .del_pmksa = ath6kl_del_pmksa, 2374 .flush_pmksa = ath6kl_flush_pmksa, 2375 CFG80211_TESTMODE_CMD(ath6kl_tm_cmd) 2376#ifdef CONFIG_PM 2377 .suspend = __ath6kl_cfg80211_suspend, 2378 .resume = __ath6kl_cfg80211_resume, 2379#endif 2380 .set_channel = ath6kl_set_channel, 2381 .add_beacon = ath6kl_add_beacon, 2382 .set_beacon = ath6kl_set_beacon, 2383 .del_beacon = ath6kl_del_beacon, 2384 .change_station = ath6kl_change_station, 2385 .remain_on_channel = ath6kl_remain_on_channel, 2386 .cancel_remain_on_channel = ath6kl_cancel_remain_on_channel, 2387 .mgmt_tx = ath6kl_mgmt_tx, 2388 .mgmt_frame_register = ath6kl_mgmt_frame_register, 2389}; 2390 2391void ath6kl_cfg80211_stop(struct ath6kl *ar) 2392{ 2393 struct ath6kl_vif *vif; 2394 2395 /* FIXME: for multi vif */ 2396 vif = ath6kl_vif_first(ar); 2397 if (!vif) { 2398 /* save the current power mode before enabling power save */ 2399 ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode; 2400 2401 if (ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER) != 0) 2402 ath6kl_warn("ath6kl_deep_sleep_enable: " 2403 "wmi_powermode_cmd failed\n"); 2404 return; 2405 } 2406 2407 switch (vif->sme_state) { 2408 case SME_CONNECTING: 2409 cfg80211_connect_result(vif->ndev, vif->bssid, NULL, 0, 2410 NULL, 0, 2411 WLAN_STATUS_UNSPECIFIED_FAILURE, 2412 GFP_KERNEL); 2413 break; 2414 case SME_CONNECTED: 2415 default: 2416 /* 2417 * FIXME: oddly enough smeState is in DISCONNECTED during 2418 * suspend, why? Need to send disconnected event in that 2419 * state. 2420 */ 2421 cfg80211_disconnected(vif->ndev, 0, NULL, 0, GFP_KERNEL); 2422 break; 2423 } 2424 2425 if (test_bit(CONNECTED, &vif->flags) || 2426 test_bit(CONNECT_PEND, &vif->flags)) 2427 ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx); 2428 2429 vif->sme_state = SME_DISCONNECTED; 2430 clear_bit(CONNECTED, &vif->flags); 2431 clear_bit(CONNECT_PEND, &vif->flags); 2432 2433 /* disable scanning */ 2434 if (ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx, 0xFFFF, 0, 0, 2435 0, 0, 0, 0, 0, 0, 0) != 0) 2436 printk(KERN_WARNING "ath6kl: failed to disable scan " 2437 "during suspend\n"); 2438 2439 ath6kl_cfg80211_scan_complete_event(vif, true); 2440} 2441 2442struct ath6kl *ath6kl_core_alloc(struct device *dev) 2443{ 2444 struct ath6kl *ar; 2445 struct wiphy *wiphy; 2446 u8 ctr; 2447 2448 /* create a new wiphy for use with cfg80211 */ 2449 wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl)); 2450 2451 if (!wiphy) { 2452 ath6kl_err("couldn't allocate wiphy device\n"); 2453 return NULL; 2454 } 2455 2456 ar = wiphy_priv(wiphy); 2457 if (!multi_norm_if_support) 2458 ar->p2p = !!ath6kl_p2p; 2459 ar->wiphy = wiphy; 2460 ar->dev = dev; 2461 2462 if (multi_norm_if_support) 2463 ar->max_norm_iface = 2; 2464 else 2465 ar->max_norm_iface = 1; 2466 2467 /* FIXME: Remove this once the multivif support is enabled */ 2468 ar->max_norm_iface = 1; 2469 2470 spin_lock_init(&ar->lock); 2471 spin_lock_init(&ar->mcastpsq_lock); 2472 spin_lock_init(&ar->list_lock); 2473 2474 init_waitqueue_head(&ar->event_wq); 2475 sema_init(&ar->sem, 1); 2476 2477 INIT_LIST_HEAD(&ar->amsdu_rx_buffer_queue); 2478 INIT_LIST_HEAD(&ar->vif_list); 2479 2480 clear_bit(WMI_ENABLED, &ar->flag); 2481 clear_bit(SKIP_SCAN, &ar->flag); 2482 clear_bit(DESTROY_IN_PROGRESS, &ar->flag); 2483 2484 ar->listen_intvl_t = A_DEFAULT_LISTEN_INTERVAL; 2485 ar->listen_intvl_b = 0; 2486 ar->tx_pwr = 0; 2487 2488 ar->intra_bss = 1; 2489 memset(&ar->sc_params, 0, sizeof(ar->sc_params)); 2490 ar->sc_params.short_scan_ratio = WMI_SHORTSCANRATIO_DEFAULT; 2491 ar->sc_params.scan_ctrl_flags = DEFAULT_SCAN_CTRL_FLAGS; 2492 ar->lrssi_roam_threshold = DEF_LRSSI_ROAM_THRESHOLD; 2493 2494 ar->state = ATH6KL_STATE_OFF; 2495 2496 memset((u8 *)ar->sta_list, 0, 2497 AP_MAX_NUM_STA * sizeof(struct ath6kl_sta)); 2498 2499 /* Init the PS queues */ 2500 for (ctr = 0; ctr < AP_MAX_NUM_STA; ctr++) { 2501 spin_lock_init(&ar->sta_list[ctr].psq_lock); 2502 skb_queue_head_init(&ar->sta_list[ctr].psq); 2503 } 2504 2505 skb_queue_head_init(&ar->mcastpsq); 2506 2507 memcpy(ar->ap_country_code, DEF_AP_COUNTRY_CODE, 3); 2508 2509 return ar; 2510} 2511 2512int ath6kl_register_ieee80211_hw(struct ath6kl *ar) 2513{ 2514 struct wiphy *wiphy = ar->wiphy; 2515 int ret; 2516 2517 wiphy->mgmt_stypes = ath6kl_mgmt_stypes; 2518 2519 wiphy->max_remain_on_channel_duration = 5000; 2520 2521 /* set device pointer for wiphy */ 2522 set_wiphy_dev(wiphy, ar->dev); 2523 2524 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 2525 BIT(NL80211_IFTYPE_ADHOC) | 2526 BIT(NL80211_IFTYPE_AP); 2527 if (ar->p2p) { 2528 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_GO) | 2529 BIT(NL80211_IFTYPE_P2P_CLIENT); 2530 } 2531 2532 /* max num of ssids that can be probed during scanning */ 2533 wiphy->max_scan_ssids = MAX_PROBED_SSID_INDEX; 2534 wiphy->max_scan_ie_len = 1000; /* FIX: what is correct limit? */ 2535 wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz; 2536 wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz; 2537 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 2538 2539 wiphy->cipher_suites = cipher_suites; 2540 wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 2541 2542 wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT | 2543 WIPHY_WOWLAN_DISCONNECT | 2544 WIPHY_WOWLAN_GTK_REKEY_FAILURE | 2545 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY | 2546 WIPHY_WOWLAN_EAP_IDENTITY_REQ | 2547 WIPHY_WOWLAN_4WAY_HANDSHAKE; 2548 wiphy->wowlan.n_patterns = WOW_MAX_FILTERS_PER_LIST; 2549 wiphy->wowlan.pattern_min_len = 1; 2550 wiphy->wowlan.pattern_max_len = WOW_PATTERN_SIZE; 2551 2552 ret = wiphy_register(wiphy); 2553 if (ret < 0) { 2554 ath6kl_err("couldn't register wiphy device\n"); 2555 return ret; 2556 } 2557 2558 return 0; 2559} 2560 2561static int ath6kl_init_if_data(struct ath6kl_vif *vif) 2562{ 2563 vif->aggr_cntxt = aggr_init(vif->ndev); 2564 if (!vif->aggr_cntxt) { 2565 ath6kl_err("failed to initialize aggr\n"); 2566 return -ENOMEM; 2567 } 2568 2569 setup_timer(&vif->disconnect_timer, disconnect_timer_handler, 2570 (unsigned long) vif->ndev); 2571 set_bit(WMM_ENABLED, &vif->flags); 2572 spin_lock_init(&vif->if_lock); 2573 2574 return 0; 2575} 2576 2577void ath6kl_deinit_if_data(struct ath6kl_vif *vif) 2578{ 2579 struct ath6kl *ar = vif->ar; 2580 2581 aggr_module_destroy(vif->aggr_cntxt); 2582 2583 ar->avail_idx_map |= BIT(vif->fw_vif_idx); 2584 2585 if (vif->nw_type == ADHOC_NETWORK) 2586 ar->ibss_if_active = false; 2587 2588 unregister_netdevice(vif->ndev); 2589 2590 ar->num_vif--; 2591} 2592 2593struct net_device *ath6kl_interface_add(struct ath6kl *ar, char *name, 2594 enum nl80211_iftype type, u8 fw_vif_idx, 2595 u8 nw_type) 2596{ 2597 struct net_device *ndev; 2598 struct ath6kl_vif *vif; 2599 2600 ndev = alloc_netdev(sizeof(*vif), name, ether_setup); 2601 if (!ndev) 2602 return NULL; 2603 2604 vif = netdev_priv(ndev); 2605 ndev->ieee80211_ptr = &vif->wdev; 2606 vif->wdev.wiphy = ar->wiphy; 2607 vif->ar = ar; 2608 vif->ndev = ndev; 2609 SET_NETDEV_DEV(ndev, wiphy_dev(vif->wdev.wiphy)); 2610 vif->wdev.netdev = ndev; 2611 vif->wdev.iftype = type; 2612 vif->fw_vif_idx = fw_vif_idx; 2613 vif->nw_type = vif->next_mode = nw_type; 2614 2615 memcpy(ndev->dev_addr, ar->mac_addr, ETH_ALEN); 2616 if (fw_vif_idx != 0) 2617 ndev->dev_addr[0] = (ndev->dev_addr[0] ^ (1 << fw_vif_idx)) | 2618 0x2; 2619 2620 init_netdev(ndev); 2621 2622 ath6kl_init_control_info(vif); 2623 2624 /* TODO: Pass interface specific pointer instead of ar */ 2625 if (ath6kl_init_if_data(vif)) 2626 goto err; 2627 2628 if (register_netdevice(ndev)) 2629 goto err; 2630 2631 ar->avail_idx_map &= ~BIT(fw_vif_idx); 2632 vif->sme_state = SME_DISCONNECTED; 2633 set_bit(WLAN_ENABLED, &vif->flags); 2634 ar->wlan_pwr_state = WLAN_POWER_STATE_ON; 2635 set_bit(NETDEV_REGISTERED, &vif->flags); 2636 2637 if (type == NL80211_IFTYPE_ADHOC) 2638 ar->ibss_if_active = true; 2639 2640 spin_lock_bh(&ar->list_lock); 2641 list_add_tail(&vif->list, &ar->vif_list); 2642 spin_unlock_bh(&ar->list_lock); 2643 2644 return ndev; 2645 2646err: 2647 aggr_module_destroy(vif->aggr_cntxt); 2648 free_netdev(ndev); 2649 return NULL; 2650} 2651 2652void ath6kl_deinit_ieee80211_hw(struct ath6kl *ar) 2653{ 2654 wiphy_unregister(ar->wiphy); 2655 wiphy_free(ar->wiphy); 2656} 2657