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