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