init.c 25.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
#include <linux/dma-mapping.h>
18
#include <linux/slab.h>
19
#include <linux/ath9k_platform.h>
20
#include <linux/module.h>
21

Sujith's avatar
Sujith committed
22
23
24
25
26
27
28
29
30
31
32
33
34
#include "ath9k.h"

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");

35
36
int ath9k_modparam_nohwcrypt;
module_param_named(nohwcrypt, ath9k_modparam_nohwcrypt, int, 0444);
Sujith's avatar
Sujith committed
37
38
MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption");

39
int led_blink;
40
41
42
module_param_named(blink, led_blink, int, 0444);
MODULE_PARM_DESC(blink, "Enable LED blink on activity");

43
44
45
46
static int ath9k_btcoex_enable;
module_param_named(btcoex_enable, ath9k_btcoex_enable, int, 0444);
MODULE_PARM_DESC(btcoex_enable, "Enable wifi-BT coexistence");

47
bool is_ath9k_unloaded;
Sujith's avatar
Sujith committed
48
49
50
/* We use the hw_value as an index into our private channel structure */

#define CHAN2G(_freq, _idx)  { \
51
	.band = IEEE80211_BAND_2GHZ, \
Sujith's avatar
Sujith committed
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
	.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 */
68
static const struct ieee80211_channel ath9k_2ghz_chantable[] = {
Sujith's avatar
Sujith committed
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
	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 */
89
static const struct ieee80211_channel ath9k_5ghz_chantable[] = {
Sujith's avatar
Sujith committed
90
91
92
93
94
95
96
97
98
99
100
101
102
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
	/* _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),
};

146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#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
161
static void ath9k_deinit_softc(struct ath_softc *sc);
Sujith's avatar
Sujith committed
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

/*
 * 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;

	if (ah->config.serialize_regmode == SER_REG_MODE_ON) {
		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;

	if (ah->config.serialize_regmode == SER_REG_MODE_ON) {
		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;
}

201
202
203
204
205
206
207
208
209
210
211
212
213
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;
}

214
215
216
217
218
219
220
221
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;

222
	if (ah->config.serialize_regmode == SER_REG_MODE_ON) {
223
		spin_lock_irqsave(&sc->sc_serial_rw, flags);
224
		val = __ath9k_reg_rmw(sc, reg_offset, set, clr);
225
		spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
226
227
	} else
		val = __ath9k_reg_rmw(sc, reg_offset, set, clr);
228
229
230
231

	return val;
}

Sujith's avatar
Sujith committed
232
233
234
235
236
237
238
/**************************/
/*     Initialization     */
/**************************/

static void setup_ht_cap(struct ath_softc *sc,
			 struct ieee80211_sta_ht_cap *ht_info)
{
239
240
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
Sujith's avatar
Sujith committed
241
	u8 tx_streams, rx_streams;
242
	int i, max_streams;
Sujith's avatar
Sujith committed
243
244
245
246
247
248
249

	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
250
251
252
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_LDPC)
		ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;

253
254
255
	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
256
257
258
	ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
	ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;

259
	if (AR_SREV_9330(ah) || AR_SREV_9485(ah))
260
		max_streams = 1;
261
262
	else if (AR_SREV_9462(ah))
		max_streams = 2;
263
	else if (AR_SREV_9300_20_OR_LATER(ah))
264
265
266
267
		max_streams = 3;
	else
		max_streams = 2;

268
	if (AR_SREV_9280_20_OR_LATER(ah)) {
269
270
271
272
273
		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
274
275
	/* set up supported mcs set */
	memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
276
277
	tx_streams = ath9k_cmn_count_streams(ah->txchainmask, max_streams);
	rx_streams = ath9k_cmn_count_streams(ah->rxchainmask, max_streams);
278

279
	ath_dbg(common, CONFIG, "TX streams %d, RX streams: %d\n",
280
		tx_streams, rx_streams);
Sujith's avatar
Sujith committed
281
282
283
284
285
286
287

	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);
	}

288
289
	for (i = 0; i < rx_streams; i++)
		ht_info->mcs.rx_mask[i] = 0xff;
Sujith's avatar
Sujith committed
290
291
292
293
294
295
296
297

	ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
}

