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