1 /* 2 * Atheros CARL9170 driver 3 * 4 * mac80211 interaction code 5 * 6 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net> 7 * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; see the file COPYING. If not, see 21 * http://www.gnu.org/licenses/. 22 * 23 * This file incorporates work covered by the following copyright and 24 * permission notice: 25 * Copyright (c) 2007-2008 Atheros Communications, Inc. 26 * 27 * Permission to use, copy, modify, and/or distribute this software for any 28 * purpose with or without fee is hereby granted, provided that the above 29 * copyright notice and this permission notice appear in all copies. 30 * 31 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 32 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 33 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 34 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 35 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 36 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 37 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 38 */ 39 40 #include <linux/init.h> 41 #include <linux/slab.h> 42 #include <linux/module.h> 43 #include <linux/etherdevice.h> 44 #include <linux/random.h> 45 #include <net/mac80211.h> 46 #include <net/cfg80211.h> 47 #include "hw.h" 48 #include "carl9170.h" 49 #include "cmd.h" 50 51 static int modparam_nohwcrypt; 52 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO); 53 MODULE_PARM_DESC(nohwcrypt, "Disable hardware crypto offload."); 54 55 int modparam_noht; 56 module_param_named(noht, modparam_noht, int, S_IRUGO); 57 MODULE_PARM_DESC(noht, "Disable MPDU aggregation."); 58 59 #define RATE(_bitrate, _hw_rate, _txpidx, _flags) { \ 60 .bitrate = (_bitrate), \ 61 .flags = (_flags), \ 62 .hw_value = (_hw_rate) | (_txpidx) << 4, \ 63 } 64 65 struct ieee80211_rate __carl9170_ratetable[] = { 66 RATE(10, 0, 0, 0), 67 RATE(20, 1, 1, IEEE80211_RATE_SHORT_PREAMBLE), 68 RATE(55, 2, 2, IEEE80211_RATE_SHORT_PREAMBLE), 69 RATE(110, 3, 3, IEEE80211_RATE_SHORT_PREAMBLE), 70 RATE(60, 0xb, 0, 0), 71 RATE(90, 0xf, 0, 0), 72 RATE(120, 0xa, 0, 0), 73 RATE(180, 0xe, 0, 0), 74 RATE(240, 0x9, 0, 0), 75 RATE(360, 0xd, 1, 0), 76 RATE(480, 0x8, 2, 0), 77 RATE(540, 0xc, 3, 0), 78 }; 79 #undef RATE 80 81 #define carl9170_g_ratetable (__carl9170_ratetable + 0) 82 #define carl9170_g_ratetable_size 12 83 #define carl9170_a_ratetable (__carl9170_ratetable + 4) 84 #define carl9170_a_ratetable_size 8 85 86 /* 87 * NB: The hw_value is used as an index into the carl9170_phy_freq_params 88 * array in phy.c so that we don't have to do frequency lookups! 89 */ 90 #define CHAN(_freq, _idx) { \ 91 .center_freq = (_freq), \ 92 .hw_value = (_idx), \ 93 .max_power = 18, /* XXX */ \ 94 } 95 96 static struct ieee80211_channel carl9170_2ghz_chantable[] = { 97 CHAN(2412, 0), 98 CHAN(2417, 1), 99 CHAN(2422, 2), 100 CHAN(2427, 3), 101 CHAN(2432, 4), 102 CHAN(2437, 5), 103 CHAN(2442, 6), 104 CHAN(2447, 7), 105 CHAN(2452, 8), 106 CHAN(2457, 9), 107 CHAN(2462, 10), 108 CHAN(2467, 11), 109 CHAN(2472, 12), 110 CHAN(2484, 13), 111 }; 112 113 static struct ieee80211_channel carl9170_5ghz_chantable[] = { 114 CHAN(4920, 14), 115 CHAN(4940, 15), 116 CHAN(4960, 16), 117 CHAN(4980, 17), 118 CHAN(5040, 18), 119 CHAN(5060, 19), 120 CHAN(5080, 20), 121 CHAN(5180, 21), 122 CHAN(5200, 22), 123 CHAN(5220, 23), 124 CHAN(5240, 24), 125 CHAN(5260, 25), 126 CHAN(5280, 26), 127 CHAN(5300, 27), 128 CHAN(5320, 28), 129 CHAN(5500, 29), 130 CHAN(5520, 30), 131 CHAN(5540, 31), 132 CHAN(5560, 32), 133 CHAN(5580, 33), 134 CHAN(5600, 34), 135 CHAN(5620, 35), 136 CHAN(5640, 36), 137 CHAN(5660, 37), 138 CHAN(5680, 38), 139 CHAN(5700, 39), 140 CHAN(5745, 40), 141 CHAN(5765, 41), 142 CHAN(5785, 42), 143 CHAN(5805, 43), 144 CHAN(5825, 44), 145 CHAN(5170, 45), 146 CHAN(5190, 46), 147 CHAN(5210, 47), 148 CHAN(5230, 48), 149 }; 150 #undef CHAN 151 152 #define CARL9170_HT_CAP \ 153 { \ 154 .ht_supported = true, \ 155 .cap = IEEE80211_HT_CAP_MAX_AMSDU | \ 156 IEEE80211_HT_CAP_SUP_WIDTH_20_40 | \ 157 IEEE80211_HT_CAP_SGI_40 | \ 158 IEEE80211_HT_CAP_DSSSCCK40 | \ 159 IEEE80211_HT_CAP_SM_PS, \ 160 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, \ 161 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \ 162 .mcs = { \ 163 .rx_mask = { 0xff, 0xff, 0, 0, 0x1, 0, 0, 0, 0, 0, }, \ 164 .rx_highest = cpu_to_le16(300), \ 165 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \ 166 }, \ 167 } 168 169 static struct ieee80211_supported_band carl9170_band_2GHz = { 170 .channels = carl9170_2ghz_chantable, 171 .n_channels = ARRAY_SIZE(carl9170_2ghz_chantable), 172 .bitrates = carl9170_g_ratetable, 173 .n_bitrates = carl9170_g_ratetable_size, 174 .ht_cap = CARL9170_HT_CAP, 175 }; 176 177 static struct ieee80211_supported_band carl9170_band_5GHz = { 178 .channels = carl9170_5ghz_chantable, 179 .n_channels = ARRAY_SIZE(carl9170_5ghz_chantable), 180 .bitrates = carl9170_a_ratetable, 181 .n_bitrates = carl9170_a_ratetable_size, 182 .ht_cap = CARL9170_HT_CAP, 183 }; 184 185 static void carl9170_ampdu_gc(struct ar9170 *ar) 186 { 187 struct carl9170_sta_tid *tid_info; 188 LIST_HEAD(tid_gc); 189 190 rcu_read_lock(); 191 list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) { 192 spin_lock_bh(&ar->tx_ampdu_list_lock); 193 if (tid_info->state == CARL9170_TID_STATE_SHUTDOWN) { 194 tid_info->state = CARL9170_TID_STATE_KILLED; 195 list_del_rcu(&tid_info->list); 196 ar->tx_ampdu_list_len--; 197 list_add_tail(&tid_info->tmp_list, &tid_gc); 198 } 199 spin_unlock_bh(&ar->tx_ampdu_list_lock); 200 201 } 202 rcu_assign_pointer(ar->tx_ampdu_iter, tid_info); 203 rcu_read_unlock(); 204 205 synchronize_rcu(); 206 207 while (!list_empty(&tid_gc)) { 208 struct sk_buff *skb; 209 tid_info = list_first_entry(&tid_gc, struct carl9170_sta_tid, 210 tmp_list); 211 212 while ((skb = __skb_dequeue(&tid_info->queue))) 213 carl9170_tx_status(ar, skb, false); 214 215 list_del_init(&tid_info->tmp_list); 216 kfree(tid_info); 217 } 218 } 219 220 static void carl9170_flush(struct ar9170 *ar, bool drop_queued) 221 { 222 if (drop_queued) { 223 int i; 224 225 /* 226 * We can only drop frames which have not been uploaded 227 * to the device yet. 228 */ 229 230 for (i = 0; i < ar->hw->queues; i++) { 231 struct sk_buff *skb; 232 233 while ((skb = skb_dequeue(&ar->tx_pending[i]))) { 234 struct ieee80211_tx_info *info; 235 236 info = IEEE80211_SKB_CB(skb); 237 if (info->flags & IEEE80211_TX_CTL_AMPDU) 238 atomic_dec(&ar->tx_ampdu_upload); 239 240 carl9170_tx_status(ar, skb, false); 241 } 242 } 243 } 244 245 /* Wait for all other outstanding frames to timeout. */ 246 if (atomic_read(&ar->tx_total_queued)) 247 WARN_ON(wait_for_completion_timeout(&ar->tx_flush, HZ) == 0); 248 } 249 250 static void carl9170_flush_ba(struct ar9170 *ar) 251 { 252 struct sk_buff_head free; 253 struct carl9170_sta_tid *tid_info; 254 struct sk_buff *skb; 255 256 __skb_queue_head_init(&free); 257 258 rcu_read_lock(); 259 spin_lock_bh(&ar->tx_ampdu_list_lock); 260 list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) { 261 if (tid_info->state > CARL9170_TID_STATE_SUSPEND) { 262 tid_info->state = CARL9170_TID_STATE_SUSPEND; 263 264 spin_lock(&tid_info->lock); 265 while ((skb = __skb_dequeue(&tid_info->queue))) 266 __skb_queue_tail(&free, skb); 267 spin_unlock(&tid_info->lock); 268 } 269 } 270 spin_unlock_bh(&ar->tx_ampdu_list_lock); 271 rcu_read_unlock(); 272 273 while ((skb = __skb_dequeue(&free))) 274 carl9170_tx_status(ar, skb, false); 275 } 276 277 static void carl9170_zap_queues(struct ar9170 *ar) 278 { 279 struct carl9170_vif_info *cvif; 280 unsigned int i; 281 282 carl9170_ampdu_gc(ar); 283 284 carl9170_flush_ba(ar); 285 carl9170_flush(ar, true); 286 287 for (i = 0; i < ar->hw->queues; i++) { 288 spin_lock_bh(&ar->tx_status[i].lock); 289 while (!skb_queue_empty(&ar->tx_status[i])) { 290 struct sk_buff *skb; 291 292 skb = skb_peek(&ar->tx_status[i]); 293 carl9170_tx_get_skb(skb); 294 spin_unlock_bh(&ar->tx_status[i].lock); 295 carl9170_tx_drop(ar, skb); 296 spin_lock_bh(&ar->tx_status[i].lock); 297 carl9170_tx_put_skb(skb); 298 } 299 spin_unlock_bh(&ar->tx_status[i].lock); 300 } 301 302 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_SOFT < 1); 303 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD < CARL9170_NUM_TX_LIMIT_SOFT); 304 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD >= CARL9170_BAW_BITS); 305 306 /* reinitialize queues statistics */ 307 memset(&ar->tx_stats, 0, sizeof(ar->tx_stats)); 308 for (i = 0; i < ar->hw->queues; i++) 309 ar->tx_stats[i].limit = CARL9170_NUM_TX_LIMIT_HARD; 310 311 for (i = 0; i < DIV_ROUND_UP(ar->fw.mem_blocks, BITS_PER_LONG); i++) 312 ar->mem_bitmap[i] = 0; 313 314 rcu_read_lock(); 315 list_for_each_entry_rcu(cvif, &ar->vif_list, list) { 316 spin_lock_bh(&ar->beacon_lock); 317 dev_kfree_skb_any(cvif->beacon); 318 cvif->beacon = NULL; 319 spin_unlock_bh(&ar->beacon_lock); 320 } 321 rcu_read_unlock(); 322 323 atomic_set(&ar->tx_ampdu_upload, 0); 324 atomic_set(&ar->tx_ampdu_scheduler, 0); 325 atomic_set(&ar->tx_total_pending, 0); 326 atomic_set(&ar->tx_total_queued, 0); 327 atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks); 328 } 329 330 #define CARL9170_FILL_QUEUE(queue, ai_fs, cwmin, cwmax, _txop) \ 331 do { \ 332 queue.aifs = ai_fs; \ 333 queue.cw_min = cwmin; \ 334 queue.cw_max = cwmax; \ 335 queue.txop = _txop; \ 336 } while (0) 337 338 static int carl9170_op_start(struct ieee80211_hw *hw) 339 { 340 struct ar9170 *ar = hw->priv; 341 int err, i; 342 343 mutex_lock(&ar->mutex); 344 345 carl9170_zap_queues(ar); 346 347 /* reset QoS defaults */ 348 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VO], 2, 3, 7, 47); 349 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VI], 2, 7, 15, 94); 350 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BE], 3, 15, 1023, 0); 351 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BK], 7, 15, 1023, 0); 352 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_SPECIAL], 2, 3, 7, 0); 353 354 ar->current_factor = ar->current_density = -1; 355 /* "The first key is unique." */ 356 ar->usedkeys = 1; 357 ar->filter_state = 0; 358 ar->ps.last_action = jiffies; 359 ar->ps.last_slept = jiffies; 360 ar->erp_mode = CARL9170_ERP_AUTO; 361 ar->rx_software_decryption = false; 362 ar->disable_offload = false; 363 364 for (i = 0; i < ar->hw->queues; i++) { 365 ar->queue_stop_timeout[i] = jiffies; 366 ar->max_queue_stop_timeout[i] = 0; 367 } 368 369 atomic_set(&ar->mem_allocs, 0); 370 371 err = carl9170_usb_open(ar); 372 if (err) 373 goto out; 374 375 err = carl9170_init_mac(ar); 376 if (err) 377 goto out; 378 379 err = carl9170_set_qos(ar); 380 if (err) 381 goto out; 382 383 if (ar->fw.rx_filter) { 384 err = carl9170_rx_filter(ar, CARL9170_RX_FILTER_OTHER_RA | 385 CARL9170_RX_FILTER_CTL_OTHER | CARL9170_RX_FILTER_BAD); 386 if (err) 387 goto out; 388 } 389 390 err = carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 391 AR9170_DMA_TRIGGER_RXQ); 392 if (err) 393 goto out; 394 395 /* Clear key-cache */ 396 for (i = 0; i < AR9170_CAM_MAX_USER + 4; i++) { 397 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE, 398 0, NULL, 0); 399 if (err) 400 goto out; 401 402 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE, 403 1, NULL, 0); 404 if (err) 405 goto out; 406 407 if (i < AR9170_CAM_MAX_USER) { 408 err = carl9170_disable_key(ar, i); 409 if (err) 410 goto out; 411 } 412 } 413 414 carl9170_set_state_when(ar, CARL9170_IDLE, CARL9170_STARTED); 415 416 ieee80211_wake_queues(ar->hw); 417 err = 0; 418 419 out: 420 mutex_unlock(&ar->mutex); 421 return err; 422 } 423 424 static void carl9170_cancel_worker(struct ar9170 *ar) 425 { 426 cancel_delayed_work_sync(&ar->tx_janitor); 427 #ifdef CONFIG_CARL9170_LEDS 428 cancel_delayed_work_sync(&ar->led_work); 429 #endif /* CONFIG_CARL9170_LEDS */ 430 cancel_work_sync(&ar->ps_work); 431 cancel_work_sync(&ar->ping_work); 432 cancel_work_sync(&ar->ampdu_work); 433 } 434 435 static void carl9170_op_stop(struct ieee80211_hw *hw) 436 { 437 struct ar9170 *ar = hw->priv; 438 439 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE); 440 441 ieee80211_stop_queues(ar->hw); 442 443 mutex_lock(&ar->mutex); 444 if (IS_ACCEPTING_CMD(ar)) { 445 rcu_assign_pointer(ar->beacon_iter, NULL); 446 447 carl9170_led_set_state(ar, 0); 448 449 /* stop DMA */ 450 carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 0); 451 carl9170_usb_stop(ar); 452 } 453 454 carl9170_zap_queues(ar); 455 mutex_unlock(&ar->mutex); 456 457 carl9170_cancel_worker(ar); 458 } 459 460 static void carl9170_restart_work(struct work_struct *work) 461 { 462 struct ar9170 *ar = container_of(work, struct ar9170, 463 restart_work); 464 int err; 465 466 ar->usedkeys = 0; 467 ar->filter_state = 0; 468 carl9170_cancel_worker(ar); 469 470 mutex_lock(&ar->mutex); 471 err = carl9170_usb_restart(ar); 472 if (net_ratelimit()) { 473 if (err) { 474 dev_err(&ar->udev->dev, "Failed to restart device " 475 " (%d).\n", err); 476 } else { 477 dev_info(&ar->udev->dev, "device restarted " 478 "successfully.\n"); 479 } 480 } 481 482 carl9170_zap_queues(ar); 483 mutex_unlock(&ar->mutex); 484 if (!err) { 485 ar->restart_counter++; 486 atomic_set(&ar->pending_restarts, 0); 487 488 ieee80211_restart_hw(ar->hw); 489 } else { 490 /* 491 * The reset was unsuccessful and the device seems to 492 * be dead. But there's still one option: a low-level 493 * usb subsystem reset... 494 */ 495 496 carl9170_usb_reset(ar); 497 } 498 } 499 500 void carl9170_restart(struct ar9170 *ar, const enum carl9170_restart_reasons r) 501 { 502 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE); 503 504 /* 505 * Sometimes, an error can trigger several different reset events. 506 * By ignoring these *surplus* reset events, the device won't be 507 * killed again, right after it has recovered. 508 */ 509 if (atomic_inc_return(&ar->pending_restarts) > 1) { 510 dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r); 511 return; 512 } 513 514 ieee80211_stop_queues(ar->hw); 515 516 dev_err(&ar->udev->dev, "restart device (%d)\n", r); 517 518 if (!WARN_ON(r == CARL9170_RR_NO_REASON) || 519 !WARN_ON(r >= __CARL9170_RR_LAST)) 520 ar->last_reason = r; 521 522 if (!ar->registered) 523 return; 524 525 if (IS_ACCEPTING_CMD(ar) && !ar->needs_full_reset) 526 ieee80211_queue_work(ar->hw, &ar->restart_work); 527 else 528 carl9170_usb_reset(ar); 529 530 /* 531 * At this point, the device instance might have vanished/disabled. 532 * So, don't put any code which access the ar9170 struct 533 * without proper protection. 534 */ 535 } 536 537 static void carl9170_ping_work(struct work_struct *work) 538 { 539 struct ar9170 *ar = container_of(work, struct ar9170, ping_work); 540 int err; 541 542 if (!IS_STARTED(ar)) 543 return; 544 545 mutex_lock(&ar->mutex); 546 err = carl9170_echo_test(ar, 0xdeadbeef); 547 if (err) 548 carl9170_restart(ar, CARL9170_RR_UNRESPONSIVE_DEVICE); 549 mutex_unlock(&ar->mutex); 550 } 551 552 static int carl9170_init_interface(struct ar9170 *ar, 553 struct ieee80211_vif *vif) 554 { 555 struct ath_common *common = &ar->common; 556 int err; 557 558 if (!vif) { 559 WARN_ON_ONCE(IS_STARTED(ar)); 560 return 0; 561 } 562 563 memcpy(common->macaddr, vif->addr, ETH_ALEN); 564 565 if (modparam_nohwcrypt || 566 ((vif->type != NL80211_IFTYPE_STATION) && 567 (vif->type != NL80211_IFTYPE_AP))) { 568 ar->rx_software_decryption = true; 569 ar->disable_offload = true; 570 } 571 572 err = carl9170_set_operating_mode(ar); 573 return err; 574 } 575 576 static int carl9170_op_add_interface(struct ieee80211_hw *hw, 577 struct ieee80211_vif *vif) 578 { 579 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv; 580 struct ieee80211_vif *main_vif; 581 struct ar9170 *ar = hw->priv; 582 int vif_id = -1, err = 0; 583 584 mutex_lock(&ar->mutex); 585 rcu_read_lock(); 586 if (vif_priv->active) { 587 /* 588 * Skip the interface structure initialization, 589 * if the vif survived the _restart call. 590 */ 591 vif_id = vif_priv->id; 592 vif_priv->enable_beacon = false; 593 594 spin_lock_bh(&ar->beacon_lock); 595 dev_kfree_skb_any(vif_priv->beacon); 596 vif_priv->beacon = NULL; 597 spin_unlock_bh(&ar->beacon_lock); 598 599 goto init; 600 } 601 602 main_vif = carl9170_get_main_vif(ar); 603 604 if (main_vif) { 605 switch (main_vif->type) { 606 case NL80211_IFTYPE_STATION: 607 if (vif->type == NL80211_IFTYPE_STATION) 608 break; 609 610 err = -EBUSY; 611 rcu_read_unlock(); 612 613 goto unlock; 614 615 case NL80211_IFTYPE_AP: 616 if ((vif->type == NL80211_IFTYPE_STATION) || 617 (vif->type == NL80211_IFTYPE_WDS) || 618 (vif->type == NL80211_IFTYPE_AP)) 619 break; 620 621 err = -EBUSY; 622 rcu_read_unlock(); 623 goto unlock; 624 625 default: 626 rcu_read_unlock(); 627 goto unlock; 628 } 629 } 630 631 vif_id = bitmap_find_free_region(&ar->vif_bitmap, ar->fw.vif_num, 0); 632 633 if (vif_id < 0) { 634 rcu_read_unlock(); 635 636 err = -ENOSPC; 637 goto unlock; 638 } 639 640 BUG_ON(ar->vif_priv[vif_id].id != vif_id); 641 642 vif_priv->active = true; 643 vif_priv->id = vif_id; 644 vif_priv->enable_beacon = false; 645 ar->vifs++; 646 list_add_tail_rcu(&vif_priv->list, &ar->vif_list); 647 rcu_assign_pointer(ar->vif_priv[vif_id].vif, vif); 648 649 init: 650 if (carl9170_get_main_vif(ar) == vif) { 651 rcu_assign_pointer(ar->beacon_iter, vif_priv); 652 rcu_read_unlock(); 653 654 err = carl9170_init_interface(ar, vif); 655 if (err) 656 goto unlock; 657 } else { 658 rcu_read_unlock(); 659 err = carl9170_mod_virtual_mac(ar, vif_id, vif->addr); 660 661 if (err) 662 goto unlock; 663 } 664 665 if (ar->fw.tx_seq_table) { 666 err = carl9170_write_reg(ar, ar->fw.tx_seq_table + vif_id * 4, 667 0); 668 if (err) 669 goto unlock; 670 } 671 672 unlock: 673 if (err && (vif_id >= 0)) { 674 vif_priv->active = false; 675 bitmap_release_region(&ar->vif_bitmap, vif_id, 0); 676 ar->vifs--; 677 rcu_assign_pointer(ar->vif_priv[vif_id].vif, NULL); 678 list_del_rcu(&vif_priv->list); 679 mutex_unlock(&ar->mutex); 680 synchronize_rcu(); 681 } else { 682 if (ar->vifs > 1) 683 ar->ps.off_override |= PS_OFF_VIF; 684 685 mutex_unlock(&ar->mutex); 686 } 687 688 return err; 689 } 690 691 static void carl9170_op_remove_interface(struct ieee80211_hw *hw, 692 struct ieee80211_vif *vif) 693 { 694 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv; 695 struct ieee80211_vif *main_vif; 696 struct ar9170 *ar = hw->priv; 697 unsigned int id; 698 699 mutex_lock(&ar->mutex); 700 701 if (WARN_ON_ONCE(!vif_priv->active)) 702 goto unlock; 703 704 ar->vifs--; 705 706 rcu_read_lock(); 707 main_vif = carl9170_get_main_vif(ar); 708 709 id = vif_priv->id; 710 711 vif_priv->active = false; 712 WARN_ON(vif_priv->enable_beacon); 713 vif_priv->enable_beacon = false; 714 list_del_rcu(&vif_priv->list); 715 rcu_assign_pointer(ar->vif_priv[id].vif, NULL); 716 717 if (vif == main_vif) { 718 rcu_read_unlock(); 719 720 if (ar->vifs) { 721 WARN_ON(carl9170_init_interface(ar, 722 carl9170_get_main_vif(ar))); 723 } else { 724 carl9170_set_operating_mode(ar); 725 } 726 } else { 727 rcu_read_unlock(); 728 729 WARN_ON(carl9170_mod_virtual_mac(ar, id, NULL)); 730 } 731 732 carl9170_update_beacon(ar, false); 733 carl9170_flush_cab(ar, id); 734 735 spin_lock_bh(&ar->beacon_lock); 736 dev_kfree_skb_any(vif_priv->beacon); 737 vif_priv->beacon = NULL; 738 spin_unlock_bh(&ar->beacon_lock); 739 740 bitmap_release_region(&ar->vif_bitmap, id, 0); 741 742 carl9170_set_beacon_timers(ar); 743 744 if (ar->vifs == 1) 745 ar->ps.off_override &= ~PS_OFF_VIF; 746 747 unlock: 748 mutex_unlock(&ar->mutex); 749 750 synchronize_rcu(); 751 } 752 753 void carl9170_ps_check(struct ar9170 *ar) 754 { 755 ieee80211_queue_work(ar->hw, &ar->ps_work); 756 } 757 758 /* caller must hold ar->mutex */ 759 static int carl9170_ps_update(struct ar9170 *ar) 760 { 761 bool ps = false; 762 int err = 0; 763 764 if (!ar->ps.off_override) 765 ps = (ar->hw->conf.flags & IEEE80211_CONF_PS); 766 767 if (ps != ar->ps.state) { 768 err = carl9170_powersave(ar, ps); 769 if (err) 770 return err; 771 772 if (ar->ps.state && !ps) { 773 ar->ps.sleep_ms = jiffies_to_msecs(jiffies - 774 ar->ps.last_action); 775 } 776 777 if (ps) 778 ar->ps.last_slept = jiffies; 779 780 ar->ps.last_action = jiffies; 781 ar->ps.state = ps; 782 } 783 784 return 0; 785 } 786 787 static void carl9170_ps_work(struct work_struct *work) 788 { 789 struct ar9170 *ar = container_of(work, struct ar9170, 790 ps_work); 791 mutex_lock(&ar->mutex); 792 if (IS_STARTED(ar)) 793 WARN_ON_ONCE(carl9170_ps_update(ar) != 0); 794 mutex_unlock(&ar->mutex); 795 } 796 797 798 static int carl9170_op_config(struct ieee80211_hw *hw, u32 changed) 799 { 800 struct ar9170 *ar = hw->priv; 801 int err = 0; 802 803 mutex_lock(&ar->mutex); 804 if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) { 805 /* TODO */ 806 err = 0; 807 } 808 809 if (changed & IEEE80211_CONF_CHANGE_PS) { 810 err = carl9170_ps_update(ar); 811 if (err) 812 goto out; 813 } 814 815 if (changed & IEEE80211_CONF_CHANGE_POWER) { 816 /* TODO */ 817 err = 0; 818 } 819 820 if (changed & IEEE80211_CONF_CHANGE_SMPS) { 821 /* TODO */ 822 err = 0; 823 } 824 825 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 826 /* adjust slot time for 5 GHz */ 827 err = carl9170_set_slot_time(ar); 828 if (err) 829 goto out; 830 831 err = carl9170_set_channel(ar, hw->conf.channel, 832 hw->conf.channel_type, CARL9170_RFI_NONE); 833 if (err) 834 goto out; 835 836 err = carl9170_set_dyn_sifs_ack(ar); 837 if (err) 838 goto out; 839 840 err = carl9170_set_rts_cts_rate(ar); 841 if (err) 842 goto out; 843 } 844 845 out: 846 mutex_unlock(&ar->mutex); 847 return err; 848 } 849 850 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw, 851 struct netdev_hw_addr_list *mc_list) 852 { 853 struct netdev_hw_addr *ha; 854 u64 mchash; 855 856 /* always get broadcast frames */ 857 mchash = 1ULL << (0xff >> 2); 858 859 netdev_hw_addr_list_for_each(ha, mc_list) 860 mchash |= 1ULL << (ha->addr[5] >> 2); 861 862 return mchash; 863 } 864 865 static void carl9170_op_configure_filter(struct ieee80211_hw *hw, 866 unsigned int changed_flags, 867 unsigned int *new_flags, 868 u64 multicast) 869 { 870 struct ar9170 *ar = hw->priv; 871 872 /* mask supported flags */ 873 *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps; 874 875 if (!IS_ACCEPTING_CMD(ar)) 876 return; 877 878 mutex_lock(&ar->mutex); 879 880 ar->filter_state = *new_flags; 881 /* 882 * We can support more by setting the sniffer bit and 883 * then checking the error flags, later. 884 */ 885 886 if (*new_flags & FIF_ALLMULTI) 887 multicast = ~0ULL; 888 889 if (multicast != ar->cur_mc_hash) 890 WARN_ON(carl9170_update_multicast(ar, multicast)); 891 892 if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) { 893 ar->sniffer_enabled = !!(*new_flags & 894 (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)); 895 896 WARN_ON(carl9170_set_operating_mode(ar)); 897 } 898 899 if (ar->fw.rx_filter && changed_flags & ar->rx_filter_caps) { 900 u32 rx_filter = 0; 901 902 if (!(*new_flags & (FIF_FCSFAIL | FIF_PLCPFAIL))) 903 rx_filter |= CARL9170_RX_FILTER_BAD; 904 905 if (!(*new_flags & FIF_CONTROL)) 906 rx_filter |= CARL9170_RX_FILTER_CTL_OTHER; 907 908 if (!(*new_flags & FIF_PSPOLL)) 909 rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL; 910 911 if (!(*new_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))) { 912 rx_filter |= CARL9170_RX_FILTER_OTHER_RA; 913 rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL; 914 } 915 916 WARN_ON(carl9170_rx_filter(ar, rx_filter)); 917 } 918 919 mutex_unlock(&ar->mutex); 920 } 921 922 923 static void carl9170_op_bss_info_changed(struct ieee80211_hw *hw, 924 struct ieee80211_vif *vif, 925 struct ieee80211_bss_conf *bss_conf, 926 u32 changed) 927 { 928 struct ar9170 *ar = hw->priv; 929 struct ath_common *common = &ar->common; 930 int err = 0; 931 struct carl9170_vif_info *vif_priv; 932 struct ieee80211_vif *main_vif; 933 934 mutex_lock(&ar->mutex); 935 vif_priv = (void *) vif->drv_priv; 936 main_vif = carl9170_get_main_vif(ar); 937 if (WARN_ON(!main_vif)) 938 goto out; 939 940 if (changed & BSS_CHANGED_BEACON_ENABLED) { 941 struct carl9170_vif_info *iter; 942 int i = 0; 943 944 vif_priv->enable_beacon = bss_conf->enable_beacon; 945 rcu_read_lock(); 946 list_for_each_entry_rcu(iter, &ar->vif_list, list) { 947 if (iter->active && iter->enable_beacon) 948 i++; 949 950 } 951 rcu_read_unlock(); 952 953 ar->beacon_enabled = i; 954 } 955 956 if (changed & BSS_CHANGED_BEACON) { 957 err = carl9170_update_beacon(ar, false); 958 if (err) 959 goto out; 960 } 961 962 if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON | 963 BSS_CHANGED_BEACON_INT)) { 964 965 if (main_vif != vif) { 966 bss_conf->beacon_int = main_vif->bss_conf.beacon_int; 967 bss_conf->dtim_period = main_vif->bss_conf.dtim_period; 968 } 969 970 /* 971 * Therefore a hard limit for the broadcast traffic should 972 * prevent false alarms. 973 */ 974 if (vif->type != NL80211_IFTYPE_STATION && 975 (bss_conf->beacon_int * bss_conf->dtim_period >= 976 (CARL9170_QUEUE_STUCK_TIMEOUT / 2))) { 977 err = -EINVAL; 978 goto out; 979 } 980 981 err = carl9170_set_beacon_timers(ar); 982 if (err) 983 goto out; 984 } 985 986 if (changed & BSS_CHANGED_HT) { 987 /* TODO */ 988 err = 0; 989 if (err) 990 goto out; 991 } 992 993 if (main_vif != vif) 994 goto out; 995 996 /* 997 * The following settings can only be changed by the 998 * master interface. 999 */ 1000 1001 if (changed & BSS_CHANGED_BSSID) { 1002 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN); 1003 err = carl9170_set_operating_mode(ar); 1004 if (err) 1005 goto out; 1006 } 1007 1008 if (changed & BSS_CHANGED_ASSOC) { 1009 ar->common.curaid = bss_conf->aid; 1010 err = carl9170_set_beacon_timers(ar); 1011 if (err) 1012 goto out; 1013 } 1014 1015 if (changed & BSS_CHANGED_ERP_SLOT) { 1016 err = carl9170_set_slot_time(ar); 1017 if (err) 1018 goto out; 1019 } 1020 1021 if (changed & BSS_CHANGED_BASIC_RATES) { 1022 err = carl9170_set_mac_rates(ar); 1023 if (err) 1024 goto out; 1025 } 1026 1027 out: 1028 WARN_ON_ONCE(err && IS_STARTED(ar)); 1029 mutex_unlock(&ar->mutex); 1030 } 1031 1032 static u64 carl9170_op_get_tsf(struct ieee80211_hw *hw) 1033 { 1034 struct ar9170 *ar = hw->priv; 1035 struct carl9170_tsf_rsp tsf; 1036 int err; 1037 1038 mutex_lock(&ar->mutex); 1039 err = carl9170_exec_cmd(ar, CARL9170_CMD_READ_TSF, 1040 0, NULL, sizeof(tsf), &tsf); 1041 mutex_unlock(&ar->mutex); 1042 if (WARN_ON(err)) 1043 return 0; 1044 1045 return le64_to_cpu(tsf.tsf_64); 1046 } 1047 1048 static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 1049 struct ieee80211_vif *vif, 1050 struct ieee80211_sta *sta, 1051 struct ieee80211_key_conf *key) 1052 { 1053 struct ar9170 *ar = hw->priv; 1054 int err = 0, i; 1055 u8 ktype; 1056 1057 if (ar->disable_offload || !vif) 1058 return -EOPNOTSUPP; 1059 1060 /* 1061 * We have to fall back to software encryption, whenever 1062 * the user choose to participates in an IBSS or is connected 1063 * to more than one network. 1064 * 1065 * This is very unfortunate, because some machines cannot handle 1066 * the high througput speed in 802.11n networks. 1067 */ 1068 1069 if (!is_main_vif(ar, vif)) { 1070 mutex_lock(&ar->mutex); 1071 goto err_softw; 1072 } 1073 1074 /* 1075 * While the hardware supports *catch-all* key, for offloading 1076 * group-key en-/de-cryption. The way of how the hardware 1077 * decides which keyId maps to which key, remains a mystery... 1078 */ 1079 if ((vif->type != NL80211_IFTYPE_STATION && 1080 vif->type != NL80211_IFTYPE_ADHOC) && 1081 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 1082 return -EOPNOTSUPP; 1083 1084 switch (key->cipher) { 1085 case WLAN_CIPHER_SUITE_WEP40: 1086 ktype = AR9170_ENC_ALG_WEP64; 1087 break; 1088 case WLAN_CIPHER_SUITE_WEP104: 1089 ktype = AR9170_ENC_ALG_WEP128; 1090 break; 1091 case WLAN_CIPHER_SUITE_TKIP: 1092 ktype = AR9170_ENC_ALG_TKIP; 1093 break; 1094 case WLAN_CIPHER_SUITE_CCMP: 1095 ktype = AR9170_ENC_ALG_AESCCMP; 1096 break; 1097 default: 1098 return -EOPNOTSUPP; 1099 } 1100 1101 mutex_lock(&ar->mutex); 1102 if (cmd == SET_KEY) { 1103 if (!IS_STARTED(ar)) { 1104 err = -EOPNOTSUPP; 1105 goto out; 1106 } 1107 1108 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) { 1109 sta = NULL; 1110 1111 i = 64 + key->keyidx; 1112 } else { 1113 for (i = 0; i < 64; i++) 1114 if (!(ar->usedkeys & BIT(i))) 1115 break; 1116 if (i == 64) 1117 goto err_softw; 1118 } 1119 1120 key->hw_key_idx = i; 1121 1122 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL, 1123 ktype, 0, key->key, 1124 min_t(u8, 16, key->keylen)); 1125 if (err) 1126 goto out; 1127 1128 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1129 err = carl9170_upload_key(ar, i, sta ? sta->addr : 1130 NULL, ktype, 1, 1131 key->key + 16, 16); 1132 if (err) 1133 goto out; 1134 1135 /* 1136 * hardware is not capable generating MMIC 1137 * of fragmented frames! 1138 */ 1139 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC; 1140 } 1141 1142 if (i < 64) 1143 ar->usedkeys |= BIT(i); 1144 1145 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 1146 } else { 1147 if (!IS_STARTED(ar)) { 1148 /* The device is gone... together with the key ;-) */ 1149 err = 0; 1150 goto out; 1151 } 1152 1153 if (key->hw_key_idx < 64) { 1154 ar->usedkeys &= ~BIT(key->hw_key_idx); 1155 } else { 1156 err = carl9170_upload_key(ar, key->hw_key_idx, NULL, 1157 AR9170_ENC_ALG_NONE, 0, 1158 NULL, 0); 1159 if (err) 1160 goto out; 1161 1162 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1163 err = carl9170_upload_key(ar, key->hw_key_idx, 1164 NULL, 1165 AR9170_ENC_ALG_NONE, 1166 1, NULL, 0); 1167 if (err) 1168 goto out; 1169 } 1170 1171 } 1172 1173 err = carl9170_disable_key(ar, key->hw_key_idx); 1174 if (err) 1175 goto out; 1176 } 1177 1178 out: 1179 mutex_unlock(&ar->mutex); 1180 return err; 1181 1182 err_softw: 1183 if (!ar->rx_software_decryption) { 1184 ar->rx_software_decryption = true; 1185 carl9170_set_operating_mode(ar); 1186 } 1187 mutex_unlock(&ar->mutex); 1188 return -ENOSPC; 1189 } 1190 1191 static int carl9170_op_sta_add(struct ieee80211_hw *hw, 1192 struct ieee80211_vif *vif, 1193 struct ieee80211_sta *sta) 1194 { 1195 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1196 unsigned int i; 1197 1198 atomic_set(&sta_info->pending_frames, 0); 1199 1200 if (sta->ht_cap.ht_supported) { 1201 if (sta->ht_cap.ampdu_density > 6) { 1202 /* 1203 * HW does support 16us AMPDU density. 1204 * No HT-Xmit for station. 1205 */ 1206 1207 return 0; 1208 } 1209 1210 for (i = 0; i < CARL9170_NUM_TID; i++) 1211 rcu_assign_pointer(sta_info->agg[i], NULL); 1212 1213 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor); 1214 sta_info->ht_sta = true; 1215 } 1216 1217 return 0; 1218 } 1219 1220 static int carl9170_op_sta_remove(struct ieee80211_hw *hw, 1221 struct ieee80211_vif *vif, 1222 struct ieee80211_sta *sta) 1223 { 1224 struct ar9170 *ar = hw->priv; 1225 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1226 unsigned int i; 1227 bool cleanup = false; 1228 1229 if (sta->ht_cap.ht_supported) { 1230 1231 sta_info->ht_sta = false; 1232 1233 rcu_read_lock(); 1234 for (i = 0; i < CARL9170_NUM_TID; i++) { 1235 struct carl9170_sta_tid *tid_info; 1236 1237 tid_info = rcu_dereference(sta_info->agg[i]); 1238 rcu_assign_pointer(sta_info->agg[i], NULL); 1239 1240 if (!tid_info) 1241 continue; 1242 1243 spin_lock_bh(&ar->tx_ampdu_list_lock); 1244 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN) 1245 tid_info->state = CARL9170_TID_STATE_SHUTDOWN; 1246 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1247 cleanup = true; 1248 } 1249 rcu_read_unlock(); 1250 1251 if (cleanup) 1252 carl9170_ampdu_gc(ar); 1253 } 1254 1255 return 0; 1256 } 1257 1258 static int carl9170_op_conf_tx(struct ieee80211_hw *hw, u16 queue, 1259 const struct ieee80211_tx_queue_params *param) 1260 { 1261 struct ar9170 *ar = hw->priv; 1262 int ret; 1263 1264 mutex_lock(&ar->mutex); 1265 if (queue < ar->hw->queues) { 1266 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param)); 1267 ret = carl9170_set_qos(ar); 1268 } else { 1269 ret = -EINVAL; 1270 } 1271 1272 mutex_unlock(&ar->mutex); 1273 return ret; 1274 } 1275 1276 static void carl9170_ampdu_work(struct work_struct *work) 1277 { 1278 struct ar9170 *ar = container_of(work, struct ar9170, 1279 ampdu_work); 1280 1281 if (!IS_STARTED(ar)) 1282 return; 1283 1284 mutex_lock(&ar->mutex); 1285 carl9170_ampdu_gc(ar); 1286 mutex_unlock(&ar->mutex); 1287 } 1288 1289 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw, 1290 struct ieee80211_vif *vif, 1291 enum ieee80211_ampdu_mlme_action action, 1292 struct ieee80211_sta *sta, 1293 u16 tid, u16 *ssn, u8 buf_size) 1294 { 1295 struct ar9170 *ar = hw->priv; 1296 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1297 struct carl9170_sta_tid *tid_info; 1298 1299 if (modparam_noht) 1300 return -EOPNOTSUPP; 1301 1302 switch (action) { 1303 case IEEE80211_AMPDU_TX_START: 1304 if (!sta_info->ht_sta) 1305 return -EOPNOTSUPP; 1306 1307 rcu_read_lock(); 1308 if (rcu_dereference(sta_info->agg[tid])) { 1309 rcu_read_unlock(); 1310 return -EBUSY; 1311 } 1312 1313 tid_info = kzalloc(sizeof(struct carl9170_sta_tid), 1314 GFP_ATOMIC); 1315 if (!tid_info) { 1316 rcu_read_unlock(); 1317 return -ENOMEM; 1318 } 1319 1320 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn); 1321 tid_info->state = CARL9170_TID_STATE_PROGRESS; 1322 tid_info->tid = tid; 1323 tid_info->max = sta_info->ampdu_max_len; 1324 1325 INIT_LIST_HEAD(&tid_info->list); 1326 INIT_LIST_HEAD(&tid_info->tmp_list); 1327 skb_queue_head_init(&tid_info->queue); 1328 spin_lock_init(&tid_info->lock); 1329 1330 spin_lock_bh(&ar->tx_ampdu_list_lock); 1331 ar->tx_ampdu_list_len++; 1332 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list); 1333 rcu_assign_pointer(sta_info->agg[tid], tid_info); 1334 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1335 rcu_read_unlock(); 1336 1337 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1338 break; 1339 1340 case IEEE80211_AMPDU_TX_STOP: 1341 rcu_read_lock(); 1342 tid_info = rcu_dereference(sta_info->agg[tid]); 1343 if (tid_info) { 1344 spin_lock_bh(&ar->tx_ampdu_list_lock); 1345 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN) 1346 tid_info->state = CARL9170_TID_STATE_SHUTDOWN; 1347 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1348 } 1349 1350 rcu_assign_pointer(sta_info->agg[tid], NULL); 1351 rcu_read_unlock(); 1352 1353 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1354 ieee80211_queue_work(ar->hw, &ar->ampdu_work); 1355 break; 1356 1357 case IEEE80211_AMPDU_TX_OPERATIONAL: 1358 rcu_read_lock(); 1359 tid_info = rcu_dereference(sta_info->agg[tid]); 1360 1361 sta_info->stats[tid].clear = true; 1362 sta_info->stats[tid].req = false; 1363 1364 if (tid_info) { 1365 bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE); 1366 tid_info->state = CARL9170_TID_STATE_IDLE; 1367 } 1368 rcu_read_unlock(); 1369 1370 if (WARN_ON_ONCE(!tid_info)) 1371 return -EFAULT; 1372 1373 break; 1374 1375 case IEEE80211_AMPDU_RX_START: 1376 case IEEE80211_AMPDU_RX_STOP: 1377 /* Handled by hardware */ 1378 break; 1379 1380 default: 1381 return -EOPNOTSUPP; 1382 } 1383 1384 return 0; 1385 } 1386 1387 #ifdef CONFIG_CARL9170_WPC 1388 static int carl9170_register_wps_button(struct ar9170 *ar) 1389 { 1390 struct input_dev *input; 1391 int err; 1392 1393 if (!(ar->features & CARL9170_WPS_BUTTON)) 1394 return 0; 1395 1396 input = input_allocate_device(); 1397 if (!input) 1398 return -ENOMEM; 1399 1400 snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button", 1401 wiphy_name(ar->hw->wiphy)); 1402 1403 snprintf(ar->wps.phys, sizeof(ar->wps.phys), 1404 "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy)); 1405 1406 input->name = ar->wps.name; 1407 input->phys = ar->wps.phys; 1408 input->id.bustype = BUS_USB; 1409 input->dev.parent = &ar->hw->wiphy->dev; 1410 1411 input_set_capability(input, EV_KEY, KEY_WPS_BUTTON); 1412 1413 err = input_register_device(input); 1414 if (err) { 1415 input_free_device(input); 1416 return err; 1417 } 1418 1419 ar->wps.pbc = input; 1420 return 0; 1421 } 1422 #endif /* CONFIG_CARL9170_WPC */ 1423 1424 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx, 1425 struct survey_info *survey) 1426 { 1427 struct ar9170 *ar = hw->priv; 1428 int err; 1429 1430 if (idx != 0) 1431 return -ENOENT; 1432 1433 mutex_lock(&ar->mutex); 1434 err = carl9170_get_noisefloor(ar); 1435 mutex_unlock(&ar->mutex); 1436 if (err) 1437 return err; 1438 1439 survey->channel = ar->channel; 1440 survey->filled = SURVEY_INFO_NOISE_DBM; 1441 survey->noise = ar->noise[0]; 1442 return 0; 1443 } 1444 1445 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop) 1446 { 1447 struct ar9170 *ar = hw->priv; 1448 unsigned int vid; 1449 1450 mutex_lock(&ar->mutex); 1451 for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num) 1452 carl9170_flush_cab(ar, vid); 1453 1454 carl9170_flush(ar, drop); 1455 mutex_unlock(&ar->mutex); 1456 } 1457 1458 static int carl9170_op_get_stats(struct ieee80211_hw *hw, 1459 struct ieee80211_low_level_stats *stats) 1460 { 1461 struct ar9170 *ar = hw->priv; 1462 1463 memset(stats, 0, sizeof(*stats)); 1464 stats->dot11ACKFailureCount = ar->tx_ack_failures; 1465 stats->dot11FCSErrorCount = ar->tx_fcs_errors; 1466 return 0; 1467 } 1468 1469 static void carl9170_op_sta_notify(struct ieee80211_hw *hw, 1470 struct ieee80211_vif *vif, 1471 enum sta_notify_cmd cmd, 1472 struct ieee80211_sta *sta) 1473 { 1474 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1475 1476 switch (cmd) { 1477 case STA_NOTIFY_SLEEP: 1478 sta_info->sleeping = true; 1479 if (atomic_read(&sta_info->pending_frames)) 1480 ieee80211_sta_block_awake(hw, sta, true); 1481 break; 1482 1483 case STA_NOTIFY_AWAKE: 1484 sta_info->sleeping = false; 1485 break; 1486 } 1487 } 1488 1489 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw) 1490 { 1491 struct ar9170 *ar = hw->priv; 1492 1493 return !!atomic_read(&ar->tx_total_queued); 1494 } 1495 1496 static const struct ieee80211_ops carl9170_ops = { 1497 .start = carl9170_op_start, 1498 .stop = carl9170_op_stop, 1499 .tx = carl9170_op_tx, 1500 .flush = carl9170_op_flush, 1501 .add_interface = carl9170_op_add_interface, 1502 .remove_interface = carl9170_op_remove_interface, 1503 .config = carl9170_op_config, 1504 .prepare_multicast = carl9170_op_prepare_multicast, 1505 .configure_filter = carl9170_op_configure_filter, 1506 .conf_tx = carl9170_op_conf_tx, 1507 .bss_info_changed = carl9170_op_bss_info_changed, 1508 .get_tsf = carl9170_op_get_tsf, 1509 .set_key = carl9170_op_set_key, 1510 .sta_add = carl9170_op_sta_add, 1511 .sta_remove = carl9170_op_sta_remove, 1512 .sta_notify = carl9170_op_sta_notify, 1513 .get_survey = carl9170_op_get_survey, 1514 .get_stats = carl9170_op_get_stats, 1515 .ampdu_action = carl9170_op_ampdu_action, 1516 .tx_frames_pending = carl9170_tx_frames_pending, 1517 }; 1518 1519 void *carl9170_alloc(size_t priv_size) 1520 { 1521 struct ieee80211_hw *hw; 1522 struct ar9170 *ar; 1523 struct sk_buff *skb; 1524 int i; 1525 1526 /* 1527 * this buffer is used for rx stream reconstruction. 1528 * Under heavy load this device (or the transport layer?) 1529 * tends to split the streams into separate rx descriptors. 1530 */ 1531 1532 skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL); 1533 if (!skb) 1534 goto err_nomem; 1535 1536 hw = ieee80211_alloc_hw(priv_size, &carl9170_ops); 1537 if (!hw) 1538 goto err_nomem; 1539 1540 ar = hw->priv; 1541 ar->hw = hw; 1542 ar->rx_failover = skb; 1543 1544 memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head)); 1545 ar->rx_has_plcp = false; 1546 1547 /* 1548 * Here's a hidden pitfall! 1549 * 1550 * All 4 AC queues work perfectly well under _legacy_ operation. 1551 * However as soon as aggregation is enabled, the traffic flow 1552 * gets very bumpy. Therefore we have to _switch_ to a 1553 * software AC with a single HW queue. 1554 */ 1555 hw->queues = __AR9170_NUM_TXQ; 1556 1557 mutex_init(&ar->mutex); 1558 spin_lock_init(&ar->beacon_lock); 1559 spin_lock_init(&ar->cmd_lock); 1560 spin_lock_init(&ar->tx_stats_lock); 1561 spin_lock_init(&ar->tx_ampdu_list_lock); 1562 spin_lock_init(&ar->mem_lock); 1563 spin_lock_init(&ar->state_lock); 1564 atomic_set(&ar->pending_restarts, 0); 1565 ar->vifs = 0; 1566 for (i = 0; i < ar->hw->queues; i++) { 1567 skb_queue_head_init(&ar->tx_status[i]); 1568 skb_queue_head_init(&ar->tx_pending[i]); 1569 } 1570 INIT_WORK(&ar->ps_work, carl9170_ps_work); 1571 INIT_WORK(&ar->ping_work, carl9170_ping_work); 1572 INIT_WORK(&ar->restart_work, carl9170_restart_work); 1573 INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work); 1574 INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor); 1575 INIT_LIST_HEAD(&ar->tx_ampdu_list); 1576 rcu_assign_pointer(ar->tx_ampdu_iter, 1577 (struct carl9170_sta_tid *) &ar->tx_ampdu_list); 1578 1579 bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num); 1580 INIT_LIST_HEAD(&ar->vif_list); 1581 init_completion(&ar->tx_flush); 1582 1583 /* firmware decides which modes we support */ 1584 hw->wiphy->interface_modes = 0; 1585 1586 hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS | 1587 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 1588 IEEE80211_HW_SUPPORTS_PS | 1589 IEEE80211_HW_PS_NULLFUNC_STACK | 1590 IEEE80211_HW_NEED_DTIM_PERIOD | 1591 IEEE80211_HW_SIGNAL_DBM; 1592 1593 if (!modparam_noht) { 1594 /* 1595 * see the comment above, why we allow the user 1596 * to disable HT by a module parameter. 1597 */ 1598 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION; 1599 } 1600 1601 hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe); 1602 hw->sta_data_size = sizeof(struct carl9170_sta_info); 1603 hw->vif_data_size = sizeof(struct carl9170_vif_info); 1604 1605 hw->max_rates = CARL9170_TX_MAX_RATES; 1606 hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES; 1607 1608 for (i = 0; i < ARRAY_SIZE(ar->noise); i++) 1609 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */ 1610 1611 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT; 1612 return ar; 1613 1614 err_nomem: 1615 kfree_skb(skb); 1616 return ERR_PTR(-ENOMEM); 1617 } 1618 1619 static int carl9170_read_eeprom(struct ar9170 *ar) 1620 { 1621 #define RW 8 /* number of words to read at once */ 1622 #define RB (sizeof(u32) * RW) 1623 u8 *eeprom = (void *)&ar->eeprom; 1624 __le32 offsets[RW]; 1625 int i, j, err; 1626 1627 BUILD_BUG_ON(sizeof(ar->eeprom) & 3); 1628 1629 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4); 1630 #ifndef __CHECKER__ 1631 /* don't want to handle trailing remains */ 1632 BUILD_BUG_ON(sizeof(ar->eeprom) % RB); 1633 #endif 1634 1635 for (i = 0; i < sizeof(ar->eeprom) / RB; i++) { 1636 for (j = 0; j < RW; j++) 1637 offsets[j] = cpu_to_le32(AR9170_EEPROM_START + 1638 RB * i + 4 * j); 1639 1640 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG, 1641 RB, (u8 *) &offsets, 1642 RB, eeprom + RB * i); 1643 if (err) 1644 return err; 1645 } 1646 1647 #undef RW 1648 #undef RB 1649 return 0; 1650 } 1651 1652 static int carl9170_parse_eeprom(struct ar9170 *ar) 1653 { 1654 struct ath_regulatory *regulatory = &ar->common.regulatory; 1655 unsigned int rx_streams, tx_streams, tx_params = 0; 1656 int bands = 0; 1657 1658 if (ar->eeprom.length == cpu_to_le16(0xffff)) 1659 return -ENODATA; 1660 1661 rx_streams = hweight8(ar->eeprom.rx_mask); 1662 tx_streams = hweight8(ar->eeprom.tx_mask); 1663 1664 if (rx_streams != tx_streams) { 1665 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF; 1666 1667 WARN_ON(!(tx_streams >= 1 && tx_streams <= 1668 IEEE80211_HT_MCS_TX_MAX_STREAMS)); 1669 1670 tx_params = (tx_streams - 1) << 1671 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT; 1672 1673 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params; 1674 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params; 1675 } 1676 1677 if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) { 1678 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = 1679 &carl9170_band_2GHz; 1680 bands++; 1681 } 1682 if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) { 1683 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = 1684 &carl9170_band_5GHz; 1685 bands++; 1686 } 1687 1688 /* 1689 * I measured this, a bandswitch takes roughly 1690 * 135 ms and a frequency switch about 80. 1691 * 1692 * FIXME: measure these values again once EEPROM settings 1693 * are used, that will influence them! 1694 */ 1695 if (bands == 2) 1696 ar->hw->channel_change_time = 135 * 1000; 1697 else 1698 ar->hw->channel_change_time = 80 * 1000; 1699 1700 regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]); 1701 regulatory->current_rd_ext = le16_to_cpu(ar->eeprom.reg_domain[1]); 1702 1703 /* second part of wiphy init */ 1704 SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address); 1705 1706 return bands ? 0 : -EINVAL; 1707 } 1708 1709 static int carl9170_reg_notifier(struct wiphy *wiphy, 1710 struct regulatory_request *request) 1711 { 1712 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 1713 struct ar9170 *ar = hw->priv; 1714 1715 return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory); 1716 } 1717 1718 int carl9170_register(struct ar9170 *ar) 1719 { 1720 struct ath_regulatory *regulatory = &ar->common.regulatory; 1721 int err = 0, i; 1722 1723 if (WARN_ON(ar->mem_bitmap)) 1724 return -EINVAL; 1725 1726 ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) * 1727 sizeof(unsigned long), GFP_KERNEL); 1728 1729 if (!ar->mem_bitmap) 1730 return -ENOMEM; 1731 1732 /* try to read EEPROM, init MAC addr */ 1733 err = carl9170_read_eeprom(ar); 1734 if (err) 1735 return err; 1736 1737 err = carl9170_fw_fix_eeprom(ar); 1738 if (err) 1739 return err; 1740 1741 err = carl9170_parse_eeprom(ar); 1742 if (err) 1743 return err; 1744 1745 err = ath_regd_init(regulatory, ar->hw->wiphy, 1746 carl9170_reg_notifier); 1747 if (err) 1748 return err; 1749 1750 if (modparam_noht) { 1751 carl9170_band_2GHz.ht_cap.ht_supported = false; 1752 carl9170_band_5GHz.ht_cap.ht_supported = false; 1753 } 1754 1755 for (i = 0; i < ar->fw.vif_num; i++) { 1756 ar->vif_priv[i].id = i; 1757 ar->vif_priv[i].vif = NULL; 1758 } 1759 1760 err = ieee80211_register_hw(ar->hw); 1761 if (err) 1762 return err; 1763 1764 /* mac80211 interface is now registered */ 1765 ar->registered = true; 1766 1767 if (!ath_is_world_regd(regulatory)) 1768 regulatory_hint(ar->hw->wiphy, regulatory->alpha2); 1769 1770 #ifdef CONFIG_CARL9170_DEBUGFS 1771 carl9170_debugfs_register(ar); 1772 #endif /* CONFIG_CARL9170_DEBUGFS */ 1773 1774 err = carl9170_led_init(ar); 1775 if (err) 1776 goto err_unreg; 1777 1778 #ifdef CONFIG_CARL9170_LEDS 1779 err = carl9170_led_register(ar); 1780 if (err) 1781 goto err_unreg; 1782 #endif /* CONFIG_CARL9170_LEDS */ 1783 1784 #ifdef CONFIG_CARL9170_WPC 1785 err = carl9170_register_wps_button(ar); 1786 if (err) 1787 goto err_unreg; 1788 #endif /* CONFIG_CARL9170_WPC */ 1789 1790 dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n", 1791 wiphy_name(ar->hw->wiphy)); 1792 1793 return 0; 1794 1795 err_unreg: 1796 carl9170_unregister(ar); 1797 return err; 1798 } 1799 1800 void carl9170_unregister(struct ar9170 *ar) 1801 { 1802 if (!ar->registered) 1803 return; 1804 1805 ar->registered = false; 1806 1807 #ifdef CONFIG_CARL9170_LEDS 1808 carl9170_led_unregister(ar); 1809 #endif /* CONFIG_CARL9170_LEDS */ 1810 1811 #ifdef CONFIG_CARL9170_DEBUGFS 1812 carl9170_debugfs_unregister(ar); 1813 #endif /* CONFIG_CARL9170_DEBUGFS */ 1814 1815 #ifdef CONFIG_CARL9170_WPC 1816 if (ar->wps.pbc) { 1817 input_unregister_device(ar->wps.pbc); 1818 ar->wps.pbc = NULL; 1819 } 1820 #endif /* CONFIG_CARL9170_WPC */ 1821 1822 carl9170_cancel_worker(ar); 1823 cancel_work_sync(&ar->restart_work); 1824 1825 ieee80211_unregister_hw(ar->hw); 1826 } 1827 1828 void carl9170_free(struct ar9170 *ar) 1829 { 1830 WARN_ON(ar->registered); 1831 WARN_ON(IS_INITIALIZED(ar)); 1832 1833 kfree_skb(ar->rx_failover); 1834 ar->rx_failover = NULL; 1835 1836 kfree(ar->mem_bitmap); 1837 ar->mem_bitmap = NULL; 1838 1839 mutex_destroy(&ar->mutex); 1840 1841 ieee80211_free_hw(ar->hw); 1842 } 1843