1 /* 2 * Atheros CARL9170 driver 3 * 4 * mac80211 interaction code 5 * 6 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net> 7 * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; see the file COPYING. If not, see 21 * http://www.gnu.org/licenses/. 22 * 23 * This file incorporates work covered by the following copyright and 24 * permission notice: 25 * Copyright (c) 2007-2008 Atheros Communications, Inc. 26 * 27 * Permission to use, copy, modify, and/or distribute this software for any 28 * purpose with or without fee is hereby granted, provided that the above 29 * copyright notice and this permission notice appear in all copies. 30 * 31 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 32 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 33 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 34 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 35 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 36 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 37 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 38 */ 39 40 #include <linux/init.h> 41 #include <linux/slab.h> 42 #include <linux/module.h> 43 #include <linux/etherdevice.h> 44 #include <linux/random.h> 45 #include <net/mac80211.h> 46 #include <net/cfg80211.h> 47 #include "hw.h" 48 #include "carl9170.h" 49 #include "cmd.h" 50 51 static int modparam_nohwcrypt; 52 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO); 53 MODULE_PARM_DESC(nohwcrypt, "Disable hardware crypto offload."); 54 55 int modparam_noht; 56 module_param_named(noht, modparam_noht, int, S_IRUGO); 57 MODULE_PARM_DESC(noht, "Disable MPDU aggregation."); 58 59 #define RATE(_bitrate, _hw_rate, _txpidx, _flags) { \ 60 .bitrate = (_bitrate), \ 61 .flags = (_flags), \ 62 .hw_value = (_hw_rate) | (_txpidx) << 4, \ 63 } 64 65 struct ieee80211_rate __carl9170_ratetable[] = { 66 RATE(10, 0, 0, 0), 67 RATE(20, 1, 1, IEEE80211_RATE_SHORT_PREAMBLE), 68 RATE(55, 2, 2, IEEE80211_RATE_SHORT_PREAMBLE), 69 RATE(110, 3, 3, IEEE80211_RATE_SHORT_PREAMBLE), 70 RATE(60, 0xb, 0, 0), 71 RATE(90, 0xf, 0, 0), 72 RATE(120, 0xa, 0, 0), 73 RATE(180, 0xe, 0, 0), 74 RATE(240, 0x9, 0, 0), 75 RATE(360, 0xd, 1, 0), 76 RATE(480, 0x8, 2, 0), 77 RATE(540, 0xc, 3, 0), 78 }; 79 #undef RATE 80 81 #define carl9170_g_ratetable (__carl9170_ratetable + 0) 82 #define carl9170_g_ratetable_size 12 83 #define carl9170_a_ratetable (__carl9170_ratetable + 4) 84 #define carl9170_a_ratetable_size 8 85 86 /* 87 * NB: The hw_value is used as an index into the carl9170_phy_freq_params 88 * array in phy.c so that we don't have to do frequency lookups! 89 */ 90 #define CHAN(_freq, _idx) { \ 91 .center_freq = (_freq), \ 92 .hw_value = (_idx), \ 93 .max_power = 18, /* XXX */ \ 94 } 95 96 static struct ieee80211_channel carl9170_2ghz_chantable[] = { 97 CHAN(2412, 0), 98 CHAN(2417, 1), 99 CHAN(2422, 2), 100 CHAN(2427, 3), 101 CHAN(2432, 4), 102 CHAN(2437, 5), 103 CHAN(2442, 6), 104 CHAN(2447, 7), 105 CHAN(2452, 8), 106 CHAN(2457, 9), 107 CHAN(2462, 10), 108 CHAN(2467, 11), 109 CHAN(2472, 12), 110 CHAN(2484, 13), 111 }; 112 113 static struct ieee80211_channel carl9170_5ghz_chantable[] = { 114 CHAN(4920, 14), 115 CHAN(4940, 15), 116 CHAN(4960, 16), 117 CHAN(4980, 17), 118 CHAN(5040, 18), 119 CHAN(5060, 19), 120 CHAN(5080, 20), 121 CHAN(5180, 21), 122 CHAN(5200, 22), 123 CHAN(5220, 23), 124 CHAN(5240, 24), 125 CHAN(5260, 25), 126 CHAN(5280, 26), 127 CHAN(5300, 27), 128 CHAN(5320, 28), 129 CHAN(5500, 29), 130 CHAN(5520, 30), 131 CHAN(5540, 31), 132 CHAN(5560, 32), 133 CHAN(5580, 33), 134 CHAN(5600, 34), 135 CHAN(5620, 35), 136 CHAN(5640, 36), 137 CHAN(5660, 37), 138 CHAN(5680, 38), 139 CHAN(5700, 39), 140 CHAN(5745, 40), 141 CHAN(5765, 41), 142 CHAN(5785, 42), 143 CHAN(5805, 43), 144 CHAN(5825, 44), 145 CHAN(5170, 45), 146 CHAN(5190, 46), 147 CHAN(5210, 47), 148 CHAN(5230, 48), 149 }; 150 #undef CHAN 151 152 #define CARL9170_HT_CAP \ 153 { \ 154 .ht_supported = true, \ 155 .cap = IEEE80211_HT_CAP_MAX_AMSDU | \ 156 IEEE80211_HT_CAP_SUP_WIDTH_20_40 | \ 157 IEEE80211_HT_CAP_SGI_40 | \ 158 IEEE80211_HT_CAP_DSSSCCK40 | \ 159 IEEE80211_HT_CAP_SM_PS, \ 160 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, \ 161 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \ 162 .mcs = { \ 163 .rx_mask = { 0xff, 0xff, 0, 0, 0x1, 0, 0, 0, 0, 0, }, \ 164 .rx_highest = cpu_to_le16(300), \ 165 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \ 166 }, \ 167 } 168 169 static struct ieee80211_supported_band carl9170_band_2GHz = { 170 .channels = carl9170_2ghz_chantable, 171 .n_channels = ARRAY_SIZE(carl9170_2ghz_chantable), 172 .bitrates = carl9170_g_ratetable, 173 .n_bitrates = carl9170_g_ratetable_size, 174 .ht_cap = CARL9170_HT_CAP, 175 }; 176 177 static struct ieee80211_supported_band carl9170_band_5GHz = { 178 .channels = carl9170_5ghz_chantable, 179 .n_channels = ARRAY_SIZE(carl9170_5ghz_chantable), 180 .bitrates = carl9170_a_ratetable, 181 .n_bitrates = carl9170_a_ratetable_size, 182 .ht_cap = CARL9170_HT_CAP, 183 }; 184 185 static void carl9170_ampdu_gc(struct ar9170 *ar) 186 { 187 struct carl9170_sta_tid *tid_info; 188 LIST_HEAD(tid_gc); 189 190 rcu_read_lock(); 191 list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) { 192 spin_lock_bh(&ar->tx_ampdu_list_lock); 193 if (tid_info->state == CARL9170_TID_STATE_SHUTDOWN) { 194 tid_info->state = CARL9170_TID_STATE_KILLED; 195 list_del_rcu(&tid_info->list); 196 ar->tx_ampdu_list_len--; 197 list_add_tail(&tid_info->tmp_list, &tid_gc); 198 } 199 spin_unlock_bh(&ar->tx_ampdu_list_lock); 200 201 } 202 rcu_assign_pointer(ar->tx_ampdu_iter, tid_info); 203 rcu_read_unlock(); 204 205 synchronize_rcu(); 206 207 while (!list_empty(&tid_gc)) { 208 struct sk_buff *skb; 209 tid_info = list_first_entry(&tid_gc, struct carl9170_sta_tid, 210 tmp_list); 211 212 while ((skb = __skb_dequeue(&tid_info->queue))) 213 carl9170_tx_status(ar, skb, false); 214 215 list_del_init(&tid_info->tmp_list); 216 kfree(tid_info); 217 } 218 } 219 220 static void carl9170_flush(struct ar9170 *ar, bool drop_queued) 221 { 222 if (drop_queued) { 223 int i; 224 225 /* 226 * We can only drop frames which have not been uploaded 227 * to the device yet. 228 */ 229 230 for (i = 0; i < ar->hw->queues; i++) { 231 struct sk_buff *skb; 232 233 while ((skb = skb_dequeue(&ar->tx_pending[i]))) { 234 struct ieee80211_tx_info *info; 235 236 info = IEEE80211_SKB_CB(skb); 237 if (info->flags & IEEE80211_TX_CTL_AMPDU) 238 atomic_dec(&ar->tx_ampdu_upload); 239 240 carl9170_tx_status(ar, skb, false); 241 } 242 } 243 } 244 245 /* Wait for all other outstanding frames to timeout. */ 246 if (atomic_read(&ar->tx_total_queued)) 247 WARN_ON(wait_for_completion_timeout(&ar->tx_flush, HZ) == 0); 248 } 249 250 static void carl9170_flush_ba(struct ar9170 *ar) 251 { 252 struct sk_buff_head free; 253 struct carl9170_sta_tid *tid_info; 254 struct sk_buff *skb; 255 256 __skb_queue_head_init(&free); 257 258 rcu_read_lock(); 259 spin_lock_bh(&ar->tx_ampdu_list_lock); 260 list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) { 261 if (tid_info->state > CARL9170_TID_STATE_SUSPEND) { 262 tid_info->state = CARL9170_TID_STATE_SUSPEND; 263 264 spin_lock(&tid_info->lock); 265 while ((skb = __skb_dequeue(&tid_info->queue))) 266 __skb_queue_tail(&free, skb); 267 spin_unlock(&tid_info->lock); 268 } 269 } 270 spin_unlock_bh(&ar->tx_ampdu_list_lock); 271 rcu_read_unlock(); 272 273 while ((skb = __skb_dequeue(&free))) 274 carl9170_tx_status(ar, skb, false); 275 } 276 277 static void carl9170_zap_queues(struct ar9170 *ar) 278 { 279 struct carl9170_vif_info *cvif; 280 unsigned int i; 281 282 carl9170_ampdu_gc(ar); 283 284 carl9170_flush_ba(ar); 285 carl9170_flush(ar, true); 286 287 for (i = 0; i < ar->hw->queues; i++) { 288 spin_lock_bh(&ar->tx_status[i].lock); 289 while (!skb_queue_empty(&ar->tx_status[i])) { 290 struct sk_buff *skb; 291 292 skb = skb_peek(&ar->tx_status[i]); 293 carl9170_tx_get_skb(skb); 294 spin_unlock_bh(&ar->tx_status[i].lock); 295 carl9170_tx_drop(ar, skb); 296 spin_lock_bh(&ar->tx_status[i].lock); 297 carl9170_tx_put_skb(skb); 298 } 299 spin_unlock_bh(&ar->tx_status[i].lock); 300 } 301 302 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_SOFT < 1); 303 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD < CARL9170_NUM_TX_LIMIT_SOFT); 304 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD >= CARL9170_BAW_BITS); 305 306 /* reinitialize queues statistics */ 307 memset(&ar->tx_stats, 0, sizeof(ar->tx_stats)); 308 for (i = 0; i < ar->hw->queues; i++) 309 ar->tx_stats[i].limit = CARL9170_NUM_TX_LIMIT_HARD; 310 311 for (i = 0; i < DIV_ROUND_UP(ar->fw.mem_blocks, BITS_PER_LONG); i++) 312 ar->mem_bitmap[i] = 0; 313 314 rcu_read_lock(); 315 list_for_each_entry_rcu(cvif, &ar->vif_list, list) { 316 spin_lock_bh(&ar->beacon_lock); 317 dev_kfree_skb_any(cvif->beacon); 318 cvif->beacon = NULL; 319 spin_unlock_bh(&ar->beacon_lock); 320 } 321 rcu_read_unlock(); 322 323 atomic_set(&ar->tx_ampdu_upload, 0); 324 atomic_set(&ar->tx_ampdu_scheduler, 0); 325 atomic_set(&ar->tx_total_pending, 0); 326 atomic_set(&ar->tx_total_queued, 0); 327 atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks); 328 } 329 330 #define CARL9170_FILL_QUEUE(queue, ai_fs, cwmin, cwmax, _txop) \ 331 do { \ 332 queue.aifs = ai_fs; \ 333 queue.cw_min = cwmin; \ 334 queue.cw_max = cwmax; \ 335 queue.txop = _txop; \ 336 } while (0) 337 338 static int carl9170_op_start(struct ieee80211_hw *hw) 339 { 340 struct ar9170 *ar = hw->priv; 341 int err, i; 342 343 mutex_lock(&ar->mutex); 344 345 carl9170_zap_queues(ar); 346 347 /* reset QoS defaults */ 348 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VO], 2, 3, 7, 47); 349 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VI], 2, 7, 15, 94); 350 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BE], 3, 15, 1023, 0); 351 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BK], 7, 15, 1023, 0); 352 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_SPECIAL], 2, 3, 7, 0); 353 354 ar->current_factor = ar->current_density = -1; 355 /* "The first key is unique." */ 356 ar->usedkeys = 1; 357 ar->filter_state = 0; 358 ar->ps.last_action = jiffies; 359 ar->ps.last_slept = jiffies; 360 ar->erp_mode = CARL9170_ERP_AUTO; 361 ar->rx_software_decryption = false; 362 ar->disable_offload = false; 363 364 for (i = 0; i < ar->hw->queues; i++) { 365 ar->queue_stop_timeout[i] = jiffies; 366 ar->max_queue_stop_timeout[i] = 0; 367 } 368 369 atomic_set(&ar->mem_allocs, 0); 370 371 err = carl9170_usb_open(ar); 372 if (err) 373 goto out; 374 375 err = carl9170_init_mac(ar); 376 if (err) 377 goto out; 378 379 err = carl9170_set_qos(ar); 380 if (err) 381 goto out; 382 383 if (ar->fw.rx_filter) { 384 err = carl9170_rx_filter(ar, CARL9170_RX_FILTER_OTHER_RA | 385 CARL9170_RX_FILTER_CTL_OTHER | CARL9170_RX_FILTER_BAD); 386 if (err) 387 goto out; 388 } 389 390 err = carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 391 AR9170_DMA_TRIGGER_RXQ); 392 if (err) 393 goto out; 394 395 /* Clear key-cache */ 396 for (i = 0; i < AR9170_CAM_MAX_USER + 4; i++) { 397 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE, 398 0, NULL, 0); 399 if (err) 400 goto out; 401 402 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE, 403 1, NULL, 0); 404 if (err) 405 goto out; 406 407 if (i < AR9170_CAM_MAX_USER) { 408 err = carl9170_disable_key(ar, i); 409 if (err) 410 goto out; 411 } 412 } 413 414 carl9170_set_state_when(ar, CARL9170_IDLE, CARL9170_STARTED); 415 416 ieee80211_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_assign_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_assign_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_assign_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_POWER) { 857 /* TODO */ 858 err = 0; 859 } 860 861 if (changed & IEEE80211_CONF_CHANGE_SMPS) { 862 /* TODO */ 863 err = 0; 864 } 865 866 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 867 /* adjust slot time for 5 GHz */ 868 err = carl9170_set_slot_time(ar); 869 if (err) 870 goto out; 871 872 err = carl9170_update_survey(ar, true, false); 873 if (err) 874 goto out; 875 876 err = carl9170_set_channel(ar, hw->conf.channel, 877 hw->conf.channel_type, CARL9170_RFI_NONE); 878 if (err) 879 goto out; 880 881 err = carl9170_update_survey(ar, false, true); 882 if (err) 883 goto out; 884 885 err = carl9170_set_dyn_sifs_ack(ar); 886 if (err) 887 goto out; 888 889 err = carl9170_set_rts_cts_rate(ar); 890 if (err) 891 goto out; 892 } 893 894 out: 895 mutex_unlock(&ar->mutex); 896 return err; 897 } 898 899 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw, 900 struct netdev_hw_addr_list *mc_list) 901 { 902 struct netdev_hw_addr *ha; 903 u64 mchash; 904 905 /* always get broadcast frames */ 906 mchash = 1ULL << (0xff >> 2); 907 908 netdev_hw_addr_list_for_each(ha, mc_list) 909 mchash |= 1ULL << (ha->addr[5] >> 2); 910 911 return mchash; 912 } 913 914 static void carl9170_op_configure_filter(struct ieee80211_hw *hw, 915 unsigned int changed_flags, 916 unsigned int *new_flags, 917 u64 multicast) 918 { 919 struct ar9170 *ar = hw->priv; 920 921 /* mask supported flags */ 922 *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps; 923 924 if (!IS_ACCEPTING_CMD(ar)) 925 return; 926 927 mutex_lock(&ar->mutex); 928 929 ar->filter_state = *new_flags; 930 /* 931 * We can support more by setting the sniffer bit and 932 * then checking the error flags, later. 933 */ 934 935 if (*new_flags & FIF_ALLMULTI) 936 multicast = ~0ULL; 937 938 if (multicast != ar->cur_mc_hash) 939 WARN_ON(carl9170_update_multicast(ar, multicast)); 940 941 if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) { 942 ar->sniffer_enabled = !!(*new_flags & 943 (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)); 944 945 WARN_ON(carl9170_set_operating_mode(ar)); 946 } 947 948 if (ar->fw.rx_filter && changed_flags & ar->rx_filter_caps) { 949 u32 rx_filter = 0; 950 951 if (!(*new_flags & (FIF_FCSFAIL | FIF_PLCPFAIL))) 952 rx_filter |= CARL9170_RX_FILTER_BAD; 953 954 if (!(*new_flags & FIF_CONTROL)) 955 rx_filter |= CARL9170_RX_FILTER_CTL_OTHER; 956 957 if (!(*new_flags & FIF_PSPOLL)) 958 rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL; 959 960 if (!(*new_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))) { 961 rx_filter |= CARL9170_RX_FILTER_OTHER_RA; 962 rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL; 963 } 964 965 WARN_ON(carl9170_rx_filter(ar, rx_filter)); 966 } 967 968 mutex_unlock(&ar->mutex); 969 } 970 971 972 static void carl9170_op_bss_info_changed(struct ieee80211_hw *hw, 973 struct ieee80211_vif *vif, 974 struct ieee80211_bss_conf *bss_conf, 975 u32 changed) 976 { 977 struct ar9170 *ar = hw->priv; 978 struct ath_common *common = &ar->common; 979 int err = 0; 980 struct carl9170_vif_info *vif_priv; 981 struct ieee80211_vif *main_vif; 982 983 mutex_lock(&ar->mutex); 984 vif_priv = (void *) vif->drv_priv; 985 main_vif = carl9170_get_main_vif(ar); 986 if (WARN_ON(!main_vif)) 987 goto out; 988 989 if (changed & BSS_CHANGED_BEACON_ENABLED) { 990 struct carl9170_vif_info *iter; 991 int i = 0; 992 993 vif_priv->enable_beacon = bss_conf->enable_beacon; 994 rcu_read_lock(); 995 list_for_each_entry_rcu(iter, &ar->vif_list, list) { 996 if (iter->active && iter->enable_beacon) 997 i++; 998 999 } 1000 rcu_read_unlock(); 1001 1002 ar->beacon_enabled = i; 1003 } 1004 1005 if (changed & BSS_CHANGED_BEACON) { 1006 err = carl9170_update_beacon(ar, false); 1007 if (err) 1008 goto out; 1009 } 1010 1011 if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON | 1012 BSS_CHANGED_BEACON_INT)) { 1013 1014 if (main_vif != vif) { 1015 bss_conf->beacon_int = main_vif->bss_conf.beacon_int; 1016 bss_conf->dtim_period = main_vif->bss_conf.dtim_period; 1017 } 1018 1019 /* 1020 * Therefore a hard limit for the broadcast traffic should 1021 * prevent false alarms. 1022 */ 1023 if (vif->type != NL80211_IFTYPE_STATION && 1024 (bss_conf->beacon_int * bss_conf->dtim_period >= 1025 (CARL9170_QUEUE_STUCK_TIMEOUT / 2))) { 1026 err = -EINVAL; 1027 goto out; 1028 } 1029 1030 err = carl9170_set_beacon_timers(ar); 1031 if (err) 1032 goto out; 1033 } 1034 1035 if (changed & BSS_CHANGED_HT) { 1036 /* TODO */ 1037 err = 0; 1038 if (err) 1039 goto out; 1040 } 1041 1042 if (main_vif != vif) 1043 goto out; 1044 1045 /* 1046 * The following settings can only be changed by the 1047 * master interface. 1048 */ 1049 1050 if (changed & BSS_CHANGED_BSSID) { 1051 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN); 1052 err = carl9170_set_operating_mode(ar); 1053 if (err) 1054 goto out; 1055 } 1056 1057 if (changed & BSS_CHANGED_ASSOC) { 1058 ar->common.curaid = bss_conf->aid; 1059 err = carl9170_set_beacon_timers(ar); 1060 if (err) 1061 goto out; 1062 } 1063 1064 if (changed & BSS_CHANGED_ERP_SLOT) { 1065 err = carl9170_set_slot_time(ar); 1066 if (err) 1067 goto out; 1068 } 1069 1070 if (changed & BSS_CHANGED_BASIC_RATES) { 1071 err = carl9170_set_mac_rates(ar); 1072 if (err) 1073 goto out; 1074 } 1075 1076 out: 1077 WARN_ON_ONCE(err && IS_STARTED(ar)); 1078 mutex_unlock(&ar->mutex); 1079 } 1080 1081 static u64 carl9170_op_get_tsf(struct ieee80211_hw *hw, 1082 struct ieee80211_vif *vif) 1083 { 1084 struct ar9170 *ar = hw->priv; 1085 struct carl9170_tsf_rsp tsf; 1086 int err; 1087 1088 mutex_lock(&ar->mutex); 1089 err = carl9170_exec_cmd(ar, CARL9170_CMD_READ_TSF, 1090 0, NULL, sizeof(tsf), &tsf); 1091 mutex_unlock(&ar->mutex); 1092 if (WARN_ON(err)) 1093 return 0; 1094 1095 return le64_to_cpu(tsf.tsf_64); 1096 } 1097 1098 static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 1099 struct ieee80211_vif *vif, 1100 struct ieee80211_sta *sta, 1101 struct ieee80211_key_conf *key) 1102 { 1103 struct ar9170 *ar = hw->priv; 1104 int err = 0, i; 1105 u8 ktype; 1106 1107 if (ar->disable_offload || !vif) 1108 return -EOPNOTSUPP; 1109 1110 /* 1111 * We have to fall back to software encryption, whenever 1112 * the user choose to participates in an IBSS or is connected 1113 * to more than one network. 1114 * 1115 * This is very unfortunate, because some machines cannot handle 1116 * the high througput speed in 802.11n networks. 1117 */ 1118 1119 if (!is_main_vif(ar, vif)) { 1120 mutex_lock(&ar->mutex); 1121 goto err_softw; 1122 } 1123 1124 /* 1125 * While the hardware supports *catch-all* key, for offloading 1126 * group-key en-/de-cryption. The way of how the hardware 1127 * decides which keyId maps to which key, remains a mystery... 1128 */ 1129 if ((vif->type != NL80211_IFTYPE_STATION && 1130 vif->type != NL80211_IFTYPE_ADHOC) && 1131 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 1132 return -EOPNOTSUPP; 1133 1134 switch (key->cipher) { 1135 case WLAN_CIPHER_SUITE_WEP40: 1136 ktype = AR9170_ENC_ALG_WEP64; 1137 break; 1138 case WLAN_CIPHER_SUITE_WEP104: 1139 ktype = AR9170_ENC_ALG_WEP128; 1140 break; 1141 case WLAN_CIPHER_SUITE_TKIP: 1142 ktype = AR9170_ENC_ALG_TKIP; 1143 break; 1144 case WLAN_CIPHER_SUITE_CCMP: 1145 ktype = AR9170_ENC_ALG_AESCCMP; 1146 break; 1147 default: 1148 return -EOPNOTSUPP; 1149 } 1150 1151 mutex_lock(&ar->mutex); 1152 if (cmd == SET_KEY) { 1153 if (!IS_STARTED(ar)) { 1154 err = -EOPNOTSUPP; 1155 goto out; 1156 } 1157 1158 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) { 1159 sta = NULL; 1160 1161 i = 64 + key->keyidx; 1162 } else { 1163 for (i = 0; i < 64; i++) 1164 if (!(ar->usedkeys & BIT(i))) 1165 break; 1166 if (i == 64) 1167 goto err_softw; 1168 } 1169 1170 key->hw_key_idx = i; 1171 1172 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL, 1173 ktype, 0, key->key, 1174 min_t(u8, 16, key->keylen)); 1175 if (err) 1176 goto out; 1177 1178 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1179 err = carl9170_upload_key(ar, i, sta ? sta->addr : 1180 NULL, ktype, 1, 1181 key->key + 16, 16); 1182 if (err) 1183 goto out; 1184 1185 /* 1186 * hardware is not capable generating MMIC 1187 * of fragmented frames! 1188 */ 1189 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC; 1190 } 1191 1192 if (i < 64) 1193 ar->usedkeys |= BIT(i); 1194 1195 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 1196 } else { 1197 if (!IS_STARTED(ar)) { 1198 /* The device is gone... together with the key ;-) */ 1199 err = 0; 1200 goto out; 1201 } 1202 1203 if (key->hw_key_idx < 64) { 1204 ar->usedkeys &= ~BIT(key->hw_key_idx); 1205 } else { 1206 err = carl9170_upload_key(ar, key->hw_key_idx, NULL, 1207 AR9170_ENC_ALG_NONE, 0, 1208 NULL, 0); 1209 if (err) 1210 goto out; 1211 1212 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { 1213 err = carl9170_upload_key(ar, key->hw_key_idx, 1214 NULL, 1215 AR9170_ENC_ALG_NONE, 1216 1, NULL, 0); 1217 if (err) 1218 goto out; 1219 } 1220 1221 } 1222 1223 err = carl9170_disable_key(ar, key->hw_key_idx); 1224 if (err) 1225 goto out; 1226 } 1227 1228 out: 1229 mutex_unlock(&ar->mutex); 1230 return err; 1231 1232 err_softw: 1233 if (!ar->rx_software_decryption) { 1234 ar->rx_software_decryption = true; 1235 carl9170_set_operating_mode(ar); 1236 } 1237 mutex_unlock(&ar->mutex); 1238 return -ENOSPC; 1239 } 1240 1241 static int carl9170_op_sta_add(struct ieee80211_hw *hw, 1242 struct ieee80211_vif *vif, 1243 struct ieee80211_sta *sta) 1244 { 1245 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1246 unsigned int i; 1247 1248 atomic_set(&sta_info->pending_frames, 0); 1249 1250 if (sta->ht_cap.ht_supported) { 1251 if (sta->ht_cap.ampdu_density > 6) { 1252 /* 1253 * HW does support 16us AMPDU density. 1254 * No HT-Xmit for station. 1255 */ 1256 1257 return 0; 1258 } 1259 1260 for (i = 0; i < CARL9170_NUM_TID; i++) 1261 rcu_assign_pointer(sta_info->agg[i], NULL); 1262 1263 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor); 1264 sta_info->ht_sta = true; 1265 } 1266 1267 return 0; 1268 } 1269 1270 static int carl9170_op_sta_remove(struct ieee80211_hw *hw, 1271 struct ieee80211_vif *vif, 1272 struct ieee80211_sta *sta) 1273 { 1274 struct ar9170 *ar = hw->priv; 1275 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1276 unsigned int i; 1277 bool cleanup = false; 1278 1279 if (sta->ht_cap.ht_supported) { 1280 1281 sta_info->ht_sta = false; 1282 1283 rcu_read_lock(); 1284 for (i = 0; i < CARL9170_NUM_TID; i++) { 1285 struct carl9170_sta_tid *tid_info; 1286 1287 tid_info = rcu_dereference(sta_info->agg[i]); 1288 rcu_assign_pointer(sta_info->agg[i], NULL); 1289 1290 if (!tid_info) 1291 continue; 1292 1293 spin_lock_bh(&ar->tx_ampdu_list_lock); 1294 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN) 1295 tid_info->state = CARL9170_TID_STATE_SHUTDOWN; 1296 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1297 cleanup = true; 1298 } 1299 rcu_read_unlock(); 1300 1301 if (cleanup) 1302 carl9170_ampdu_gc(ar); 1303 } 1304 1305 return 0; 1306 } 1307 1308 static int carl9170_op_conf_tx(struct ieee80211_hw *hw, 1309 struct ieee80211_vif *vif, u16 queue, 1310 const struct ieee80211_tx_queue_params *param) 1311 { 1312 struct ar9170 *ar = hw->priv; 1313 int ret; 1314 1315 mutex_lock(&ar->mutex); 1316 if (queue < ar->hw->queues) { 1317 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param)); 1318 ret = carl9170_set_qos(ar); 1319 } else { 1320 ret = -EINVAL; 1321 } 1322 1323 mutex_unlock(&ar->mutex); 1324 return ret; 1325 } 1326 1327 static void carl9170_ampdu_work(struct work_struct *work) 1328 { 1329 struct ar9170 *ar = container_of(work, struct ar9170, 1330 ampdu_work); 1331 1332 if (!IS_STARTED(ar)) 1333 return; 1334 1335 mutex_lock(&ar->mutex); 1336 carl9170_ampdu_gc(ar); 1337 mutex_unlock(&ar->mutex); 1338 } 1339 1340 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw, 1341 struct ieee80211_vif *vif, 1342 enum ieee80211_ampdu_mlme_action action, 1343 struct ieee80211_sta *sta, 1344 u16 tid, u16 *ssn, u8 buf_size) 1345 { 1346 struct ar9170 *ar = hw->priv; 1347 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1348 struct carl9170_sta_tid *tid_info; 1349 1350 if (modparam_noht) 1351 return -EOPNOTSUPP; 1352 1353 switch (action) { 1354 case IEEE80211_AMPDU_TX_START: 1355 if (!sta_info->ht_sta) 1356 return -EOPNOTSUPP; 1357 1358 rcu_read_lock(); 1359 if (rcu_dereference(sta_info->agg[tid])) { 1360 rcu_read_unlock(); 1361 return -EBUSY; 1362 } 1363 1364 tid_info = kzalloc(sizeof(struct carl9170_sta_tid), 1365 GFP_ATOMIC); 1366 if (!tid_info) { 1367 rcu_read_unlock(); 1368 return -ENOMEM; 1369 } 1370 1371 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn); 1372 tid_info->state = CARL9170_TID_STATE_PROGRESS; 1373 tid_info->tid = tid; 1374 tid_info->max = sta_info->ampdu_max_len; 1375 1376 INIT_LIST_HEAD(&tid_info->list); 1377 INIT_LIST_HEAD(&tid_info->tmp_list); 1378 skb_queue_head_init(&tid_info->queue); 1379 spin_lock_init(&tid_info->lock); 1380 1381 spin_lock_bh(&ar->tx_ampdu_list_lock); 1382 ar->tx_ampdu_list_len++; 1383 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list); 1384 rcu_assign_pointer(sta_info->agg[tid], tid_info); 1385 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1386 rcu_read_unlock(); 1387 1388 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1389 break; 1390 1391 case IEEE80211_AMPDU_TX_STOP: 1392 rcu_read_lock(); 1393 tid_info = rcu_dereference(sta_info->agg[tid]); 1394 if (tid_info) { 1395 spin_lock_bh(&ar->tx_ampdu_list_lock); 1396 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN) 1397 tid_info->state = CARL9170_TID_STATE_SHUTDOWN; 1398 spin_unlock_bh(&ar->tx_ampdu_list_lock); 1399 } 1400 1401 rcu_assign_pointer(sta_info->agg[tid], NULL); 1402 rcu_read_unlock(); 1403 1404 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1405 ieee80211_queue_work(ar->hw, &ar->ampdu_work); 1406 break; 1407 1408 case IEEE80211_AMPDU_TX_OPERATIONAL: 1409 rcu_read_lock(); 1410 tid_info = rcu_dereference(sta_info->agg[tid]); 1411 1412 sta_info->stats[tid].clear = true; 1413 sta_info->stats[tid].req = false; 1414 1415 if (tid_info) { 1416 bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE); 1417 tid_info->state = CARL9170_TID_STATE_IDLE; 1418 } 1419 rcu_read_unlock(); 1420 1421 if (WARN_ON_ONCE(!tid_info)) 1422 return -EFAULT; 1423 1424 break; 1425 1426 case IEEE80211_AMPDU_RX_START: 1427 case IEEE80211_AMPDU_RX_STOP: 1428 /* Handled by hardware */ 1429 break; 1430 1431 default: 1432 return -EOPNOTSUPP; 1433 } 1434 1435 return 0; 1436 } 1437 1438 #ifdef CONFIG_CARL9170_WPC 1439 static int carl9170_register_wps_button(struct ar9170 *ar) 1440 { 1441 struct input_dev *input; 1442 int err; 1443 1444 if (!(ar->features & CARL9170_WPS_BUTTON)) 1445 return 0; 1446 1447 input = input_allocate_device(); 1448 if (!input) 1449 return -ENOMEM; 1450 1451 snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button", 1452 wiphy_name(ar->hw->wiphy)); 1453 1454 snprintf(ar->wps.phys, sizeof(ar->wps.phys), 1455 "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy)); 1456 1457 input->name = ar->wps.name; 1458 input->phys = ar->wps.phys; 1459 input->id.bustype = BUS_USB; 1460 input->dev.parent = &ar->hw->wiphy->dev; 1461 1462 input_set_capability(input, EV_KEY, KEY_WPS_BUTTON); 1463 1464 err = input_register_device(input); 1465 if (err) { 1466 input_free_device(input); 1467 return err; 1468 } 1469 1470 ar->wps.pbc = input; 1471 return 0; 1472 } 1473 #endif /* CONFIG_CARL9170_WPC */ 1474 1475 #ifdef CONFIG_CARL9170_HWRNG 1476 static int carl9170_rng_get(struct ar9170 *ar) 1477 { 1478 1479 #define RW (CARL9170_MAX_CMD_PAYLOAD_LEN / sizeof(u32)) 1480 #define RB (CARL9170_MAX_CMD_PAYLOAD_LEN) 1481 1482 static const __le32 rng_load[RW] = { 1483 [0 ... (RW - 1)] = cpu_to_le32(AR9170_RAND_REG_NUM)}; 1484 1485 u32 buf[RW]; 1486 1487 unsigned int i, off = 0, transfer, count; 1488 int err; 1489 1490 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_PAYLOAD_LEN); 1491 1492 if (!IS_ACCEPTING_CMD(ar) || !ar->rng.initialized) 1493 return -EAGAIN; 1494 1495 count = ARRAY_SIZE(ar->rng.cache); 1496 while (count) { 1497 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG, 1498 RB, (u8 *) rng_load, 1499 RB, (u8 *) buf); 1500 if (err) 1501 return err; 1502 1503 transfer = min_t(unsigned int, count, RW); 1504 for (i = 0; i < transfer; i++) 1505 ar->rng.cache[off + i] = buf[i]; 1506 1507 off += transfer; 1508 count -= transfer; 1509 } 1510 1511 ar->rng.cache_idx = 0; 1512 1513 #undef RW 1514 #undef RB 1515 return 0; 1516 } 1517 1518 static int carl9170_rng_read(struct hwrng *rng, u32 *data) 1519 { 1520 struct ar9170 *ar = (struct ar9170 *)rng->priv; 1521 int ret = -EIO; 1522 1523 mutex_lock(&ar->mutex); 1524 if (ar->rng.cache_idx >= ARRAY_SIZE(ar->rng.cache)) { 1525 ret = carl9170_rng_get(ar); 1526 if (ret) { 1527 mutex_unlock(&ar->mutex); 1528 return ret; 1529 } 1530 } 1531 1532 *data = ar->rng.cache[ar->rng.cache_idx++]; 1533 mutex_unlock(&ar->mutex); 1534 1535 return sizeof(u16); 1536 } 1537 1538 static void carl9170_unregister_hwrng(struct ar9170 *ar) 1539 { 1540 if (ar->rng.initialized) { 1541 hwrng_unregister(&ar->rng.rng); 1542 ar->rng.initialized = false; 1543 } 1544 } 1545 1546 static int carl9170_register_hwrng(struct ar9170 *ar) 1547 { 1548 int err; 1549 1550 snprintf(ar->rng.name, ARRAY_SIZE(ar->rng.name), 1551 "%s_%s", KBUILD_MODNAME, wiphy_name(ar->hw->wiphy)); 1552 ar->rng.rng.name = ar->rng.name; 1553 ar->rng.rng.data_read = carl9170_rng_read; 1554 ar->rng.rng.priv = (unsigned long)ar; 1555 1556 if (WARN_ON(ar->rng.initialized)) 1557 return -EALREADY; 1558 1559 err = hwrng_register(&ar->rng.rng); 1560 if (err) { 1561 dev_err(&ar->udev->dev, "Failed to register the random " 1562 "number generator (%d)\n", err); 1563 return err; 1564 } 1565 1566 ar->rng.initialized = true; 1567 1568 err = carl9170_rng_get(ar); 1569 if (err) { 1570 carl9170_unregister_hwrng(ar); 1571 return err; 1572 } 1573 1574 return 0; 1575 } 1576 #endif /* CONFIG_CARL9170_HWRNG */ 1577 1578 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx, 1579 struct survey_info *survey) 1580 { 1581 struct ar9170 *ar = hw->priv; 1582 struct ieee80211_channel *chan; 1583 struct ieee80211_supported_band *band; 1584 int err, b, i; 1585 1586 chan = ar->channel; 1587 if (!chan) 1588 return -ENODEV; 1589 1590 if (idx == chan->hw_value) { 1591 mutex_lock(&ar->mutex); 1592 err = carl9170_update_survey(ar, false, true); 1593 mutex_unlock(&ar->mutex); 1594 if (err) 1595 return err; 1596 } 1597 1598 for (b = 0; b < IEEE80211_NUM_BANDS; b++) { 1599 band = ar->hw->wiphy->bands[b]; 1600 1601 if (!band) 1602 continue; 1603 1604 for (i = 0; i < band->n_channels; i++) { 1605 if (band->channels[i].hw_value == idx) { 1606 chan = &band->channels[i]; 1607 goto found; 1608 } 1609 } 1610 } 1611 return -ENOENT; 1612 1613 found: 1614 memcpy(survey, &ar->survey[idx], sizeof(*survey)); 1615 1616 survey->channel = chan; 1617 survey->filled = SURVEY_INFO_NOISE_DBM; 1618 1619 if (ar->channel == chan) 1620 survey->filled |= SURVEY_INFO_IN_USE; 1621 1622 if (ar->fw.hw_counters) { 1623 survey->filled |= SURVEY_INFO_CHANNEL_TIME | 1624 SURVEY_INFO_CHANNEL_TIME_BUSY | 1625 SURVEY_INFO_CHANNEL_TIME_TX; 1626 } 1627 1628 return 0; 1629 } 1630 1631 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop) 1632 { 1633 struct ar9170 *ar = hw->priv; 1634 unsigned int vid; 1635 1636 mutex_lock(&ar->mutex); 1637 for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num) 1638 carl9170_flush_cab(ar, vid); 1639 1640 carl9170_flush(ar, drop); 1641 mutex_unlock(&ar->mutex); 1642 } 1643 1644 static int carl9170_op_get_stats(struct ieee80211_hw *hw, 1645 struct ieee80211_low_level_stats *stats) 1646 { 1647 struct ar9170 *ar = hw->priv; 1648 1649 memset(stats, 0, sizeof(*stats)); 1650 stats->dot11ACKFailureCount = ar->tx_ack_failures; 1651 stats->dot11FCSErrorCount = ar->tx_fcs_errors; 1652 return 0; 1653 } 1654 1655 static void carl9170_op_sta_notify(struct ieee80211_hw *hw, 1656 struct ieee80211_vif *vif, 1657 enum sta_notify_cmd cmd, 1658 struct ieee80211_sta *sta) 1659 { 1660 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv; 1661 1662 switch (cmd) { 1663 case STA_NOTIFY_SLEEP: 1664 sta_info->sleeping = true; 1665 if (atomic_read(&sta_info->pending_frames)) 1666 ieee80211_sta_block_awake(hw, sta, true); 1667 break; 1668 1669 case STA_NOTIFY_AWAKE: 1670 sta_info->sleeping = false; 1671 break; 1672 } 1673 } 1674 1675 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw) 1676 { 1677 struct ar9170 *ar = hw->priv; 1678 1679 return !!atomic_read(&ar->tx_total_queued); 1680 } 1681 1682 static const struct ieee80211_ops carl9170_ops = { 1683 .start = carl9170_op_start, 1684 .stop = carl9170_op_stop, 1685 .tx = carl9170_op_tx, 1686 .flush = carl9170_op_flush, 1687 .add_interface = carl9170_op_add_interface, 1688 .remove_interface = carl9170_op_remove_interface, 1689 .config = carl9170_op_config, 1690 .prepare_multicast = carl9170_op_prepare_multicast, 1691 .configure_filter = carl9170_op_configure_filter, 1692 .conf_tx = carl9170_op_conf_tx, 1693 .bss_info_changed = carl9170_op_bss_info_changed, 1694 .get_tsf = carl9170_op_get_tsf, 1695 .set_key = carl9170_op_set_key, 1696 .sta_add = carl9170_op_sta_add, 1697 .sta_remove = carl9170_op_sta_remove, 1698 .sta_notify = carl9170_op_sta_notify, 1699 .get_survey = carl9170_op_get_survey, 1700 .get_stats = carl9170_op_get_stats, 1701 .ampdu_action = carl9170_op_ampdu_action, 1702 .tx_frames_pending = carl9170_tx_frames_pending, 1703 }; 1704 1705 void *carl9170_alloc(size_t priv_size) 1706 { 1707 struct ieee80211_hw *hw; 1708 struct ar9170 *ar; 1709 struct sk_buff *skb; 1710 int i; 1711 1712 /* 1713 * this buffer is used for rx stream reconstruction. 1714 * Under heavy load this device (or the transport layer?) 1715 * tends to split the streams into separate rx descriptors. 1716 */ 1717 1718 skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL); 1719 if (!skb) 1720 goto err_nomem; 1721 1722 hw = ieee80211_alloc_hw(priv_size, &carl9170_ops); 1723 if (!hw) 1724 goto err_nomem; 1725 1726 ar = hw->priv; 1727 ar->hw = hw; 1728 ar->rx_failover = skb; 1729 1730 memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head)); 1731 ar->rx_has_plcp = false; 1732 1733 /* 1734 * Here's a hidden pitfall! 1735 * 1736 * All 4 AC queues work perfectly well under _legacy_ operation. 1737 * However as soon as aggregation is enabled, the traffic flow 1738 * gets very bumpy. Therefore we have to _switch_ to a 1739 * software AC with a single HW queue. 1740 */ 1741 hw->queues = __AR9170_NUM_TXQ; 1742 1743 mutex_init(&ar->mutex); 1744 spin_lock_init(&ar->beacon_lock); 1745 spin_lock_init(&ar->cmd_lock); 1746 spin_lock_init(&ar->tx_stats_lock); 1747 spin_lock_init(&ar->tx_ampdu_list_lock); 1748 spin_lock_init(&ar->mem_lock); 1749 spin_lock_init(&ar->state_lock); 1750 atomic_set(&ar->pending_restarts, 0); 1751 ar->vifs = 0; 1752 for (i = 0; i < ar->hw->queues; i++) { 1753 skb_queue_head_init(&ar->tx_status[i]); 1754 skb_queue_head_init(&ar->tx_pending[i]); 1755 } 1756 INIT_WORK(&ar->ps_work, carl9170_ps_work); 1757 INIT_WORK(&ar->ping_work, carl9170_ping_work); 1758 INIT_WORK(&ar->restart_work, carl9170_restart_work); 1759 INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work); 1760 INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work); 1761 INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor); 1762 INIT_LIST_HEAD(&ar->tx_ampdu_list); 1763 rcu_assign_pointer(ar->tx_ampdu_iter, 1764 (struct carl9170_sta_tid *) &ar->tx_ampdu_list); 1765 1766 bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num); 1767 INIT_LIST_HEAD(&ar->vif_list); 1768 init_completion(&ar->tx_flush); 1769 1770 /* firmware decides which modes we support */ 1771 hw->wiphy->interface_modes = 0; 1772 1773 hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS | 1774 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 1775 IEEE80211_HW_SUPPORTS_PS | 1776 IEEE80211_HW_PS_NULLFUNC_STACK | 1777 IEEE80211_HW_NEED_DTIM_PERIOD | 1778 IEEE80211_HW_SIGNAL_DBM; 1779 1780 if (!modparam_noht) { 1781 /* 1782 * see the comment above, why we allow the user 1783 * to disable HT by a module parameter. 1784 */ 1785 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION; 1786 } 1787 1788 hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe); 1789 hw->sta_data_size = sizeof(struct carl9170_sta_info); 1790 hw->vif_data_size = sizeof(struct carl9170_vif_info); 1791 1792 hw->max_rates = CARL9170_TX_MAX_RATES; 1793 hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES; 1794 1795 for (i = 0; i < ARRAY_SIZE(ar->noise); i++) 1796 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */ 1797 1798 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT; 1799 return ar; 1800 1801 err_nomem: 1802 kfree_skb(skb); 1803 return ERR_PTR(-ENOMEM); 1804 } 1805 1806 static int carl9170_read_eeprom(struct ar9170 *ar) 1807 { 1808 #define RW 8 /* number of words to read at once */ 1809 #define RB (sizeof(u32) * RW) 1810 u8 *eeprom = (void *)&ar->eeprom; 1811 __le32 offsets[RW]; 1812 int i, j, err; 1813 1814 BUILD_BUG_ON(sizeof(ar->eeprom) & 3); 1815 1816 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4); 1817 #ifndef __CHECKER__ 1818 /* don't want to handle trailing remains */ 1819 BUILD_BUG_ON(sizeof(ar->eeprom) % RB); 1820 #endif 1821 1822 for (i = 0; i < sizeof(ar->eeprom) / RB; i++) { 1823 for (j = 0; j < RW; j++) 1824 offsets[j] = cpu_to_le32(AR9170_EEPROM_START + 1825 RB * i + 4 * j); 1826 1827 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG, 1828 RB, (u8 *) &offsets, 1829 RB, eeprom + RB * i); 1830 if (err) 1831 return err; 1832 } 1833 1834 #undef RW 1835 #undef RB 1836 return 0; 1837 } 1838 1839 static int carl9170_parse_eeprom(struct ar9170 *ar) 1840 { 1841 struct ath_regulatory *regulatory = &ar->common.regulatory; 1842 unsigned int rx_streams, tx_streams, tx_params = 0; 1843 int bands = 0; 1844 int chans = 0; 1845 1846 if (ar->eeprom.length == cpu_to_le16(0xffff)) 1847 return -ENODATA; 1848 1849 rx_streams = hweight8(ar->eeprom.rx_mask); 1850 tx_streams = hweight8(ar->eeprom.tx_mask); 1851 1852 if (rx_streams != tx_streams) { 1853 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF; 1854 1855 WARN_ON(!(tx_streams >= 1 && tx_streams <= 1856 IEEE80211_HT_MCS_TX_MAX_STREAMS)); 1857 1858 tx_params = (tx_streams - 1) << 1859 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT; 1860 1861 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params; 1862 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params; 1863 } 1864 1865 if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) { 1866 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = 1867 &carl9170_band_2GHz; 1868 chans += carl9170_band_2GHz.n_channels; 1869 bands++; 1870 } 1871 if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) { 1872 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = 1873 &carl9170_band_5GHz; 1874 chans += carl9170_band_5GHz.n_channels; 1875 bands++; 1876 } 1877 1878 if (!bands) 1879 return -EINVAL; 1880 1881 ar->survey = kzalloc(sizeof(struct survey_info) * chans, GFP_KERNEL); 1882 if (!ar->survey) 1883 return -ENOMEM; 1884 ar->num_channels = chans; 1885 1886 /* 1887 * I measured this, a bandswitch takes roughly 1888 * 135 ms and a frequency switch about 80. 1889 * 1890 * FIXME: measure these values again once EEPROM settings 1891 * are used, that will influence them! 1892 */ 1893 if (bands == 2) 1894 ar->hw->channel_change_time = 135 * 1000; 1895 else 1896 ar->hw->channel_change_time = 80 * 1000; 1897 1898 regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]); 1899 1900 /* second part of wiphy init */ 1901 SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address); 1902 1903 return 0; 1904 } 1905 1906 static int carl9170_reg_notifier(struct wiphy *wiphy, 1907 struct regulatory_request *request) 1908 { 1909 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 1910 struct ar9170 *ar = hw->priv; 1911 1912 return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory); 1913 } 1914 1915 int carl9170_register(struct ar9170 *ar) 1916 { 1917 struct ath_regulatory *regulatory = &ar->common.regulatory; 1918 int err = 0, i; 1919 1920 if (WARN_ON(ar->mem_bitmap)) 1921 return -EINVAL; 1922 1923 ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) * 1924 sizeof(unsigned long), GFP_KERNEL); 1925 1926 if (!ar->mem_bitmap) 1927 return -ENOMEM; 1928 1929 /* try to read EEPROM, init MAC addr */ 1930 err = carl9170_read_eeprom(ar); 1931 if (err) 1932 return err; 1933 1934 err = carl9170_fw_fix_eeprom(ar); 1935 if (err) 1936 return err; 1937 1938 err = carl9170_parse_eeprom(ar); 1939 if (err) 1940 return err; 1941 1942 err = ath_regd_init(regulatory, ar->hw->wiphy, 1943 carl9170_reg_notifier); 1944 if (err) 1945 return err; 1946 1947 if (modparam_noht) { 1948 carl9170_band_2GHz.ht_cap.ht_supported = false; 1949 carl9170_band_5GHz.ht_cap.ht_supported = false; 1950 } 1951 1952 for (i = 0; i < ar->fw.vif_num; i++) { 1953 ar->vif_priv[i].id = i; 1954 ar->vif_priv[i].vif = NULL; 1955 } 1956 1957 err = ieee80211_register_hw(ar->hw); 1958 if (err) 1959 return err; 1960 1961 /* mac80211 interface is now registered */ 1962 ar->registered = true; 1963 1964 if (!ath_is_world_regd(regulatory)) 1965 regulatory_hint(ar->hw->wiphy, regulatory->alpha2); 1966 1967 #ifdef CONFIG_CARL9170_DEBUGFS 1968 carl9170_debugfs_register(ar); 1969 #endif /* CONFIG_CARL9170_DEBUGFS */ 1970 1971 err = carl9170_led_init(ar); 1972 if (err) 1973 goto err_unreg; 1974 1975 #ifdef CONFIG_CARL9170_LEDS 1976 err = carl9170_led_register(ar); 1977 if (err) 1978 goto err_unreg; 1979 #endif /* CONFIG_CARL9170_LEDS */ 1980 1981 #ifdef CONFIG_CARL9170_WPC 1982 err = carl9170_register_wps_button(ar); 1983 if (err) 1984 goto err_unreg; 1985 #endif /* CONFIG_CARL9170_WPC */ 1986 1987 #ifdef CONFIG_CARL9170_HWRNG 1988 err = carl9170_register_hwrng(ar); 1989 if (err) 1990 goto err_unreg; 1991 #endif /* CONFIG_CARL9170_HWRNG */ 1992 1993 dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n", 1994 wiphy_name(ar->hw->wiphy)); 1995 1996 return 0; 1997 1998 err_unreg: 1999 carl9170_unregister(ar); 2000 return err; 2001 } 2002 2003 void carl9170_unregister(struct ar9170 *ar) 2004 { 2005 if (!ar->registered) 2006 return; 2007 2008 ar->registered = false; 2009 2010 #ifdef CONFIG_CARL9170_LEDS 2011 carl9170_led_unregister(ar); 2012 #endif /* CONFIG_CARL9170_LEDS */ 2013 2014 #ifdef CONFIG_CARL9170_DEBUGFS 2015 carl9170_debugfs_unregister(ar); 2016 #endif /* CONFIG_CARL9170_DEBUGFS */ 2017 2018 #ifdef CONFIG_CARL9170_WPC 2019 if (ar->wps.pbc) { 2020 input_unregister_device(ar->wps.pbc); 2021 ar->wps.pbc = NULL; 2022 } 2023 #endif /* CONFIG_CARL9170_WPC */ 2024 2025 #ifdef CONFIG_CARL9170_HWRNG 2026 carl9170_unregister_hwrng(ar); 2027 #endif /* CONFIG_CARL9170_HWRNG */ 2028 2029 carl9170_cancel_worker(ar); 2030 cancel_work_sync(&ar->restart_work); 2031 2032 ieee80211_unregister_hw(ar->hw); 2033 } 2034 2035 void carl9170_free(struct ar9170 *ar) 2036 { 2037 WARN_ON(ar->registered); 2038 WARN_ON(IS_INITIALIZED(ar)); 2039 2040 kfree_skb(ar->rx_failover); 2041 ar->rx_failover = NULL; 2042 2043 kfree(ar->mem_bitmap); 2044 ar->mem_bitmap = NULL; 2045 2046 kfree(ar->survey); 2047 ar->survey = NULL; 2048 2049 mutex_destroy(&ar->mutex); 2050 2051 ieee80211_free_hw(ar->hw); 2052 } 2053