static int ath9k_reg_notifier(struct wiphy *wiphy,
			      struct regulatory_request *request)
{
	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
298
	struct ath_softc *sc = hw->priv;
299
300
301
302
303
304
305
306
307
308
309
310
311
312
	struct ath_hw *ah = sc->sc_ah;
	struct ath_regulatory *reg = ath9k_hw_regulatory(ah);
	int ret;

	ret = ath_reg_notifier_apply(wiphy, request, reg);

	/* 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;
		ath9k_ps_restore(sc);
	}
Sujith's avatar
Sujith committed
313

314
	return ret;
Sujith's avatar
Sujith committed
315
316
317
318
319
320
321
322
323
}

/*
 *  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,
324
		      int nbuf, int ndesc, bool is_tx)
Sujith's avatar
Sujith committed
325
326
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
327
	u8 *ds;
Sujith's avatar
Sujith committed
328
	struct ath_buf *bf;
329
	int i, bsize, error, desc_len;
Sujith's avatar
Sujith committed
330

331
	ath_dbg(common, CONFIG, "%s DMA: %u buffers %u desc/buf\n",
332
		name, nbuf, ndesc);
Sujith's avatar
Sujith committed
333
334

	INIT_LIST_HEAD(head);
335
336
337
338
339
340

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

Sujith's avatar
Sujith committed
341
	/* ath_desc must be a multiple of DWORDs */
342
	if ((desc_len % 4) != 0) {
343
		ath_err(common, "ath_desc not DWORD aligned\n");
344
		BUG_ON((desc_len % 4) != 0);
Sujith's avatar
Sujith committed
345
346
347
348
		error = -ENOMEM;
		goto fail;
	}

349
	dd->dd_desc_len = desc_len * nbuf * ndesc;
Sujith's avatar
Sujith committed
350
351
352
353
354
355
356
357
358
359
360
361

	/*
	 * 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) {
362
			dma_len = ndesc_skipped * desc_len;
Sujith's avatar
Sujith committed
363
364
365
			dd->dd_desc_len += dma_len;

			ndesc_skipped = ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len);
366
		}
Sujith's avatar
Sujith committed
367
368
369
370
371
372
373
374
375
	}

	/* allocate descriptors */
	dd->dd_desc = dma_alloc_coherent(sc->dev, dd->dd_desc_len,
					 &dd->dd_desc_paddr, GFP_KERNEL);
	if (dd->dd_desc == NULL) {
		error = -ENOMEM;
		goto fail;
	}
376
	ds = (u8 *) dd->dd_desc;
377
	ath_dbg(common, CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
378
379
		name, ds, (u32) dd->dd_desc_len,
		ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
Sujith's avatar
Sujith committed
380
381
382
383
384
385
386
387
388
389

	/* allocate buffers */
	bsize = sizeof(struct ath_buf) * nbuf;
	bf = kzalloc(bsize, GFP_KERNEL);
	if (bf == NULL) {
		error = -ENOMEM;
		goto fail2;
	}
	dd->dd_bufptr = bf;

390
	for (i = 0; i < nbuf; i++, bf++, ds += (desc_len * ndesc)) {
Sujith's avatar
Sujith committed
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
		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));

406
				ds += (desc_len * ndesc);
Sujith's avatar
Sujith committed
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
				bf->bf_desc = ds;
				bf->bf_daddr = DS2PHYS(dd, ds);
			}
		}
		list_add_tail(&bf->list, head);
	}
	return 0;
fail2:
	dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
			  dd->dd_desc_paddr);
