Merge ssh://master.kernel.org/pub/scm/linux/kernel/git/linville/wireless-2.6
[linux-2.6.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_softc *sc = hw->priv;
254         struct ath_regulatory *reg = ath9k_hw_regulatory(sc->sc_ah);
255
256         return ath_reg_notifier_apply(wiphy, request, reg);
257 }
258
259 /*
260  *  This function will allocate both the DMA descriptor structure, and the
261  *  buffers it contains.  These are used to contain the descriptors used
262  *  by the system.
263 */
264 int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
265                       struct list_head *head, const char *name,
266                       int nbuf, int ndesc, bool is_tx)
267 {
268 #define DS2PHYS(_dd, _ds)                                               \
269         ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
270 #define ATH_DESC_4KB_BOUND_CHECK(_daddr) ((((_daddr) & 0xFFF) > 0xF7F) ? 1 : 0)
271 #define ATH_DESC_4KB_BOUND_NUM_SKIPPED(_len) ((_len) / 4096)
272         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
273         u8 *ds;
274         struct ath_buf *bf;
275         int i, bsize, error, desc_len;
276
277         ath_dbg(common, ATH_DBG_CONFIG, "%s DMA: %u buffers %u desc/buf\n",
278                 name, nbuf, ndesc);
279
280         INIT_LIST_HEAD(head);
281
282         if (is_tx)
283                 desc_len = sc->sc_ah->caps.tx_desc_len;
284         else
285                 desc_len = sizeof(struct ath_desc);
286
287         /* ath_desc must be a multiple of DWORDs */
288         if ((desc_len % 4) != 0) {
289                 ath_err(common, "ath_desc not DWORD aligned\n");
290                 BUG_ON((desc_len % 4) != 0);
291                 error = -ENOMEM;
292                 goto fail;
293         }
294
295         dd->dd_desc_len = desc_len * nbuf * ndesc;
296
297         /*
298          * Need additional DMA memory because we can't use
299          * descriptors that cross the 4K page boundary. Assume
300          * one skipped descriptor per 4K page.
301          */
302         if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_4KB_SPLITTRANS)) {
303                 u32 ndesc_skipped =
304                         ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd->dd_desc_len);
305                 u32 dma_len;
306
307                 while (ndesc_skipped) {
308                         dma_len = ndesc_skipped * desc_len;
309                         dd->dd_desc_len += dma_len;
310
311                         ndesc_skipped = ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len);
312                 }
313         }
314
315         /* allocate descriptors */
316         dd->dd_desc = dma_alloc_coherent(sc->dev, dd->dd_desc_len,
317                                          &dd->dd_desc_paddr, GFP_KERNEL);
318         if (dd->dd_desc == NULL) {
319                 error = -ENOMEM;
320                 goto fail;
321         }
322         ds = (u8 *) dd->dd_desc;
323         ath_dbg(common, ATH_DBG_CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
324                 name, ds, (u32) dd->dd_desc_len,
325                 ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
326
327         /* allocate buffers */
328         bsize = sizeof(struct ath_buf) * nbuf;
329         bf = kzalloc(bsize, GFP_KERNEL);
330         if (bf == NULL) {
331                 error = -ENOMEM;
332                 goto fail2;
333         }
334         dd->dd_bufptr = bf;
335
336         for (i = 0; i < nbuf; i++, bf++, ds += (desc_len * ndesc)) {
337                 bf->bf_desc = ds;
338                 bf->bf_daddr = DS2PHYS(dd, ds);
339
340                 if (!(sc->sc_ah->caps.hw_caps &
341                       ATH9K_HW_CAP_4KB_SPLITTRANS)) {
342                         /*
343                          * Skip descriptor addresses which can cause 4KB
344                          * boundary crossing (addr + length) with a 32 dword
345                          * descriptor fetch.
346                          */
347                         while (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr)) {
348                                 BUG_ON((caddr_t) bf->bf_desc >=
349                                        ((caddr_t) dd->dd_desc +
350                                         dd->dd_desc_len));
351
352                                 ds += (desc_len * ndesc);
353                                 bf->bf_desc = ds;
354                                 bf->bf_daddr = DS2PHYS(dd, ds);
355                         }
356                 }
357                 list_add_tail(&bf->list, head);
358         }
359         return 0;
360 fail2:
361         dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
362                           dd->dd_desc_paddr);
363 fail:
364         memset(dd, 0, sizeof(*dd));
365         return error;
366 #undef ATH_DESC_4KB_BOUND_CHECK
367 #undef ATH_DESC_4KB_BOUND_NUM_SKIPPED
368 #undef DS2PHYS
369 }
370
371 void ath9k_init_crypto(struct ath_softc *sc)
372 {
373         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
374         int i = 0;
375
376         /* Get the hardware key cache size. */
377         common->keymax = sc->sc_ah->caps.keycache_size;
378         if (common->keymax > ATH_KEYMAX) {
379                 ath_dbg(common, ATH_DBG_ANY,
380                         "Warning, using only %u entries in %u key cache\n",
381                         ATH_KEYMAX, common->keymax);
382                 common->keymax = ATH_KEYMAX;
383         }
384
385         /*
386          * Reset the key cache since some parts do not
387          * reset the contents on initial power up.
388          */
389         for (i = 0; i < common->keymax; i++)
390                 ath_hw_keyreset(common, (u16) i);
391
392         /*
393          * Check whether the separate key cache entries
394          * are required to handle both tx+rx MIC keys.
395          * With split mic keys the number of stations is limited
396          * to 27 otherwise 59.
397          */
398         if (sc->sc_ah->misc_mode & AR_PCU_MIC_NEW_LOC_ENA)
399                 common->crypt_caps |= ATH_CRYPT_CAP_MIC_COMBINED;
400 }
401
402 static int ath9k_init_btcoex(struct ath_softc *sc)
403 {
404         struct ath_txq *txq;
405         int r;
406
407         switch (sc->sc_ah->btcoex_hw.scheme) {
408         case ATH_BTCOEX_CFG_NONE:
409                 break;
410         case ATH_BTCOEX_CFG_2WIRE:
411                 ath9k_hw_btcoex_init_2wire(sc->sc_ah);
412                 break;
413         case ATH_BTCOEX_CFG_3WIRE:
414                 ath9k_hw_btcoex_init_3wire(sc->sc_ah);
415                 r = ath_init_btcoex_timer(sc);
416                 if (r)
417                         return -1;
418                 txq = sc->tx.txq_map[WME_AC_BE];
419                 ath9k_hw_init_btcoex_hw(sc->sc_ah, txq->axq_qnum);
420                 sc->btcoex.bt_stomp_type = ATH_BTCOEX_STOMP_LOW;
421                 break;
422         default:
423                 WARN_ON(1);
424                 break;
425         }
426
427         return 0;
428 }
429
430 static int ath9k_init_queues(struct ath_softc *sc)
431 {
432         int i = 0;
433
434         sc->beacon.beaconq = ath9k_hw_beaconq_setup(sc->sc_ah);
435         sc->beacon.cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0);
436
437         sc->config.cabqReadytime = ATH_CABQ_READY_TIME;
438         ath_cabq_update(sc);
439
440         for (i = 0; i < WME_NUM_AC; i++) {
441                 sc->tx.txq_map[i] = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, i);
442                 sc->tx.txq_map[i]->mac80211_qnum = 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
518         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
519                 sc->ant_comb.count = ATH_ANT_DIV_COMB_INIT_COUNT;
520 }
521
522 static int ath9k_init_softc(u16 devid, struct ath_softc *sc, u16 subsysid,
523                             const struct ath_bus_ops *bus_ops)
524 {
525         struct ath_hw *ah = NULL;
526         struct ath_common *common;
527         int ret = 0, i;
528         int csz = 0;
529
530         ah = kzalloc(sizeof(struct ath_hw), GFP_KERNEL);
531         if (!ah)
532                 return -ENOMEM;
533
534         ah->hw = sc->hw;
535         ah->hw_version.devid = devid;
536         ah->hw_version.subsysid = subsysid;
537         sc->sc_ah = ah;
538
539         if (!sc->dev->platform_data)
540                 ah->ah_flags |= AH_USE_EEPROM;
541
542         common = ath9k_hw_common(ah);
543         common->ops = &ath9k_common_ops;
544         common->bus_ops = bus_ops;
545         common->ah = ah;
546         common->hw = sc->hw;
547         common->priv = sc;
548         common->debug_mask = ath9k_debug;
549         common->btcoex_enabled = ath9k_btcoex_enable == 1;
550         spin_lock_init(&common->cc_lock);
551
552         spin_lock_init(&sc->sc_serial_rw);
553         spin_lock_init(&sc->sc_pm_lock);
554         mutex_init(&sc->mutex);
555 #ifdef CONFIG_ATH9K_DEBUGFS
556         spin_lock_init(&sc->nodes_lock);
557         INIT_LIST_HEAD(&sc->nodes);
558 #endif
559         tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
560         tasklet_init(&sc->bcon_tasklet, ath_beacon_tasklet,
561                      (unsigned long)sc);
562
563         /*
564          * Cache line size is used to size and align various
565          * structures used to communicate with the hardware.
566          */
567         ath_read_cachesize(common, &csz);
568         common->cachelsz = csz << 2; /* convert to bytes */
569
570         /* Initializes the hardware for all supported chipsets */
571         ret = ath9k_hw_init(ah);
572         if (ret)
573                 goto err_hw;
574
575         ret = ath9k_init_queues(sc);
576         if (ret)
577                 goto err_queues;
578
579         ret =  ath9k_init_btcoex(sc);
580         if (ret)
581                 goto err_btcoex;
582
583         ret = ath9k_init_channels_rates(sc);
584         if (ret)
585                 goto err_btcoex;
586
587         ath9k_init_crypto(sc);
588         ath9k_init_misc(sc);
589
590         return 0;
591
592 err_btcoex:
593         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
594                 if (ATH_TXQ_SETUP(sc, i))
595                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
596 err_queues:
597         ath9k_hw_deinit(ah);
598 err_hw:
599
600         kfree(ah);
601         sc->sc_ah = NULL;
602
603         return ret;
604 }
605
606 static void ath9k_init_band_txpower(struct ath_softc *sc, int band)
607 {
608         struct ieee80211_supported_band *sband;
609         struct ieee80211_channel *chan;
610         struct ath_hw *ah = sc->sc_ah;
611         struct ath_regulatory *reg = ath9k_hw_regulatory(ah);
612         int i;
613
614         sband = &sc->sbands[band];
615         for (i = 0; i < sband->n_channels; i++) {
616                 chan = &sband->channels[i];
617                 ah->curchan = &ah->channels[chan->hw_value];
618                 ath9k_cmn_update_ichannel(ah->curchan, chan, NL80211_CHAN_HT20);
619                 ath9k_hw_set_txpowerlimit(ah, MAX_RATE_POWER, true);
620                 chan->max_power = reg->max_power_level / 2;
621         }
622 }
623
624 static void ath9k_init_txpower_limits(struct ath_softc *sc)
625 {
626         struct ath_hw *ah = sc->sc_ah;
627         struct ath9k_channel *curchan = ah->curchan;
628
629         if (ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
630                 ath9k_init_band_txpower(sc, IEEE80211_BAND_2GHZ);
631         if (ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
632                 ath9k_init_band_txpower(sc, IEEE80211_BAND_5GHZ);
633
634         ah->curchan = curchan;
635 }
636
637 void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
638 {
639         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
640
641         hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
642                 IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
643                 IEEE80211_HW_SIGNAL_DBM |
644                 IEEE80211_HW_SUPPORTS_PS |
645                 IEEE80211_HW_PS_NULLFUNC_STACK |
646                 IEEE80211_HW_SPECTRUM_MGMT |
647                 IEEE80211_HW_REPORTS_TX_ACK_STATUS;
648
649         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
650                  hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
651
652         if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || ath9k_modparam_nohwcrypt)
653                 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
654
655         hw->wiphy->interface_modes =
656                 BIT(NL80211_IFTYPE_P2P_GO) |
657                 BIT(NL80211_IFTYPE_P2P_CLIENT) |
658                 BIT(NL80211_IFTYPE_AP) |
659                 BIT(NL80211_IFTYPE_WDS) |
660                 BIT(NL80211_IFTYPE_STATION) |
661                 BIT(NL80211_IFTYPE_ADHOC) |
662                 BIT(NL80211_IFTYPE_MESH_POINT);
663
664         if (AR_SREV_5416(sc->sc_ah))
665                 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
666
667         hw->queues = 4;
668         hw->max_rates = 4;
669         hw->channel_change_time = 5000;
670         hw->max_listen_interval = 10;
671         hw->max_rate_tries = 10;
672         hw->sta_data_size = sizeof(struct ath_node);
673         hw->vif_data_size = sizeof(struct ath_vif);
674
675 #ifdef CONFIG_ATH9K_RATE_CONTROL
676         hw->rate_control_algorithm = "ath9k_rate_control";
677 #endif
678
679         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
680                 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
681                         &sc->sbands[IEEE80211_BAND_2GHZ];
682         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
683                 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
684                         &sc->sbands[IEEE80211_BAND_5GHZ];
685
686         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
687                 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
688                         setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_2GHZ].ht_cap);
689                 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
690                         setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_5GHZ].ht_cap);
691         }
692
693         SET_IEEE80211_PERM_ADDR(hw, common->macaddr);
694 }
695
696 int ath9k_init_device(u16 devid, struct ath_softc *sc, u16 subsysid,
697                     const struct ath_bus_ops *bus_ops)
698 {
699         struct ieee80211_hw *hw = sc->hw;
700         struct ath_common *common;
701         struct ath_hw *ah;
702         int error = 0;
703         struct ath_regulatory *reg;
704
705         /* Bring up device */
706         error = ath9k_init_softc(devid, sc, subsysid, bus_ops);
707         if (error != 0)
708                 goto error_init;
709
710         ah = sc->sc_ah;
711         common = ath9k_hw_common(ah);
712         ath9k_set_hw_capab(sc, hw);
713
714         /* Initialize regulatory */
715         error = ath_regd_init(&common->regulatory, sc->hw->wiphy,
716                               ath9k_reg_notifier);
717         if (error)
718                 goto error_regd;
719
720         reg = &common->regulatory;
721
722         /* Setup TX DMA */
723         error = ath_tx_init(sc, ATH_TXBUF);
724         if (error != 0)
725                 goto error_tx;
726
727         /* Setup RX DMA */
728         error = ath_rx_init(sc, ATH_RXBUF);
729         if (error != 0)
730                 goto error_rx;
731
732         ath9k_init_txpower_limits(sc);
733
734         /* Register with mac80211 */
735         error = ieee80211_register_hw(hw);
736         if (error)
737                 goto error_register;
738
739         error = ath9k_init_debug(ah);
740         if (error) {
741                 ath_err(common, "Unable to create debugfs files\n");
742                 goto error_world;
743         }
744
745         /* Handle world regulatory */
746         if (!ath_is_world_regd(reg)) {
747                 error = regulatory_hint(hw->wiphy, reg->alpha2);
748                 if (error)
749                         goto error_world;
750         }
751
752         INIT_WORK(&sc->hw_check_work, ath_hw_check);
753         INIT_WORK(&sc->paprd_work, ath_paprd_calibrate);
754         sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
755
756         ath_init_leds(sc);
757         ath_start_rfkill_poll(sc);
758
759         return 0;
760
761 error_world:
762         ieee80211_unregister_hw(hw);
763 error_register:
764         ath_rx_cleanup(sc);
765 error_rx:
766         ath_tx_cleanup(sc);
767 error_tx:
768         /* Nothing */
769 error_regd:
770         ath9k_deinit_softc(sc);
771 error_init:
772         return error;
773 }
774
775 /*****************************/
776 /*     De-Initialization     */
777 /*****************************/
778
779 static void ath9k_deinit_softc(struct ath_softc *sc)
780 {
781         int i = 0;
782
783         if (sc->sbands[IEEE80211_BAND_2GHZ].channels)
784                 kfree(sc->sbands[IEEE80211_BAND_2GHZ].channels);
785
786         if (sc->sbands[IEEE80211_BAND_5GHZ].channels)
787                 kfree(sc->sbands[IEEE80211_BAND_5GHZ].channels);
788
789         if ((sc->btcoex.no_stomp_timer) &&
790             sc->sc_ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
791                 ath_gen_timer_free(sc->sc_ah, sc->btcoex.no_stomp_timer);
792
793         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
794                 if (ATH_TXQ_SETUP(sc, i))
795                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
796
797         ath9k_hw_deinit(sc->sc_ah);
798
799         kfree(sc->sc_ah);
800         sc->sc_ah = NULL;
801 }
802
803 void ath9k_deinit_device(struct ath_softc *sc)
804 {
805         struct ieee80211_hw *hw = sc->hw;
806
807         ath9k_ps_wakeup(sc);
808
809         wiphy_rfkill_stop_polling(sc->hw->wiphy);
810         ath_deinit_leds(sc);
811
812         ath9k_ps_restore(sc);
813
814         ieee80211_unregister_hw(hw);
815         ath_rx_cleanup(sc);
816         ath_tx_cleanup(sc);
817         ath9k_deinit_softc(sc);
818 }
819
820 void ath_descdma_cleanup(struct ath_softc *sc,
821                          struct ath_descdma *dd,
822                          struct list_head *head)
823 {
824         dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
825                           dd->dd_desc_paddr);
826
827         INIT_LIST_HEAD(head);
828         kfree(dd->dd_bufptr);
829         memset(dd, 0, sizeof(*dd));
830 }
831
832 /************************/
833 /*     Module Hooks     */
834 /************************/
835
836 static int __init ath9k_init(void)
837 {
838         int error;
839
840         /* Register rate control algorithm */
841         error = ath_rate_control_register();
842         if (error != 0) {
843                 printk(KERN_ERR
844                         "ath9k: Unable to register rate control "
845                         "algorithm: %d\n",
846                         error);
847                 goto err_out;
848         }
849
850         error = ath_pci_init();
851         if (error < 0) {
852                 printk(KERN_ERR
853                         "ath9k: No PCI devices found, driver not installed.\n");
854                 error = -ENODEV;
855                 goto err_rate_unregister;
856         }
857
858         error = ath_ahb_init();
859         if (error < 0) {
860                 error = -ENODEV;
861                 goto err_pci_exit;
862         }
863
864         return 0;
865
866  err_pci_exit:
867         ath_pci_exit();
868
869  err_rate_unregister:
870         ath_rate_control_unregister();
871  err_out:
872         return error;
873 }
874 module_init(ath9k_init);
875
876 static void __exit ath9k_exit(void)
877 {
878         is_ath9k_unloaded = true;
879         ath_ahb_exit();
880         ath_pci_exit();
881         ath_rate_control_unregister();
882         printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
883 }
884 module_exit(ath9k_exit);