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