fail:
	memset(dd, 0, sizeof(*dd));
	return error;
}

Sujith's avatar
Sujith committed
422
423
static int ath9k_init_btcoex(struct ath_softc *sc)
{
424
	struct ath_txq *txq;
425
	struct ath_hw *ah = sc->sc_ah;
426
	int r;
Sujith's avatar
Sujith committed
427

428
	switch (ath9k_hw_get_btcoex_scheme(sc->sc_ah)) {
Sujith's avatar
Sujith committed
429
430
431
432
433
434
435
436
437
438
	case ATH_BTCOEX_CFG_NONE:
		break;
	case ATH_BTCOEX_CFG_2WIRE:
		ath9k_hw_btcoex_init_2wire(sc->sc_ah);
		break;
	case ATH_BTCOEX_CFG_3WIRE:
		ath9k_hw_btcoex_init_3wire(sc->sc_ah);
		r = ath_init_btcoex_timer(sc);
		if (r)
			return -1;
439
440
		txq = sc->tx.txq_map[WME_AC_BE];
		ath9k_hw_init_btcoex_hw(sc->sc_ah, txq->axq_qnum);
441
442
443
		sc->btcoex.bt_stomp_type = ATH_BTCOEX_STOMP_LOW;
		break;
	case ATH_BTCOEX_CFG_MCI:
Sujith's avatar
Sujith committed
444
		sc->btcoex.bt_stomp_type = ATH_BTCOEX_STOMP_LOW;
445
446
		sc->btcoex.duty_cycle = ATH_BTCOEX_DEF_DUTY_CYCLE;
		INIT_LIST_HEAD(&sc->btcoex.mci.info);
447
448
449
450
451

		r = ath_mci_setup(sc);
		if (r)
			return r;

452
453
		ath9k_hw_btcoex_init_mci(ah);

Sujith's avatar
Sujith committed
454
455
456
457
458
459
460
461
462
463
464
465
466
467
		break;
	default:
		WARN_ON(1);
		break;
	}

	return 0;
}

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
468
469
470
471
472
	sc->beacon.cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0);

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

473
	for (i = 0; i < WME_NUM_AC; i++) {
474
		sc->tx.txq_map[i] = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, i);
475
476
		sc->tx.txq_map[i]->mac80211_qnum = i;
	}
Sujith's avatar
Sujith committed
477
478
479
	return 0;
}

480
static int ath9k_init_channels_rates(struct ath_softc *sc)
Sujith's avatar
Sujith committed
481
{
482
483
	void *channels;

484
485
486
487
	BUILD_BUG_ON(ARRAY_SIZE(ath9k_2ghz_chantable) +
		     ARRAY_SIZE(ath9k_5ghz_chantable) !=
		     ATH9K_NUM_CHANNELS);

488
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ) {
489
490
491
492
493
494
		channels = kmemdup(ath9k_2ghz_chantable,
			sizeof(ath9k_2ghz_chantable), GFP_KERNEL);
		if (!channels)
		    return -ENOMEM;

		sc->sbands[IEEE80211_BAND_2GHZ].channels = channels;
Sujith's avatar
Sujith committed
495
496
497
498
499
500
		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
501
502
	}

503
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ) {
504
505
506
507
508
509
510
511
512
		channels = kmemdup(ath9k_5ghz_chantable,
			sizeof(ath9k_5ghz_chantable), GFP_KERNEL);
		if (!channels) {
			if (sc->sbands[IEEE80211_BAND_2GHZ].channels)
				kfree(sc->sbands[IEEE80211_BAND_2GHZ].channels);
			return -ENOMEM;
		}

		sc->sbands[IEEE80211_BAND_5GHZ].channels = channels;
Sujith's avatar
Sujith committed
513
514
515
516
517
518
519
520
		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;
	}
521
	return 0;
Sujith's avatar
Sujith committed
522
}
Sujith's avatar
Sujith committed
523

