init.c 27.5 KB
Newer Older
Sujith's avatar
Sujith committed
1
/*
2
 * Copyright (c) 2008-2011 Atheros Communications Inc.
Sujith's avatar
Sujith committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

17
18
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

19
#include <linux/dma-mapping.h>
20
#include <linux/slab.h>
21
#include <linux/ath9k_platform.h>
22
#include <linux/module.h>
23
#include <linux/relay.h>
24
#include <net/ieee80211_radiotap.h>
25

Sujith's avatar
Sujith committed
26
27
#include "ath9k.h"

28
29
30
31
32
struct ath9k_eeprom_ctx {
	struct completion complete;
	struct ath_hw *ah;
};

Sujith's avatar
Sujith committed
33
34
35
36
37
38
39
40
41
42
43
static char *dev_info = "ath9k";

MODULE_AUTHOR("Atheros Communications");
MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
MODULE_LICENSE("Dual BSD/GPL");

static unsigned int ath9k_debug = ATH_DBG_DEFAULT;
module_param_named(debug, ath9k_debug, uint, 0);
MODULE_PARM_DESC(debug, "Debugging mask");

44
45
int ath9k_modparam_nohwcrypt;
module_param_named(nohwcrypt, ath9k_modparam_nohwcrypt, int, 0444);
Sujith's avatar
Sujith committed
46
47
MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption");

48
int led_blink;
49
50
51
module_param_named(blink, led_blink, int, 0444);
MODULE_PARM_DESC(blink, "Enable LED blink on activity");

52
53
54
55
static int ath9k_btcoex_enable;
module_param_named(btcoex_enable, ath9k_btcoex_enable, int, 0444);
MODULE_PARM_DESC(btcoex_enable, "Enable wifi-BT coexistence");

56
57
58
59
static int ath9k_enable_diversity;
module_param_named(enable_diversity, ath9k_enable_diversity, int, 0444);
MODULE_PARM_DESC(enable_diversity, "Enable Antenna diversity for AR9565");

60
bool is_ath9k_unloaded;
Sujith's avatar
Sujith committed
61
62
63
/* We use the hw_value as an index into our private channel structure */

#define CHAN2G(_freq, _idx)  { \
64
	.band = IEEE80211_BAND_2GHZ, \
Sujith's avatar
Sujith committed
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
	.center_freq = (_freq), \
	.hw_value = (_idx), \
	.max_power = 20, \
}

#define CHAN5G(_freq, _idx) { \
	.band = IEEE80211_BAND_5GHZ, \
	.center_freq = (_freq), \
	.hw_value = (_idx), \
	.max_power = 20, \
}

/* Some 2 GHz radios are actually tunable on 2312-2732
 * on 5 MHz steps, we support the channels which we know
 * we have calibration data for all cards though to make
 * this static */
81
static const struct ieee80211_channel ath9k_2ghz_chantable[] = {
Sujith's avatar
Sujith committed
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
	CHAN2G(2412, 0), /* Channel 1 */
	CHAN2G(2417, 1), /* Channel 2 */
	CHAN2G(2422, 2), /* Channel 3 */
	CHAN2G(2427, 3), /* Channel 4 */
	CHAN2G(2432, 4), /* Channel 5 */
	CHAN2G(2437, 5), /* Channel 6 */
	CHAN2G(2442, 6), /* Channel 7 */
	CHAN2G(2447, 7), /* Channel 8 */
	CHAN2G(2452, 8), /* Channel 9 */
	CHAN2G(2457, 9), /* Channel 10 */
	CHAN2G(2462, 10), /* Channel 11 */
	CHAN2G(2467, 11), /* Channel 12 */
	CHAN2G(2472, 12), /* Channel 13 */
	CHAN2G(2484, 13), /* Channel 14 */
};

/* Some 5 GHz radios are actually tunable on XXXX-YYYY
 * on 5 MHz steps, we support the channels which we know
 * we have calibration data for all cards though to make
 * this static */
102
static const struct ieee80211_channel ath9k_5ghz_chantable[] = {
Sujith's avatar
Sujith committed
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
	/* _We_ call this UNII 1 */
	CHAN5G(5180, 14), /* Channel 36 */
	CHAN5G(5200, 15), /* Channel 40 */
	CHAN5G(5220, 16), /* Channel 44 */
	CHAN5G(5240, 17), /* Channel 48 */
	/* _We_ call this UNII 2 */
	CHAN5G(5260, 18), /* Channel 52 */
	CHAN5G(5280, 19), /* Channel 56 */
	CHAN5G(5300, 20), /* Channel 60 */
	CHAN5G(5320, 21), /* Channel 64 */
	/* _We_ call this "Middle band" */
	CHAN5G(5500, 22), /* Channel 100 */
	CHAN5G(5520, 23), /* Channel 104 */
	CHAN5G(5540, 24), /* Channel 108 */
	CHAN5G(5560, 25), /* Channel 112 */
	CHAN5G(5580, 26), /* Channel 116 */
	CHAN5G(5600, 27), /* Channel 120 */
	CHAN5G(5620, 28), /* Channel 124 */
	CHAN5G(5640, 29), /* Channel 128 */
	CHAN5G(5660, 30), /* Channel 132 */
	CHAN5G(5680, 31), /* Channel 136 */
	CHAN5G(5700, 32), /* Channel 140 */
	/* _We_ call this UNII 3 */
	CHAN5G(5745, 33), /* Channel 149 */
	CHAN5G(5765, 34), /* Channel 153 */
	CHAN5G(5785, 35), /* Channel 157 */
	CHAN5G(5805, 36), /* Channel 161 */
	CHAN5G(5825, 37), /* Channel 165 */
};

