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

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