Sujith's avatar
Sujith committed
524
525
526
527
528
static void ath9k_init_misc(struct ath_softc *sc)
{
	struct ath_common *common = ath9k_hw_common(sc->sc_ah);
	int i = 0;
	setup_timer(&common->ani.timer, ath_ani_calibrate, (unsigned long)sc);
Sujith's avatar
Sujith committed
529
530
531

	sc->config.txpowlimit = ATH_TXPOWER_MAX;

Sujith's avatar
Sujith committed
532
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
Sujith's avatar
Sujith committed
533
534
535
536
		sc->sc_flags |= SC_OP_TXAGGR;
		sc->sc_flags |= SC_OP_RXAGGR;
	}

Sujith's avatar
Sujith committed
537
	sc->rx.defant = ath9k_hw_getdefantenna(sc->sc_ah);
Sujith's avatar
Sujith committed
538

539
	memcpy(common->bssidmask, ath_bcast_mac, ETH_ALEN);
Sujith's avatar
Sujith committed
540

Sujith's avatar
Sujith committed
541
	sc->beacon.slottime = ATH9K_SLOT_TIME_9;
Sujith's avatar
Sujith committed
542

543
	for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++)
Sujith's avatar
Sujith committed
544
		sc->beacon.bslot[i] = NULL;
545
546
547

	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
		sc->ant_comb.count = ATH_ANT_DIV_COMB_INIT_COUNT;
Sujith's avatar
Sujith committed
548
}
Sujith's avatar
Sujith committed
549

550
static int ath9k_init_softc(u16 devid, struct ath_softc *sc,
Sujith's avatar
Sujith committed
551
552
			    const struct ath_bus_ops *bus_ops)
{
553
	struct ath9k_platform_data *pdata = sc->dev->platform_data;
Sujith's avatar
Sujith committed
554
555
556
557
	struct ath_hw *ah = NULL;
	struct ath_common *common;
	int ret = 0, i;
	int csz = 0;
Sujith's avatar
Sujith committed
558

Sujith's avatar
Sujith committed
559
560
561
562
	ah = kzalloc(sizeof(struct ath_hw), GFP_KERNEL);
	if (!ah)
		return -ENOMEM;

Ben Greear's avatar
Ben Greear committed
563
	ah->hw = sc->hw;
Sujith's avatar
Sujith committed
564
	ah->hw_version.devid = devid;
565
566
	ah->reg_ops.read = ath9k_ioread32;
	ah->reg_ops.write = ath9k_iowrite32;
567
	ah->reg_ops.rmw = ath9k_reg_rmw;
568
	atomic_set(&ah->intr_ref_cnt, -1);
Sujith's avatar
Sujith committed
569
570
	sc->sc_ah = ah;

571
	if (!pdata) {
572
		ah->ah_flags |= AH_USE_EEPROM;
573
574
575
576
577
		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;
578
		ah->is_clk_25mhz = pdata->is_clk_25mhz;
579
		ah->get_mac_revision = pdata->get_mac_revision;
580
		ah->external_reset = pdata->external_reset;
581
	}
582

Sujith's avatar
Sujith committed
583
	common = ath9k_hw_common(ah);
584
	common->ops = &ah->reg_ops;
Sujith's avatar
Sujith committed
585
586
587
588
589
	common->bus_ops = bus_ops;
	common->ah = ah;
	common->hw = sc->hw;
	common->priv = sc;
	common->debug_mask = ath9k_debug;
590
	common->btcoex_enabled = ath9k_btcoex_enable == 1;
591
	common->disable_ani = false;
592
	spin_lock_init(&common->cc_lock);
Sujith's avatar
Sujith committed
593
594
595
596

	spin_lock_init(&sc->sc_serial_rw);
	spin_lock_init(&sc->sc_pm_lock);
	mutex_init(&sc->mutex);
597
598
#ifdef CONFIG_ATH9K_DEBUGFS
	spin_lock_init(&sc->nodes_lock);
599
	spin_lock_init(&sc->debug.samp_lock);
600
601
	INIT_LIST_HEAD(&sc->nodes);
#endif
Sujith's avatar
Sujith committed
602
603
604
605
606
607
608
609
610
611
612
	tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
	tasklet_init(&sc->bcon_tasklet, ath_beacon_tasklet,
		     (unsigned long)sc);

	/*
	 * 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 */

613
	/* Initializes the hardware for all supported chipsets */
Sujith's avatar
Sujith committed
614
	ret = ath9k_hw_init(ah);
615
	if (ret)
Sujith's avatar
Sujith committed
616
		goto err_hw;
Sujith's avatar
Sujith committed
617

618
619
620
	if (pdata && pdata->macaddr)
		memcpy(common->macaddr, pdata->macaddr, ETH_ALEN);

Sujith's avatar
Sujith committed
621
622
623
624
625
626
627
628
	ret = ath9k_init_queues(sc);
	if (ret)
		goto err_queues;

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

629
630
631
632
	ret = ath9k_init_channels_rates(sc);
	if (ret)
		goto err_btcoex;

633
	ath9k_cmn_init_crypto(sc->sc_ah);
Sujith's avatar
Sujith committed
634
635
	ath9k_init_misc(sc);

Sujith's avatar
Sujith committed
636
	return 0;
Sujith's avatar
Sujith committed
637
638

err_btcoex:
Sujith's avatar
Sujith committed
639
640
641
	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
642
643
644
err_queues:
	ath9k_hw_deinit(ah);
err_hw:
Sujith's avatar
Sujith committed
645

Sujith's avatar
Sujith committed
646
647
648
649
	kfree(ah);
	sc->sc_ah = NULL;

	return ret;
Sujith's avatar
Sujith committed
650
651
}

