1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18
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
26#include "ath9k.h"
27
28struct ath9k_eeprom_ctx {
29 struct completion complete;
30 struct ath_hw *ah;
31};
32
33static char *dev_info = "ath9k";
34
35MODULE_AUTHOR("Atheros Communications");
36MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
37MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
38MODULE_LICENSE("Dual BSD/GPL");
39
40static unsigned int ath9k_debug = ATH_DBG_DEFAULT;
41module_param_named(debug, ath9k_debug, uint, 0);
42MODULE_PARM_DESC(debug, "Debugging mask");
43
44int ath9k_modparam_nohwcrypt;
45module_param_named(nohwcrypt, ath9k_modparam_nohwcrypt, int, 0444);
46MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption");
47
48int led_blink;
49module_param_named(blink, led_blink, int, 0444);
50MODULE_PARM_DESC(blink, "Enable LED blink on activity");
51
52static int ath9k_btcoex_enable;
53module_param_named(btcoex_enable, ath9k_btcoex_enable, int, 0444);
54MODULE_PARM_DESC(btcoex_enable, "Enable wifi-BT coexistence");
55
56static int ath9k_enable_diversity;
57module_param_named(enable_diversity, ath9k_enable_diversity, int, 0444);
58MODULE_PARM_DESC(enable_diversity, "Enable Antenna diversity for AR9565");
59
60bool is_ath9k_unloaded;
61
62
63#define CHAN2G(_freq, _idx) { \
64 .band = IEEE80211_BAND_2GHZ, \
65 .center_freq = (_freq), \
66 .hw_value = (_idx), \
67 .max_power = 20, \
68}
69
70#define CHAN5G(_freq, _idx) { \
71 .band = IEEE80211_BAND_5GHZ, \
72 .center_freq = (_freq), \
73 .hw_value = (_idx), \
74 .max_power = 20, \
75}
76
77
78
79
80
81static const struct ieee80211_channel ath9k_2ghz_chantable[] = {
82 CHAN2G(2412, 0),
83 CHAN2G(2417, 1),
84 CHAN2G(2422, 2),
85 CHAN2G(2427, 3),
86 CHAN2G(2432, 4),
87 CHAN2G(2437, 5),
88 CHAN2G(2442, 6),
89 CHAN2G(2447, 7),
90 CHAN2G(2452, 8),
91 CHAN2G(2457, 9),
92 CHAN2G(2462, 10),
93 CHAN2G(2467, 11),
94 CHAN2G(2472, 12),
95 CHAN2G(2484, 13),
96};
97
98
99
100
101
102static const struct ieee80211_channel ath9k_5ghz_chantable[] = {
103
104 CHAN5G(5180, 14),
105 CHAN5G(5200, 15),
106 CHAN5G(5220, 16),
107 CHAN5G(5240, 17),
108
109 CHAN5G(5260, 18),
110 CHAN5G(5280, 19),
111 CHAN5G(5300, 20),
112 CHAN5G(5320, 21),
113
114 CHAN5G(5500, 22),
115 CHAN5G(5520, 23),
116 CHAN5G(5540, 24),
117 CHAN5G(5560, 25),
118 CHAN5G(5580, 26),
119 CHAN5G(5600, 27),
120 CHAN5G(5620, 28),
121 CHAN5G(5640, 29),
122 CHAN5G(5660, 30),
123 CHAN5G(5680, 31),
124 CHAN5G(5700, 32),
125
126 CHAN5G(5745, 33),
127 CHAN5G(5765, 34),
128 CHAN5G(5785, 35),
129 CHAN5G(5805, 36),
130 CHAN5G(5825, 37),
131};
132
133
134#define SHPCHECK(__hw_rate, __flags) \
135 ((__flags & IEEE80211_RATE_SHORT_PREAMBLE) ? (__hw_rate | 0x04 ) : 0)
136
137#define RATE(_bitrate, _hw_rate, _flags) { \
138 .bitrate = (_bitrate), \
139 .flags = (_flags), \
140 .hw_value = (_hw_rate), \
141 .hw_value_short = (SHPCHECK(_hw_rate, _flags)) \
142}
143
144static struct ieee80211_rate ath9k_legacy_rates[] = {
145 RATE(10, 0x1b, 0),
146 RATE(20, 0x1a, IEEE80211_RATE_SHORT_PREAMBLE),
147 RATE(55, 0x19, IEEE80211_RATE_SHORT_PREAMBLE),
148 RATE(110, 0x18, IEEE80211_RATE_SHORT_PREAMBLE),
149 RATE(60, 0x0b, 0),
150 RATE(90, 0x0f, 0),
151 RATE(120, 0x0a, 0),
152 RATE(180, 0x0e, 0),
153 RATE(240, 0x09, 0),
154 RATE(360, 0x0d, 0),
155 RATE(480, 0x08, 0),
156 RATE(540, 0x0c, 0),
157};
158
159#ifdef CONFIG_MAC80211_LEDS
160static const struct ieee80211_tpt_blink ath9k_tpt_blink[] = {
161 { .throughput = 0 * 1024, .blink_time = 334 },
162 { .throughput = 1 * 1024, .blink_time = 260 },
163 { .throughput = 5 * 1024, .blink_time = 220 },
164 { .throughput = 10 * 1024, .blink_time = 190 },
165 { .throughput = 20 * 1024, .blink_time = 170 },
166 { .throughput = 50 * 1024, .blink_time = 150 },
167 { .throughput = 70 * 1024, .blink_time = 130 },
168 { .throughput = 100 * 1024, .blink_time = 110 },
169 { .throughput = 200 * 1024, .blink_time = 80 },
170 { .throughput = 300 * 1024, .blink_time = 50 },
171};
172#endif
173
174static void ath9k_deinit_softc(struct ath_softc *sc);
175
176
177
178
179
180
181
182static void ath9k_iowrite32(void *hw_priv, u32 val, u32 reg_offset)
183{
184 struct ath_hw *ah = (struct ath_hw *) hw_priv;
185 struct ath_common *common = ath9k_hw_common(ah);
186 struct ath_softc *sc = (struct ath_softc *) common->priv;
187
188 if (NR_CPUS > 1 && ah->config.serialize_regmode == SER_REG_MODE_ON) {
189 unsigned long flags;
190 spin_lock_irqsave(&sc->sc_serial_rw, flags);
191 iowrite32(val, sc->mem + reg_offset);
192 spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
193 } else
194 iowrite32(val, sc->mem + reg_offset);
195}
196
197static unsigned int ath9k_ioread32(void *hw_priv, u32 reg_offset)
198{
199 struct ath_hw *ah = (struct ath_hw *) hw_priv;
200 struct ath_common *common = ath9k_hw_common(ah);
201 struct ath_softc *sc = (struct ath_softc *) common->priv;
202 u32 val;
203
204 if (NR_CPUS > 1 && ah->config.serialize_regmode == SER_REG_MODE_ON) {
205 unsigned long flags;
206 spin_lock_irqsave(&sc->sc_serial_rw, flags);
207 val = ioread32(sc->mem + reg_offset);
208 spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
209 } else
210 val = ioread32(sc->mem + reg_offset);
211 return val;
212}
213
214static unsigned int __ath9k_reg_rmw(struct ath_softc *sc, u32 reg_offset,
215 u32 set, u32 clr)
216{
217 u32 val;
218
219 val = ioread32(sc->mem + reg_offset);
220 val &= ~clr;
221 val |= set;
222 iowrite32(val, sc->mem + reg_offset);
223
224 return val;
225}
226
227static unsigned int ath9k_reg_rmw(void *hw_priv, u32 reg_offset, u32 set, u32 clr)
228{
229 struct ath_hw *ah = (struct ath_hw *) hw_priv;
230 struct ath_common *common = ath9k_hw_common(ah);
231 struct ath_softc *sc = (struct ath_softc *) common->priv;
232 unsigned long uninitialized_var(flags);
233 u32 val;
234
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 } else
240 val = __ath9k_reg_rmw(sc, reg_offset, set, clr);
241
242 return val;
243}
244
245
246
247
248
249static void setup_ht_cap(struct ath_softc *sc,
250 struct ieee80211_sta_ht_cap *ht_info)
251{
252 struct ath_hw *ah = sc->sc_ah;
253 struct ath_common *common = ath9k_hw_common(ah);
254 u8 tx_streams, rx_streams;
255 int i, max_streams;
256
257 ht_info->ht_supported = true;
258 ht_info->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
259 IEEE80211_HT_CAP_SM_PS |
260 IEEE80211_HT_CAP_SGI_40 |
261 IEEE80211_HT_CAP_DSSSCCK40;
262
263 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_LDPC)
264 ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;
265
266 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20)
267 ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
268
269 ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
270 ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
271
272 if (AR_SREV_9330(ah) || AR_SREV_9485(ah) || AR_SREV_9565(ah))
273 max_streams = 1;
274 else if (AR_SREV_9462(ah))
275 max_streams = 2;
276 else if (AR_SREV_9300_20_OR_LATER(ah))
277 max_streams = 3;
278 else
279 max_streams = 2;
280
281 if (AR_SREV_9280_20_OR_LATER(ah)) {
282 if (max_streams >= 2)
283 ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
284 ht_info->cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
285 }
286
287
288 memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
289 tx_streams = ath9k_cmn_count_streams(ah->txchainmask, max_streams);
290 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);
294
295 if (tx_streams != rx_streams) {
296 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
297 ht_info->mcs.tx_params |= ((tx_streams - 1) <<
298 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
299 }
300
301 for (i = 0; i < rx_streams; i++)
302 ht_info->mcs.rx_mask[i] = 0xff;
303
304 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
305}
306
307static void ath9k_reg_notifier(struct wiphy *wiphy,
308 struct regulatory_request *request)
309{
310 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
311 struct ath_softc *sc = hw->priv;
312 struct ath_hw *ah = sc->sc_ah;
313 struct ath_regulatory *reg = ath9k_hw_regulatory(ah);
314
315 ath_reg_notifier_apply(wiphy, request, reg);
316
317
318 if (ah->curchan) {
319 sc->config.txpowlimit = 2 * ah->curchan->chan->max_power;
320 ath9k_ps_wakeup(sc);
321 ath9k_hw_set_txpowerlimit(ah, sc->config.txpowlimit, false);
322 sc->curtxpow = ath9k_hw_regulatory(ah)->power_limit;
323
324 if (sc->dfs_detector != NULL)
325 sc->dfs_detector->set_dfs_domain(sc->dfs_detector,
326 request->dfs_region);
327 ath9k_ps_restore(sc);
328 }
329}
330
331
332
333
334
335
336int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
337 struct list_head *head, const char *name,
338 int nbuf, int ndesc, bool is_tx)
339{
340 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
341 u8 *ds;
342 struct ath_buf *bf;
343 int i, bsize, desc_len;
344
345 ath_dbg(common, CONFIG, "%s DMA: %u buffers %u desc/buf\n",
346 name, nbuf, ndesc);
347
348 INIT_LIST_HEAD(head);
349
350 if (is_tx)
351 desc_len = sc->sc_ah->caps.tx_desc_len;
352 else
353 desc_len = sizeof(struct ath_desc);
354
355
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;
360 }
361
362 dd->dd_desc_len = desc_len * nbuf * ndesc;
363
364
365
366
367
368
369 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_4KB_SPLITTRANS)) {
370 u32 ndesc_skipped =
371 ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd->dd_desc_len);
372 u32 dma_len;
373
374 while (ndesc_skipped) {
375 dma_len = ndesc_skipped * desc_len;
376 dd->dd_desc_len += dma_len;
377
378 ndesc_skipped = ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len);
379 }
380 }
381
382
383 dd->dd_desc = dmam_alloc_coherent(sc->dev, dd->dd_desc_len,
384 &dd->dd_desc_paddr, GFP_KERNEL);
385 if (!dd->dd_desc)
386 return -ENOMEM;
387
388 ds = (u8 *) dd->dd_desc;
389 ath_dbg(common, CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
390 name, ds, (u32) dd->dd_desc_len,
391 ito64(dd->dd_desc_paddr), (u32) dd->dd_desc_len);
392
393
394 bsize = sizeof(struct ath_buf) * nbuf;
395 bf = devm_kzalloc(sc->dev, bsize, GFP_KERNEL);
396 if (!bf)
397 return -ENOMEM;
398
399 for (i = 0; i < nbuf; i++, bf++, ds += (desc_len * ndesc)) {
400 bf->bf_desc = ds;
401 bf->bf_daddr = DS2PHYS(dd, ds);
402
403 if (!(sc->sc_ah->caps.hw_caps &
404 ATH9K_HW_CAP_4KB_SPLITTRANS)) {
405
406
407
408
409
410 while (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr)) {
411 BUG_ON((caddr_t) bf->bf_desc >=
412 ((caddr_t) dd->dd_desc +
413 dd->dd_desc_len));
414
415 ds += (desc_len * ndesc);
416 bf->bf_desc = ds;
417 bf->bf_daddr = DS2PHYS(dd, ds);
418 }
419 }
420 list_add_tail(&bf->list, head);
421 }
422 return 0;
423}
424
425static int ath9k_init_queues(struct ath_softc *sc)
426{
427 int i = 0;
428
429 sc->beacon.beaconq = ath9k_hw_beaconq_setup(sc->sc_ah);
430 sc->beacon.cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0);
431
432 sc->config.cabqReadytime = ATH_CABQ_READY_TIME;
433 ath_cabq_update(sc);
434
435 sc->tx.uapsdq = ath_txq_setup(sc, ATH9K_TX_QUEUE_UAPSD, 0);
436
437 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
438 sc->tx.txq_map[i] = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, i);
439 sc->tx.txq_map[i]->mac80211_qnum = i;
440 sc->tx.txq_max_pending[i] = ATH_MAX_QDEPTH;
441 }
442 return 0;
443}
444
445static int ath9k_init_channels_rates(struct ath_softc *sc)
446{
447 void *channels;
448
449 BUILD_BUG_ON(ARRAY_SIZE(ath9k_2ghz_chantable) +
450 ARRAY_SIZE(ath9k_5ghz_chantable) !=
451 ATH9K_NUM_CHANNELS);
452
453 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ) {
454 channels = devm_kzalloc(sc->dev,
455 sizeof(ath9k_2ghz_chantable), GFP_KERNEL);
456 if (!channels)
457 return -ENOMEM;
458
459 memcpy(channels, ath9k_2ghz_chantable,
460 sizeof(ath9k_2ghz_chantable));
461 sc->sbands[IEEE80211_BAND_2GHZ].channels = channels;
462 sc->sbands[IEEE80211_BAND_2GHZ].band = IEEE80211_BAND_2GHZ;
463 sc->sbands[IEEE80211_BAND_2GHZ].n_channels =
464 ARRAY_SIZE(ath9k_2ghz_chantable);
465 sc->sbands[IEEE80211_BAND_2GHZ].bitrates = ath9k_legacy_rates;
466 sc->sbands[IEEE80211_BAND_2GHZ].n_bitrates =
467 ARRAY_SIZE(ath9k_legacy_rates);
468 }
469
470 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ) {
471 channels = devm_kzalloc(sc->dev,
472 sizeof(ath9k_5ghz_chantable), GFP_KERNEL);
473 if (!channels)
474 return -ENOMEM;
475
476 memcpy(channels, ath9k_5ghz_chantable,
477 sizeof(ath9k_5ghz_chantable));
478 sc->sbands[IEEE80211_BAND_5GHZ].channels = channels;
479 sc->sbands[IEEE80211_BAND_5GHZ].band = IEEE80211_BAND_5GHZ;
480 sc->sbands[IEEE80211_BAND_5GHZ].n_channels =
481 ARRAY_SIZE(ath9k_5ghz_chantable);
482 sc->sbands[IEEE80211_BAND_5GHZ].bitrates =
483 ath9k_legacy_rates + 4;
484 sc->sbands[IEEE80211_BAND_5GHZ].n_bitrates =
485 ARRAY_SIZE(ath9k_legacy_rates) - 4;
486 }
487 return 0;
488}
489
490static void ath9k_init_misc(struct ath_softc *sc)
491{
492 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
493 int i = 0;
494
495 setup_timer(&common->ani.timer, ath_ani_calibrate, (unsigned long)sc);
496
497 sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
498 sc->config.txpowlimit = ATH_TXPOWER_MAX;
499 memcpy(common->bssidmask, ath_bcast_mac, ETH_ALEN);
500 sc->beacon.slottime = ATH9K_SLOT_TIME_9;
501
502 for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++)
503 sc->beacon.bslot[i] = NULL;
504
505 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
506 sc->ant_comb.count = ATH_ANT_DIV_COMB_INIT_COUNT;
507
508 sc->spec_config.enabled = 0;
509 sc->spec_config.short_repeat = true;
510 sc->spec_config.count = 8;
511 sc->spec_config.endless = false;
512 sc->spec_config.period = 0xFF;
513 sc->spec_config.fft_period = 0xF;
514}
515
516static void ath9k_init_platform(struct ath_softc *sc)
517{
518 struct ath_hw *ah = sc->sc_ah;
519 struct ath_common *common = ath9k_hw_common(ah);
520
521 if (common->bus_ops->ath_bus_type != ATH_PCI)
522 return;
523
524 if (sc->driver_data & (ATH9K_PCI_CUS198 |
525 ATH9K_PCI_CUS230)) {
526 ah->config.xlna_gpio = 9;
527 ah->config.xatten_margin_cfg = true;
528
529 ath_info(common, "Set parameters for %s\n",
530 (sc->driver_data & ATH9K_PCI_CUS198) ?
531 "CUS198" : "CUS230");
532 } else if (sc->driver_data & ATH9K_PCI_CUS217) {
533 ath_info(common, "CUS217 card detected\n");
534 }
535}
536
537static void ath9k_eeprom_request_cb(const struct firmware *eeprom_blob,
538 void *ctx)
539{
540 struct ath9k_eeprom_ctx *ec = ctx;
541
542 if (eeprom_blob)
543 ec->ah->eeprom_blob = eeprom_blob;
544
545 complete(&ec->complete);
546}
547
548static int ath9k_eeprom_request(struct ath_softc *sc, const char *name)
549{
550 struct ath9k_eeprom_ctx ec;
551 struct ath_hw *ah = ah = sc->sc_ah;
552 int err;
553
554
555 init_completion(&ec.complete);
556 ec.ah = sc->sc_ah;
557
558 err = request_firmware_nowait(THIS_MODULE, 1, name, sc->dev, GFP_KERNEL,
559 &ec, ath9k_eeprom_request_cb);
560 if (err < 0) {
561 ath_err(ath9k_hw_common(ah),
562 "EEPROM request failed\n");
563 return err;
564 }
565
566 wait_for_completion(&ec.complete);
567
568 if (!ah->eeprom_blob) {
569 ath_err(ath9k_hw_common(ah),
570 "Unable to load EEPROM file %s\n", name);
571 return -EINVAL;
572 }
573
574 return 0;
575}
576
577static void ath9k_eeprom_release(struct ath_softc *sc)
578{
579 release_firmware(sc->sc_ah->eeprom_blob);
580}
581
582static int ath9k_init_softc(u16 devid, struct ath_softc *sc,
583 const struct ath_bus_ops *bus_ops)
584{
585 struct ath9k_platform_data *pdata = sc->dev->platform_data;
586 struct ath_hw *ah = NULL;
587 struct ath_common *common;
588 int ret = 0, i;
589 int csz = 0;
590
591 ah = devm_kzalloc(sc->dev, sizeof(struct ath_hw), GFP_KERNEL);
592 if (!ah)
593 return -ENOMEM;
594
595 ah->dev = sc->dev;
596 ah->hw = sc->hw;
597 ah->hw_version.devid = devid;
598 ah->reg_ops.read = ath9k_ioread32;
599 ah->reg_ops.write = ath9k_iowrite32;
600 ah->reg_ops.rmw = ath9k_reg_rmw;
601 atomic_set(&ah->intr_ref_cnt, -1);
602 sc->sc_ah = ah;
603
604 sc->dfs_detector = dfs_pattern_detector_init(ah, NL80211_DFS_UNSET);
605
606 if (!pdata) {
607 ah->ah_flags |= AH_USE_EEPROM;
608 sc->sc_ah->led_pin = -1;
609 } else {
610 sc->sc_ah->gpio_mask = pdata->gpio_mask;
611 sc->sc_ah->gpio_val = pdata->gpio_val;
612 sc->sc_ah->led_pin = pdata->led_pin;
613 ah->is_clk_25mhz = pdata->is_clk_25mhz;
614 ah->get_mac_revision = pdata->get_mac_revision;
615 ah->external_reset = pdata->external_reset;
616 }
617
618 common = ath9k_hw_common(ah);
619 common->ops = &ah->reg_ops;
620 common->bus_ops = bus_ops;
621 common->ah = ah;
622 common->hw = sc->hw;
623 common->priv = sc;
624 common->debug_mask = ath9k_debug;
625 common->btcoex_enabled = ath9k_btcoex_enable == 1;
626 common->disable_ani = false;
627
628
629
630
631 ath9k_init_platform(sc);
632
633
634
635
636
637 if (!common->btcoex_enabled && ath9k_enable_diversity)
638 common->antenna_diversity = 1;
639
640 spin_lock_init(&common->cc_lock);
641
642 spin_lock_init(&sc->sc_serial_rw);
643 spin_lock_init(&sc->sc_pm_lock);
644 mutex_init(&sc->mutex);
645 tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
646 tasklet_init(&sc->bcon_tasklet, ath9k_beacon_tasklet,
647 (unsigned long)sc);
648
649 INIT_WORK(&sc->hw_reset_work, ath_reset_work);
650 INIT_WORK(&sc->hw_check_work, ath_hw_check);
651 INIT_WORK(&sc->paprd_work, ath_paprd_calibrate);
652 INIT_DELAYED_WORK(&sc->hw_pll_work, ath_hw_pll_work);
653 setup_timer(&sc->rx_poll_timer, ath_rx_poll, (unsigned long)sc);
654
655
656
657
658
659 ath_read_cachesize(common, &csz);
660 common->cachelsz = csz << 2;
661
662 if (pdata && pdata->eeprom_name) {
663 ret = ath9k_eeprom_request(sc, pdata->eeprom_name);
664 if (ret)
665 return ret;
666 }
667
668
669 ret = ath9k_hw_init(ah);
670 if (ret)
671 goto err_hw;
672
673 if (pdata && pdata->macaddr)
674 memcpy(common->macaddr, pdata->macaddr, ETH_ALEN);
675
676 ret = ath9k_init_queues(sc);
677 if (ret)
678 goto err_queues;
679
680 ret = ath9k_init_btcoex(sc);
681 if (ret)
682 goto err_btcoex;
683
684 ret = ath9k_init_channels_rates(sc);
685 if (ret)
686 goto err_btcoex;
687
688 ath9k_cmn_init_crypto(sc->sc_ah);
689 ath9k_init_misc(sc);
690 ath_fill_led_pin(sc);
691
692 if (common->bus_ops->aspm_init)
693 common->bus_ops->aspm_init(common);
694
695 return 0;
696
697err_btcoex:
698 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
699 if (ATH_TXQ_SETUP(sc, i))
700 ath_tx_cleanupq(sc, &sc->tx.txq[i]);
701err_queues:
702 ath9k_hw_deinit(ah);
703err_hw:
704 ath9k_eeprom_release(sc);
705 return ret;
706}
707
708static void ath9k_init_band_txpower(struct ath_softc *sc, int band)
709{
710 struct ieee80211_supported_band *sband;
711 struct ieee80211_channel *chan;
712 struct ath_hw *ah = sc->sc_ah;
713 int i;
714
715 sband = &sc->sbands[band];
716 for (i = 0; i < sband->n_channels; i++) {
717 chan = &sband->channels[i];
718 ah->curchan = &ah->channels[chan->hw_value];
719 ath9k_cmn_update_ichannel(ah->curchan, chan, NL80211_CHAN_HT20);
720 ath9k_hw_set_txpowerlimit(ah, MAX_RATE_POWER, true);
721 }
722}
723
724static void ath9k_init_txpower_limits(struct ath_softc *sc)
725{
726 struct ath_hw *ah = sc->sc_ah;
727 struct ath9k_channel *curchan = ah->curchan;
728
729 if (ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
730 ath9k_init_band_txpower(sc, IEEE80211_BAND_2GHZ);
731 if (ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
732 ath9k_init_band_txpower(sc, IEEE80211_BAND_5GHZ);
733
734 ah->curchan = curchan;
735}
736
737void ath9k_reload_chainmask_settings(struct ath_softc *sc)
738{
739 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT))
740 return;
741
742 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
743 setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_2GHZ].ht_cap);
744 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
745 setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_5GHZ].ht_cap);
746}
747
748static const struct ieee80211_iface_limit if_limits[] = {
749 { .max = 2048, .types = BIT(NL80211_IFTYPE_STATION) |
750 BIT(NL80211_IFTYPE_P2P_CLIENT) |
751 BIT(NL80211_IFTYPE_WDS) },
752 { .max = 8, .types =
753#ifdef CONFIG_MAC80211_MESH
754 BIT(NL80211_IFTYPE_MESH_POINT) |
755#endif
756 BIT(NL80211_IFTYPE_AP) |
757 BIT(NL80211_IFTYPE_P2P_GO) },
758};
759
760
761static const struct ieee80211_iface_limit if_dfs_limits[] = {
762 { .max = 1, .types = BIT(NL80211_IFTYPE_AP) },
763};
764
765static const struct ieee80211_iface_combination if_comb[] = {
766 {
767 .limits = if_limits,
768 .n_limits = ARRAY_SIZE(if_limits),
769 .max_interfaces = 2048,
770 .num_different_channels = 1,
771 .beacon_int_infra_match = true,
772 },
773 {
774 .limits = if_dfs_limits,
775 .n_limits = ARRAY_SIZE(if_dfs_limits),
776 .max_interfaces = 1,
777 .num_different_channels = 1,
778 .beacon_int_infra_match = true,
779 .radar_detect_widths = BIT(NL80211_CHAN_NO_HT) |
780 BIT(NL80211_CHAN_HT20),
781 }
782};
783
784#ifdef CONFIG_PM
785static const struct wiphy_wowlan_support ath9k_wowlan_support = {
786 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
787 .n_patterns = MAX_NUM_USER_PATTERN,
788 .pattern_min_len = 1,
789 .pattern_max_len = MAX_PATTERN_SIZE,
790};
791#endif
792
793void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
794{
795 struct ath_hw *ah = sc->sc_ah;
796 struct ath_common *common = ath9k_hw_common(ah);
797
798 hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
799 IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
800 IEEE80211_HW_SIGNAL_DBM |
801 IEEE80211_HW_SUPPORTS_PS |
802 IEEE80211_HW_PS_NULLFUNC_STACK |
803 IEEE80211_HW_SPECTRUM_MGMT |
804 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
805 IEEE80211_HW_SUPPORTS_RC_TABLE |
806 IEEE80211_HW_SUPPORTS_HT_CCK_RATES;
807
808 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
809 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
810
811 if (AR_SREV_9280_20_OR_LATER(ah))
812 hw->radiotap_mcs_details |=
813 IEEE80211_RADIOTAP_MCS_HAVE_STBC;
814 }
815
816 if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || ath9k_modparam_nohwcrypt)
817 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
818
819 hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR;
820
821 hw->wiphy->interface_modes =
822 BIT(NL80211_IFTYPE_P2P_GO) |
823 BIT(NL80211_IFTYPE_P2P_CLIENT) |
824 BIT(NL80211_IFTYPE_AP) |
825 BIT(NL80211_IFTYPE_WDS) |
826 BIT(NL80211_IFTYPE_STATION) |
827 BIT(NL80211_IFTYPE_ADHOC) |
828 BIT(NL80211_IFTYPE_MESH_POINT);
829
830 hw->wiphy->iface_combinations = if_comb;
831 hw->wiphy->n_iface_combinations = ARRAY_SIZE(if_comb);
832
833 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
834
835 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
836 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
837 hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
838
839#ifdef CONFIG_PM_SLEEP
840 if ((ah->caps.hw_caps & ATH9K_HW_WOW_DEVICE_CAPABLE) &&
841 (sc->driver_data & ATH9K_PCI_WOW) &&
842 device_can_wakeup(sc->dev))
843 hw->wiphy->wowlan = &ath9k_wowlan_support;
844
845 atomic_set(&sc->wow_sleep_proc_intr, -1);
846 atomic_set(&sc->wow_got_bmiss_intr, -1);
847#endif
848
849 hw->queues = 4;
850 hw->max_rates = 4;
851 hw->channel_change_time = 5000;
852 hw->max_listen_interval = 1;
853 hw->max_rate_tries = 10;
854 hw->sta_data_size = sizeof(struct ath_node);
855 hw->vif_data_size = sizeof(struct ath_vif);
856
857 hw->wiphy->available_antennas_rx = BIT(ah->caps.max_rxchains) - 1;
858 hw->wiphy->available_antennas_tx = BIT(ah->caps.max_txchains) - 1;
859
860
861 if (ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
862 hw->wiphy->available_antennas_rx = BIT(0) | BIT(1);
863
864 sc->ant_rx = hw->wiphy->available_antennas_rx;
865 sc->ant_tx = hw->wiphy->available_antennas_tx;
866
867 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
868 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
869 &sc->sbands[IEEE80211_BAND_2GHZ];
870 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
871 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
872 &sc->sbands[IEEE80211_BAND_5GHZ];
873
874 ath9k_reload_chainmask_settings(sc);
875
876 SET_IEEE80211_PERM_ADDR(hw, common->macaddr);
877}
878
879int ath9k_init_device(u16 devid, struct ath_softc *sc,
880 const struct ath_bus_ops *bus_ops)
881{
882 struct ieee80211_hw *hw = sc->hw;
883 struct ath_common *common;
884 struct ath_hw *ah;
885 int error = 0;
886 struct ath_regulatory *reg;
887
888
889 error = ath9k_init_softc(devid, sc, bus_ops);
890 if (error)
891 return error;
892
893 ah = sc->sc_ah;
894 common = ath9k_hw_common(ah);
895 ath9k_set_hw_capab(sc, hw);
896
897
898 error = ath_regd_init(&common->regulatory, sc->hw->wiphy,
899 ath9k_reg_notifier);
900 if (error)
901 goto deinit;
902
903 reg = &common->regulatory;
904
905
906 error = ath_tx_init(sc, ATH_TXBUF);
907 if (error != 0)
908 goto deinit;
909
910
911 error = ath_rx_init(sc, ATH_RXBUF);
912 if (error != 0)
913 goto deinit;
914
915 ath9k_init_txpower_limits(sc);
916
917#ifdef CONFIG_MAC80211_LEDS
918
919 sc->led_cdev.default_trigger = ieee80211_create_tpt_led_trigger(sc->hw,
920 IEEE80211_TPT_LEDTRIG_FL_RADIO, ath9k_tpt_blink,
921 ARRAY_SIZE(ath9k_tpt_blink));
922#endif
923
924
925 error = ieee80211_register_hw(hw);
926 if (error)
927 goto rx_cleanup;
928
929 error = ath9k_init_debug(ah);
930 if (error) {
931 ath_err(common, "Unable to create debugfs files\n");
932 goto unregister;
933 }
934
935
936 if (!ath_is_world_regd(reg)) {
937 error = regulatory_hint(hw->wiphy, reg->alpha2);
938 if (error)
939 goto debug_cleanup;
940 }
941
942 ath_init_leds(sc);
943 ath_start_rfkill_poll(sc);
944
945 return 0;
946
947debug_cleanup:
948 ath9k_deinit_debug(sc);
949unregister:
950 ieee80211_unregister_hw(hw);
951rx_cleanup:
952 ath_rx_cleanup(sc);
953deinit:
954 ath9k_deinit_softc(sc);
955 return error;
956}
957
958
959
960
961
962static void ath9k_deinit_softc(struct ath_softc *sc)
963{
964 int i = 0;
965
966 ath9k_deinit_btcoex(sc);
967
968 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
969 if (ATH_TXQ_SETUP(sc, i))
970 ath_tx_cleanupq(sc, &sc->tx.txq[i]);
971
972 ath9k_hw_deinit(sc->sc_ah);
973 if (sc->dfs_detector != NULL)
974 sc->dfs_detector->exit(sc->dfs_detector);
975
976 ath9k_eeprom_release(sc);
977}
978
979void ath9k_deinit_device(struct ath_softc *sc)
980{
981 struct ieee80211_hw *hw = sc->hw;
982
983 ath9k_ps_wakeup(sc);
984
985 wiphy_rfkill_stop_polling(sc->hw->wiphy);
986 ath_deinit_leds(sc);
987
988 ath9k_ps_restore(sc);
989
990 ath9k_deinit_debug(sc);
991 ieee80211_unregister_hw(hw);
992 ath_rx_cleanup(sc);
993 ath9k_deinit_softc(sc);
994}
995
996
997
998
999
1000static int __init ath9k_init(void)
1001{
1002 int error;
1003
1004
1005 error = ath_rate_control_register();
1006 if (error != 0) {
1007 pr_err("Unable to register rate control algorithm: %d\n",
1008 error);
1009 goto err_out;
1010 }
1011
1012 error = ath_pci_init();
1013 if (error < 0) {
1014 pr_err("No PCI devices found, driver not installed\n");
1015 error = -ENODEV;
1016 goto err_rate_unregister;
1017 }
1018
1019 error = ath_ahb_init();
1020 if (error < 0) {
1021 error = -ENODEV;
1022 goto err_pci_exit;
1023 }
1024
1025 return 0;
1026
1027 err_pci_exit:
1028 ath_pci_exit();
1029
1030 err_rate_unregister:
1031 ath_rate_control_unregister();
1032 err_out:
1033 return error;
1034}
1035module_init(ath9k_init);
1036
1037static void __exit ath9k_exit(void)
1038{
1039 is_ath9k_unloaded = true;
1040 ath_ahb_exit();
1041 ath_pci_exit();
1042 ath_rate_control_unregister();
1043 pr_info("%s: Driver unloaded\n", dev_info);
1044}
1045module_exit(ath9k_exit);
1046