/* Atheros hardware rate code addition for short premble */
#define SHPCHECK(__hw_rate, __flags) \
	((__flags & IEEE80211_RATE_SHORT_PREAMBLE) ? (__hw_rate | 0x04 ) : 0)

#define RATE(_bitrate, _hw_rate, _flags) {              \
	.bitrate        = (_bitrate),                   \
	.flags          = (_flags),                     \
	.hw_value       = (_hw_rate),                   \
	.hw_value_short = (SHPCHECK(_hw_rate, _flags))  \
}

static struct ieee80211_rate ath9k_legacy_rates[] = {
	RATE(10, 0x1b, 0),
	RATE(20, 0x1a, IEEE80211_RATE_SHORT_PREAMBLE),
	RATE(55, 0x19, IEEE80211_RATE_SHORT_PREAMBLE),
	RATE(110, 0x18, IEEE80211_RATE_SHORT_PREAMBLE),
	RATE(60, 0x0b, 0),
	RATE(90, 0x0f, 0),
	RATE(120, 0x0a, 0),
	RATE(180, 0x0e, 0),
	RATE(240, 0x09, 0),
	RATE(360, 0x0d, 0),
	RATE(480, 0x08, 0),
	RATE(540, 0x0c, 0),
};

159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
#ifdef CONFIG_MAC80211_LEDS
static const struct ieee80211_tpt_blink ath9k_tpt_blink[] = {
	{ .throughput = 0 * 1024, .blink_time = 334 },
	{ .throughput = 1 * 1024, .blink_time = 260 },
	{ .throughput = 5 * 1024, .blink_time = 220 },
	{ .throughput = 10 * 1024, .blink_time = 190 },
	{ .throughput = 20 * 1024, .blink_time = 170 },
	{ .throughput = 50 * 1024, .blink_time = 150 },
	{ .throughput = 70 * 1024, .blink_time = 130 },
	{ .throughput = 100 * 1024, .blink_time = 110 },
	{ .throughput = 200 * 1024, .blink_time = 80 },
	{ .throughput = 300 * 1024, .blink_time = 50 },
};
#endif

Sujith's avatar
Sujith committed
174
static void ath9k_deinit_softc(struct ath_softc *sc);
Sujith's avatar
Sujith committed
175
176
177
178
179
180
181
182
183
184
185
186
187

/*
 * Read and write, they both share the same lock. We do this to serialize
 * reads and writes on Atheros 802.11n PCI devices only. This is required
 * as the FIFO on these devices can only accept sanely 2 requests.
 */

static void ath9k_iowrite32(void *hw_priv, u32 val, u32 reg_offset)
{
	struct ath_hw *ah = (struct ath_hw *) hw_priv;
	struct ath_common *common = ath9k_hw_common(ah);
	struct ath_softc *sc = (struct ath_softc *) common->priv;

188
	if (NR_CPUS > 1 && ah->config.serialize_regmode == SER_REG_MODE_ON) {
Sujith's avatar
Sujith committed
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
		unsigned long flags;
		spin_lock_irqsave(&sc->sc_serial_rw, flags);
		iowrite32(val, sc->mem + reg_offset);
		spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
	} else
		iowrite32(val, sc->mem + reg_offset);
}

static unsigned int ath9k_ioread32(void *hw_priv, u32 reg_offset)
{
	struct ath_hw *ah = (struct ath_hw *) hw_priv;
	struct ath_common *common = ath9k_hw_common(ah);
	struct ath_softc *sc = (struct ath_softc *) common->priv;
	u32 val;

204
	if (NR_CPUS > 1 && ah->config.serialize_regmode == SER_REG_MODE_ON) {
Sujith's avatar
Sujith committed
205
206
207
208
209
210
211
212
213
		unsigned long flags;
		spin_lock_irqsave(&sc->sc_serial_rw, flags);
		val = ioread32(sc->mem + reg_offset);
		spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
	} else
		val = ioread32(sc->mem + reg_offset);
	return val;
}

214
215
216
217
218
219
220
221
222
223
224
225
226
static unsigned int __ath9k_reg_rmw(struct ath_softc *sc, u32 reg_offset,
				    u32 set, u32 clr)
{
	u32 val;

	val = ioread32(sc->mem + reg_offset);
	val &= ~clr;
	val |= set;
	iowrite32(val, sc->mem + reg_offset);

	return val;
}

227
228
229
230
231
232
233
234
static unsigned int ath9k_reg_rmw(void *hw_priv, u32 reg_offset, u32 set, u32 clr)
{
	struct ath_hw *ah = (struct ath_hw *) hw_priv;
	struct ath_common *common = ath9k_hw_common(ah);
	struct ath_softc *sc = (struct ath_softc *) common->priv;
	unsigned long uninitialized_var(flags);
	u32 val;

235
	if (NR_CPUS > 1 && ah->config.serialize_regmode == SER_REG_MODE_ON) {
236
		spin_lock_irqsave(&sc->sc_serial_rw, flags);
237
		val = __ath9k_reg_rmw(sc, reg_offset, set, clr);
238
		spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
239
240
	} else
		val = __ath9k_reg_rmw(sc, reg_offset, set, clr);
241
242
243
244

	return val;
}

Sujith's avatar
Sujith committed
245
246
247
248
249
250
251
/**************************/
/*     Initialization     */
/**************************/

static void setup_ht_cap(struct ath_softc *sc,
			 struct ieee80211_sta_ht_cap *ht_info)
{
252
253
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
Sujith's avatar
Sujith committed
254
	u8 tx_streams, rx_streams;
255
	int i, max_streams;
Sujith's avatar
Sujith committed
256
257
258
259
260
261
262