652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
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;
}

681
682
683
684
685
686
687
688
689
690
691
692
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);
}


Sujith's avatar
Sujith committed
693
void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
Sujith's avatar
Sujith committed
694
{
695
696
	struct ath_hw *ah = sc->sc_ah;
	struct ath_common *common = ath9k_hw_common(ah);
Sujith's avatar
Sujith committed
697

Sujith's avatar
Sujith committed
698
699
700
701
702
	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 |
703
		IEEE80211_HW_SPECTRUM_MGMT |
704
		IEEE80211_HW_REPORTS_TX_ACK_STATUS;
Sujith's avatar
Sujith committed
705

706
707
708
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
		 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;

709
	if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || ath9k_modparam_nohwcrypt)
Sujith's avatar
Sujith committed
710
711
712
		hw->flags |= IEEE80211_HW_MFP_CAPABLE;

	hw->wiphy->interface_modes =
Johannes Berg's avatar
Johannes Berg committed
713
714
		BIT(NL80211_IFTYPE_P2P_GO) |
		BIT(NL80211_IFTYPE_P2P_CLIENT) |
Sujith's avatar
Sujith committed
715
		BIT(NL80211_IFTYPE_AP) |
716
		BIT(NL80211_IFTYPE_WDS) |
Sujith's avatar
Sujith committed
717
718
719
720
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC) |
		BIT(NL80211_IFTYPE_MESH_POINT);

721
722
	if (AR_SREV_5416(sc->sc_ah))
		hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
Sujith's avatar
Sujith committed
723

Jouni Malinen's avatar
Jouni Malinen committed
724
	hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
725
	hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
Jouni Malinen's avatar
Jouni Malinen committed
726

Sujith's avatar
Sujith committed
727
728
729
730
	hw->queues = 4;
	hw->max_rates = 4;
	hw->channel_change_time = 5000;
	hw->max_listen_interval = 10;
731
	hw->max_rate_tries = 10;
