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 goto err_softw; 1071 1072 /* 1073 * While the hardware supports *catch-all* key, for offloading 1074 * group-key en-/de-cryption. The way of how the hardware 1075 * decides which keyId maps to which key, remains a mystery... 1076 */ 1077 if ((vif->type != NL80211_IFTYPE_STATION && 1078 vif->type != NL80211_IFTYPE_ADHOC) && 1079 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 1080 return -EOPNOTSUPP; 1081 1082 switch (key->cipher) { 1083 case WLAN_CIPHER_SUITE_WEP40: 1084 ktype = AR9170_ENC_ALG_WEP64; 1085 break; 1086 case WLAN_CIPHER_SUITE_WEP104: 1087 ktype = AR9170_ENC_ALG_WEP128; 1088 break; 1089 case WLAN_CIPHER_SUITE_TKIP: 1090 ktype = AR9170_ENC_ALG_TKIP; 1091 break; 1092 case WLAN_CIPHER_SUITE_CCMP: 1093 ktype = AR9170_ENC_ALG_AESCCMP; 1094 break; 1095 default: 1096 return -EOPNOTSUPP; 1097 } 1098 1099 mutex_lock(&ar->mutex); 1100 if (cmd == SET_KEY) { 1101 if (!IS_STARTED(ar)) { 1102 err = -EOPNOTSUPP; 1103 goto out; 1104 } 1105 1106 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) { 1107 sta = NULL; 1108 1109 i = 64 + key->keyidx; 1110 } else { 1111 for (i = 0; i < 64; i++) 1112 if (!(ar->usedkeys & BIT(i))) 1113 break; 1114 if (i == 64) 1115 goto err_softw; 1116 } 1117 1118 key->hw_key_idx = i; 1119 1120 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL, 1121 ktype, 0, key->key, 1122 min_t(u8, 16, key->keylen)); 1123 if (err) 1124 goto out; 1125 1126 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1127 err = carl9170_upload_key(ar, i, sta ? sta->addr : 1128 NULL, ktype, 1, 1129 key->key + 16, 16); 1130 if (err) 1131 goto out; 1132 1133 /* 1134 * hardware is not capable generating MMIC 1135 * of fragmented frames! 1136 */ 1137 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC; 1138 } 1139 1140 if (i < 64) 1141 ar->usedkeys |= BIT(i); 1142 1143 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 1144 } else { 1145 if (!IS_STARTED(ar)) { 1146 /* The device is gone... together with the key ;-) */ 1147 err = 0; 1148 goto out; 1149 } 1150 1151 if (key->hw_key_idx < 64) { 1152 ar->usedkeys &= ~BIT(key->hw_key_idx); 1153 } else { 1154 err = carl9170_upload_key(ar, key->hw_key_idx, NULL, 1155 AR9170_ENC_ALG_NONE, 0, 1156 NULL, 0); 1157 if (err) 1158 goto out; 1159 1160 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1161 err = carl9170_upload_key(ar, key->hw_key_idx, 1162 NULL, 1163 AR9170_ENC_ALG_NONE, 1164 1, NULL, 0); 1165 if (err) 1166 goto out; 1167 } 1168 1169 } 1170 1171 err = carl9170_disable_key(ar, key->hw_key_idx); 1172 if (err) 1173 goto out; 1174 } 1175 1176 out: 1177 mutex_unlock(&ar->mutex); 1178 return err; 1179 1180 err_softw: 1181 if (!ar->rx_software_decryption) { 1182 ar->rx_software_decryption = true; 1183 carl9170_set_operating_mode(ar); 1184 } 1185 mutex_unlock(&ar->mutex); 1186 return -ENOSPC; 1187 } 1188 1189 static int carl9170_op_sta_add(struct ieee80211_hw *hw, 1190 struct ieee80211_vif *vif, 1191 struct ieee80211_sta *sta) 1192 { 1193 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1194 unsigned int i; 1195 1196 atomic_set(&sta_info->pending_frames, 0); 1197 1198 if (sta->ht_cap.ht_supported) { 1199 if (sta->ht_cap.ampdu_density > 6) { 1200 /* 1201 * HW does support 16us AMPDU density. 1202 * No HT-Xmit for station. 1203 */ 1204 1205 return 0; 1206 } 1207 1208 for (i = 0; i < CARL9170_NUM_TID; i++) 1209 rcu_assign_pointer(sta_info->agg[i], NULL); 1210 1211 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor); 1212 sta_info->ht_sta = true; 1213 } 1214 1215 return 0; 1216 } 1217 1218 static int carl9170_op_sta_remove(struct ieee80211_hw *hw, 1219 struct ieee80211_vif *vif, 1220 struct ieee80211_sta *sta) 1221 { 1222 struct ar9170 *ar = hw->priv; 1223 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1224 unsigned int i; 1225 bool cleanup = false; 1226 1227 if (sta->ht_cap.ht_supported) { 1228 1229 sta_info->ht_sta = false; 1230 1231 rcu_read_lock(); 1232 for (i = 0; i < CARL9170_NUM_TID; i++) { 1233 struct carl9170_sta_tid *tid_info; 1234 1235 tid_info = rcu_dereference(sta_info->agg[i]); 1236 rcu_assign_pointer(sta_info->agg[i], NULL); 1237 1238 if (!tid_info) 1239 continue; 1240 1241 spin_lock_bh(&ar->tx_ampdu_list_lock); 1242 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN) 1243 tid_info->state = CARL9170_TID_STATE_SHUTDOWN; 1244 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1245 cleanup = true; 1246 } 1247 rcu_read_unlock(); 1248 1249 if (cleanup) 1250 carl9170_ampdu_gc(ar); 1251 } 1252 1253 return 0; 1254 } 1255 1256 static int carl9170_op_conf_tx(struct ieee80211_hw *hw, u16 queue, 1257 const struct ieee80211_tx_queue_params *param) 1258 { 1259 struct ar9170 *ar = hw->priv; 1260 int ret; 1261 1262 mutex_lock(&ar->mutex); 1263 if (queue < ar->hw->queues) { 1264 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param)); 1265 ret = carl9170_set_qos(ar); 1266 } else { 1267 ret = -EINVAL; 1268 } 1269 1270 mutex_unlock(&ar->mutex); 1271 return ret; 1272 } 1273 1274 static void carl9170_ampdu_work(struct work_struct *work) 1275 { 1276 struct ar9170 *ar = container_of(work, struct ar9170, 1277 ampdu_work); 1278 1279 if (!IS_STARTED(ar)) 1280 return; 1281 1282 mutex_lock(&ar->mutex); 1283 carl9170_ampdu_gc(ar); 1284 mutex_unlock(&ar->mutex); 1285 } 1286 1287 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw, 1288 struct ieee80211_vif *vif, 1289 enum ieee80211_ampdu_mlme_action action, 1290 struct ieee80211_sta *sta, 1291 u16 tid, u16 *ssn, u8 buf_size) 1292 { 1293 struct ar9170 *ar = hw->priv; 1294 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1295 struct carl9170_sta_tid *tid_info; 1296 1297 if (modparam_noht) 1298 return -EOPNOTSUPP; 1299 1300 switch (action) { 1301 case IEEE80211_AMPDU_TX_START: 1302 if (!sta_info->ht_sta) 1303 return -EOPNOTSUPP; 1304 1305 rcu_read_lock(); 1306 if (rcu_dereference(sta_info->agg[tid])) { 1307 rcu_read_unlock(); 1308 return -EBUSY; 1309 } 1310 1311 tid_info = kzalloc(sizeof(struct carl9170_sta_tid), 1312 GFP_ATOMIC); 1313 if (!tid_info) { 1314 rcu_read_unlock(); 1315 return -ENOMEM; 1316 } 1317 1318 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn); 1319 tid_info->state = CARL9170_TID_STATE_PROGRESS; 1320 tid_info->tid = tid; 1321 tid_info->max = sta_info->ampdu_max_len; 1322 1323 INIT_LIST_HEAD(&tid_info->list); 1324 INIT_LIST_HEAD(&tid_info->tmp_list); 1325 skb_queue_head_init(&tid_info->queue); 1326 spin_lock_init(&tid_info->lock); 1327 1328 spin_lock_bh(&ar->tx_ampdu_list_lock); 1329 ar->tx_ampdu_list_len++; 1330 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list); 1331 rcu_assign_pointer(sta_info->agg[tid], tid_info); 1332 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1333 rcu_read_unlock(); 1334 1335 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1336 break; 1337 1338 case IEEE80211_AMPDU_TX_STOP: 1339 rcu_read_lock(); 1340 tid_info = rcu_dereference(sta_info->agg[tid]); 1341 if (tid_info) { 1342 spin_lock_bh(&ar->tx_ampdu_list_lock); 1343 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN) 1344 tid_info->state = CARL9170_TID_STATE_SHUTDOWN; 1345 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1346 } 1347 1348 rcu_assign_pointer(sta_info->agg[tid], NULL); 1349 rcu_read_unlock(); 1350 1351 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1352 ieee80211_queue_work(ar->hw, &ar->ampdu_work); 1353 break; 1354 1355 case IEEE80211_AMPDU_TX_OPERATIONAL: 1356 rcu_read_lock(); 1357 tid_info = rcu_dereference(sta_info->agg[tid]); 1358 1359 sta_info->stats[tid].clear = true; 1360 sta_info->stats[tid].req = false; 1361 1362 if (tid_info) { 1363 bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE); 1364 tid_info->state = CARL9170_TID_STATE_IDLE; 1365 } 1366 rcu_read_unlock(); 1367 1368 if (WARN_ON_ONCE(!tid_info)) 1369 return -EFAULT; 1370 1371 break; 1372 1373 case IEEE80211_AMPDU_RX_START: 1374 case IEEE80211_AMPDU_RX_STOP: 1375 /* Handled by hardware */ 1376 break; 1377 1378 default: 1379 return -EOPNOTSUPP; 1380 } 1381 1382 return 0; 1383 } 1384 1385 #ifdef CONFIG_CARL9170_WPC 1386 static int carl9170_register_wps_button(struct ar9170 *ar) 1387 { 1388 struct input_dev *input; 1389 int err; 1390 1391 if (!(ar->features & CARL9170_WPS_BUTTON)) 1392 return 0; 1393 1394 input = input_allocate_device(); 1395 if (!input) 1396 return -ENOMEM; 1397 1398 snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button", 1399 wiphy_name(ar->hw->wiphy)); 1400 1401 snprintf(ar->wps.phys, sizeof(ar->wps.phys), 1402 "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy)); 1403 1404 input->name = ar->wps.name; 1405 input->phys = ar->wps.phys; 1406 input->id.bustype = BUS_USB; 1407 input->dev.parent = &ar->hw->wiphy->dev; 1408 1409 input_set_capability(input, EV_KEY, KEY_WPS_BUTTON); 1410 1411 err = input_register_device(input); 1412 if (err) { 1413 input_free_device(input); 1414 return err; 1415 } 1416 1417 ar->wps.pbc = input; 1418 return 0; 1419 } 1420 #endif /* CONFIG_CARL9170_WPC */ 1421 1422 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx, 1423 struct survey_info *survey) 1424 { 1425 struct ar9170 *ar = hw->priv; 1426 int err; 1427 1428 if (idx != 0) 1429 return -ENOENT; 1430 1431 mutex_lock(&ar->mutex); 1432 err = carl9170_get_noisefloor(ar); 1433 mutex_unlock(&ar->mutex); 1434 if (err) 1435 return err; 1436 1437 survey->channel = ar->channel; 1438 survey->filled = SURVEY_INFO_NOISE_DBM; 1439 survey->noise = ar->noise[0]; 1440 return 0; 1441 } 1442 1443 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop) 1444 { 1445 struct ar9170 *ar = hw->priv; 1446 unsigned int vid; 1447 1448 mutex_lock(&ar->mutex); 1449 for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num) 1450 carl9170_flush_cab(ar, vid); 1451 1452 carl9170_flush(ar, drop); 1453 mutex_unlock(&ar->mutex); 1454 } 1455 1456 static int carl9170_op_get_stats(struct ieee80211_hw *hw, 1457 struct ieee80211_low_level_stats *stats) 1458 { 1459 struct ar9170 *ar = hw->priv; 1460 1461 memset(stats, 0, sizeof(*stats)); 1462 stats->dot11ACKFailureCount = ar->tx_ack_failures; 1463 stats->dot11FCSErrorCount = ar->tx_fcs_errors; 1464 return 0; 1465 } 1466 1467 static void carl9170_op_sta_notify(struct ieee80211_hw *hw, 1468 struct ieee80211_vif *vif, 1469 enum sta_notify_cmd cmd, 1470 struct ieee80211_sta *sta) 1471 { 1472 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1473 1474 switch (cmd) { 1475 case STA_NOTIFY_SLEEP: 1476 sta_info->sleeping = true; 1477 if (atomic_read(&sta_info->pending_frames)) 1478 ieee80211_sta_block_awake(hw, sta, true); 1479 break; 1480 1481 case STA_NOTIFY_AWAKE: 1482 sta_info->sleeping = false; 1483 break; 1484 } 1485 } 1486 1487 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw) 1488 { 1489 struct ar9170 *ar = hw->priv; 1490 1491 return !!atomic_read(&ar->tx_total_queued); 1492 } 1493 1494 static const struct ieee80211_ops carl9170_ops = { 1495 .start = carl9170_op_start, 1496 .stop = carl9170_op_stop, 1497 .tx = carl9170_op_tx, 1498 .flush = carl9170_op_flush, 1499 .add_interface = carl9170_op_add_interface, 1500 .remove_interface = carl9170_op_remove_interface, 1501 .config = carl9170_op_config, 1502 .prepare_multicast = carl9170_op_prepare_multicast, 1503 .configure_filter = carl9170_op_configure_filter, 1504 .conf_tx = carl9170_op_conf_tx, 1505 .bss_info_changed = carl9170_op_bss_info_changed, 1506 .get_tsf = carl9170_op_get_tsf, 1507 .set_key = carl9170_op_set_key, 1508 .sta_add = carl9170_op_sta_add, 1509 .sta_remove = carl9170_op_sta_remove, 1510 .sta_notify = carl9170_op_sta_notify, 1511 .get_survey = carl9170_op_get_survey, 1512 .get_stats = carl9170_op_get_stats, 1513 .ampdu_action = carl9170_op_ampdu_action, 1514 .tx_frames_pending = carl9170_tx_frames_pending, 1515 }; 1516 1517 void *carl9170_alloc(size_t priv_size) 1518 { 1519 struct ieee80211_hw *hw; 1520 struct ar9170 *ar; 1521 struct sk_buff *skb; 1522 int i; 1523 1524 /* 1525 * this buffer is used for rx stream reconstruction. 1526 * Under heavy load this device (or the transport layer?) 1527 * tends to split the streams into separate rx descriptors. 1528 */ 1529 1530 skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL); 1531 if (!skb) 1532 goto err_nomem; 1533 1534 hw = ieee80211_alloc_hw(priv_size, &carl9170_ops); 1535 if (!hw) 1536 goto err_nomem; 1537 1538 ar = hw->priv; 1539 ar->hw = hw; 1540 ar->rx_failover = skb; 1541 1542 memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head)); 1543 ar->rx_has_plcp = false; 1544 1545 /* 1546 * Here's a hidden pitfall! 1547 * 1548 * All 4 AC queues work perfectly well under _legacy_ operation. 1549 * However as soon as aggregation is enabled, the traffic flow 1550 * gets very bumpy. Therefore we have to _switch_ to a 1551 * software AC with a single HW queue. 1552 */ 1553 hw->queues = __AR9170_NUM_TXQ; 1554 1555 mutex_init(&ar->mutex); 1556 spin_lock_init(&ar->beacon_lock); 1557 spin_lock_init(&ar->cmd_lock); 1558 spin_lock_init(&ar->tx_stats_lock); 1559 spin_lock_init(&ar->tx_ampdu_list_lock); 1560 spin_lock_init(&ar->mem_lock); 1561 spin_lock_init(&ar->state_lock); 1562 atomic_set(&ar->pending_restarts, 0); 1563 ar->vifs = 0; 1564 for (i = 0; i < ar->hw->queues; i++) { 1565 skb_queue_head_init(&ar->tx_status[i]); 1566 skb_queue_head_init(&ar->tx_pending[i]); 1567 } 1568 INIT_WORK(&ar->ps_work, carl9170_ps_work); 1569 INIT_WORK(&ar->ping_work, carl9170_ping_work); 1570 INIT_WORK(&ar->restart_work, carl9170_restart_work); 1571 INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work); 1572 INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor); 1573 INIT_LIST_HEAD(&ar->tx_ampdu_list); 1574 rcu_assign_pointer(ar->tx_ampdu_iter, 1575 (struct carl9170_sta_tid *) &ar->tx_ampdu_list); 1576 1577 bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num); 1578 INIT_LIST_HEAD(&ar->vif_list); 1579 init_completion(&ar->tx_flush); 1580 1581 /* firmware decides which modes we support */ 1582 hw->wiphy->interface_modes = 0; 1583 1584 hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS | 1585 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 1586 IEEE80211_HW_SUPPORTS_PS | 1587 IEEE80211_HW_PS_NULLFUNC_STACK | 1588 IEEE80211_HW_NEED_DTIM_PERIOD | 1589 IEEE80211_HW_SIGNAL_DBM; 1590 1591 if (!modparam_noht) { 1592 /* 1593 * see the comment above, why we allow the user 1594 * to disable HT by a module parameter. 1595 */ 1596 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION; 1597 } 1598 1599 hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe); 1600 hw->sta_data_size = sizeof(struct carl9170_sta_info); 1601 hw->vif_data_size = sizeof(struct carl9170_vif_info); 1602 1603 hw->max_rates = CARL9170_TX_MAX_RATES; 1604 hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES; 1605 1606 for (i = 0; i < ARRAY_SIZE(ar->noise); i++) 1607 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */ 1608 1609 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT; 1610 return ar; 1611 1612 err_nomem: 1613 kfree_skb(skb); 1614 return ERR_PTR(-ENOMEM); 1615 } 1616 1617 static int carl9170_read_eeprom(struct ar9170 *ar) 1618 { 1619 #define RW 8 /* number of words to read at once */ 1620 #define RB (sizeof(u32) * RW) 1621 u8 *eeprom = (void *)&ar->eeprom; 1622 __le32 offsets[RW]; 1623 int i, j, err; 1624 1625 BUILD_BUG_ON(sizeof(ar->eeprom) & 3); 1626 1627 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4); 1628 #ifndef __CHECKER__ 1629 /* don't want to handle trailing remains */ 1630 BUILD_BUG_ON(sizeof(ar->eeprom) % RB); 1631 #endif 1632 1633 for (i = 0; i < sizeof(ar->eeprom)/RB; i++) { 1634 for (j = 0; j < RW; j++) 1635 offsets[j] = cpu_to_le32(AR9170_EEPROM_START + 1636 RB * i + 4 * j); 1637 1638 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG, 1639 RB, (u8 *) &offsets, 1640 RB, eeprom + RB * i); 1641 if (err) 1642 return err; 1643 } 1644 1645 #undef RW 1646 #undef RB 1647 return 0; 1648 } 1649 1650 static int carl9170_parse_eeprom(struct ar9170 *ar) 1651 { 1652 struct ath_regulatory *regulatory = &ar->common.regulatory; 1653 unsigned int rx_streams, tx_streams, tx_params = 0; 1654 int bands = 0; 1655 1656 if (ar->eeprom.length == cpu_to_le16(0xffff)) 1657 return -ENODATA; 1658 1659 rx_streams = hweight8(ar->eeprom.rx_mask); 1660 tx_streams = hweight8(ar->eeprom.tx_mask); 1661 1662 if (rx_streams != tx_streams) { 1663 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF; 1664 1665 WARN_ON(!(tx_streams >= 1 && tx_streams <= 1666 IEEE80211_HT_MCS_TX_MAX_STREAMS)); 1667 1668 tx_params = (tx_streams - 1) << 1669 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT; 1670 1671 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params; 1672 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params; 1673 } 1674 1675 if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) { 1676 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = 1677 &carl9170_band_2GHz; 1678 bands++; 1679 } 1680 if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) { 1681 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = 1682 &carl9170_band_5GHz; 1683 bands++; 1684 } 1685 1686 /* 1687 * I measured this, a bandswitch takes roughly 1688 * 135 ms and a frequency switch about 80. 1689 * 1690 * FIXME: measure these values again once EEPROM settings 1691 * are used, that will influence them! 1692 */ 1693 if (bands == 2) 1694 ar->hw->channel_change_time = 135 * 1000; 1695 else 1696 ar->hw->channel_change_time = 80 * 1000; 1697 1698 regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]); 1699 regulatory->current_rd_ext = le16_to_cpu(ar->eeprom.reg_domain[1]); 1700 1701 /* second part of wiphy init */ 1702 SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address); 1703 1704 return bands ? 0 : -EINVAL; 1705 } 1706 1707 static int carl9170_reg_notifier(struct wiphy *wiphy, 1708 struct regulatory_request *request) 1709 { 1710 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 1711 struct ar9170 *ar = hw->priv; 1712 1713 return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory); 1714 } 1715 1716 int carl9170_register(struct ar9170 *ar) 1717 { 1718 struct ath_regulatory *regulatory = &ar->common.regulatory; 1719 int err = 0, i; 1720 1721 if (WARN_ON(ar->mem_bitmap)) 1722 return -EINVAL; 1723 1724 ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) * 1725 sizeof(unsigned long), GFP_KERNEL); 1726 1727 if (!ar->mem_bitmap) 1728 return -ENOMEM; 1729 1730 /* try to read EEPROM, init MAC addr */ 1731 err = carl9170_read_eeprom(ar); 1732 if (err) 1733 return err; 1734 1735 err = carl9170_fw_fix_eeprom(ar); 1736 if (err) 1737 return err; 1738 1739 err = carl9170_parse_eeprom(ar); 1740 if (err) 1741 return err; 1742 1743 err = ath_regd_init(regulatory, ar->hw->wiphy, 1744 carl9170_reg_notifier); 1745 if (err) 1746 return err; 1747 1748 if (modparam_noht) { 1749 carl9170_band_2GHz.ht_cap.ht_supported = false; 1750 carl9170_band_5GHz.ht_cap.ht_supported = false; 1751 } 1752 1753 for (i = 0; i < ar->fw.vif_num; i++) { 1754 ar->vif_priv[i].id = i; 1755 ar->vif_priv[i].vif = NULL; 1756 } 1757 1758 err = ieee80211_register_hw(ar->hw); 1759 if (err) 1760 return err; 1761 1762 /* mac80211 interface is now registered */ 1763 ar->registered = true; 1764 1765 if (!ath_is_world_regd(regulatory)) 1766 regulatory_hint(ar->hw->wiphy, regulatory->alpha2); 1767 1768 #ifdef CONFIG_CARL9170_DEBUGFS 1769 carl9170_debugfs_register(ar); 1770 #endif /* CONFIG_CARL9170_DEBUGFS */ 1771 1772 err = carl9170_led_init(ar); 1773 if (err) 1774 goto err_unreg; 1775 1776 #ifdef CONFIG_CARL9170_LEDS 1777 err = carl9170_led_register(ar); 1778 if (err) 1779 goto err_unreg; 1780 #endif /* CONFIG_CARL9170_LEDS */ 1781 1782 #ifdef CONFIG_CARL9170_WPC 1783 err = carl9170_register_wps_button(ar); 1784 if (err) 1785 goto err_unreg; 1786 #endif /* CONFIG_CARL9170_WPC */ 1787 1788 dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n", 1789 wiphy_name(ar->hw->wiphy)); 1790 1791 return 0; 1792 1793 err_unreg: 1794 carl9170_unregister(ar); 1795 return err; 1796 } 1797 1798 void carl9170_unregister(struct ar9170 *ar) 1799 { 1800 if (!ar->registered) 1801 return; 1802 1803 ar->registered = false; 1804 1805 #ifdef CONFIG_CARL9170_LEDS 1806 carl9170_led_unregister(ar); 1807 #endif /* CONFIG_CARL9170_LEDS */ 1808 1809 #ifdef CONFIG_CARL9170_DEBUGFS 1810 carl9170_debugfs_unregister(ar); 1811 #endif /* CONFIG_CARL9170_DEBUGFS */ 1812 1813 #ifdef CONFIG_CARL9170_WPC 1814 if (ar->wps.pbc) { 1815 input_unregister_device(ar->wps.pbc); 1816 ar->wps.pbc = NULL; 1817 } 1818 #endif /* CONFIG_CARL9170_WPC */ 1819 1820 carl9170_cancel_worker(ar); 1821 cancel_work_sync(&ar->restart_work); 1822 1823 ieee80211_unregister_hw(ar->hw); 1824 } 1825 1826 void carl9170_free(struct ar9170 *ar) 1827 { 1828 WARN_ON(ar->registered); 1829 WARN_ON(IS_INITIALIZED(ar)); 1830 1831 kfree_skb(ar->rx_failover); 1832 ar->rx_failover = NULL; 1833 1834 kfree(ar->mem_bitmap); 1835 ar->mem_bitmap = NULL; 1836 1837 mutex_destroy(&ar->mutex); 1838 1839 ieee80211_free_hw(ar->hw); 1840 } 1841