	ht_info->ht_supported = true;
	ht_info->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
		       IEEE80211_HT_CAP_SM_PS |
		       IEEE80211_HT_CAP_SGI_40 |
		       IEEE80211_HT_CAP_DSSSCCK40;

Luis R. Rodriguez's avatar
Luis R. Rodriguez committed
263
264
265
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_LDPC)
		ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;

266
267
268
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20)
		ht_info->cap |= IEEE80211_HT_CAP_SGI_20;

Sujith's avatar
Sujith committed
269
270
271
	ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
	ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;

272
	if (AR_SREV_9330(ah) || AR_SREV_9485(ah) || AR_SREV_9565(ah))
273
		max_streams = 1;
274
275
	else if (AR_SREV_9462(ah))
		max_streams = 2;
276
	else if (AR_SREV_9300_20_OR_LATER(ah))
277
278
279
280
		max_streams = 3;
	else
		max_streams = 2;

281
	if (AR_SREV_9280_20_OR_LATER(ah)) {
282
283
284
285
286
		if (max_streams >= 2)
			ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
		ht_info->cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
	}

Sujith's avatar
Sujith committed
287
288
	/* set up supported mcs set */
	memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
289
290
	tx_streams = ath9k_cmn_count_streams(ah->txchainmask, max_streams);
	rx_streams = ath9k_cmn_count_streams(ah->rxchainmask, max_streams);
291

292
	ath_dbg(common, CONFIG, "TX streams %d, RX streams: %d\n",
293
		tx_streams, rx_streams);
Sujith's avatar
Sujith committed
294
295
296
297
298
299
300

	if (tx_streams != rx_streams) {
		ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		ht_info->mcs.tx_params |= ((tx_streams - 1) <<
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
	}

301
302
	for (i = 0; i < rx_streams; i++)
		ht_info->mcs.rx_mask[i] = 0xff;
Sujith's avatar
Sujith committed
303
304
305
306

	ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
}

307
308
static void ath9k_reg_notifier(struct wiphy *wiphy,
			       struct regulatory_request *request)
Sujith's avatar
Sujith committed
309
310
{
	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
311
	struct ath_softc *sc = hw->priv;
312
313
314
	struct ath_hw *ah = sc->sc_ah;
	struct ath_regulatory *reg = ath9k_hw_regulatory(ah);

315
	ath_reg_notifier_apply(wiphy, request, reg);
316
317
318
319
320
321
322

	/* Set tx power */
	if (ah->curchan) {
		sc->config.txpowlimit = 2 * ah->curchan->chan->max_power;
		ath9k_ps_wakeup(sc);
		ath9k_hw_set_txpowerlimit(ah, sc->config.txpowlimit, false);
		sc->curtxpow = ath9k_hw_regulatory(ah)->power_limit;
323
324
325
326
		/* synchronize DFS detector if regulatory domain changed */
		if (sc->dfs_detector != NULL)
			sc->dfs_detector->set_dfs_domain(sc->dfs_detector,
							 request->dfs_region);
327
328
		ath9k_ps_restore(sc);
	}
Sujith's avatar
Sujith committed
329
330
331
332
333
334
335
336
337
}

/*
 *  This function will allocate both the DMA descriptor structure, and the
 *  buffers it contains.  These are used to contain the descriptors used
 *  by the system.
*/
int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
		      struct list_head *head, const char *name,
338
		      int nbuf, int ndesc, bool is_tx)
Sujith's avatar
Sujith committed
339
340
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
341
	u8 *ds;
Sujith's avatar
Sujith committed
342
	struct ath_buf *bf;
343
	int i, bsize, desc_len;
Sujith's avatar
Sujith committed
344

345
	ath_dbg(common, CONFIG, "%s DMA: %u buffers %u desc/buf\n",
346
		name, nbuf, ndesc);
Sujith's avatar
Sujith committed
347
348

	INIT_LIST_HEAD(head);
349
350
351
352
353
354

	if (is_tx)
		desc_len = sc->sc_ah->caps.tx_desc_len;
	else
		desc_len = sizeof(struct ath_desc);

Sujith's avatar
Sujith committed
355
	/* ath_desc must be a multiple of DWORDs */
356
	if ((desc_len % 4) != 0) {
357
		ath_err(common, "ath_desc not DWORD aligned\n");
358
		BUG_ON((desc_len % 4) != 0);
359
		return -ENOMEM;
Sujith's avatar
Sujith committed
360
361
	}

362
	dd->dd_desc_len = desc_len * nbuf * ndesc;
Sujith's avatar
Sujith committed
363
364
365
366
367
368
369
370
371
372
373
374

	/*
	 * Need additional DMA memory because we can't use
	 * descriptors that cross the 4K page boundary. Assume
	 * one skipped descriptor per 4K page.
	 */
	if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_4KB_SPLITTRANS)) {
		u32 ndesc_skipped =
			ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd->dd_desc_len);
		u32 dma_len;

		while (ndesc_skipped) {
375
			dma_len = ndesc_skipped * desc_len;
Sujith's avatar
Sujith committed
376
377
378
			dd->dd_desc_len += dma_len;

			ndesc_skipped = ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len);
379
		}
Sujith's avatar
Sujith committed
380
381
382
	}

	/* allocate descriptors */
383
384
385
386
387
	dd->dd_desc = dmam_alloc_coherent(sc->dev, dd->dd_desc_len,
					  &dd->dd_desc_paddr, GFP_KERNEL);
	if (!dd->dd_desc)
		return -ENOMEM;

388
	ds = (u8 *) dd->dd_desc;
