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