Sujith's avatar
Sujith committed
732
733
734
	hw->sta_data_size = sizeof(struct ath_node);
	hw->vif_data_size = sizeof(struct ath_vif);

735
736
737
738
739
740
741
742
743
744
	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;

745
#ifdef CONFIG_ATH9K_RATE_CONTROL
Sujith's avatar
Sujith committed
746
	hw->rate_control_algorithm = "ath9k_rate_control";
747
#endif
Sujith's avatar
Sujith committed
748

749
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
Sujith's avatar
Sujith committed
750
751
		hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&sc->sbands[IEEE80211_BAND_2GHZ];
752
	if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
Sujith's avatar
Sujith committed
753
754
		hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&sc->sbands[IEEE80211_BAND_5GHZ];
Sujith's avatar
Sujith committed
755

756
	ath9k_reload_chainmask_settings(sc);
Sujith's avatar
Sujith committed
757
758

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

761
int ath9k_init_device(u16 devid, struct ath_softc *sc,
Sujith's avatar
Sujith committed
762
763
764
765
766
		    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
767
	int error = 0;
Sujith's avatar
Sujith committed
768
769
	struct ath_regulatory *reg;

Sujith's avatar
Sujith committed
770
	/* Bring up device */
771
	error = ath9k_init_softc(devid, sc, bus_ops);
Sujith's avatar
Sujith committed
772
	if (error != 0)
Sujith's avatar
Sujith committed
773
		goto error_init;
Sujith's avatar
Sujith committed
774
775
776

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

Sujith's avatar
Sujith committed
779
	/* Initialize regulatory */
Sujith's avatar
Sujith committed
780
781
782
	error = ath_regd_init(&common->regulatory, sc->hw->wiphy,
			      ath9k_reg_notifier);
	if (error)
Sujith's avatar
Sujith committed
783
		goto error_regd;
Sujith's avatar
Sujith committed
784
785
786

	reg = &common->regulatory;

Sujith's avatar
Sujith committed
787
	/* Setup TX DMA */
Sujith's avatar
Sujith committed
788
789
	error = ath_tx_init(sc, ATH_TXBUF);
	if (error != 0)
Sujith's avatar
Sujith committed
790
		goto error_tx;
Sujith's avatar
Sujith committed
791

Sujith's avatar
Sujith committed
792
	/* Setup RX DMA */
Sujith's avatar
Sujith committed
793
794
	error = ath_rx_init(sc, ATH_RXBUF);
	if (error != 0)
Sujith's avatar
Sujith committed
795
		goto error_rx;
Sujith's avatar
Sujith committed
796

797
798
	ath9k_init_txpower_limits(sc);

799
800
801
802
803
804
805
#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

806
807
808
809
810
	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);

Sujith's avatar
Sujith committed
811
	/* Register with mac80211 */
Sujith's avatar
Sujith committed
812
	error = ieee80211_register_hw(hw);
Sujith's avatar
Sujith committed
813
814
	if (error)
		goto error_register;
Sujith's avatar
Sujith committed
815

816
817
	error = ath9k_init_debug(ah);
	if (error) {
818
		ath_err(common, "Unable to create debugfs files\n");
819
820
821
		goto error_world;
	}

Sujith's avatar
Sujith committed
822
	/* Handle world regulatory */
Sujith's avatar
Sujith committed
823
824
825
	if (!ath_is_world_regd(reg)) {
		error = regulatory_hint(hw->wiphy, reg->alpha2);
		if (error)
Sujith's avatar
Sujith committed
826
			goto error_world;
Sujith's avatar
Sujith committed
827
828
	}

829
	sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
Sujith's avatar
Sujith committed
830

Sujith's avatar
Sujith committed
831
	ath_init_leds(sc);
Sujith's avatar
Sujith committed
832
833
834
835
	ath_start_rfkill_poll(sc);

	return 0;

Sujith's avatar
Sujith committed
836
837
838
839
840
841
842
843
844
845
846
error_world:
	ieee80211_unregister_hw(hw);
