drivers/net/wireless/ath/ath9k/init.c

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