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(lock: &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(entry: &tid_info->list);
195	ar->tx_ampdu_list_len--;
196	list_add_tail(new: &tid_info->tmp_list, head: &tid_gc);
197	}
198	spin_unlock_bh(lock: &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(head: &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(list: &tid_info->queue)))
212	carl9170_tx_status(ar, skb, success: false);
213
214	list_del_init(entry: &tid_info->tmp_list);
215	kfree(objp: 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(list: &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(v: &ar->tx_ampdu_upload);
238
239	carl9170_tx_status(ar, skb, success: false);
240	}
241	}
242	}
243
244	/* Wait for all other outstanding frames to timeout. */
245	if (atomic_read(v: &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(list: &free);
256
257	rcu_read_lock();
258	spin_lock_bh(lock: &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(lock: &tid_info->lock);
264	while ((skb = __skb_dequeue(list: &tid_info->queue)))
265	__skb_queue_tail(list: &free, newsk: skb);
266	spin_unlock(lock: &tid_info->lock);
267	}
268	}
269	spin_unlock_bh(lock: &ar->tx_ampdu_list_lock);
270	rcu_read_unlock();
271
272	while ((skb = __skb_dequeue(list: &free)))
273	carl9170_tx_status(ar, skb, success: 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, drop_queued: true);
285
286	for (i = 0; i < ar->hw->queues; i++) {
287	spin_lock_bh(lock: &ar->tx_status[i].lock);
288	while (!skb_queue_empty(list: &ar->tx_status[i])) {
289	struct sk_buff *skb;
290
291	skb = skb_peek(list_: &ar->tx_status[i]);
292	carl9170_tx_get_skb(skb);
293	spin_unlock_bh(lock: &ar->tx_status[i].lock);
294	carl9170_tx_drop(ar, skb);
295	spin_lock_bh(lock: &ar->tx_status[i].lock);
296	carl9170_tx_put_skb(skb);
297	}
298	spin_unlock_bh(lock: &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(dst: ar->mem_bitmap, nbits: ar->fw.mem_blocks);
311
312	rcu_read_lock();
313	list_for_each_entry_rcu(cvif, &ar->vif_list, list) {
314	spin_lock_bh(lock: &ar->beacon_lock);
315	dev_kfree_skb_any(skb: cvif->beacon);
316	cvif->beacon = NULL;
317	spin_unlock_bh(lock: &ar->beacon_lock);
318	}
319	rcu_read_unlock();
320
321	atomic_set(v: &ar->tx_ampdu_upload, i: 0);
322	atomic_set(v: &ar->tx_ampdu_scheduler, i: 0);
323	atomic_set(v: &ar->tx_total_pending, i: 0);
324	atomic_set(v: &ar->tx_total_queued, i: 0);
325	atomic_set(v: &ar->mem_free_blocks, i: 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(v: &ar->mem_allocs, i: 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, id: i, NULL, AR9170_ENC_ALG_NONE,
401	keyidx: 0, NULL, keylen: 0);
402	if (err)
403	goto out;
404
405	err = carl9170_upload_key(ar, id: i, NULL, AR9170_ENC_ALG_NONE,
406	keyidx: 1, NULL, keylen: 0);
407	if (err)
408	goto out;
409
410	if (i < AR9170_CAM_MAX_USER) {
411	err = carl9170_disable_key(ar, id: i);
412	if (err)
413	goto out;
414	}
415	}
416
417	carl9170_set_state_when(ar, min: CARL9170_IDLE, newstate: CARL9170_STARTED);
418
419	ieee80211_queue_delayed_work(hw: ar->hw, dwork: &ar->stat_work,
420	delay: round_jiffies(j: msecs_to_jiffies(CARL9170_STAT_WORK)));
421
422	ieee80211_wake_queues(hw: ar->hw);
423	err = 0;
424
425	out:
426	mutex_unlock(lock: &ar->mutex);
427	return err;
428	}
429
430	static void carl9170_cancel_worker(struct ar9170 *ar)
431	{
432	cancel_delayed_work_sync(dwork: &ar->stat_work);
433	cancel_delayed_work_sync(dwork: &ar->tx_janitor);
434	#ifdef CONFIG_CARL9170_LEDS
435	cancel_delayed_work_sync(dwork: &ar->led_work);
436	#endif /* CONFIG_CARL9170_LEDS */
437	cancel_work_sync(work: &ar->ps_work);
438	cancel_work_sync(work: &ar->ping_work);
439	cancel_work_sync(work: &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, min: CARL9170_STARTED, newstate: CARL9170_IDLE);
447
448	ieee80211_stop_queues(hw: 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, led_state: 0);
455
456	/* stop DMA */
457	carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, val: 0);
458	carl9170_usb_stop(ar);
459	}
460
461	carl9170_zap_queues(ar);
462	mutex_unlock(lock: &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(lock: &ar->mutex);
489
490	if (!err && !ar->force_usb_reset) {
491	ar->restart_counter++;
492	atomic_set(v: &ar->pending_restarts, i: 0);
493
494	ieee80211_restart_hw(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, min: CARL9170_STARTED, newstate: 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(v: &ar->pending_restarts) > 1) {
516	dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r);
517	return;
518	}
519
520	ieee80211_stop_queues(hw: 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(hw: ar->hw, work: &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, v: 0xdeadbeef);
553	if (err)
554	carl9170_restart(ar, r: CARL9170_RR_UNRESPONSIVE_DEVICE);
555	mutex_unlock(lock: &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(lock: &ar->beacon_lock);
616	dev_kfree_skb_any(skb: vif_priv->beacon);
617	vif_priv->beacon = NULL;
618	spin_unlock_bh(lock: &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(bitmap: &ar->vif_bitmap, bits: ar->fw.vif_num, order: 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(new: &vif_priv->list, head: &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(new: &vif_priv->list, head: &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, id: old_main_priv->id,
707	mac: 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, id: vif_id, mac: vif->addr);
718
719	if (err)
720	goto unlock;
721	}
722
723	if (ar->fw.tx_seq_table) {
724	err = carl9170_write_reg(ar, reg: ar->fw.tx_seq_table + vif_id * 4,
725	val: 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(bitmap: &ar->vif_bitmap, pos: vif_id, order: 0);
734	ar->vifs--;
735	RCU_INIT_POINTER(ar->vif_priv[vif_id].vif, NULL);
736	list_del_rcu(entry: &vif_priv->list);
737	mutex_unlock(lock: &ar->mutex);
738	synchronize_rcu();
739	} else {
740	if (ar->vifs > 1)
741	ar->ps.off_override |= PS_OFF_VIF;
742
743	mutex_unlock(lock: &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(entry: &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, submit: false);
791	carl9170_flush_cab(ar, vif_id: id);
792
793	spin_lock_bh(lock: &ar->beacon_lock);
794	dev_kfree_skb_any(skb: vif_priv->beacon);
795	vif_priv->beacon = NULL;
796	spin_unlock_bh(lock: &ar->beacon_lock);
797
798	bitmap_release_region(bitmap: &ar->vif_bitmap, pos: id, order: 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(lock: &ar->mutex);
807
808	synchronize_rcu();
809	}
810
811	void carl9170_ps_check(struct ar9170 *ar)
812	{
813	ieee80211_queue_work(hw: ar->hw, work: &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, power_on: ps);
827	if (err)
828	return err;
829
830	if (ar->ps.state && !ps) {
831	ar->ps.sleep_ms = jiffies_to_msecs(j: 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(lock: &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, flush: false, noise: true);
884	mutex_unlock(lock: &ar->mutex);
885
886	if (err)
887	return;
888
889	ieee80211_queue_delayed_work(hw: ar->hw, dwork: &ar->stat_work,
890	delay: round_jiffies(j: 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(chandef: &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, flush: true, noise: false);
925	if (err)
926	goto out;
927
928	err = carl9170_set_channel(ar, channel: hw->conf.chandef.chan,
929	bw: channel_type);
930	if (err)
931	goto out;
932
933	err = carl9170_update_survey(ar, flush: false, noise: 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, channel: ar->hw->conf.chandef.chan);
948	if (err)
949	goto out;
950	}
951
952	out:
953	mutex_unlock(lock: &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(lock: &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, submit: 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(lock: &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	plen: 0, NULL, rlen: sizeof(tsf), resp: &tsf);
1151	mutex_unlock(lock: &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, id: i, mac: sta ? sta->addr : NULL,
1232	ktype, keyidx: 0, keydata: 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, id: i, mac: sta ? sta->addr :
1239	NULL, ktype, keyidx: 1,
1240	keydata: key->key + 16, keylen: 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, id: key->hw_key_idx, NULL,
1266	AR9170_ENC_ALG_NONE, keyidx: 0,
1267	NULL, keylen: 0);
1268	if (err)
1269	goto out;
1270
1271	if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1272	err = carl9170_upload_key(ar, id: key->hw_key_idx,
1273	NULL,
1274	AR9170_ENC_ALG_NONE,
1275	keyidx: 1, NULL, keylen: 0);
1276	if (err)
1277	goto out;
1278	}
1279
1280	}
1281
1282	err = carl9170_disable_key(ar, id: key->hw_key_idx);
1283	if (err)
1284	goto out;
1285	}
1286
1287	out:
1288	mutex_unlock(lock: &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(lock: &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(v: &sta_info->pending_frames, i: 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(lock: &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(lock: &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(lock: &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(lock: &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(size: 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(list: &tid_info->list);
1428	INIT_LIST_HEAD(list: &tid_info->tmp_list);
1429	skb_queue_head_init(list: &tid_info->queue);
1430	spin_lock_init(&tid_info->lock);
1431
1432	spin_lock_bh(lock: &ar->tx_ampdu_list_lock);
1433	ar->tx_ampdu_list_len++;
1434	list_add_tail_rcu(new: &tid_info->list, head: &ar->tx_ampdu_list);
1435	rcu_assign_pointer(sta_info->agg[tid], tid_info);
1436	spin_unlock_bh(lock: &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(lock: &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(lock: &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, ra: sta->addr, tid);
1456	ieee80211_queue_work(hw: ar->hw, work: &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(dst: 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(buf: ar->wps.name, size: sizeof(ar->wps.name), fmt: "%s WPS Button",
1503	wiphy_name(wiphy: ar->hw->wiphy));
1504
1505	snprintf(buf: ar->wps.phys, size: sizeof(ar->wps.phys),
1506	fmt: "ieee80211/%s/input0", wiphy_name(wiphy: 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(dev: 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, payload: (u8 *) rng_load,
1548	RB, resp: (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(lock: &ar->mutex);
1577	return ret;
1578	}
1579	}
1580
1581	*data = ar->rng.cache[ar->rng.cache_idx++];
1582	mutex_unlock(lock: &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(buf: ar->rng.name, ARRAY_SIZE(ar->rng.name),
1592	fmt: "%s_%s", KBUILD_MODNAME, wiphy_name(wiphy: 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(dev: &ar->udev->dev, rng: &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, flush: false, noise: true);
1623	mutex_unlock(lock: &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, vif_id: vid);
1671
1672	carl9170_flush(ar, drop_queued: drop);
1673	mutex_unlock(lock: &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(v: &sta_info->pending_frames))
1698	ieee80211_sta_block_awake(hw, pubsta: sta, block: 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(v: &ar->tx_total_queued);
1712	}
1713
1714	static const struct ieee80211_ops carl9170_ops = {
1715	.add_chanctx = ieee80211_emulate_add_chanctx,
1716	.remove_chanctx = ieee80211_emulate_remove_chanctx,
1717	.change_chanctx = ieee80211_emulate_change_chanctx,
1718	.switch_vif_chanctx = ieee80211_emulate_switch_vif_chanctx,
1719	.start = carl9170_op_start,
1720	.stop = carl9170_op_stop,
1721	.tx = carl9170_op_tx,
1722	.wake_tx_queue = ieee80211_handle_wake_tx_queue,
1723	.flush = carl9170_op_flush,
1724	.add_interface = carl9170_op_add_interface,
1725	.remove_interface = carl9170_op_remove_interface,
1726	.config = carl9170_op_config,
1727	.prepare_multicast = carl9170_op_prepare_multicast,
1728	.configure_filter = carl9170_op_configure_filter,
1729	.conf_tx = carl9170_op_conf_tx,
1730	.bss_info_changed = carl9170_op_bss_info_changed,
1731	.get_tsf = carl9170_op_get_tsf,
1732	.set_key = carl9170_op_set_key,
1733	.sta_add = carl9170_op_sta_add,
1734	.sta_remove = carl9170_op_sta_remove,
1735	.sta_notify = carl9170_op_sta_notify,
1736	.get_survey = carl9170_op_get_survey,
1737	.get_stats = carl9170_op_get_stats,
1738	.ampdu_action = carl9170_op_ampdu_action,
1739	.tx_frames_pending = carl9170_tx_frames_pending,
1740	};
1741
1742	void *carl9170_alloc(size_t priv_size)
1743	{
1744	struct ieee80211_hw *hw;
1745	struct ar9170 *ar;
1746	struct sk_buff *skb;
1747	int i;
1748
1749	/*
1750	* this buffer is used for rx stream reconstruction.
1751	* Under heavy load this device (or the transport layer?)
1752	* tends to split the streams into separate rx descriptors.
1753	*/
1754
1755	skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1756	if (!skb)
1757	goto err_nomem;
1758
1759	hw = ieee80211_alloc_hw(priv_data_len: priv_size, ops: &carl9170_ops);
1760	if (!hw)
1761	goto err_nomem;
1762
1763	ar = hw->priv;
1764	ar->hw = hw;
1765	ar->rx_failover = skb;
1766
1767	memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1768	ar->rx_has_plcp = false;
1769
1770	/*
1771	* Here's a hidden pitfall!
1772	*
1773	* All 4 AC queues work perfectly well under _legacy_ operation.
1774	* However as soon as aggregation is enabled, the traffic flow
1775	* gets very bumpy. Therefore we have to _switch_ to a
1776	* software AC with a single HW queue.
1777	*/
1778	hw->queues = __AR9170_NUM_TXQ;
1779
1780	mutex_init(&ar->mutex);
1781	spin_lock_init(&ar->beacon_lock);
1782	spin_lock_init(&ar->cmd_lock);
1783	spin_lock_init(&ar->tx_stats_lock);
1784	spin_lock_init(&ar->tx_ampdu_list_lock);
1785	spin_lock_init(&ar->mem_lock);
1786	spin_lock_init(&ar->state_lock);
1787	atomic_set(v: &ar->pending_restarts, i: 0);
1788	ar->vifs = 0;
1789	for (i = 0; i < ar->hw->queues; i++) {
1790	skb_queue_head_init(list: &ar->tx_status[i]);
1791	skb_queue_head_init(list: &ar->tx_pending[i]);
1792
1793	INIT_LIST_HEAD(list: &ar->bar_list[i]);
1794	spin_lock_init(&ar->bar_list_lock[i]);
1795	}
1796	INIT_WORK(&ar->ps_work, carl9170_ps_work);
1797	INIT_WORK(&ar->ping_work, carl9170_ping_work);
1798	INIT_WORK(&ar->restart_work, carl9170_restart_work);
1799	INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1800	INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work);
1801	INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1802	INIT_LIST_HEAD(list: &ar->tx_ampdu_list);
1803	rcu_assign_pointer(ar->tx_ampdu_iter,
1804	(struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1805
1806	bitmap_zero(dst: &ar->vif_bitmap, nbits: ar->fw.vif_num);
1807	INIT_LIST_HEAD(list: &ar->vif_list);
1808	init_completion(x: &ar->tx_flush);
1809
1810	/* firmware decides which modes we support */
1811	hw->wiphy->interface_modes = 0;
1812
1813	ieee80211_hw_set(hw, RX_INCLUDES_FCS);
1814	ieee80211_hw_set(hw, MFP_CAPABLE);
1815	ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
1816	ieee80211_hw_set(hw, SUPPORTS_PS);
1817	ieee80211_hw_set(hw, PS_NULLFUNC_STACK);
1818	ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
1819	ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
1820	ieee80211_hw_set(hw, SIGNAL_DBM);
1821	ieee80211_hw_set(hw, SUPPORTS_HT_CCK_RATES);
1822
1823	if (!modparam_noht) {
1824	/*
1825	* see the comment above, why we allow the user
1826	* to disable HT by a module parameter.
1827	*/
1828	ieee80211_hw_set(hw, AMPDU_AGGREGATION);
1829	}
1830
1831	hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1832	hw->sta_data_size = sizeof(struct carl9170_sta_info);
1833	hw->vif_data_size = sizeof(struct carl9170_vif_info);
1834
1835	hw->max_rates = CARL9170_TX_MAX_RATES;
1836	hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1837
1838	for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1839	ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1840
1841	wiphy_ext_feature_set(wiphy: hw->wiphy, ftidx: NL80211_EXT_FEATURE_CQM_RSSI_LIST);
1842
1843	return ar;
1844
1845	err_nomem:
1846	kfree_skb(skb);
1847	return ERR_PTR(error: -ENOMEM);
1848	}
1849
1850	static int carl9170_read_eeprom(struct ar9170 *ar)
1851	{
1852	#define RW 8 /* number of words to read at once */
1853	#define RB (sizeof(u32) * RW)
1854	u8 *eeprom = (void *)&ar->eeprom;
1855	__le32 offsets[RW];
1856	int i, j, err;
1857
1858	BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1859
1860	BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1861	#ifndef __CHECKER__
1862	/* don't want to handle trailing remains */
1863	BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1864	#endif
1865
1866	for (i = 0; i < sizeof(ar->eeprom) / RB; i++) {
1867	for (j = 0; j < RW; j++)
1868	offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1869	RB * i + 4 * j);
1870
1871	err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1872	RB, payload: (u8 *) &offsets,
1873	RB, resp: eeprom + RB * i);
1874	if (err)
1875	return err;
1876	}
1877
1878	#undef RW
1879	#undef RB
1880	return 0;
1881	}
1882
1883	static int carl9170_parse_eeprom(struct ar9170 *ar)
1884	{
1885	struct ath_regulatory *regulatory = &ar->common.regulatory;
1886	unsigned int rx_streams, tx_streams, tx_params = 0;
1887	int bands = 0;
1888	int chans = 0;
1889
1890	if (ar->eeprom.length == cpu_to_le16(0xffff))
1891	return -ENODATA;
1892
1893	rx_streams = hweight8(ar->eeprom.rx_mask);
1894	tx_streams = hweight8(ar->eeprom.tx_mask);
1895
1896	if (rx_streams != tx_streams) {
1897	tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1898
1899	WARN_ON(!(tx_streams >= 1 && tx_streams <=
1900	IEEE80211_HT_MCS_TX_MAX_STREAMS));
1901
1902	tx_params |= (tx_streams - 1) <<
1903	IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1904
1905	carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1906	carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1907	}
1908
1909	if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1910	ar->hw->wiphy->bands[NL80211_BAND_2GHZ] =
1911	&carl9170_band_2GHz;
1912	chans += carl9170_band_2GHz.n_channels;
1913	bands++;
1914	}
1915	if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1916	ar->hw->wiphy->bands[NL80211_BAND_5GHZ] =
1917	&carl9170_band_5GHz;
1918	chans += carl9170_band_5GHz.n_channels;
1919	bands++;
1920	}
1921
1922	if (!bands)
1923	return -EINVAL;
1924
1925	ar->survey = devm_kcalloc(dev: &ar->udev->dev, n: chans,
1926	size: sizeof(struct survey_info), GFP_KERNEL);
1927	if (!ar->survey)
1928	return -ENOMEM;
1929	ar->num_channels = chans;
1930
1931	regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1932
1933	/* second part of wiphy init */
1934	SET_IEEE80211_PERM_ADDR(hw: ar->hw, addr: ar->eeprom.mac_address);
1935
1936	return 0;
1937	}
1938
1939	static void carl9170_reg_notifier(struct wiphy *wiphy,
1940	struct regulatory_request *request)
1941	{
1942	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1943	struct ar9170 *ar = hw->priv;
1944
1945	ath_reg_notifier_apply(wiphy, request, reg: &ar->common.regulatory);
1946	}
1947
1948	int carl9170_register(struct ar9170 *ar)
1949	{
1950	struct ath_regulatory *regulatory = &ar->common.regulatory;
1951	int err = 0, i;
1952
1953	ar->mem_bitmap = devm_bitmap_zalloc(dev: &ar->udev->dev, nbits: ar->fw.mem_blocks, GFP_KERNEL);
1954	if (!ar->mem_bitmap)
1955	return -ENOMEM;
1956
1957	/* try to read EEPROM, init MAC addr */
1958	err = carl9170_read_eeprom(ar);
1959	if (err)
1960	return err;
1961
1962	err = carl9170_parse_eeprom(ar);
1963	if (err)
1964	return err;
1965
1966	err = ath_regd_init(reg: regulatory, wiphy: ar->hw->wiphy,
1967	reg_notifier: carl9170_reg_notifier);
1968	if (err)
1969	return err;
1970
1971	if (modparam_noht) {
1972	carl9170_band_2GHz.ht_cap.ht_supported = false;
1973	carl9170_band_5GHz.ht_cap.ht_supported = false;
1974	}
1975
1976	for (i = 0; i < ar->fw.vif_num; i++) {
1977	ar->vif_priv[i].id = i;
1978	ar->vif_priv[i].vif = NULL;
1979	}
1980
1981	err = ieee80211_register_hw(hw: ar->hw);
1982	if (err)
1983	return err;
1984
1985	/* mac80211 interface is now registered */
1986	ar->registered = true;
1987
1988	if (!ath_is_world_regd(reg: regulatory))
1989	regulatory_hint(wiphy: ar->hw->wiphy, alpha2: regulatory->alpha2);
1990
1991	#ifdef CONFIG_CARL9170_DEBUGFS
1992	carl9170_debugfs_register(ar);
1993	#endif /* CONFIG_CARL9170_DEBUGFS */
1994
1995	err = carl9170_led_init(ar);
1996	if (err)
1997	goto err_unreg;
1998
1999	#ifdef CONFIG_CARL9170_LEDS
2000	err = carl9170_led_register(ar);
2001	if (err)
2002	goto err_unreg;
2003	#endif /* CONFIG_CARL9170_LEDS */
2004
2005	#ifdef CONFIG_CARL9170_WPC
2006	err = carl9170_register_wps_button(ar);
2007	if (err)
2008	goto err_unreg;
2009	#endif /* CONFIG_CARL9170_WPC */
2010
2011	#ifdef CONFIG_CARL9170_HWRNG
2012	err = carl9170_register_hwrng(ar);
2013	if (err)
2014	goto err_unreg;
2015	#endif /* CONFIG_CARL9170_HWRNG */
2016
2017	dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
2018	wiphy_name(ar->hw->wiphy));
2019
2020	return 0;
2021
2022	err_unreg:
2023	carl9170_unregister(ar);
2024	return err;
2025	}
2026
2027	void carl9170_unregister(struct ar9170 *ar)
2028	{
2029	if (!ar->registered)
2030	return;
2031
2032	ar->registered = false;
2033
2034	#ifdef CONFIG_CARL9170_LEDS
2035	carl9170_led_unregister(ar);
2036	#endif /* CONFIG_CARL9170_LEDS */
2037
2038	#ifdef CONFIG_CARL9170_DEBUGFS
2039	carl9170_debugfs_unregister(ar);
2040	#endif /* CONFIG_CARL9170_DEBUGFS */
2041
2042	carl9170_cancel_worker(ar);
2043	cancel_work_sync(work: &ar->restart_work);
2044
2045	ieee80211_unregister_hw(hw: ar->hw);
2046	}
2047
2048	void carl9170_free(struct ar9170 *ar)
2049	{
2050	WARN_ON(ar->registered);
2051	WARN_ON(IS_INITIALIZED(ar));
2052
2053	kfree_skb(skb: ar->rx_failover);
2054	ar->rx_failover = NULL;
2055
2056	mutex_destroy(lock: &ar->mutex);
2057
2058	ieee80211_free_hw(hw: ar->hw);
2059	}
2060