error_register:
	ath_rx_cleanup(sc);
error_rx:
	ath_tx_cleanup(sc);
error_tx:
	/* Nothing */
error_regd:
	ath9k_deinit_softc(sc);
error_init:
Sujith's avatar
Sujith committed
847
848
849
850
851
852
853
	return error;
}

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

Sujith's avatar
Sujith committed
854
static void ath9k_deinit_softc(struct ath_softc *sc)
Sujith's avatar
Sujith committed
855
{
Sujith's avatar
Sujith committed
856
	int i = 0;
Sujith's avatar
Sujith committed
857

858
859
860
861
862
863
	if (sc->sbands[IEEE80211_BAND_2GHZ].channels)
		kfree(sc->sbands[IEEE80211_BAND_2GHZ].channels);

	if (sc->sbands[IEEE80211_BAND_5GHZ].channels)
		kfree(sc->sbands[IEEE80211_BAND_5GHZ].channels);

Sujith's avatar
Sujith committed
864
        if ((sc->btcoex.no_stomp_timer) &&
865
	    ath9k_hw_get_btcoex_scheme(sc->sc_ah) == ATH_BTCOEX_CFG_3WIRE)
Sujith's avatar
Sujith committed
866
		ath_gen_timer_free(sc->sc_ah, sc->btcoex.no_stomp_timer);
Sujith's avatar
Sujith committed
867

868
	if (ath9k_hw_get_btcoex_scheme(sc->sc_ah) == ATH_BTCOEX_CFG_MCI)
869
870
		ath_mci_cleanup(sc);

Sujith's avatar
Sujith committed
871
872
873
874
875
876
	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);

Sujith's avatar
Sujith committed
877
878
	kfree(sc->sc_ah);
	sc->sc_ah = NULL;
Sujith's avatar
Sujith committed
879
880
}

Sujith's avatar
Sujith committed
881
void ath9k_deinit_device(struct ath_softc *sc)
Sujith's avatar
Sujith committed
882
883
884
885
886
887
{
	struct ieee80211_hw *hw = sc->hw;

	ath9k_ps_wakeup(sc);

	wiphy_rfkill_stop_polling(sc->hw->wiphy);
Sujith's avatar
Sujith committed
888
	ath_deinit_leds(sc);
Sujith's avatar
Sujith committed
889

890
891
	ath9k_ps_restore(sc);

Sujith's avatar
Sujith committed
892
893
894
	ieee80211_unregister_hw(hw);
	ath_rx_cleanup(sc);
	ath_tx_cleanup(sc);
Sujith's avatar
Sujith committed
895
	ath9k_deinit_softc(sc);
Sujith's avatar
Sujith committed
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
}

void ath_descdma_cleanup(struct ath_softc *sc,
			 struct ath_descdma *dd,
			 struct list_head *head)
{
	dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
			  dd->dd_desc_paddr);

	INIT_LIST_HEAD(head);
	kfree(dd->dd_bufptr);
	memset(dd, 0, sizeof(*dd));
}

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

static int __init ath9k_init(void)
{
	int error;

	/* Register rate control algorithm */
	error = ath_rate_control_register();
	if (error != 0) {
		printk(KERN_ERR
			"ath9k: Unable to register rate control "
			"algorithm: %d\n",
			error);
		goto err_out;
	}

	error = ath_pci_init();
	if (error < 0) {
		printk(KERN_ERR
			"ath9k: No PCI devices found, driver not installed.\n");
		error = -ENODEV;
933
		goto err_rate_unregister;
Sujith's avatar
Sujith committed
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
	}

	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)
{
956
	is_ath9k_unloaded = true;
Sujith's avatar
Sujith committed
957
958
959
960
961
962
	ath_ahb_exit();
	ath_pci_exit();
	ath_rate_control_unregister();
	printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
}
module_exit(ath9k_exit);