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 bool 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_queue_delayed_work(ar->hw, &ar->stat_work, 417 round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK))); 418 419 ieee80211_wake_queues(ar->hw); 420 err = 0; 421 422 out: 423 mutex_unlock(&ar->mutex); 424 return err; 425 } 426 427 static void carl9170_cancel_worker(struct ar9170 *ar) 428 { 429 cancel_delayed_work_sync(&ar->stat_work); 430 cancel_delayed_work_sync(&ar->tx_janitor); 431 #ifdef CONFIG_CARL9170_LEDS 432 cancel_delayed_work_sync(&ar->led_work); 433 #endif /* CONFIG_CARL9170_LEDS */ 434 cancel_work_sync(&ar->ps_work); 435 cancel_work_sync(&ar->ping_work); 436 cancel_work_sync(&ar->ampdu_work); 437 } 438 439 static void carl9170_op_stop(struct ieee80211_hw *hw) 440 { 441 struct ar9170 *ar = hw->priv; 442 443 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE); 444 445 ieee80211_stop_queues(ar->hw); 446 447 mutex_lock(&ar->mutex); 448 if (IS_ACCEPTING_CMD(ar)) { 449 RCU_INIT_POINTER(ar->beacon_iter, NULL); 450 451 carl9170_led_set_state(ar, 0); 452 453 /* stop DMA */ 454 carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 0); 455 carl9170_usb_stop(ar); 456 } 457 458 carl9170_zap_queues(ar); 459 mutex_unlock(&ar->mutex); 460 461 carl9170_cancel_worker(ar); 462 } 463 464 static void carl9170_restart_work(struct work_struct *work) 465 { 466 struct ar9170 *ar = container_of(work, struct ar9170, 467 restart_work); 468 int err; 469 470 ar->usedkeys = 0; 471 ar->filter_state = 0; 472 carl9170_cancel_worker(ar); 473 474 mutex_lock(&ar->mutex); 475 err = carl9170_usb_restart(ar); 476 if (net_ratelimit()) { 477 if (err) { 478 dev_err(&ar->udev->dev, "Failed to restart device " 479 " (%d).\n", err); 480 } else { 481 dev_info(&ar->udev->dev, "device restarted " 482 "successfully.\n"); 483 } 484 } 485 486 carl9170_zap_queues(ar); 487 mutex_unlock(&ar->mutex); 488 if (!err) { 489 ar->restart_counter++; 490 atomic_set(&ar->pending_restarts, 0); 491 492 ieee80211_restart_hw(ar->hw); 493 } else { 494 /* 495 * The reset was unsuccessful and the device seems to 496 * be dead. But there's still one option: a low-level 497 * usb subsystem reset... 498 */ 499 500 carl9170_usb_reset(ar); 501 } 502 } 503 504 void carl9170_restart(struct ar9170 *ar, const enum carl9170_restart_reasons r) 505 { 506 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE); 507 508 /* 509 * Sometimes, an error can trigger several different reset events. 510 * By ignoring these *surplus* reset events, the device won't be 511 * killed again, right after it has recovered. 512 */ 513 if (atomic_inc_return(&ar->pending_restarts) > 1) { 514 dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r); 515 return; 516 } 517 518 ieee80211_stop_queues(ar->hw); 519 520 dev_err(&ar->udev->dev, "restart device (%d)\n", r); 521 522 if (!WARN_ON(r == CARL9170_RR_NO_REASON) || 523 !WARN_ON(r >= __CARL9170_RR_LAST)) 524 ar->last_reason = r; 525 526 if (!ar->registered) 527 return; 528 529 if (IS_ACCEPTING_CMD(ar) && !ar->needs_full_reset) 530 ieee80211_queue_work(ar->hw, &ar->restart_work); 531 else 532 carl9170_usb_reset(ar); 533 534 /* 535 * At this point, the device instance might have vanished/disabled. 536 * So, don't put any code which access the ar9170 struct 537 * without proper protection. 538 */ 539 } 540 541 static void carl9170_ping_work(struct work_struct *work) 542 { 543 struct ar9170 *ar = container_of(work, struct ar9170, ping_work); 544 int err; 545 546 if (!IS_STARTED(ar)) 547 return; 548 549 mutex_lock(&ar->mutex); 550 err = carl9170_echo_test(ar, 0xdeadbeef); 551 if (err) 552 carl9170_restart(ar, CARL9170_RR_UNRESPONSIVE_DEVICE); 553 mutex_unlock(&ar->mutex); 554 } 555 556 static int carl9170_init_interface(struct ar9170 *ar, 557 struct ieee80211_vif *vif) 558 { 559 struct ath_common *common = &ar->common; 560 int err; 561 562 if (!vif) { 563 WARN_ON_ONCE(IS_STARTED(ar)); 564 return 0; 565 } 566 567 memcpy(common->macaddr, vif->addr, ETH_ALEN); 568 569 if (modparam_nohwcrypt || 570 ((vif->type != NL80211_IFTYPE_STATION) && 571 (vif->type != NL80211_IFTYPE_AP))) { 572 ar->rx_software_decryption = true; 573 ar->disable_offload = true; 574 } 575 576 err = carl9170_set_operating_mode(ar); 577 return err; 578 } 579 580 static int carl9170_op_add_interface(struct ieee80211_hw *hw, 581 struct ieee80211_vif *vif) 582 { 583 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv; 584 struct ieee80211_vif *main_vif; 585 struct ar9170 *ar = hw->priv; 586 int vif_id = -1, err = 0; 587 588 mutex_lock(&ar->mutex); 589 rcu_read_lock(); 590 if (vif_priv->active) { 591 /* 592 * Skip the interface structure initialization, 593 * if the vif survived the _restart call. 594 */ 595 vif_id = vif_priv->id; 596 vif_priv->enable_beacon = false; 597 598 spin_lock_bh(&ar->beacon_lock); 599 dev_kfree_skb_any(vif_priv->beacon); 600 vif_priv->beacon = NULL; 601 spin_unlock_bh(&ar->beacon_lock); 602 603 goto init; 604 } 605 606 main_vif = carl9170_get_main_vif(ar); 607 608 if (main_vif) { 609 switch (main_vif->type) { 610 case NL80211_IFTYPE_STATION: 611 if (vif->type == NL80211_IFTYPE_STATION) 612 break; 613 614 err = -EBUSY; 615 rcu_read_unlock(); 616 617 goto unlock; 618 619 case NL80211_IFTYPE_AP: 620 if ((vif->type == NL80211_IFTYPE_STATION) || 621 (vif->type == NL80211_IFTYPE_WDS) || 622 (vif->type == NL80211_IFTYPE_AP)) 623 break; 624 625 err = -EBUSY; 626 rcu_read_unlock(); 627 goto unlock; 628 629 default: 630 rcu_read_unlock(); 631 goto unlock; 632 } 633 } 634 635 vif_id = bitmap_find_free_region(&ar->vif_bitmap, ar->fw.vif_num, 0); 636 637 if (vif_id < 0) { 638 rcu_read_unlock(); 639 640 err = -ENOSPC; 641 goto unlock; 642 } 643 644 BUG_ON(ar->vif_priv[vif_id].id != vif_id); 645 646 vif_priv->active = true; 647 vif_priv->id = vif_id; 648 vif_priv->enable_beacon = false; 649 ar->vifs++; 650 list_add_tail_rcu(&vif_priv->list, &ar->vif_list); 651 rcu_assign_pointer(ar->vif_priv[vif_id].vif, vif); 652 653 init: 654 if (carl9170_get_main_vif(ar) == vif) { 655 rcu_assign_pointer(ar->beacon_iter, vif_priv); 656 rcu_read_unlock(); 657 658 err = carl9170_init_interface(ar, vif); 659 if (err) 660 goto unlock; 661 } else { 662 rcu_read_unlock(); 663 err = carl9170_mod_virtual_mac(ar, vif_id, vif->addr); 664 665 if (err) 666 goto unlock; 667 } 668 669 if (ar->fw.tx_seq_table) { 670 err = carl9170_write_reg(ar, ar->fw.tx_seq_table + vif_id * 4, 671 0); 672 if (err) 673 goto unlock; 674 } 675 676 unlock: 677 if (err && (vif_id >= 0)) { 678 vif_priv->active = false; 679 bitmap_release_region(&ar->vif_bitmap, vif_id, 0); 680 ar->vifs--; 681 RCU_INIT_POINTER(ar->vif_priv[vif_id].vif, NULL); 682 list_del_rcu(&vif_priv->list); 683 mutex_unlock(&ar->mutex); 684 synchronize_rcu(); 685 } else { 686 if (ar->vifs > 1) 687 ar->ps.off_override |= PS_OFF_VIF; 688 689 mutex_unlock(&ar->mutex); 690 } 691 692 return err; 693 } 694 695 static void carl9170_op_remove_interface(struct ieee80211_hw *hw, 696 struct ieee80211_vif *vif) 697 { 698 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv; 699 struct ieee80211_vif *main_vif; 700 struct ar9170 *ar = hw->priv; 701 unsigned int id; 702 703 mutex_lock(&ar->mutex); 704 705 if (WARN_ON_ONCE(!vif_priv->active)) 706 goto unlock; 707 708 ar->vifs--; 709 710 rcu_read_lock(); 711 main_vif = carl9170_get_main_vif(ar); 712 713 id = vif_priv->id; 714 715 vif_priv->active = false; 716 WARN_ON(vif_priv->enable_beacon); 717 vif_priv->enable_beacon = false; 718 list_del_rcu(&vif_priv->list); 719 RCU_INIT_POINTER(ar->vif_priv[id].vif, NULL); 720 721 if (vif == main_vif) { 722 rcu_read_unlock(); 723 724 if (ar->vifs) { 725 WARN_ON(carl9170_init_interface(ar, 726 carl9170_get_main_vif(ar))); 727 } else { 728 carl9170_set_operating_mode(ar); 729 } 730 } else { 731 rcu_read_unlock(); 732 733 WARN_ON(carl9170_mod_virtual_mac(ar, id, NULL)); 734 } 735 736 carl9170_update_beacon(ar, false); 737 carl9170_flush_cab(ar, id); 738 739 spin_lock_bh(&ar->beacon_lock); 740 dev_kfree_skb_any(vif_priv->beacon); 741 vif_priv->beacon = NULL; 742 spin_unlock_bh(&ar->beacon_lock); 743 744 bitmap_release_region(&ar->vif_bitmap, id, 0); 745 746 carl9170_set_beacon_timers(ar); 747 748 if (ar->vifs == 1) 749 ar->ps.off_override &= ~PS_OFF_VIF; 750 751 unlock: 752 mutex_unlock(&ar->mutex); 753 754 synchronize_rcu(); 755 } 756 757 void carl9170_ps_check(struct ar9170 *ar) 758 { 759 ieee80211_queue_work(ar->hw, &ar->ps_work); 760 } 761 762 /* caller must hold ar->mutex */ 763 static int carl9170_ps_update(struct ar9170 *ar) 764 { 765 bool ps = false; 766 int err = 0; 767 768 if (!ar->ps.off_override) 769 ps = (ar->hw->conf.flags & IEEE80211_CONF_PS); 770 771 if (ps != ar->ps.state) { 772 err = carl9170_powersave(ar, ps); 773 if (err) 774 return err; 775 776 if (ar->ps.state && !ps) { 777 ar->ps.sleep_ms = jiffies_to_msecs(jiffies - 778 ar->ps.last_action); 779 } 780 781 if (ps) 782 ar->ps.last_slept = jiffies; 783 784 ar->ps.last_action = jiffies; 785 ar->ps.state = ps; 786 } 787 788 return 0; 789 } 790 791 static void carl9170_ps_work(struct work_struct *work) 792 { 793 struct ar9170 *ar = container_of(work, struct ar9170, 794 ps_work); 795 mutex_lock(&ar->mutex); 796 if (IS_STARTED(ar)) 797 WARN_ON_ONCE(carl9170_ps_update(ar) != 0); 798 mutex_unlock(&ar->mutex); 799 } 800 801 static int carl9170_update_survey(struct ar9170 *ar, bool flush, bool noise) 802 { 803 int err; 804 805 if (noise) { 806 err = carl9170_get_noisefloor(ar); 807 if (err) 808 return err; 809 } 810 811 if (ar->fw.hw_counters) { 812 err = carl9170_collect_tally(ar); 813 if (err) 814 return err; 815 } 816 817 if (flush) 818 memset(&ar->tally, 0, sizeof(ar->tally)); 819 820 return 0; 821 } 822 823 static void carl9170_stat_work(struct work_struct *work) 824 { 825 struct ar9170 *ar = container_of(work, struct ar9170, stat_work.work); 826 int err; 827 828 mutex_lock(&ar->mutex); 829 err = carl9170_update_survey(ar, false, true); 830 mutex_unlock(&ar->mutex); 831 832 if (err) 833 return; 834 835 ieee80211_queue_delayed_work(ar->hw, &ar->stat_work, 836 round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK))); 837 } 838 839 static int carl9170_op_config(struct ieee80211_hw *hw, u32 changed) 840 { 841 struct ar9170 *ar = hw->priv; 842 int err = 0; 843 844 mutex_lock(&ar->mutex); 845 if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) { 846 /* TODO */ 847 err = 0; 848 } 849 850 if (changed & IEEE80211_CONF_CHANGE_PS) { 851 err = carl9170_ps_update(ar); 852 if (err) 853 goto out; 854 } 855 856 if (changed & IEEE80211_CONF_CHANGE_SMPS) { 857 /* TODO */ 858 err = 0; 859 } 860 861 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 862 /* adjust slot time for 5 GHz */ 863 err = carl9170_set_slot_time(ar); 864 if (err) 865 goto out; 866 867 err = carl9170_update_survey(ar, true, false); 868 if (err) 869 goto out; 870 871 err = carl9170_set_channel(ar, hw->conf.channel, 872 hw->conf.channel_type, CARL9170_RFI_NONE); 873 if (err) 874 goto out; 875 876 err = carl9170_update_survey(ar, false, true); 877 if (err) 878 goto out; 879 880 err = carl9170_set_dyn_sifs_ack(ar); 881 if (err) 882 goto out; 883 884 err = carl9170_set_rts_cts_rate(ar); 885 if (err) 886 goto out; 887 } 888 889 if (changed & IEEE80211_CONF_CHANGE_POWER) { 890 err = carl9170_set_mac_tpc(ar, ar->hw->conf.channel); 891 if (err) 892 goto out; 893 } 894 895 out: 896 mutex_unlock(&ar->mutex); 897 return err; 898 } 899 900 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw, 901 struct netdev_hw_addr_list *mc_list) 902 { 903 struct netdev_hw_addr *ha; 904 u64 mchash; 905 906 /* always get broadcast frames */ 907 mchash = 1ULL << (0xff >> 2); 908 909 netdev_hw_addr_list_for_each(ha, mc_list) 910 mchash |= 1ULL << (ha->addr[5] >> 2); 911 912 return mchash; 913 } 914 915 static void carl9170_op_configure_filter(struct ieee80211_hw *hw, 916 unsigned int changed_flags, 917 unsigned int *new_flags, 918 u64 multicast) 919 { 920 struct ar9170 *ar = hw->priv; 921 922 /* mask supported flags */ 923 *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps; 924 925 if (!IS_ACCEPTING_CMD(ar)) 926 return; 927 928 mutex_lock(&ar->mutex); 929 930 ar->filter_state = *new_flags; 931 /* 932 * We can support more by setting the sniffer bit and 933 * then checking the error flags, later. 934 */ 935 936 if (*new_flags & FIF_ALLMULTI) 937 multicast = ~0ULL; 938 939 if (multicast != ar->cur_mc_hash) 940 WARN_ON(carl9170_update_multicast(ar, multicast)); 941 942 if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) { 943 ar->sniffer_enabled = !!(*new_flags & 944 (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)); 945 946 WARN_ON(carl9170_set_operating_mode(ar)); 947 } 948 949 if (ar->fw.rx_filter && changed_flags & ar->rx_filter_caps) { 950 u32 rx_filter = 0; 951 952 if (!ar->fw.ba_filter) 953 rx_filter |= CARL9170_RX_FILTER_CTL_OTHER; 954 955 if (!(*new_flags & (FIF_FCSFAIL | FIF_PLCPFAIL))) 956 rx_filter |= CARL9170_RX_FILTER_BAD; 957 958 if (!(*new_flags & FIF_CONTROL)) 959 rx_filter |= CARL9170_RX_FILTER_CTL_OTHER; 960 961 if (!(*new_flags & FIF_PSPOLL)) 962 rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL; 963 964 if (!(*new_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))) { 965 rx_filter |= CARL9170_RX_FILTER_OTHER_RA; 966 rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL; 967 } 968 969 WARN_ON(carl9170_rx_filter(ar, rx_filter)); 970 } 971 972 mutex_unlock(&ar->mutex); 973 } 974 975 976 static void carl9170_op_bss_info_changed(struct ieee80211_hw *hw, 977 struct ieee80211_vif *vif, 978 struct ieee80211_bss_conf *bss_conf, 979 u32 changed) 980 { 981 struct ar9170 *ar = hw->priv; 982 struct ath_common *common = &ar->common; 983 int err = 0; 984 struct carl9170_vif_info *vif_priv; 985 struct ieee80211_vif *main_vif; 986 987 mutex_lock(&ar->mutex); 988 vif_priv = (void *) vif->drv_priv; 989 main_vif = carl9170_get_main_vif(ar); 990 if (WARN_ON(!main_vif)) 991 goto out; 992 993 if (changed & BSS_CHANGED_BEACON_ENABLED) { 994 struct carl9170_vif_info *iter; 995 int i = 0; 996 997 vif_priv->enable_beacon = bss_conf->enable_beacon; 998 rcu_read_lock(); 999 list_for_each_entry_rcu(iter, &ar->vif_list, list) { 1000 if (iter->active && iter->enable_beacon) 1001 i++; 1002 1003 } 1004 rcu_read_unlock(); 1005 1006 ar->beacon_enabled = i; 1007 } 1008 1009 if (changed & BSS_CHANGED_BEACON) { 1010 err = carl9170_update_beacon(ar, false); 1011 if (err) 1012 goto out; 1013 } 1014 1015 if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON | 1016 BSS_CHANGED_BEACON_INT)) { 1017 1018 if (main_vif != vif) { 1019 bss_conf->beacon_int = main_vif->bss_conf.beacon_int; 1020 bss_conf->dtim_period = main_vif->bss_conf.dtim_period; 1021 } 1022 1023 /* 1024 * Therefore a hard limit for the broadcast traffic should 1025 * prevent false alarms. 1026 */ 1027 if (vif->type != NL80211_IFTYPE_STATION && 1028 (bss_conf->beacon_int * bss_conf->dtim_period >= 1029 (CARL9170_QUEUE_STUCK_TIMEOUT / 2))) { 1030 err = -EINVAL; 1031 goto out; 1032 } 1033 1034 err = carl9170_set_beacon_timers(ar); 1035 if (err) 1036 goto out; 1037 } 1038 1039 if (changed & BSS_CHANGED_HT) { 1040 /* TODO */ 1041 err = 0; 1042 if (err) 1043 goto out; 1044 } 1045 1046 if (main_vif != vif) 1047 goto out; 1048 1049 /* 1050 * The following settings can only be changed by the 1051 * master interface. 1052 */ 1053 1054 if (changed & BSS_CHANGED_BSSID) { 1055 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN); 1056 err = carl9170_set_operating_mode(ar); 1057 if (err) 1058 goto out; 1059 } 1060 1061 if (changed & BSS_CHANGED_ASSOC) { 1062 ar->common.curaid = bss_conf->aid; 1063 err = carl9170_set_beacon_timers(ar); 1064 if (err) 1065 goto out; 1066 } 1067 1068 if (changed & BSS_CHANGED_ERP_SLOT) { 1069 err = carl9170_set_slot_time(ar); 1070 if (err) 1071 goto out; 1072 } 1073 1074 if (changed & BSS_CHANGED_BASIC_RATES) { 1075 err = carl9170_set_mac_rates(ar); 1076 if (err) 1077 goto out; 1078 } 1079 1080 out: 1081 WARN_ON_ONCE(err && IS_STARTED(ar)); 1082 mutex_unlock(&ar->mutex); 1083 } 1084 1085 static u64 carl9170_op_get_tsf(struct ieee80211_hw *hw, 1086 struct ieee80211_vif *vif) 1087 { 1088 struct ar9170 *ar = hw->priv; 1089 struct carl9170_tsf_rsp tsf; 1090 int err; 1091 1092 mutex_lock(&ar->mutex); 1093 err = carl9170_exec_cmd(ar, CARL9170_CMD_READ_TSF, 1094 0, NULL, sizeof(tsf), &tsf); 1095 mutex_unlock(&ar->mutex); 1096 if (WARN_ON(err)) 1097 return 0; 1098 1099 return le64_to_cpu(tsf.tsf_64); 1100 } 1101 1102 static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 1103 struct ieee80211_vif *vif, 1104 struct ieee80211_sta *sta, 1105 struct ieee80211_key_conf *key) 1106 { 1107 struct ar9170 *ar = hw->priv; 1108 int err = 0, i; 1109 u8 ktype; 1110 1111 if (ar->disable_offload || !vif) 1112 return -EOPNOTSUPP; 1113 1114 /* 1115 * We have to fall back to software encryption, whenever 1116 * the user choose to participates in an IBSS or is connected 1117 * to more than one network. 1118 * 1119 * This is very unfortunate, because some machines cannot handle 1120 * the high througput speed in 802.11n networks. 1121 */ 1122 1123 if (!is_main_vif(ar, vif)) { 1124 mutex_lock(&ar->mutex); 1125 goto err_softw; 1126 } 1127 1128 /* 1129 * While the hardware supports *catch-all* key, for offloading 1130 * group-key en-/de-cryption. The way of how the hardware 1131 * decides which keyId maps to which key, remains a mystery... 1132 */ 1133 if ((vif->type != NL80211_IFTYPE_STATION && 1134 vif->type != NL80211_IFTYPE_ADHOC) && 1135 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 1136 return -EOPNOTSUPP; 1137 1138 switch (key->cipher) { 1139 case WLAN_CIPHER_SUITE_WEP40: 1140 ktype = AR9170_ENC_ALG_WEP64; 1141 break; 1142 case WLAN_CIPHER_SUITE_WEP104: 1143 ktype = AR9170_ENC_ALG_WEP128; 1144 break; 1145 case WLAN_CIPHER_SUITE_TKIP: 1146 ktype = AR9170_ENC_ALG_TKIP; 1147 break; 1148 case WLAN_CIPHER_SUITE_CCMP: 1149 ktype = AR9170_ENC_ALG_AESCCMP; 1150 break; 1151 default: 1152 return -EOPNOTSUPP; 1153 } 1154 1155 mutex_lock(&ar->mutex); 1156 if (cmd == SET_KEY) { 1157 if (!IS_STARTED(ar)) { 1158 err = -EOPNOTSUPP; 1159 goto out; 1160 } 1161 1162 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) { 1163 sta = NULL; 1164 1165 i = 64 + key->keyidx; 1166 } else { 1167 for (i = 0; i < 64; i++) 1168 if (!(ar->usedkeys & BIT(i))) 1169 break; 1170 if (i == 64) 1171 goto err_softw; 1172 } 1173 1174 key->hw_key_idx = i; 1175 1176 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL, 1177 ktype, 0, key->key, 1178 min_t(u8, 16, key->keylen)); 1179 if (err) 1180 goto out; 1181 1182 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1183 err = carl9170_upload_key(ar, i, sta ? sta->addr : 1184 NULL, ktype, 1, 1185 key->key + 16, 16); 1186 if (err) 1187 goto out; 1188 1189 /* 1190 * hardware is not capable generating MMIC 1191 * of fragmented frames! 1192 */ 1193 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC; 1194 } 1195 1196 if (i < 64) 1197 ar->usedkeys |= BIT(i); 1198 1199 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 1200 } else { 1201 if (!IS_STARTED(ar)) { 1202 /* The device is gone... together with the key ;-) */ 1203 err = 0; 1204 goto out; 1205 } 1206 1207 if (key->hw_key_idx < 64) { 1208 ar->usedkeys &= ~BIT(key->hw_key_idx); 1209 } else { 1210 err = carl9170_upload_key(ar, key->hw_key_idx, NULL, 1211 AR9170_ENC_ALG_NONE, 0, 1212 NULL, 0); 1213 if (err) 1214 goto out; 1215 1216 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1217 err = carl9170_upload_key(ar, key->hw_key_idx, 1218 NULL, 1219 AR9170_ENC_ALG_NONE, 1220 1, NULL, 0); 1221 if (err) 1222 goto out; 1223 } 1224 1225 } 1226 1227 err = carl9170_disable_key(ar, key->hw_key_idx); 1228 if (err) 1229 goto out; 1230 } 1231 1232 out: 1233 mutex_unlock(&ar->mutex); 1234 return err; 1235 1236 err_softw: 1237 if (!ar->rx_software_decryption) { 1238 ar->rx_software_decryption = true; 1239 carl9170_set_operating_mode(ar); 1240 } 1241 mutex_unlock(&ar->mutex); 1242 return -ENOSPC; 1243 } 1244 1245 static int carl9170_op_sta_add(struct ieee80211_hw *hw, 1246 struct ieee80211_vif *vif, 1247 struct ieee80211_sta *sta) 1248 { 1249 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1250 unsigned int i; 1251 1252 atomic_set(&sta_info->pending_frames, 0); 1253 1254 if (sta->ht_cap.ht_supported) { 1255 if (sta->ht_cap.ampdu_density > 6) { 1256 /* 1257 * HW does support 16us AMPDU density. 1258 * No HT-Xmit for station. 1259 */ 1260 1261 return 0; 1262 } 1263 1264 for (i = 0; i < CARL9170_NUM_TID; i++) 1265 RCU_INIT_POINTER(sta_info->agg[i], NULL); 1266 1267 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor); 1268 sta_info->ht_sta = true; 1269 } 1270 1271 return 0; 1272 } 1273 1274 static int carl9170_op_sta_remove(struct ieee80211_hw *hw, 1275 struct ieee80211_vif *vif, 1276 struct ieee80211_sta *sta) 1277 { 1278 struct ar9170 *ar = hw->priv; 1279 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1280 unsigned int i; 1281 bool cleanup = false; 1282 1283 if (sta->ht_cap.ht_supported) { 1284 1285 sta_info->ht_sta = false; 1286 1287 rcu_read_lock(); 1288 for (i = 0; i < CARL9170_NUM_TID; i++) { 1289 struct carl9170_sta_tid *tid_info; 1290 1291 tid_info = rcu_dereference(sta_info->agg[i]); 1292 RCU_INIT_POINTER(sta_info->agg[i], NULL); 1293 1294 if (!tid_info) 1295 continue; 1296 1297 spin_lock_bh(&ar->tx_ampdu_list_lock); 1298 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN) 1299 tid_info->state = CARL9170_TID_STATE_SHUTDOWN; 1300 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1301 cleanup = true; 1302 } 1303 rcu_read_unlock(); 1304 1305 if (cleanup) 1306 carl9170_ampdu_gc(ar); 1307 } 1308 1309 return 0; 1310 } 1311 1312 static int carl9170_op_conf_tx(struct ieee80211_hw *hw, 1313 struct ieee80211_vif *vif, u16 queue, 1314 const struct ieee80211_tx_queue_params *param) 1315 { 1316 struct ar9170 *ar = hw->priv; 1317 int ret; 1318 1319 mutex_lock(&ar->mutex); 1320 if (queue < ar->hw->queues) { 1321 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param)); 1322 ret = carl9170_set_qos(ar); 1323 } else { 1324 ret = -EINVAL; 1325 } 1326 1327 mutex_unlock(&ar->mutex); 1328 return ret; 1329 } 1330 1331 static void carl9170_ampdu_work(struct work_struct *work) 1332 { 1333 struct ar9170 *ar = container_of(work, struct ar9170, 1334 ampdu_work); 1335 1336 if (!IS_STARTED(ar)) 1337 return; 1338 1339 mutex_lock(&ar->mutex); 1340 carl9170_ampdu_gc(ar); 1341 mutex_unlock(&ar->mutex); 1342 } 1343 1344 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw, 1345 struct ieee80211_vif *vif, 1346 enum ieee80211_ampdu_mlme_action action, 1347 struct ieee80211_sta *sta, 1348 u16 tid, u16 *ssn, u8 buf_size) 1349 { 1350 struct ar9170 *ar = hw->priv; 1351 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1352 struct carl9170_sta_tid *tid_info; 1353 1354 if (modparam_noht) 1355 return -EOPNOTSUPP; 1356 1357 switch (action) { 1358 case IEEE80211_AMPDU_TX_START: 1359 if (!sta_info->ht_sta) 1360 return -EOPNOTSUPP; 1361 1362 rcu_read_lock(); 1363 if (rcu_dereference(sta_info->agg[tid])) { 1364 rcu_read_unlock(); 1365 return -EBUSY; 1366 } 1367 1368 tid_info = kzalloc(sizeof(struct carl9170_sta_tid), 1369 GFP_ATOMIC); 1370 if (!tid_info) { 1371 rcu_read_unlock(); 1372 return -ENOMEM; 1373 } 1374 1375 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn); 1376 tid_info->state = CARL9170_TID_STATE_PROGRESS; 1377 tid_info->tid = tid; 1378 tid_info->max = sta_info->ampdu_max_len; 1379 1380 INIT_LIST_HEAD(&tid_info->list); 1381 INIT_LIST_HEAD(&tid_info->tmp_list); 1382 skb_queue_head_init(&tid_info->queue); 1383 spin_lock_init(&tid_info->lock); 1384 1385 spin_lock_bh(&ar->tx_ampdu_list_lock); 1386 ar->tx_ampdu_list_len++; 1387 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list); 1388 rcu_assign_pointer(sta_info->agg[tid], tid_info); 1389 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1390 rcu_read_unlock(); 1391 1392 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1393 break; 1394 1395 case IEEE80211_AMPDU_TX_STOP: 1396 rcu_read_lock(); 1397 tid_info = rcu_dereference(sta_info->agg[tid]); 1398 if (tid_info) { 1399 spin_lock_bh(&ar->tx_ampdu_list_lock); 1400 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN) 1401 tid_info->state = CARL9170_TID_STATE_SHUTDOWN; 1402 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1403 } 1404 1405 RCU_INIT_POINTER(sta_info->agg[tid], NULL); 1406 rcu_read_unlock(); 1407 1408 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1409 ieee80211_queue_work(ar->hw, &ar->ampdu_work); 1410 break; 1411 1412 case IEEE80211_AMPDU_TX_OPERATIONAL: 1413 rcu_read_lock(); 1414 tid_info = rcu_dereference(sta_info->agg[tid]); 1415 1416 sta_info->stats[tid].clear = true; 1417 sta_info->stats[tid].req = false; 1418 1419 if (tid_info) { 1420 bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE); 1421 tid_info->state = CARL9170_TID_STATE_IDLE; 1422 } 1423 rcu_read_unlock(); 1424 1425 if (WARN_ON_ONCE(!tid_info)) 1426 return -EFAULT; 1427 1428 break; 1429 1430 case IEEE80211_AMPDU_RX_START: 1431 case IEEE80211_AMPDU_RX_STOP: 1432 /* Handled by hardware */ 1433 break; 1434 1435 default: 1436 return -EOPNOTSUPP; 1437 } 1438 1439 return 0; 1440 } 1441 1442 #ifdef CONFIG_CARL9170_WPC 1443 static int carl9170_register_wps_button(struct ar9170 *ar) 1444 { 1445 struct input_dev *input; 1446 int err; 1447 1448 if (!(ar->features & CARL9170_WPS_BUTTON)) 1449 return 0; 1450 1451 input = input_allocate_device(); 1452 if (!input) 1453 return -ENOMEM; 1454 1455 snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button", 1456 wiphy_name(ar->hw->wiphy)); 1457 1458 snprintf(ar->wps.phys, sizeof(ar->wps.phys), 1459 "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy)); 1460 1461 input->name = ar->wps.name; 1462 input->phys = ar->wps.phys; 1463 input->id.bustype = BUS_USB; 1464 input->dev.parent = &ar->hw->wiphy->dev; 1465 1466 input_set_capability(input, EV_KEY, KEY_WPS_BUTTON); 1467 1468 err = input_register_device(input); 1469 if (err) { 1470 input_free_device(input); 1471 return err; 1472 } 1473 1474 ar->wps.pbc = input; 1475 return 0; 1476 } 1477 #endif /* CONFIG_CARL9170_WPC */ 1478 1479 #ifdef CONFIG_CARL9170_HWRNG 1480 static int carl9170_rng_get(struct ar9170 *ar) 1481 { 1482 1483 #define RW (CARL9170_MAX_CMD_PAYLOAD_LEN / sizeof(u32)) 1484 #define RB (CARL9170_MAX_CMD_PAYLOAD_LEN) 1485 1486 static const __le32 rng_load[RW] = { 1487 [0 ... (RW - 1)] = cpu_to_le32(AR9170_RAND_REG_NUM)}; 1488 1489 u32 buf[RW]; 1490 1491 unsigned int i, off = 0, transfer, count; 1492 int err; 1493 1494 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_PAYLOAD_LEN); 1495 1496 if (!IS_ACCEPTING_CMD(ar) || !ar->rng.initialized) 1497 return -EAGAIN; 1498 1499 count = ARRAY_SIZE(ar->rng.cache); 1500 while (count) { 1501 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG, 1502 RB, (u8 *) rng_load, 1503 RB, (u8 *) buf); 1504 if (err) 1505 return err; 1506 1507 transfer = min_t(unsigned int, count, RW); 1508 for (i = 0; i < transfer; i++) 1509 ar->rng.cache[off + i] = buf[i]; 1510 1511 off += transfer; 1512 count -= transfer; 1513 } 1514 1515 ar->rng.cache_idx = 0; 1516 1517 #undef RW 1518 #undef RB 1519 return 0; 1520 } 1521 1522 static int carl9170_rng_read(struct hwrng *rng, u32 *data) 1523 { 1524 struct ar9170 *ar = (struct ar9170 *)rng->priv; 1525 int ret = -EIO; 1526 1527 mutex_lock(&ar->mutex); 1528 if (ar->rng.cache_idx >= ARRAY_SIZE(ar->rng.cache)) { 1529 ret = carl9170_rng_get(ar); 1530 if (ret) { 1531 mutex_unlock(&ar->mutex); 1532 return ret; 1533 } 1534 } 1535 1536 *data = ar->rng.cache[ar->rng.cache_idx++]; 1537 mutex_unlock(&ar->mutex); 1538 1539 return sizeof(u16); 1540 } 1541 1542 static void carl9170_unregister_hwrng(struct ar9170 *ar) 1543 { 1544 if (ar->rng.initialized) { 1545 hwrng_unregister(&ar->rng.rng); 1546 ar->rng.initialized = false; 1547 } 1548 } 1549 1550 static int carl9170_register_hwrng(struct ar9170 *ar) 1551 { 1552 int err; 1553 1554 snprintf(ar->rng.name, ARRAY_SIZE(ar->rng.name), 1555 "%s_%s", KBUILD_MODNAME, wiphy_name(ar->hw->wiphy)); 1556 ar->rng.rng.name = ar->rng.name; 1557 ar->rng.rng.data_read = carl9170_rng_read; 1558 ar->rng.rng.priv = (unsigned long)ar; 1559 1560 if (WARN_ON(ar->rng.initialized)) 1561 return -EALREADY; 1562 1563 err = hwrng_register(&ar->rng.rng); 1564 if (err) { 1565 dev_err(&ar->udev->dev, "Failed to register the random " 1566 "number generator (%d)\n", err); 1567 return err; 1568 } 1569 1570 ar->rng.initialized = true; 1571 1572 err = carl9170_rng_get(ar); 1573 if (err) { 1574 carl9170_unregister_hwrng(ar); 1575 return err; 1576 } 1577 1578 return 0; 1579 } 1580 #endif /* CONFIG_CARL9170_HWRNG */ 1581 1582 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx, 1583 struct survey_info *survey) 1584 { 1585 struct ar9170 *ar = hw->priv; 1586 struct ieee80211_channel *chan; 1587 struct ieee80211_supported_band *band; 1588 int err, b, i; 1589 1590 chan = ar->channel; 1591 if (!chan) 1592 return -ENODEV; 1593 1594 if (idx == chan->hw_value) { 1595 mutex_lock(&ar->mutex); 1596 err = carl9170_update_survey(ar, false, true); 1597 mutex_unlock(&ar->mutex); 1598 if (err) 1599 return err; 1600 } 1601 1602 for (b = 0; b < IEEE80211_NUM_BANDS; b++) { 1603 band = ar->hw->wiphy->bands[b]; 1604 1605 if (!band) 1606 continue; 1607 1608 for (i = 0; i < band->n_channels; i++) { 1609 if (band->channels[i].hw_value == idx) { 1610 chan = &band->channels[i]; 1611 goto found; 1612 } 1613 } 1614 } 1615 return -ENOENT; 1616 1617 found: 1618 memcpy(survey, &ar->survey[idx], sizeof(*survey)); 1619 1620 survey->channel = chan; 1621 survey->filled = SURVEY_INFO_NOISE_DBM; 1622 1623 if (ar->channel == chan) 1624 survey->filled |= SURVEY_INFO_IN_USE; 1625 1626 if (ar->fw.hw_counters) { 1627 survey->filled |= SURVEY_INFO_CHANNEL_TIME | 1628 SURVEY_INFO_CHANNEL_TIME_BUSY | 1629 SURVEY_INFO_CHANNEL_TIME_TX; 1630 } 1631 1632 return 0; 1633 } 1634 1635 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop) 1636 { 1637 struct ar9170 *ar = hw->priv; 1638 unsigned int vid; 1639 1640 mutex_lock(&ar->mutex); 1641 for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num) 1642 carl9170_flush_cab(ar, vid); 1643 1644 carl9170_flush(ar, drop); 1645 mutex_unlock(&ar->mutex); 1646 } 1647 1648 static int carl9170_op_get_stats(struct ieee80211_hw *hw, 1649 struct ieee80211_low_level_stats *stats) 1650 { 1651 struct ar9170 *ar = hw->priv; 1652 1653 memset(stats, 0, sizeof(*stats)); 1654 stats->dot11ACKFailureCount = ar->tx_ack_failures; 1655 stats->dot11FCSErrorCount = ar->tx_fcs_errors; 1656 return 0; 1657 } 1658 1659 static void carl9170_op_sta_notify(struct ieee80211_hw *hw, 1660 struct ieee80211_vif *vif, 1661 enum sta_notify_cmd cmd, 1662 struct ieee80211_sta *sta) 1663 { 1664 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1665 1666 switch (cmd) { 1667 case STA_NOTIFY_SLEEP: 1668 sta_info->sleeping = true; 1669 if (atomic_read(&sta_info->pending_frames)) 1670 ieee80211_sta_block_awake(hw, sta, true); 1671 break; 1672 1673 case STA_NOTIFY_AWAKE: 1674 sta_info->sleeping = false; 1675 break; 1676 } 1677 } 1678 1679 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw) 1680 { 1681 struct ar9170 *ar = hw->priv; 1682 1683 return !!atomic_read(&ar->tx_total_queued); 1684 } 1685 1686 static const struct ieee80211_ops carl9170_ops = { 1687 .start = carl9170_op_start, 1688 .stop = carl9170_op_stop, 1689 .tx = carl9170_op_tx, 1690 .flush = carl9170_op_flush, 1691 .add_interface = carl9170_op_add_interface, 1692 .remove_interface = carl9170_op_remove_interface, 1693 .config = carl9170_op_config, 1694 .prepare_multicast = carl9170_op_prepare_multicast, 1695 .configure_filter = carl9170_op_configure_filter, 1696 .conf_tx = carl9170_op_conf_tx, 1697 .bss_info_changed = carl9170_op_bss_info_changed, 1698 .get_tsf = carl9170_op_get_tsf, 1699 .set_key = carl9170_op_set_key, 1700 .sta_add = carl9170_op_sta_add, 1701 .sta_remove = carl9170_op_sta_remove, 1702 .sta_notify = carl9170_op_sta_notify, 1703 .get_survey = carl9170_op_get_survey, 1704 .get_stats = carl9170_op_get_stats, 1705 .ampdu_action = carl9170_op_ampdu_action, 1706 .tx_frames_pending = carl9170_tx_frames_pending, 1707 }; 1708 1709 void *carl9170_alloc(size_t priv_size) 1710 { 1711 struct ieee80211_hw *hw; 1712 struct ar9170 *ar; 1713 struct sk_buff *skb; 1714 int i; 1715 1716 /* 1717 * this buffer is used for rx stream reconstruction. 1718 * Under heavy load this device (or the transport layer?) 1719 * tends to split the streams into separate rx descriptors. 1720 */ 1721 1722 skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL); 1723 if (!skb) 1724 goto err_nomem; 1725 1726 hw = ieee80211_alloc_hw(priv_size, &carl9170_ops); 1727 if (!hw) 1728 goto err_nomem; 1729 1730 ar = hw->priv; 1731 ar->hw = hw; 1732 ar->rx_failover = skb; 1733 1734 memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head)); 1735 ar->rx_has_plcp = false; 1736 1737 /* 1738 * Here's a hidden pitfall! 1739 * 1740 * All 4 AC queues work perfectly well under _legacy_ operation. 1741 * However as soon as aggregation is enabled, the traffic flow 1742 * gets very bumpy. Therefore we have to _switch_ to a 1743 * software AC with a single HW queue. 1744 */ 1745 hw->queues = __AR9170_NUM_TXQ; 1746 1747 mutex_init(&ar->mutex); 1748 spin_lock_init(&ar->beacon_lock); 1749 spin_lock_init(&ar->cmd_lock); 1750 spin_lock_init(&ar->tx_stats_lock); 1751 spin_lock_init(&ar->tx_ampdu_list_lock); 1752 spin_lock_init(&ar->mem_lock); 1753 spin_lock_init(&ar->state_lock); 1754 atomic_set(&ar->pending_restarts, 0); 1755 ar->vifs = 0; 1756 for (i = 0; i < ar->hw->queues; i++) { 1757 skb_queue_head_init(&ar->tx_status[i]); 1758 skb_queue_head_init(&ar->tx_pending[i]); 1759 1760 INIT_LIST_HEAD(&ar->bar_list[i]); 1761 spin_lock_init(&ar->bar_list_lock[i]); 1762 } 1763 INIT_WORK(&ar->ps_work, carl9170_ps_work); 1764 INIT_WORK(&ar->ping_work, carl9170_ping_work); 1765 INIT_WORK(&ar->restart_work, carl9170_restart_work); 1766 INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work); 1767 INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work); 1768 INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor); 1769 INIT_LIST_HEAD(&ar->tx_ampdu_list); 1770 rcu_assign_pointer(ar->tx_ampdu_iter, 1771 (struct carl9170_sta_tid *) &ar->tx_ampdu_list); 1772 1773 bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num); 1774 INIT_LIST_HEAD(&ar->vif_list); 1775 init_completion(&ar->tx_flush); 1776 1777 /* firmware decides which modes we support */ 1778 hw->wiphy->interface_modes = 0; 1779 1780 hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS | 1781 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 1782 IEEE80211_HW_SUPPORTS_PS | 1783 IEEE80211_HW_PS_NULLFUNC_STACK | 1784 IEEE80211_HW_NEED_DTIM_PERIOD | 1785 IEEE80211_HW_SIGNAL_DBM; 1786 1787 if (!modparam_noht) { 1788 /* 1789 * see the comment above, why we allow the user 1790 * to disable HT by a module parameter. 1791 */ 1792 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION; 1793 } 1794 1795 hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe); 1796 hw->sta_data_size = sizeof(struct carl9170_sta_info); 1797 hw->vif_data_size = sizeof(struct carl9170_vif_info); 1798 1799 hw->max_rates = CARL9170_TX_MAX_RATES; 1800 hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES; 1801 1802 for (i = 0; i < ARRAY_SIZE(ar->noise); i++) 1803 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */ 1804 1805 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT; 1806 1807 /* As IBSS Encryption is software-based, IBSS RSN is supported. */ 1808 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 1809 return ar; 1810 1811 err_nomem: 1812 kfree_skb(skb); 1813 return ERR_PTR(-ENOMEM); 1814 } 1815 1816 static int carl9170_read_eeprom(struct ar9170 *ar) 1817 { 1818 #define RW 8 /* number of words to read at once */ 1819 #define RB (sizeof(u32) * RW) 1820 u8 *eeprom = (void *)&ar->eeprom; 1821 __le32 offsets[RW]; 1822 int i, j, err; 1823 1824 BUILD_BUG_ON(sizeof(ar->eeprom) & 3); 1825 1826 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4); 1827 #ifndef __CHECKER__ 1828 /* don't want to handle trailing remains */ 1829 BUILD_BUG_ON(sizeof(ar->eeprom) % RB); 1830 #endif 1831 1832 for (i = 0; i < sizeof(ar->eeprom) / RB; i++) { 1833 for (j = 0; j < RW; j++) 1834 offsets[j] = cpu_to_le32(AR9170_EEPROM_START + 1835 RB * i + 4 * j); 1836 1837 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG, 1838 RB, (u8 *) &offsets, 1839 RB, eeprom + RB * i); 1840 if (err) 1841 return err; 1842 } 1843 1844 #undef RW 1845 #undef RB 1846 return 0; 1847 } 1848 1849 static int carl9170_parse_eeprom(struct ar9170 *ar) 1850 { 1851 struct ath_regulatory *regulatory = &ar->common.regulatory; 1852 unsigned int rx_streams, tx_streams, tx_params = 0; 1853 int bands = 0; 1854 int chans = 0; 1855 1856 if (ar->eeprom.length == cpu_to_le16(0xffff)) 1857 return -ENODATA; 1858 1859 rx_streams = hweight8(ar->eeprom.rx_mask); 1860 tx_streams = hweight8(ar->eeprom.tx_mask); 1861 1862 if (rx_streams != tx_streams) { 1863 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF; 1864 1865 WARN_ON(!(tx_streams >= 1 && tx_streams <= 1866 IEEE80211_HT_MCS_TX_MAX_STREAMS)); 1867 1868 tx_params = (tx_streams - 1) << 1869 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT; 1870 1871 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params; 1872 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params; 1873 } 1874 1875 if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) { 1876 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = 1877 &carl9170_band_2GHz; 1878 chans += carl9170_band_2GHz.n_channels; 1879 bands++; 1880 } 1881 if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) { 1882 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = 1883 &carl9170_band_5GHz; 1884 chans += carl9170_band_5GHz.n_channels; 1885 bands++; 1886 } 1887 1888 if (!bands) 1889 return -EINVAL; 1890 1891 ar->survey = kzalloc(sizeof(struct survey_info) * chans, GFP_KERNEL); 1892 if (!ar->survey) 1893 return -ENOMEM; 1894 ar->num_channels = chans; 1895 1896 /* 1897 * I measured this, a bandswitch takes roughly 1898 * 135 ms and a frequency switch about 80. 1899 * 1900 * FIXME: measure these values again once EEPROM settings 1901 * are used, that will influence them! 1902 */ 1903 if (bands == 2) 1904 ar->hw->channel_change_time = 135 * 1000; 1905 else 1906 ar->hw->channel_change_time = 80 * 1000; 1907 1908 regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]); 1909 1910 /* second part of wiphy init */ 1911 SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address); 1912 1913 return 0; 1914 } 1915 1916 static int carl9170_reg_notifier(struct wiphy *wiphy, 1917 struct regulatory_request *request) 1918 { 1919 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 1920 struct ar9170 *ar = hw->priv; 1921 1922 return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory); 1923 } 1924 1925 int carl9170_register(struct ar9170 *ar) 1926 { 1927 struct ath_regulatory *regulatory = &ar->common.regulatory; 1928 int err = 0, i; 1929 1930 if (WARN_ON(ar->mem_bitmap)) 1931 return -EINVAL; 1932 1933 ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) * 1934 sizeof(unsigned long), GFP_KERNEL); 1935 1936 if (!ar->mem_bitmap) 1937 return -ENOMEM; 1938 1939 /* try to read EEPROM, init MAC addr */ 1940 err = carl9170_read_eeprom(ar); 1941 if (err) 1942 return err; 1943 1944 err = carl9170_parse_eeprom(ar); 1945 if (err) 1946 return err; 1947 1948 err = ath_regd_init(regulatory, ar->hw->wiphy, 1949 carl9170_reg_notifier); 1950 if (err) 1951 return err; 1952 1953 if (modparam_noht) { 1954 carl9170_band_2GHz.ht_cap.ht_supported = false; 1955 carl9170_band_5GHz.ht_cap.ht_supported = false; 1956 } 1957 1958 for (i = 0; i < ar->fw.vif_num; i++) { 1959 ar->vif_priv[i].id = i; 1960 ar->vif_priv[i].vif = NULL; 1961 } 1962 1963 err = ieee80211_register_hw(ar->hw); 1964 if (err) 1965 return err; 1966 1967 /* mac80211 interface is now registered */ 1968 ar->registered = true; 1969 1970 if (!ath_is_world_regd(regulatory)) 1971 regulatory_hint(ar->hw->wiphy, regulatory->alpha2); 1972 1973 #ifdef CONFIG_CARL9170_DEBUGFS 1974 carl9170_debugfs_register(ar); 1975 #endif /* CONFIG_CARL9170_DEBUGFS */ 1976 1977 err = carl9170_led_init(ar); 1978 if (err) 1979 goto err_unreg; 1980 1981 #ifdef CONFIG_CARL9170_LEDS 1982 err = carl9170_led_register(ar); 1983 if (err) 1984 goto err_unreg; 1985 #endif /* CONFIG_CARL9170_LEDS */ 1986 1987 #ifdef CONFIG_CARL9170_WPC 1988 err = carl9170_register_wps_button(ar); 1989 if (err) 1990 goto err_unreg; 1991 #endif /* CONFIG_CARL9170_WPC */ 1992 1993 #ifdef CONFIG_CARL9170_HWRNG 1994 err = carl9170_register_hwrng(ar); 1995 if (err) 1996 goto err_unreg; 1997 #endif /* CONFIG_CARL9170_HWRNG */ 1998 1999 dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n", 2000 wiphy_name(ar->hw->wiphy)); 2001 2002 return 0; 2003 2004 err_unreg: 2005 carl9170_unregister(ar); 2006 return err; 2007 } 2008 2009 void carl9170_unregister(struct ar9170 *ar) 2010 { 2011 if (!ar->registered) 2012 return; 2013 2014 ar->registered = false; 2015 2016 #ifdef CONFIG_CARL9170_LEDS 2017 carl9170_led_unregister(ar); 2018 #endif /* CONFIG_CARL9170_LEDS */ 2019 2020 #ifdef CONFIG_CARL9170_DEBUGFS 2021 carl9170_debugfs_unregister(ar); 2022 #endif /* CONFIG_CARL9170_DEBUGFS */ 2023 2024 #ifdef CONFIG_CARL9170_WPC 2025 if (ar->wps.pbc) { 2026 input_unregister_device(ar->wps.pbc); 2027 ar->wps.pbc = NULL; 2028 } 2029 #endif /* CONFIG_CARL9170_WPC */ 2030 2031 #ifdef CONFIG_CARL9170_HWRNG 2032 carl9170_unregister_hwrng(ar); 2033 #endif /* CONFIG_CARL9170_HWRNG */ 2034 2035 carl9170_cancel_worker(ar); 2036 cancel_work_sync(&ar->restart_work); 2037 2038 ieee80211_unregister_hw(ar->hw); 2039 } 2040 2041 void carl9170_free(struct ar9170 *ar) 2042 { 2043 WARN_ON(ar->registered); 2044 WARN_ON(IS_INITIALIZED(ar)); 2045 2046 kfree_skb(ar->rx_failover); 2047 ar->rx_failover = NULL; 2048 2049 kfree(ar->mem_bitmap); 2050 ar->mem_bitmap = NULL; 2051 2052 kfree(ar->survey); 2053 ar->survey = NULL; 2054 2055 mutex_destroy(&ar->mutex); 2056 2057 ieee80211_free_hw(ar->hw); 2058 } 2059