projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ip6ip6: autoload ip6 tunnel
[deliverable/linux.git] / drivers / net / wireless / ath / ath9k / init.c
1 /*
2 * Copyright (c) 2008-2009 Atheros Communications Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 #include <linux/slab.h>
18
19 #include "ath9k.h"
20
21 static char *dev_info = "ath9k";
22
23 MODULE_AUTHOR("Atheros Communications");
24 MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
25 MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
26 MODULE_LICENSE("Dual BSD/GPL");
27
28 static unsigned int ath9k_debug = ATH_DBG_DEFAULT;
29 module_param_named(debug, ath9k_debug, uint, 0);
30 MODULE_PARM_DESC(debug, "Debugging mask");
31
32 int ath9k_modparam_nohwcrypt;
33 module_param_named(nohwcrypt, ath9k_modparam_nohwcrypt, int, 0444);
34 MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption");
35
36 int led_blink;
37 module_param_named(blink, led_blink, int, 0444);
38 MODULE_PARM_DESC(blink, "Enable LED blink on activity");
39
40 static int ath9k_btcoex_enable;
41 module_param_named(btcoex_enable, ath9k_btcoex_enable, int, 0444);
42 MODULE_PARM_DESC(btcoex_enable, "Enable wifi-BT coexistence");
43
44 bool is_ath9k_unloaded;
45 /* We use the hw_value as an index into our private channel structure */
46
47 #define CHAN2G(_freq, _idx) { \
48 .band = IEEE80211_BAND_2GHZ, \
49 .center_freq = (_freq), \
50 .hw_value = (_idx), \
51 .max_power = 20, \
52 }
53
54 #define CHAN5G(_freq, _idx) { \
55 .band = IEEE80211_BAND_5GHZ, \
56 .center_freq = (_freq), \
57 .hw_value = (_idx), \
58 .max_power = 20, \
59 }
60
61 /* Some 2 GHz radios are actually tunable on 2312-2732
62 * on 5 MHz steps, we support the channels which we know
63 * we have calibration data for all cards though to make
64 * this static */
65 static const struct ieee80211_channel ath9k_2ghz_chantable[] = {
66 CHAN2G(2412, 0), /* Channel 1 */
67 CHAN2G(2417, 1), /* Channel 2 */
68 CHAN2G(2422, 2), /* Channel 3 */
69 CHAN2G(2427, 3), /* Channel 4 */
70 CHAN2G(2432, 4), /* Channel 5 */
71 CHAN2G(2437, 5), /* Channel 6 */
72 CHAN2G(2442, 6), /* Channel 7 */
73 CHAN2G(2447, 7), /* Channel 8 */
74 CHAN2G(2452, 8), /* Channel 9 */
75 CHAN2G(2457, 9), /* Channel 10 */
76 CHAN2G(2462, 10), /* Channel 11 */
77 CHAN2G(2467, 11), /* Channel 12 */
78 CHAN2G(2472, 12), /* Channel 13 */
79 CHAN2G(2484, 13), /* Channel 14 */
80 };
81
82 /* Some 5 GHz radios are actually tunable on XXXX-YYYY
83 * on 5 MHz steps, we support the channels which we know
84 * we have calibration data for all cards though to make
85 * this static */
86 static const struct ieee80211_channel ath9k_5ghz_chantable[] = {
87 /* _We_ call this UNII 1 */
88 CHAN5G(5180, 14), /* Channel 36 */
89 CHAN5G(5200, 15), /* Channel 40 */
90 CHAN5G(5220, 16), /* Channel 44 */
91 CHAN5G(5240, 17), /* Channel 48 */
92 /* _We_ call this UNII 2 */
93 CHAN5G(5260, 18), /* Channel 52 */
94 CHAN5G(5280, 19), /* Channel 56 */
95 CHAN5G(5300, 20), /* Channel 60 */
96 CHAN5G(5320, 21), /* Channel 64 */
97 /* _We_ call this "Middle band" */
98 CHAN5G(5500, 22), /* Channel 100 */
99 CHAN5G(5520, 23), /* Channel 104 */
100 CHAN5G(5540, 24), /* Channel 108 */
101 CHAN5G(5560, 25), /* Channel 112 */
102 CHAN5G(5580, 26), /* Channel 116 */
103 CHAN5G(5600, 27), /* Channel 120 */
104 CHAN5G(5620, 28), /* Channel 124 */
105 CHAN5G(5640, 29), /* Channel 128 */
106 CHAN5G(5660, 30), /* Channel 132 */
107 CHAN5G(5680, 31), /* Channel 136 */
108 CHAN5G(5700, 32), /* Channel 140 */
109 /* _We_ call this UNII 3 */
110 CHAN5G(5745, 33), /* Channel 149 */
111 CHAN5G(5765, 34), /* Channel 153 */
112 CHAN5G(5785, 35), /* Channel 157 */
113 CHAN5G(5805, 36), /* Channel 161 */
114 CHAN5G(5825, 37), /* Channel 165 */
115 };
116
117 /* Atheros hardware rate code addition for short premble */
118 #define SHPCHECK(__hw_rate, __flags) \
119 ((__flags & IEEE80211_RATE_SHORT_PREAMBLE) ? (__hw_rate | 0x04 ) : 0)
120
121 #define RATE(_bitrate, _hw_rate, _flags) { \
122 .bitrate = (_bitrate), \
123 .flags = (_flags), \
124 .hw_value = (_hw_rate), \
125 .hw_value_short = (SHPCHECK(_hw_rate, _flags)) \
126 }
127
128 static struct ieee80211_rate ath9k_legacy_rates[] = {
129 RATE(10, 0x1b, 0),
130 RATE(20, 0x1a, IEEE80211_RATE_SHORT_PREAMBLE),
131 RATE(55, 0x19, IEEE80211_RATE_SHORT_PREAMBLE),
132 RATE(110, 0x18, IEEE80211_RATE_SHORT_PREAMBLE),
133 RATE(60, 0x0b, 0),
134 RATE(90, 0x0f, 0),
135 RATE(120, 0x0a, 0),
136 RATE(180, 0x0e, 0),
137 RATE(240, 0x09, 0),
138 RATE(360, 0x0d, 0),
139 RATE(480, 0x08, 0),
140 RATE(540, 0x0c, 0),
141 };
142
143 static void ath9k_deinit_softc(struct ath_softc *sc);
144
145 /*
146 * Read and write, they both share the same lock. We do this to serialize
147 * reads and writes on Atheros 802.11n PCI devices only. This is required
148 * as the FIFO on these devices can only accept sanely 2 requests.
149 */
150
151 static void ath9k_iowrite32(void *hw_priv, u32 val, u32 reg_offset)
152 {
153 struct ath_hw *ah = (struct ath_hw *) hw_priv;
154 struct ath_common *common = ath9k_hw_common(ah);
155 struct ath_softc *sc = (struct ath_softc *) common->priv;
156
157 if (ah->config.serialize_regmode == SER_REG_MODE_ON) {
158 unsigned long flags;
159 spin_lock_irqsave(&sc->sc_serial_rw, flags);
160 iowrite32(val, sc->mem + reg_offset);
161 spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
162 } else
163 iowrite32(val, sc->mem + reg_offset);
164 }
165
166 static unsigned int ath9k_ioread32(void *hw_priv, u32 reg_offset)
167 {
168 struct ath_hw *ah = (struct ath_hw *) hw_priv;
169 struct ath_common *common = ath9k_hw_common(ah);
170 struct ath_softc *sc = (struct ath_softc *) common->priv;
171 u32 val;
172
173 if (ah->config.serialize_regmode == SER_REG_MODE_ON) {
174 unsigned long flags;
175 spin_lock_irqsave(&sc->sc_serial_rw, flags);
176 val = ioread32(sc->mem + reg_offset);
177 spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
178 } else
179 val = ioread32(sc->mem + reg_offset);
180 return val;
181 }
182
183 static const struct ath_ops ath9k_common_ops = {
184 .read = ath9k_ioread32,
185 .write = ath9k_iowrite32,
186 };
187
188 /**************************/
189 /* Initialization */
190 /**************************/
191
192 static void setup_ht_cap(struct ath_softc *sc,
193 struct ieee80211_sta_ht_cap *ht_info)
194 {
195 struct ath_hw *ah = sc->sc_ah;
196 struct ath_common *common = ath9k_hw_common(ah);
197 u8 tx_streams, rx_streams;
198 int i, max_streams;
199
200 ht_info->ht_supported = true;
201 ht_info->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
202 IEEE80211_HT_CAP_SM_PS |
203 IEEE80211_HT_CAP_SGI_40 |
204 IEEE80211_HT_CAP_DSSSCCK40;
205
206 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_LDPC)
207 ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;
208
209 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20)
210 ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
211
212 ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
213 ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
214
215 if (AR_SREV_9485(ah))
216 max_streams = 1;
217 else if (AR_SREV_9300_20_OR_LATER(ah))
218 max_streams = 3;
219 else
220 max_streams = 2;
221
222 if (AR_SREV_9280_20_OR_LATER(ah)) {
223 if (max_streams >= 2)
224 ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
225 ht_info->cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
226 }
227
228 /* set up supported mcs set */
229 memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
230 tx_streams = ath9k_cmn_count_streams(common->tx_chainmask, max_streams);
231 rx_streams = ath9k_cmn_count_streams(common->rx_chainmask, max_streams);
232
233 ath_dbg(common, ATH_DBG_CONFIG,
234 "TX streams %d, RX streams: %d\n",
235 tx_streams, rx_streams);
236
237 if (tx_streams != rx_streams) {
238 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
239 ht_info->mcs.tx_params |= ((tx_streams - 1) <<
240 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
241 }
242
243 for (i = 0; i < rx_streams; i++)
244 ht_info->mcs.rx_mask[i] = 0xff;
245
246 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
247 }
248
249 static int ath9k_reg_notifier(struct wiphy *wiphy,
250 struct regulatory_request *request)
251 {
252 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
253 struct ath_wiphy *aphy = hw->priv;
254 struct ath_softc *sc = aphy->sc;
255 struct ath_regulatory *reg = ath9k_hw_regulatory(sc->sc_ah);
256
257 return ath_reg_notifier_apply(wiphy, request, reg);
258 }
259
260 /*
261 * This function will allocate both the DMA descriptor structure, and the
262 * buffers it contains. These are used to contain the descriptors used
263 * by the system.
264 */
265 int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
266 struct list_head *head, const char *name,
267 int nbuf, int ndesc, bool is_tx)
268 {
269 #define DS2PHYS(_dd, _ds) \
270 ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
271 #define ATH_DESC_4KB_BOUND_CHECK(_daddr) ((((_daddr) & 0xFFF) > 0xF7F) ? 1 : 0)
272 #define ATH_DESC_4KB_BOUND_NUM_SKIPPED(_len) ((_len) / 4096)
273 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
274 u8 *ds;
275 struct ath_buf *bf;
276 int i, bsize, error, desc_len;
277
278 ath_dbg(common, ATH_DBG_CONFIG, "%s DMA: %u buffers %u desc/buf\n",
279 name, nbuf, ndesc);
280
281 INIT_LIST_HEAD(head);
282
283 if (is_tx)
284 desc_len = sc->sc_ah->caps.tx_desc_len;
285 else
286 desc_len = sizeof(struct ath_desc);
287
288 /* ath_desc must be a multiple of DWORDs */
289 if ((desc_len % 4) != 0) {
290 ath_err(common, "ath_desc not DWORD aligned\n");
291 BUG_ON((desc_len % 4) != 0);
292 error = -ENOMEM;
293 goto fail;
294 }
295
296 dd->dd_desc_len = desc_len * nbuf * ndesc;
297
298 /*
299 * Need additional DMA memory because we can't use
300 * descriptors that cross the 4K page boundary. Assume
301 * one skipped descriptor per 4K page.
302 */
303 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_4KB_SPLITTRANS)) {
304 u32 ndesc_skipped =
305 ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd->dd_desc_len);
306 u32 dma_len;
307
308 while (ndesc_skipped) {
309 dma_len = ndesc_skipped * desc_len;
310 dd->dd_desc_len += dma_len;
311
312 ndesc_skipped = ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len);
313 }
314 }
315
316 /* allocate descriptors */
317 dd->dd_desc = dma_alloc_coherent(sc->dev, dd->dd_desc_len,
318 &dd->dd_desc_paddr, GFP_KERNEL);
319 if (dd->dd_desc == NULL) {
320 error = -ENOMEM;
321 goto fail;
322 }
323 ds = (u8 *) dd->dd_desc;
324 ath_dbg(common, ATH_DBG_CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
325 name, ds, (u32) dd->dd_desc_len,
326 ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
327
328 /* allocate buffers */
329 bsize = sizeof(struct ath_buf) * nbuf;
330 bf = kzalloc(bsize, GFP_KERNEL);
331 if (bf == NULL) {
332 error = -ENOMEM;
333 goto fail2;
334 }
335 dd->dd_bufptr = bf;
336
337 for (i = 0; i < nbuf; i++, bf++, ds += (desc_len * ndesc)) {
338 bf->bf_desc = ds;
339 bf->bf_daddr = DS2PHYS(dd, ds);
340
341 if (!(sc->sc_ah->caps.hw_caps &
342 ATH9K_HW_CAP_4KB_SPLITTRANS)) {
343 /*
344 * Skip descriptor addresses which can cause 4KB
345 * boundary crossing (addr + length) with a 32 dword
346 * descriptor fetch.
347 */
348 while (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr)) {
349 BUG_ON((caddr_t) bf->bf_desc >=
350 ((caddr_t) dd->dd_desc +
351 dd->dd_desc_len));
352
353 ds += (desc_len * ndesc);
354 bf->bf_desc = ds;
355 bf->bf_daddr = DS2PHYS(dd, ds);
356 }
357 }
358 list_add_tail(&bf->list, head);
359 }
360 return 0;
361 fail2:
362 dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
363 dd->dd_desc_paddr);
364 fail:
365 memset(dd, 0, sizeof(*dd));
366 return error;
367 #undef ATH_DESC_4KB_BOUND_CHECK
368 #undef ATH_DESC_4KB_BOUND_NUM_SKIPPED
369 #undef DS2PHYS
370 }
371
372 void ath9k_init_crypto(struct ath_softc *sc)
373 {
374 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
375 int i = 0;
376
377 /* Get the hardware key cache size. */
378 common->keymax = sc->sc_ah->caps.keycache_size;
379 if (common->keymax > ATH_KEYMAX) {
380 ath_dbg(common, ATH_DBG_ANY,
381 "Warning, using only %u entries in %u key cache\n",
382 ATH_KEYMAX, common->keymax);
383 common->keymax = ATH_KEYMAX;
384 }
385
386 /*
387 * Reset the key cache since some parts do not
388 * reset the contents on initial power up.
389 */
390 for (i = 0; i < common->keymax; i++)
391 ath_hw_keyreset(common, (u16) i);
392
393 /*
394 * Check whether the separate key cache entries
395 * are required to handle both tx+rx MIC keys.
396 * With split mic keys the number of stations is limited
397 * to 27 otherwise 59.
398 */
399 if (sc->sc_ah->misc_mode & AR_PCU_MIC_NEW_LOC_ENA)
400 common->crypt_caps |= ATH_CRYPT_CAP_MIC_COMBINED;
401 }
402
403 static int ath9k_init_btcoex(struct ath_softc *sc)
404 {
405 struct ath_txq *txq;
406 int r;
407
408 switch (sc->sc_ah->btcoex_hw.scheme) {
409 case ATH_BTCOEX_CFG_NONE:
410 break;
411 case ATH_BTCOEX_CFG_2WIRE:
412 ath9k_hw_btcoex_init_2wire(sc->sc_ah);
413 break;
414 case ATH_BTCOEX_CFG_3WIRE:
415 ath9k_hw_btcoex_init_3wire(sc->sc_ah);
416 r = ath_init_btcoex_timer(sc);
417 if (r)
418 return -1;
419 txq = sc->tx.txq_map[WME_AC_BE];
420 ath9k_hw_init_btcoex_hw(sc->sc_ah, txq->axq_qnum);
421 sc->btcoex.bt_stomp_type = ATH_BTCOEX_STOMP_LOW;
422 break;
423 default:
424 WARN_ON(1);
425 break;
426 }
427
428 return 0;
429 }
430
431 static int ath9k_init_queues(struct ath_softc *sc)
432 {
433 int i = 0;
434
435 sc->beacon.beaconq = ath9k_hw_beaconq_setup(sc->sc_ah);
436 sc->beacon.cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0);
437
438 sc->config.cabqReadytime = ATH_CABQ_READY_TIME;
439 ath_cabq_update(sc);
440
441 for (i = 0; i < WME_NUM_AC; i++)
442 sc->tx.txq_map[i] = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, i);
443
444 return 0;
445 }
446
447 static int ath9k_init_channels_rates(struct ath_softc *sc)
448 {
449 void *channels;
450
451 BUILD_BUG_ON(ARRAY_SIZE(ath9k_2ghz_chantable) +
452 ARRAY_SIZE(ath9k_5ghz_chantable) !=
453 ATH9K_NUM_CHANNELS);
454
455 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ) {
456 channels = kmemdup(ath9k_2ghz_chantable,
457 sizeof(ath9k_2ghz_chantable), GFP_KERNEL);
458 if (!channels)
459 return -ENOMEM;
460
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 = kmemdup(ath9k_5ghz_chantable,
472 sizeof(ath9k_5ghz_chantable), GFP_KERNEL);
473 if (!channels) {
474 if (sc->sbands[IEEE80211_BAND_2GHZ].channels)
475 kfree(sc->sbands[IEEE80211_BAND_2GHZ].channels);
476 return -ENOMEM;
477 }
478
479 sc->sbands[IEEE80211_BAND_5GHZ].channels = channels;
480 sc->sbands[IEEE80211_BAND_5GHZ].band = IEEE80211_BAND_5GHZ;
481 sc->sbands[IEEE80211_BAND_5GHZ].n_channels =
482 ARRAY_SIZE(ath9k_5ghz_chantable);
483 sc->sbands[IEEE80211_BAND_5GHZ].bitrates =
484 ath9k_legacy_rates + 4;
485 sc->sbands[IEEE80211_BAND_5GHZ].n_bitrates =
486 ARRAY_SIZE(ath9k_legacy_rates) - 4;
487 }
488 return 0;
489 }
490
491 static void ath9k_init_misc(struct ath_softc *sc)
492 {
493 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
494 int i = 0;
495
496 setup_timer(&common->ani.timer, ath_ani_calibrate, (unsigned long)sc);
497
498 sc->config.txpowlimit = ATH_TXPOWER_MAX;
499
500 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
501 sc->sc_flags |= SC_OP_TXAGGR;
502 sc->sc_flags |= SC_OP_RXAGGR;
503 }
504
505 common->tx_chainmask = sc->sc_ah->caps.tx_chainmask;
506 common->rx_chainmask = sc->sc_ah->caps.rx_chainmask;
507
508 ath9k_hw_set_diversity(sc->sc_ah, true);
509 sc->rx.defant = ath9k_hw_getdefantenna(sc->sc_ah);
510
511 memcpy(common->bssidmask, ath_bcast_mac, ETH_ALEN);
512
513 sc->beacon.slottime = ATH9K_SLOT_TIME_9;
514
515 for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++) {
516 sc->beacon.bslot[i] = NULL;
517 sc->beacon.bslot_aphy[i] = NULL;
518 }
519
520 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
521 sc->ant_comb.count = ATH_ANT_DIV_COMB_INIT_COUNT;
522 }
523
524 static int ath9k_init_softc(u16 devid, struct ath_softc *sc, u16 subsysid,
525 const struct ath_bus_ops *bus_ops)
526 {
527 struct ath_hw *ah = NULL;
528 struct ath_common *common;
529 int ret = 0, i;
530 int csz = 0;
531
532 ah = kzalloc(sizeof(struct ath_hw), GFP_KERNEL);
533 if (!ah)
534 return -ENOMEM;
535
536 ah->hw_version.devid = devid;
537 ah->hw_version.subsysid = subsysid;
538 sc->sc_ah = ah;
539
540 if (!sc->dev->platform_data)
541 ah->ah_flags |= AH_USE_EEPROM;
542
543 common = ath9k_hw_common(ah);
544 common->ops = &ath9k_common_ops;
545 common->bus_ops = bus_ops;
546 common->ah = ah;
547 common->hw = sc->hw;
548 common->priv = sc;
549 common->debug_mask = ath9k_debug;
550 common->btcoex_enabled = ath9k_btcoex_enable == 1;
551 spin_lock_init(&common->cc_lock);
552
553 spin_lock_init(&sc->wiphy_lock);
554 spin_lock_init(&sc->sc_serial_rw);
555 spin_lock_init(&sc->sc_pm_lock);
556 mutex_init(&sc->mutex);
557 tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
558 tasklet_init(&sc->bcon_tasklet, ath_beacon_tasklet,
559 (unsigned long)sc);
560
561 /*
562 * Cache line size is used to size and align various
563 * structures used to communicate with the hardware.
564 */
565 ath_read_cachesize(common, &csz);
566 common->cachelsz = csz << 2; /* convert to bytes */
567
568 /* Initializes the hardware for all supported chipsets */
569 ret = ath9k_hw_init(ah);
570 if (ret)
571 goto err_hw;
572
573 ret = ath9k_init_queues(sc);
574 if (ret)
575 goto err_queues;
576
577 ret = ath9k_init_btcoex(sc);
578 if (ret)
579 goto err_btcoex;
580
581 ret = ath9k_init_channels_rates(sc);
582 if (ret)
583 goto err_btcoex;
584
585 ath9k_init_crypto(sc);
586 ath9k_init_misc(sc);
587
588 return 0;
589
590 err_btcoex:
591 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
592 if (ATH_TXQ_SETUP(sc, i))
593 ath_tx_cleanupq(sc, &sc->tx.txq[i]);
594 err_queues:
595 ath9k_hw_deinit(ah);
596 err_hw:
597
598 kfree(ah);
599 sc->sc_ah = NULL;
600
601 return ret;
602 }
603
604 static void ath9k_init_band_txpower(struct ath_softc *sc, int band)
605 {
606 struct ieee80211_supported_band *sband;
607 struct ieee80211_channel *chan;
608 struct ath_hw *ah = sc->sc_ah;
609 struct ath_regulatory *reg = ath9k_hw_regulatory(ah);
610 int i;
611
612 sband = &sc->sbands[band];
613 for (i = 0; i < sband->n_channels; i++) {
614 chan = &sband->channels[i];
615 ah->curchan = &ah->channels[chan->hw_value];
616 ath9k_cmn_update_ichannel(ah->curchan, chan, NL80211_CHAN_HT20);
617 ath9k_hw_set_txpowerlimit(ah, MAX_RATE_POWER, true);
618 chan->max_power = reg->max_power_level / 2;
619 }
620 }
621
622 static void ath9k_init_txpower_limits(struct ath_softc *sc)
623 {
624 struct ath_hw *ah = sc->sc_ah;
625 struct ath9k_channel *curchan = ah->curchan;
626
627 if (ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
628 ath9k_init_band_txpower(sc, IEEE80211_BAND_2GHZ);
629 if (ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
630 ath9k_init_band_txpower(sc, IEEE80211_BAND_5GHZ);
631
632 ah->curchan = curchan;
633 }
634
635 void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
636 {
637 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
638
639 hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
640 IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
641 IEEE80211_HW_SIGNAL_DBM |
642 IEEE80211_HW_SUPPORTS_PS |
643 IEEE80211_HW_PS_NULLFUNC_STACK |
644 IEEE80211_HW_SPECTRUM_MGMT |
645 IEEE80211_HW_REPORTS_TX_ACK_STATUS;
646
647 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
648 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
649
650 if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || ath9k_modparam_nohwcrypt)
651 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
652
653 hw->wiphy->interface_modes =
654 BIT(NL80211_IFTYPE_P2P_GO) |
655 BIT(NL80211_IFTYPE_P2P_CLIENT) |
656 BIT(NL80211_IFTYPE_AP) |
657 BIT(NL80211_IFTYPE_WDS) |
658 BIT(NL80211_IFTYPE_STATION) |
659 BIT(NL80211_IFTYPE_ADHOC) |
660 BIT(NL80211_IFTYPE_MESH_POINT);
661
662 if (AR_SREV_5416(sc->sc_ah))
663 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
664
665 hw->queues = 4;
666 hw->max_rates = 4;
667 hw->channel_change_time = 5000;
668 hw->max_listen_interval = 10;
669 hw->max_rate_tries = 10;
670 hw->sta_data_size = sizeof(struct ath_node);
671 hw->vif_data_size = sizeof(struct ath_vif);
672
673 #ifdef CONFIG_ATH9K_RATE_CONTROL
674 hw->rate_control_algorithm = "ath9k_rate_control";
675 #endif
676
677 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
678 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
679 &sc->sbands[IEEE80211_BAND_2GHZ];
680 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
681 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
682 &sc->sbands[IEEE80211_BAND_5GHZ];
683
684 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
685 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
686 setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_2GHZ].ht_cap);
687 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
688 setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_5GHZ].ht_cap);
689 }
690
691 SET_IEEE80211_PERM_ADDR(hw, common->macaddr);
692 }
693
694 int ath9k_init_device(u16 devid, struct ath_softc *sc, u16 subsysid,
695 const struct ath_bus_ops *bus_ops)
696 {
697 struct ieee80211_hw *hw = sc->hw;
698 struct ath_wiphy *aphy = hw->priv;
699 struct ath_common *common;
700 struct ath_hw *ah;
701 int error = 0;
702 struct ath_regulatory *reg;
703
704 /* Bring up device */
705 error = ath9k_init_softc(devid, sc, subsysid, bus_ops);
706 if (error != 0)
707 goto error_init;
708
709 ah = sc->sc_ah;
710 common = ath9k_hw_common(ah);
711 ath9k_set_hw_capab(sc, hw);
712
713 /* Initialize regulatory */
714 error = ath_regd_init(&common->regulatory, sc->hw->wiphy,
715 ath9k_reg_notifier);
716 if (error)
717 goto error_regd;
718
719 reg = &common->regulatory;
720
721 /* Setup TX DMA */
722 error = ath_tx_init(sc, ATH_TXBUF);
723 if (error != 0)
724 goto error_tx;
725
726 /* Setup RX DMA */
727 error = ath_rx_init(sc, ATH_RXBUF);
728 if (error != 0)
729 goto error_rx;
730
731 ath9k_init_txpower_limits(sc);
732
733 /* Register with mac80211 */
734 error = ieee80211_register_hw(hw);
735 if (error)
736 goto error_register;
737
738 error = ath9k_init_debug(ah);
739 if (error) {
740 ath_err(common, "Unable to create debugfs files\n");
741 goto error_world;
742 }
743
744 /* Handle world regulatory */
745 if (!ath_is_world_regd(reg)) {
746 error = regulatory_hint(hw->wiphy, reg->alpha2);
747 if (error)
748 goto error_world;
749 }
750
751 INIT_WORK(&sc->hw_check_work, ath_hw_check);
752 INIT_WORK(&sc->paprd_work, ath_paprd_calibrate);
753 INIT_WORK(&sc->chan_work, ath9k_wiphy_chan_work);
754 INIT_DELAYED_WORK(&sc->wiphy_work, ath9k_wiphy_work);
755 sc->wiphy_scheduler_int = msecs_to_jiffies(500);
756 aphy->last_rssi = ATH_RSSI_DUMMY_MARKER;
757
758 ath_init_leds(sc);
759 ath_start_rfkill_poll(sc);
760
761 return 0;
762
763 error_world:
764 ieee80211_unregister_hw(hw);
765 error_register:
766 ath_rx_cleanup(sc);
767 error_rx:
768 ath_tx_cleanup(sc);
769 error_tx:
770 /* Nothing */
771 error_regd:
772 ath9k_deinit_softc(sc);
773 error_init:
774 return error;
775 }
776
777 /*****************************/
778 /* De-Initialization */
779 /*****************************/
780
781 static void ath9k_deinit_softc(struct ath_softc *sc)
782 {
783 int i = 0;
784
785 if (sc->sbands[IEEE80211_BAND_2GHZ].channels)
786 kfree(sc->sbands[IEEE80211_BAND_2GHZ].channels);
787
788 if (sc->sbands[IEEE80211_BAND_5GHZ].channels)
789 kfree(sc->sbands[IEEE80211_BAND_5GHZ].channels);
790
791 if ((sc->btcoex.no_stomp_timer) &&
792 sc->sc_ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
793 ath_gen_timer_free(sc->sc_ah, sc->btcoex.no_stomp_timer);
794
795 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
796 if (ATH_TXQ_SETUP(sc, i))
797 ath_tx_cleanupq(sc, &sc->tx.txq[i]);
798
799 ath9k_hw_deinit(sc->sc_ah);
800
801 kfree(sc->sc_ah);
802 sc->sc_ah = NULL;
803 }
804
805 void ath9k_deinit_device(struct ath_softc *sc)
806 {
807 struct ieee80211_hw *hw = sc->hw;
808 int i = 0;
809
810 ath9k_ps_wakeup(sc);
811
812 wiphy_rfkill_stop_polling(sc->hw->wiphy);
813 ath_deinit_leds(sc);
814
815 ath9k_ps_restore(sc);
816
817 for (i = 0; i < sc->num_sec_wiphy; i++) {
818 struct ath_wiphy *aphy = sc->sec_wiphy[i];
819 if (aphy == NULL)
820 continue;
821 sc->sec_wiphy[i] = NULL;
822 ieee80211_unregister_hw(aphy->hw);
823 ieee80211_free_hw(aphy->hw);
824 }
825
826 ieee80211_unregister_hw(hw);
827 ath_rx_cleanup(sc);
828 ath_tx_cleanup(sc);
829 ath9k_deinit_softc(sc);
830 kfree(sc->sec_wiphy);
831 }
832
833 void ath_descdma_cleanup(struct ath_softc *sc,
834 struct ath_descdma *dd,
835 struct list_head *head)
836 {
837 dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
838 dd->dd_desc_paddr);
839
840 INIT_LIST_HEAD(head);
841 kfree(dd->dd_bufptr);
842 memset(dd, 0, sizeof(*dd));
843 }
844
845 /************************/
846 /* Module Hooks */
847 /************************/
848
849 static int __init ath9k_init(void)
850 {
851 int error;
852
853 /* Register rate control algorithm */
854 error = ath_rate_control_register();
855 if (error != 0) {
856 printk(KERN_ERR
857 "ath9k: Unable to register rate control "
858 "algorithm: %d\n",
859 error);
860 goto err_out;
861 }
862
863 error = ath_pci_init();
864 if (error < 0) {
865 printk(KERN_ERR
866 "ath9k: No PCI devices found, driver not installed.\n");
867 error = -ENODEV;
868 goto err_rate_unregister;
869 }
870
871 error = ath_ahb_init();
872 if (error < 0) {
873 error = -ENODEV;
874 goto err_pci_exit;
875 }
876
877 return 0;
878
879 err_pci_exit:
880 ath_pci_exit();
881
882 err_rate_unregister:
883 ath_rate_control_unregister();
884 err_out:
885 return error;
886 }
887 module_init(ath9k_init);
888
889 static void __exit ath9k_exit(void)
890 {
891 is_ath9k_unloaded = true;
892 ath_ahb_exit();
893 ath_pci_exit();
894 ath_rate_control_unregister();
895 printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
896 }
897 module_exit(ath9k_exit);
Linux kernel - Deliverables
This page took 0.049523 seconds and 5 git commands to generate.