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