389
	ath_dbg(common, CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
390
391
		name, ds, (u32) dd->dd_desc_len,
		ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
Sujith's avatar
Sujith committed
392
393
394

	/* allocate buffers */
	bsize = sizeof(struct ath_buf) * nbuf;
395
396
397
	bf = devm_kzalloc(sc->dev, bsize, GFP_KERNEL);
	if (!bf)
		return -ENOMEM;
Sujith's avatar
Sujith committed
398

399
	for (i = 0; i < nbuf; i++, bf++, ds += (desc_len * ndesc)) {
Sujith's avatar
Sujith committed
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
		bf->bf_desc = ds;
		bf->bf_daddr = DS2PHYS(dd, ds);

		if (!(sc->sc_ah->caps.hw_caps &
		      ATH9K_HW_CAP_4KB_SPLITTRANS)) {
			/*
			 * Skip descriptor addresses which can cause 4KB
			 * boundary crossing (addr + length) with a 32 dword
			 * descriptor fetch.
			 */
			while (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr)) {
				BUG_ON((caddr_t) bf->bf_desc >=
				       ((caddr_t) dd->dd_desc +
					dd->dd_desc_len));

415
				ds += (desc_len * ndesc);
Sujith's avatar
Sujith committed
416
417
418
419
420
421
422
423
424
				bf->bf_desc = ds;
				bf->bf_daddr = DS2PHYS(dd, ds);
			}
		}
		list_add_tail(&bf->list, head);
	}
	return 0;
}

Sujith's avatar
Sujith committed
425
426
427
428
429
static int ath9k_init_queues(struct ath_softc *sc)
{
	int i = 0;

	sc->beacon.beaconq = ath9k_hw_beaconq_setup(sc->sc_ah);
Sujith's avatar
Sujith committed
430
431
432
433
434
	sc->beacon.cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0);

	sc->config.cabqReadytime = ATH_CABQ_READY_TIME;
	ath_cabq_update(sc);

435
	for (i = 0; i < IEEE80211_NUM_ACS; i++) {
436
		sc->tx.txq_map[i] = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, i);
437
		sc->tx.txq_map[i]->mac80211_qnum = i;
438
		sc->tx.txq_max_pending[i] = ATH_MAX_QDEPTH;
439
	}
Sujith's avatar
Sujith committed
440
441
442
	return 0;
}

443
static int ath9k_init_channels_rates(struct ath_softc *sc)
Sujith's avatar
Sujith committed
444
{
445
446
	void *channels;

447
448
449
450
	BUILD_BUG_ON(ARRAY_SIZE(ath9k_2ghz_chantable) +
		     ARRAY_SIZE(ath9k_5ghz_chantable) !=
		     ATH9K_NUM_CHANNELS);

451
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ) {
452
		channels = devm_kzalloc(sc->dev,
453
454
455
456
			sizeof(ath9k_2ghz_chantable), GFP_KERNEL);
		if (!channels)
		    return -ENOMEM;

457
458
		memcpy(channels, ath9k_2ghz_chantable,
		       sizeof(ath9k_2ghz_chantable));
459
		sc->sbands[IEEE80211_BAND_2GHZ].channels = channels;
Sujith's avatar
Sujith committed
460
461
462
463
464
465
		sc->sbands[IEEE80211_BAND_2GHZ].band = IEEE80211_BAND_2GHZ;
		sc->sbands[IEEE80211_BAND_2GHZ].n_channels =
			ARRAY_SIZE(ath9k_2ghz_chantable);
		sc->sbands[IEEE80211_BAND_2GHZ].bitrates = ath9k_legacy_rates;
		sc->sbands[IEEE80211_BAND_2GHZ].n_bitrates =
			ARRAY_SIZE(ath9k_legacy_rates);
Sujith's avatar
Sujith committed
466
467
	}

468
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ) {
469
		channels = devm_kzalloc(sc->dev,
470
			sizeof(ath9k_5ghz_chantable), GFP_KERNEL);
471
		if (!channels)
472
473
			return -ENOMEM;

474
475
		memcpy(channels, ath9k_5ghz_chantable,
		       sizeof(ath9k_5ghz_chantable));
476
		sc->sbands[IEEE80211_BAND_5GHZ].channels = channels;
Sujith's avatar
Sujith committed
477
478
479
480
481
482
483
484
		sc->sbands[IEEE80211_BAND_5GHZ].band = IEEE80211_BAND_5GHZ;
		sc->sbands[IEEE80211_BAND_5GHZ].n_channels =
			ARRAY_SIZE(ath9k_5ghz_chantable);
		sc->sbands[IEEE80211_BAND_5GHZ].bitrates =
			ath9k_legacy_rates + 4;
		sc->sbands[IEEE80211_BAND_5GHZ].n_bitrates =
			ARRAY_SIZE(ath9k_legacy_rates) - 4;
	}
485
	return 0;
Sujith's avatar
Sujith committed
486
}
Sujith's avatar
Sujith committed
487

Sujith's avatar
Sujith committed
488
489
490
491
static void ath9k_init_misc(struct ath_softc *sc)
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	int i = 0;
492

Sujith's avatar
Sujith committed
493
	setup_timer(&common->ani.timer, ath_ani_calibrate, (unsigned long)sc);
Sujith's avatar
Sujith committed
494

495
	sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
Sujith's avatar
Sujith committed
496
	sc->config.txpowlimit = ATH_TXPOWER_MAX;
497
	memcpy(common->bssidmask, ath_bcast_mac, ETH_ALEN);
Sujith's avatar
Sujith committed
498
	sc->beacon.slottime = ATH9K_SLOT_TIME_9;
Sujith's avatar
Sujith committed
499

500
	for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++)
Sujith's avatar
Sujith committed
501
		sc->beacon.bslot[i] = NULL;
502
503
504

	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
		sc->ant_comb.count = ATH_ANT_DIV_COMB_INIT_COUNT;
505
506
507
508
509
510
511

	sc->spec_config.enabled = 0;
	sc->spec_config.short_repeat = true;
	sc->spec_config.count = 8;
	sc->spec_config.endless = false;
	sc->spec_config.period = 0xFF;
	sc->spec_config.fft_period = 0xF;
Sujith's avatar
Sujith committed
512
}
Sujith's avatar
Sujith committed
513

514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
static void ath9k_eeprom_request_cb(const struct firmware *eeprom_blob,
				    void *ctx)
{
	struct ath9k_eeprom_ctx *ec = ctx;

	if (eeprom_blob)
		ec->ah->eeprom_blob = eeprom_blob;

	complete(&ec->complete);
}

static int ath9k_eeprom_request(struct ath_softc *sc, const char *name)
{
	struct ath9k_eeprom_ctx ec;
	struct ath_hw *ah = ah = sc->sc_ah;
	int err;

	/* try to load the EEPROM content asynchronously */
	init_completion(&ec.complete);
	ec.ah = sc->sc_ah;

	err = request_firmware_nowait(THIS_MODULE, 1, name, sc->dev, GFP_KERNEL,
				      &ec, ath9k_eeprom_request_cb);
	if (err < 0) {
		ath_err(ath9k_hw_common(ah),
			"EEPROM request failed\n");
		return err;
	}

	wait_for_completion(&ec.complete);

	if (!ah->eeprom_blob) {
		ath_err(ath9k_hw_common(ah),
			"Unable to load EEPROM file %s\n", name);
		return -EINVAL;
	}

	return 0;
}

static void ath9k_eeprom_release(struct ath_softc *sc)
{
	release_firmware(sc->sc_ah->eeprom_blob);
}

559
static int ath9k_init_softc(u16 devid, struct ath_softc *sc,
Sujith's avatar
Sujith committed
560
561
			    const struct ath_bus_ops *bus_ops)
{
562
	struct ath9k_platform_data *pdata = sc->dev->platform_data;
Sujith's avatar
Sujith committed
563
564
565
566
	struct ath_hw *ah = NULL;
	struct ath_common *common;
	int ret = 0, i;
	int csz = 0;
Sujith's avatar
Sujith committed
567

568
	ah = devm_kzalloc(sc->dev, sizeof(struct ath_hw), GFP_KERNEL);
Sujith's avatar
Sujith committed
569
570
571
	if (!ah)
		return -ENOMEM;

572
	ah->dev = sc->dev;
Ben Greear's avatar
Ben Greear committed
573
	ah->hw = sc->hw;
Sujith's avatar
Sujith committed
574
	ah->hw_version.devid = devid;
575
576
	ah->reg_ops.read = ath9k_ioread32;
	ah->reg_ops.write = ath9k_iowrite32;
577
	ah->reg_ops.rmw = ath9k_reg_rmw;
578
	atomic_set(&ah->intr_ref_cnt, -1);
Sujith's avatar
Sujith committed
579
580
	sc->sc_ah = ah;

581
	sc->dfs_detector = dfs_pattern_detector_init(ah, NL80211_DFS_UNSET);
582

583
	if (!pdata) {
584
		ah->ah_flags |= AH_USE_EEPROM;
585
586
587
588
589
		sc->sc_ah->led_pin = -1;
	} else {
		sc->sc_ah->gpio_mask = pdata->gpio_mask;
		sc->sc_ah->gpio_val = pdata->gpio_val;
		sc->sc_ah->led_pin = pdata->led_pin;
590
		ah->is_clk_25mhz = pdata->is_clk_25mhz;
591
		ah->get_mac_revision = pdata->get_mac_revision;
592
		ah->external_reset = pdata->external_reset;
593
	}
594

Sujith's avatar
Sujith committed
595
	common = ath9k_hw_common(ah);
596
	common->ops = &ah->reg_ops;
Sujith's avatar
Sujith committed
597
598
599
600
601
	common->bus_ops = bus_ops;
	common->ah = ah;
	common->hw = sc->hw;
	common->priv = sc;
	common->debug_mask = ath9k_debug;
602
	common->btcoex_enabled = ath9k_btcoex_enable == 1;
603
	common->disable_ani = false;
604
605
606
607
608
609
610
611

	/*
	 * Enable Antenna diversity only when BTCOEX is disabled
	 * and the user manually requests the feature.
	 */
	if (!common->btcoex_enabled && ath9k_enable_diversity)
		common->antenna_diversity = 1;

612
	spin_lock_init(&common->cc_lock);
Sujith's avatar
Sujith committed
613
614
615
616
617

	spin_lock_init(&sc->sc_serial_rw);
	spin_lock_init(&sc->sc_pm_lock);
	mutex_init(&sc->mutex);
	tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
618
	tasklet_init(&sc->bcon_tasklet, ath9k_beacon_tasklet,
Sujith's avatar
Sujith committed
619
620
		     (unsigned long)sc);

621
622
623
624
625
626
	INIT_WORK(&sc->hw_reset_work, ath_reset_work);
	INIT_WORK(&sc->hw_check_work, ath_hw_check);
	INIT_WORK(&sc->paprd_work, ath_paprd_calibrate);
	INIT_DELAYED_WORK(&sc->hw_pll_work, ath_hw_pll_work);
	setup_timer(&sc->rx_poll_timer, ath_rx_poll, (unsigned long)sc);

Sujith's avatar
Sujith committed
627
628
629
630
631
632
633
	/*
	 * Cache line size is used to size and align various
	 * structures used to communicate with the hardware.
	 */
	ath_read_cachesize(common, &csz);
	common->cachelsz = csz << 2; /* convert to bytes */

634
	if (pdata && pdata->eeprom_name) {
635
636
		ret = ath9k_eeprom_request(sc, pdata->eeprom_name);
		if (ret)
637
			return ret;
638
639
	}

640
	/* Initializes the hardware for all supported chipsets */
Sujith's avatar
Sujith committed
641
	ret = ath9k_hw_init(ah);
642
	if (ret)
Sujith's avatar
Sujith committed
643
		goto err_hw;
Sujith's avatar
Sujith committed
644

645
646
647
	if (pdata && pdata->macaddr)
		memcpy(common->macaddr, pdata->macaddr, ETH_ALEN);

Sujith's avatar
Sujith committed
648
649
650
651
652
653
654
655
	ret = ath9k_init_queues(sc);
	if (ret)
		goto err_queues;

	ret =  ath9k_init_btcoex(sc);
	if (ret)
		goto err_btcoex;

656
657
658
659
	ret = ath9k_init_channels_rates(sc);
	if (ret)
		goto err_btcoex;

660
	ath9k_cmn_init_crypto(sc->sc_ah);
Sujith's avatar
Sujith committed
661
	ath9k_init_misc(sc);
662
	ath_fill_led_pin(sc);
Sujith's avatar
Sujith committed
663

Sujith Manoharan's avatar
Sujith Manoharan committed
664
665
666
	if (common->bus_ops->aspm_init)
		common->bus_ops->aspm_init(common);

Sujith's avatar
Sujith committed
667
	return 0;
Sujith's avatar
Sujith committed
668
669

err_btcoex:
Sujith's avatar
Sujith committed
670
671
672
	for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
		if (ATH_TXQ_SETUP(sc, i))
			ath_tx_cleanupq(sc, &sc->tx.txq[i]);
Sujith's avatar
Sujith committed
673
674
675
err_queues:
	ath9k_hw_deinit(ah);
err_hw:
676
	ath9k_eeprom_release(sc);
Sujith's avatar
Sujith committed
677
	return ret;
Sujith's avatar
Sujith committed
678
679
}

680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
static void ath9k_init_band_txpower(struct ath_softc *sc, int band)
{
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *chan;
	struct ath_hw *ah = sc->sc_ah;
	int i;

	sband = &sc->sbands[band];
	for (i = 0; i < sband->n_channels; i++) {
		chan = &sband->channels[i];
		ah->curchan = &ah->channels[chan->hw_value];
		ath9k_cmn_update_ichannel(ah->curchan, chan, NL80211_CHAN_HT20);
		ath9k_hw_set_txpowerlimit(ah, MAX_RATE_POWER, true);
	}
}

static void ath9k_init_txpower_limits(struct ath_softc *sc)
{
	struct ath_hw *ah = sc->sc_ah;
	struct ath9k_channel *curchan = ah->curchan;

	if (ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
		ath9k_init_band_txpower(sc, IEEE80211_BAND_2GHZ);
	if (ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
		ath9k_init_band_txpower(sc, IEEE80211_BAND_5GHZ);

	ah->curchan = curchan;
}

709
710
711
712
713
714
715
716
717
718
719
void ath9k_reload_chainmask_settings(struct ath_softc *sc)
{
	if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT))
		return;

	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
		setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_2GHZ].ht_cap);
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
		setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_5GHZ].ht_cap);
}

720
721
722
723
724
725
726
727
728
729
730
731
static const struct ieee80211_iface_limit if_limits[] = {
	{ .max = 2048,	.types = BIT(NL80211_IFTYPE_STATION) |
				 BIT(NL80211_IFTYPE_P2P_CLIENT) |
				 BIT(NL80211_IFTYPE_WDS) },
	{ .max = 8,	.types =
#ifdef CONFIG_MAC80211_MESH
				 BIT(NL80211_IFTYPE_MESH_POINT) |
#endif
				 BIT(NL80211_IFTYPE_AP) |
				 BIT(NL80211_IFTYPE_P2P_GO) },
};

732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753

static const struct ieee80211_iface_limit if_dfs_limits[] = {
	{ .max = 1,	.types = BIT(NL80211_IFTYPE_AP) },
};

static const struct ieee80211_iface_combination if_comb[] = {
	{
		.limits = if_limits,
		.n_limits = ARRAY_SIZE(if_limits),
		.max_interfaces = 2048,
		.num_different_channels = 1,
		.beacon_int_infra_match = true,
	},
	{
		.limits = if_dfs_limits,
		.n_limits = ARRAY_SIZE(if_dfs_limits),
		.max_interfaces = 1,
		.num_different_channels = 1,
		.beacon_int_infra_match = true,
		.radar_detect_widths =	BIT(NL80211_CHAN_NO_HT) |
					BIT(NL80211_CHAN_HT20),
	}
754
};
755

Sujith's avatar
Sujith committed
756
void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
Sujith's avatar
Sujith committed
757
{
758
759
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
Sujith's avatar
Sujith committed
760

Sujith's avatar
Sujith committed
761
762
763
764
765
	hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
		IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
		IEEE80211_HW_SIGNAL_DBM |
		IEEE80211_HW_SUPPORTS_PS |
		IEEE80211_HW_PS_NULLFUNC_STACK |
766
		IEEE80211_HW_SPECTRUM_MGMT |
767
768
		IEEE80211_HW_REPORTS_TX_ACK_STATUS |
		IEEE80211_HW_SUPPORTS_RC_TABLE;
Sujith's avatar
Sujith committed
769

770
771
772
773
774
775
776
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
		hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;

		if (AR_SREV_9280_20_OR_LATER(ah))
			hw->radiotap_mcs_details |=
				IEEE80211_RADIOTAP_MCS_HAVE_STBC;
	}
777

778
	if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || ath9k_modparam_nohwcrypt)
Sujith's avatar
Sujith committed
779
780
		hw->flags |= IEEE80211_HW_MFP_CAPABLE;

781
782
	hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR;

Sujith's avatar
Sujith committed
783
	hw->wiphy->interface_modes =
Johannes Berg's avatar
Johannes Berg committed
784
785
		BIT(NL80211_IFTYPE_P2P_GO) |
		BIT(NL80211_IFTYPE_P2P_CLIENT) |
Sujith's avatar
Sujith committed
786
		BIT(NL80211_IFTYPE_AP) |
787
		BIT(NL80211_IFTYPE_WDS) |
Sujith's avatar
Sujith committed
788
789
790
791
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC) |
		BIT(NL80211_IFTYPE_MESH_POINT);

792
793
	hw->wiphy->iface_combinations = if_comb;
	hw->wiphy->n_iface_combinations = ARRAY_SIZE(if_comb);
794

795
796
	if (AR_SREV_5416(sc->sc_ah))
		hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
Sujith's avatar
Sujith committed
797

Jouni Malinen's avatar
Jouni Malinen committed
798
	hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
799
	hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
800
	hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
Jouni Malinen's avatar
Jouni Malinen committed
801

802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
#ifdef CONFIG_PM_SLEEP

	if ((ah->caps.hw_caps & ATH9K_HW_WOW_DEVICE_CAPABLE) &&
	    device_can_wakeup(sc->dev)) {

		hw->wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
					  WIPHY_WOWLAN_DISCONNECT;
		hw->wiphy->wowlan.n_patterns = MAX_NUM_USER_PATTERN;
		hw->wiphy->wowlan.pattern_min_len = 1;
		hw->wiphy->wowlan.pattern_max_len = MAX_PATTERN_SIZE;

	}

	atomic_set(&sc->wow_sleep_proc_intr, -1);
	atomic_set(&sc->wow_got_bmiss_intr, -1);

#endif

Sujith's avatar
Sujith committed
820
821
822
	hw->queues = 4;
	hw->max_rates = 4;
	hw->channel_change_time = 5000;
823
	hw->max_listen_interval = 1;
824
	hw->max_rate_tries = 10;
Sujith's avatar
Sujith committed
825
826
827
	hw->sta_data_size = sizeof(struct ath_node);
	hw->vif_data_size = sizeof(struct ath_vif);

828
829
830
831
832
833
834
835
836
837
	hw->wiphy->available_antennas_rx = BIT(ah->caps.max_rxchains) - 1;
	hw->wiphy->available_antennas_tx = BIT(ah->caps.max_txchains) - 1;

	/* single chain devices with rx diversity */
	if (ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
		hw->wiphy->available_antennas_rx = BIT(0) | BIT(1);

	sc->ant_rx = hw->wiphy->available_antennas_rx;
	sc->ant_tx = hw->wiphy->available_antennas_tx;

838
#ifdef CONFIG_ATH9K_RATE_CONTROL
Sujith's avatar
Sujith committed
839
	hw->rate_control_algorithm = "ath9k_rate_control";
840
#endif
Sujith's avatar
Sujith committed
841

842
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
Sujith's avatar
Sujith committed
843
844
		hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&sc->sbands[IEEE80211_BAND_2GHZ];
845
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
Sujith's avatar
Sujith committed
846
847
		hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&sc->sbands[IEEE80211_BAND_5GHZ];
Sujith's avatar
Sujith committed
848

849
	ath9k_reload_chainmask_settings(sc);
Sujith's avatar
Sujith committed
850
851

	SET_IEEE80211_PERM_ADDR(hw, common->macaddr);
Sujith's avatar
Sujith committed
852
853
}

854
int ath9k_init_device(u16 devid, struct ath_softc *sc,
Sujith's avatar
Sujith committed
855
856
857
858
859
		    const struct ath_bus_ops *bus_ops)
{
	struct ieee80211_hw *hw = sc->hw;
	struct ath_common *common;
	struct ath_hw *ah;
Sujith's avatar
Sujith committed
860
	int error = 0;
Sujith's avatar
Sujith committed
861
862
	struct ath_regulatory *reg;

Sujith's avatar
Sujith committed
863
	/* Bring up device */
864
	error = ath9k_init_softc(devid, sc, bus_ops);
865
866
	if (error)
		return error;
Sujith's avatar
Sujith committed
867
868
869

	ah = sc->sc_ah;
	common = ath9k_hw_common(ah);
Sujith's avatar
Sujith committed
870
	ath9k_set_hw_capab(sc, hw);
Sujith's avatar
Sujith committed
871

Sujith's avatar
Sujith committed
872
	/* Initialize regulatory */
Sujith's avatar
Sujith committed
873
874
875
	error = ath_regd_init(&common->regulatory, sc->hw->wiphy,
			      ath9k_reg_notifier);
	if (error)
876
		goto deinit;
Sujith's avatar
Sujith committed
877
878
879

	reg = &common->regulatory;

Sujith's avatar
Sujith committed
880
	/* Setup TX DMA */
Sujith's avatar
Sujith committed
881
882
	error = ath_tx_init(sc, ATH_TXBUF);
	if (error != 0)
883
		goto deinit;
Sujith's avatar
Sujith committed
884

Sujith's avatar
Sujith committed
885
	/* Setup RX DMA */
Sujith's avatar
Sujith committed
886
887
	error = ath_rx_init(sc, ATH_RXBUF);
	if (error != 0)
888
		goto deinit;
Sujith's avatar
Sujith committed
889

890
891
	ath9k_init_txpower_limits(sc);

892
893
894
895
896
897
898
#ifdef CONFIG_MAC80211_LEDS
	/* must be initialized before ieee80211_register_hw */
	sc->led_cdev.default_trigger = ieee80211_create_tpt_led_trigger(sc->hw,
		IEEE80211_TPT_LEDTRIG_FL_RADIO, ath9k_tpt_blink,
		ARRAY_SIZE(ath9k_tpt_blink));
#endif

Sujith's avatar
Sujith committed
899
	/* Register with mac80211 */
Sujith's avatar
Sujith committed
900
	error = ieee80211_register_hw(hw);
Sujith's avatar
Sujith committed
901
	if (error)
902
		goto rx_cleanup;
Sujith's avatar
Sujith committed
903

904
905
	error = ath9k_init_debug(ah);
	if (error) {
906
		ath_err(common, "Unable to create debugfs files\n");
907
		goto unregister;
908
909
	}

Sujith's avatar
Sujith committed
910
	/* Handle world regulatory */
Sujith's avatar
Sujith committed
911
912
913
	if (!ath_is_world_regd(reg)) {
		error = regulatory_hint(hw->wiphy, reg->alpha2);
		if (error)
914
			goto unregister;
Sujith's avatar
Sujith committed
915
916
	}

Sujith's avatar
Sujith committed
917
	ath_init_leds(sc);
Sujith's avatar
Sujith committed
918
919
920
921
	ath_start_rfkill_poll(sc);

	return 0;

922
unregister:
Sujith's avatar
Sujith committed
923
	ieee80211_unregister_hw(hw);
924
rx_cleanup:
Sujith's avatar
Sujith committed
925
	ath_rx_cleanup(sc);
926
deinit:
Sujith's avatar
Sujith committed
927
	ath9k_deinit_softc(sc);
Sujith's avatar
Sujith committed
928
929
930
931
932
933
934
	return error;
}

/*****************************/
/*     De-Initialization     */
/*****************************/

Sujith's avatar
Sujith committed
935
static void ath9k_deinit_softc(struct ath_softc *sc)
Sujith's avatar
Sujith committed
936
{
Sujith's avatar
Sujith committed
937
	int i = 0;
Sujith's avatar
Sujith committed
938

939
	ath9k_deinit_btcoex(sc);
940

Sujith's avatar
Sujith committed
941
942
943
944
945
	for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
		if (ATH_TXQ_SETUP(sc, i))
			ath_tx_cleanupq(sc, &sc->tx.txq[i]);

	ath9k_hw_deinit(sc->sc_ah);
946
947
	if (sc->dfs_detector != NULL)
		sc->dfs_detector->exit(sc->dfs_detector);
Sujith's avatar
Sujith committed
948

949
	ath9k_eeprom_release(sc);
950

951
	if (config_enabled(CONFIG_ATH9K_DEBUGFS) && sc->rfs_chan_spec_scan) {
952
953
954
		relay_close(sc->rfs_chan_spec_scan);
		sc->rfs_chan_spec_scan = NULL;
	}
Sujith's avatar
Sujith committed
955
956
}

Sujith's avatar
Sujith committed
957
void ath9k_deinit_device(struct ath_softc *sc)
Sujith's avatar
Sujith committed
958
959
960
961
962
963
{
	struct ieee80211_hw *hw = sc->hw;

	ath9k_ps_wakeup(sc);

	wiphy_rfkill_stop_polling(sc->hw->wiphy);
Sujith's avatar
Sujith committed
964
	ath_deinit_leds(sc);
Sujith's avatar
Sujith committed
965

966
967
	ath9k_ps_restore(sc);

Sujith's avatar
Sujith committed
968
969
	ieee80211_unregister_hw(hw);
	ath_rx_cleanup(sc);
Sujith's avatar
Sujith committed
970
	ath9k_deinit_softc(sc);
Sujith's avatar
Sujith committed
971
972
973
974
975
976
977
978
979
980
981
982
983
}

/************************/
/*     Module Hooks     */
/************************/

static int __init ath9k_init(void)
{
	int error;

	/* Register rate control algorithm */
	error = ath_rate_control_register();
	if (error != 0) {
984
985
		pr_err("Unable to register rate control algorithm: %d\n",
		       error);
Sujith's avatar
Sujith committed
986
987
988
989
990
		goto err_out;
	}

	error = ath_pci_init();
	if (error < 0) {
991
		pr_err("No PCI devices found, driver not installed\n");
Sujith's avatar
Sujith committed
992
		error = -ENODEV;
993
		goto err_rate_unregister;
Sujith's avatar
Sujith committed
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
	}

	error = ath_ahb_init();
	if (error < 0) {
		error = -ENODEV;
		goto err_pci_exit;
	}

	return 0;

 err_pci_exit:
	ath_pci_exit();

 err_rate_unregister:
	ath_rate_control_unregister();
 err_out:
	return error;
}
module_init(ath9k_init);

static void __exit ath9k_exit(void)
{
1016
	is_ath9k_unloaded = true;
Sujith's avatar
Sujith committed
1017
1018
1019
	ath_ahb_exit();
	ath_pci_exit();
	ath_rate_control_unregister();
1020
	pr_info("%s: Driver unloaded\n", dev_info);
Sujith's avatar
Sujith committed
1021
1022
}
module_exit(ath9k_exit);