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(struct ath_softc *sc, u32 reg_offset,
 200                                     u32 set, u32 clr)
 201 {
 202         u32 val;
 203
 204         val = ioread32(sc->mem + reg_offset);
 205         val &= ~clr;
 206         val |= set;
 207         iowrite32(val, sc->mem + reg_offset);
 208
 209         return val;
 210 }
 211
 212 static unsigned int ath9k_reg_rmw(void *hw_priv, u32 reg_offset, u32 set, u32 clr)
 213 {
 214         struct ath_hw *ah = (struct ath_hw *) hw_priv;
 215         struct ath_common *common = ath9k_hw_common(ah);
 216         struct ath_softc *sc = (struct ath_softc *) common->priv;
 217         unsigned long uninitialized_var(flags);
 218         u32 val;
 219
 220         if (ah->config.serialize_regmode == SER_REG_MODE_ON) {
 221                 spin_lock_irqsave(&sc->sc_serial_rw, flags);
 222                 val = __ath9k_reg_rmw(sc, reg_offset, set, clr);
 223                 spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
 224         } else
 225                 val = __ath9k_reg_rmw(sc, reg_offset, set, clr);
 226
 227         return val;
 228 }
 229
 230 /**************************/
 231 /*     Initialization     */
 232 /**************************/
 233
 234 static void setup_ht_cap(struct ath_softc *sc,
 235                          struct ieee80211_sta_ht_cap *ht_info)
 236 {
 237         struct ath_hw *ah = sc->sc_ah;
 238         struct ath_common *common = ath9k_hw_common(ah);
 239         u8 tx_streams, rx_streams;
 240         int i, max_streams;
 241
 242         ht_info->ht_supported = true;
 243         ht_info->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
 244                        IEEE80211_HT_CAP_SM_PS |
 245                        IEEE80211_HT_CAP_SGI_40 |
 246                        IEEE80211_HT_CAP_DSSSCCK40;
 247
 248         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_LDPC)
 249                 ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;
 250
 251         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20)
 252                 ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
 253
 254         ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
 255         ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
 256
 257         if (AR_SREV_9330(ah) || AR_SREV_9485(ah))
 258                 max_streams = 1;
 259         else if (AR_SREV_9300_20_OR_LATER(ah))
 260                 max_streams = 3;
 261         else
 262                 max_streams = 2;
 263
 264         if (AR_SREV_9280_20_OR_LATER(ah)) {
 265                 if (max_streams >= 2)
 266                         ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
 267                 ht_info->cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
 268         }
 269
 270         /* set up supported mcs set */
 271         memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
 272         tx_streams = ath9k_cmn_count_streams(common->tx_chainmask, max_streams);
 273         rx_streams = ath9k_cmn_count_streams(common->rx_chainmask, max_streams);
 274
 275         ath_dbg(common, ATH_DBG_CONFIG,
 276                 "TX streams %d, RX streams: %d\n",
 277                 tx_streams, rx_streams);
 278
 279         if (tx_streams != rx_streams) {
 280                 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
 281                 ht_info->mcs.tx_params |= ((tx_streams - 1) <<
 282                                 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
 283         }
 284
 285         for (i = 0; i < rx_streams; i++)
 286                 ht_info->mcs.rx_mask[i] = 0xff;
 287
 288         ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
 289 }
 290
 291 static int ath9k_reg_notifier(struct wiphy *wiphy,
 292                               struct regulatory_request *request)
 293 {
 294         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
 295         struct ath_softc *sc = hw->priv;
 296         struct ath_regulatory *reg = ath9k_hw_regulatory(sc->sc_ah);
 297
 298         return ath_reg_notifier_apply(wiphy, request, reg);
 299 }
 300
 301 /*
 302  *  This function will allocate both the DMA descriptor structure, and the
 303  *  buffers it contains.  These are used to contain the descriptors used
 304  *  by the system.
 305 */
 306 int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
 307                       struct list_head *head, const char *name,
 308                       int nbuf, int ndesc, bool is_tx)
 309 {
 310         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 311         u8 *ds;
 312         struct ath_buf *bf;
 313         int i, bsize, error, desc_len;
 314
 315         ath_dbg(common, ATH_DBG_CONFIG, "%s DMA: %u buffers %u desc/buf\n",
 316                 name, nbuf, ndesc);
 317
 318         INIT_LIST_HEAD(head);
 319
 320         if (is_tx)
 321                 desc_len = sc->sc_ah->caps.tx_desc_len;
 322         else
 323                 desc_len = sizeof(struct ath_desc);
 324
 325         /* ath_desc must be a multiple of DWORDs */
 326         if ((desc_len % 4) != 0) {
 327                 ath_err(common, "ath_desc not DWORD aligned\n");
 328                 BUG_ON((desc_len % 4) != 0);
 329                 error = -ENOMEM;
 330                 goto fail;
 331         }
 332
 333         dd->dd_desc_len = desc_len * nbuf * ndesc;
 334
 335         /*
 336          * Need additional DMA memory because we can't use
 337          * descriptors that cross the 4K page boundary. Assume
 338          * one skipped descriptor per 4K page.
 339          */
 340         if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_4KB_SPLITTRANS)) {
 341                 u32 ndesc_skipped =
 342                         ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd->dd_desc_len);
 343                 u32 dma_len;
 344
 345                 while (ndesc_skipped) {
 346                         dma_len = ndesc_skipped * desc_len;
 347                         dd->dd_desc_len += dma_len;
 348
 349                         ndesc_skipped = ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len);
 350                 }
 351         }
 352
 353         /* allocate descriptors */
 354         dd->dd_desc = dma_alloc_coherent(sc->dev, dd->dd_desc_len,
 355                                          &dd->dd_desc_paddr, GFP_KERNEL);
 356         if (dd->dd_desc == NULL) {
 357                 error = -ENOMEM;
 358                 goto fail;
 359         }
 360         ds = (u8 *) dd->dd_desc;
 361         ath_dbg(common, ATH_DBG_CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
 362                 name, ds, (u32) dd->dd_desc_len,
 363                 ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
 364
 365         /* allocate buffers */
 366         bsize = sizeof(struct ath_buf) * nbuf;
 367         bf = kzalloc(bsize, GFP_KERNEL);
 368         if (bf == NULL) {
 369                 error = -ENOMEM;
 370                 goto fail2;
 371         }
 372         dd->dd_bufptr = bf;
 373
 374         for (i = 0; i < nbuf; i++, bf++, ds += (desc_len * ndesc)) {
 375                 bf->bf_desc = ds;
 376                 bf->bf_daddr = DS2PHYS(dd, ds);
 377
 378                 if (!(sc->sc_ah->caps.hw_caps &
 379                       ATH9K_HW_CAP_4KB_SPLITTRANS)) {
 380                         /*
 381                          * Skip descriptor addresses which can cause 4KB
 382                          * boundary crossing (addr + length) with a 32 dword
 383                          * descriptor fetch.
 384                          */
 385                         while (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr)) {
 386                                 BUG_ON((caddr_t) bf->bf_desc >=
 387                                        ((caddr_t) dd->dd_desc +
 388                                         dd->dd_desc_len));
 389
 390                                 ds += (desc_len * ndesc);
 391                                 bf->bf_desc = ds;
 392                                 bf->bf_daddr = DS2PHYS(dd, ds);
 393                         }
 394                 }
 395                 list_add_tail(&bf->list, head);
 396         }
 397         return 0;
 398 fail2:
 399         dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
 400                           dd->dd_desc_paddr);
 401 fail:
 402         memset(dd, 0, sizeof(*dd));
 403         return error;
 404 }
 405
 406 void ath9k_init_crypto(struct ath_softc *sc)
 407 {
 408         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 409         int i = 0;
 410
 411         /* Get the hardware key cache size. */
 412         common->keymax = AR_KEYTABLE_SIZE;
 413
 414         /*
 415          * Reset the key cache since some parts do not
 416          * reset the contents on initial power up.
 417          */
 418         for (i = 0; i < common->keymax; i++)
 419                 ath_hw_keyreset(common, (u16) i);
 420
 421         /*
 422          * Check whether the separate key cache entries
 423          * are required to handle both tx+rx MIC keys.
 424          * With split mic keys the number of stations is limited
 425          * to 27 otherwise 59.
 426          */
 427         if (sc->sc_ah->misc_mode & AR_PCU_MIC_NEW_LOC_ENA)
 428                 common->crypt_caps |= ATH_CRYPT_CAP_MIC_COMBINED;
 429 }
 430
 431 static int ath9k_init_btcoex(struct ath_softc *sc)
 432 {
 433         struct ath_txq *txq;
 434         int r;
 435
 436         switch (sc->sc_ah->btcoex_hw.scheme) {
 437         case ATH_BTCOEX_CFG_NONE:
 438                 break;
 439         case ATH_BTCOEX_CFG_2WIRE:
 440                 ath9k_hw_btcoex_init_2wire(sc->sc_ah);
 441                 break;
 442         case ATH_BTCOEX_CFG_3WIRE:
 443                 ath9k_hw_btcoex_init_3wire(sc->sc_ah);
 444                 r = ath_init_btcoex_timer(sc);
 445                 if (r)
 446                         return -1;
 447                 txq = sc->tx.txq_map[WME_AC_BE];
 448                 ath9k_hw_init_btcoex_hw(sc->sc_ah, txq->axq_qnum);
 449                 sc->btcoex.bt_stomp_type = ATH_BTCOEX_STOMP_LOW;
 450                 break;
 451         default:
 452                 WARN_ON(1);
 453                 break;
 454         }
 455
 456         return 0;
 457 }
 458
 459 static int ath9k_init_queues(struct ath_softc *sc)
 460 {
 461         int i = 0;
 462
 463         sc->beacon.beaconq = ath9k_hw_beaconq_setup(sc->sc_ah);
 464         sc->beacon.cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0);
 465
 466         sc->config.cabqReadytime = ATH_CABQ_READY_TIME;
 467         ath_cabq_update(sc);
 468
 469         for (i = 0; i < WME_NUM_AC; i++) {
 470                 sc->tx.txq_map[i] = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, i);
 471                 sc->tx.txq_map[i]->mac80211_qnum = i;
 472         }
 473         return 0;
 474 }
 475
 476 static int ath9k_init_channels_rates(struct ath_softc *sc)
 477 {
 478         void *channels;
 479
 480         BUILD_BUG_ON(ARRAY_SIZE(ath9k_2ghz_chantable) +
 481                      ARRAY_SIZE(ath9k_5ghz_chantable) !=
 482                      ATH9K_NUM_CHANNELS);
 483
 484         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ) {
 485                 channels = kmemdup(ath9k_2ghz_chantable,
 486                         sizeof(ath9k_2ghz_chantable), GFP_KERNEL);
 487                 if (!channels)
 488                     return -ENOMEM;
 489
 490                 sc->sbands[IEEE80211_BAND_2GHZ].channels = channels;
 491                 sc->sbands[IEEE80211_BAND_2GHZ].band = IEEE80211_BAND_2GHZ;
 492                 sc->sbands[IEEE80211_BAND_2GHZ].n_channels =
 493                         ARRAY_SIZE(ath9k_2ghz_chantable);
 494                 sc->sbands[IEEE80211_BAND_2GHZ].bitrates = ath9k_legacy_rates;
 495                 sc->sbands[IEEE80211_BAND_2GHZ].n_bitrates =
 496                         ARRAY_SIZE(ath9k_legacy_rates);
 497         }
 498
 499         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ) {
 500                 channels = kmemdup(ath9k_5ghz_chantable,
 501                         sizeof(ath9k_5ghz_chantable), GFP_KERNEL);
 502                 if (!channels) {
 503                         if (sc->sbands[IEEE80211_BAND_2GHZ].channels)
 504                                 kfree(sc->sbands[IEEE80211_BAND_2GHZ].channels);
 505                         return -ENOMEM;
 506                 }
 507
 508                 sc->sbands[IEEE80211_BAND_5GHZ].channels = channels;
 509                 sc->sbands[IEEE80211_BAND_5GHZ].band = IEEE80211_BAND_5GHZ;
 510                 sc->sbands[IEEE80211_BAND_5GHZ].n_channels =
 511                         ARRAY_SIZE(ath9k_5ghz_chantable);
 512                 sc->sbands[IEEE80211_BAND_5GHZ].bitrates =
 513                         ath9k_legacy_rates + 4;
 514                 sc->sbands[IEEE80211_BAND_5GHZ].n_bitrates =
 515                         ARRAY_SIZE(ath9k_legacy_rates) - 4;
 516         }
 517         return 0;
 518 }
 519
 520 static void ath9k_init_misc(struct ath_softc *sc)
 521 {
 522         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 523         int i = 0;
 524         setup_timer(&common->ani.timer, ath_ani_calibrate, (unsigned long)sc);
 525
 526         sc->config.txpowlimit = ATH_TXPOWER_MAX;
 527
 528         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
 529                 sc->sc_flags |= SC_OP_TXAGGR;
 530                 sc->sc_flags |= SC_OP_RXAGGR;
 531         }
 532
 533         common->tx_chainmask = sc->sc_ah->caps.tx_chainmask;
 534         common->rx_chainmask = sc->sc_ah->caps.rx_chainmask;
 535
 536         ath9k_hw_set_diversity(sc->sc_ah, true);
 537         sc->rx.defant = ath9k_hw_getdefantenna(sc->sc_ah);
 538
 539         memcpy(common->bssidmask, ath_bcast_mac, ETH_ALEN);
 540
 541         sc->beacon.slottime = ATH9K_SLOT_TIME_9;
 542
 543         for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++)
 544                 sc->beacon.bslot[i] = NULL;
 545
 546         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)
 547                 sc->ant_comb.count = ATH_ANT_DIV_COMB_INIT_COUNT;
 548 }
 549
 550 static int ath9k_init_softc(u16 devid, struct ath_softc *sc, u16 subsysid,
 551                             const struct ath_bus_ops *bus_ops)
 552 {
 553         struct ath9k_platform_data *pdata = sc->dev->platform_data;
 554         struct ath_hw *ah = NULL;
 555         struct ath_common *common;
 556         int ret = 0, i;
 557         int csz = 0;
 558
 559         ah = kzalloc(sizeof(struct ath_hw), GFP_KERNEL);
 560         if (!ah)
 561                 return -ENOMEM;
 562
 563         ah->hw = sc->hw;
 564         ah->hw_version.devid = devid;
 565         ah->hw_version.subsysid = subsysid;
 566         ah->reg_ops.read = ath9k_ioread32;
 567         ah->reg_ops.write = ath9k_iowrite32;
 568         ah->reg_ops.rmw = ath9k_reg_rmw;
 569         sc->sc_ah = ah;
 570
 571         if (!pdata) {
 572                 ah->ah_flags |= AH_USE_EEPROM;
 573                 sc->sc_ah->led_pin = -1;
 574         } else {
 575                 sc->sc_ah->gpio_mask = pdata->gpio_mask;
 576                 sc->sc_ah->gpio_val = pdata->gpio_val;
 577                 sc->sc_ah->led_pin = pdata->led_pin;
 578                 ah->is_clk_25mhz = pdata->is_clk_25mhz;
 579                 ah->get_mac_revision = pdata->get_mac_revision;
 580                 ah->external_reset = pdata->external_reset;
 581         }
 582
 583         common = ath9k_hw_common(ah);
 584         common->ops = &ah->reg_ops;
 585         common->bus_ops = bus_ops;
 586         common->ah = ah;
 587         common->hw = sc->hw;
 588         common->priv = sc;
 589         common->debug_mask = ath9k_debug;
 590         common->btcoex_enabled = ath9k_btcoex_enable == 1;
 591         common->disable_ani = false;
 592         spin_lock_init(&common->cc_lock);
 593
 594         spin_lock_init(&sc->sc_serial_rw);
 595         spin_lock_init(&sc->sc_pm_lock);
 596         mutex_init(&sc->mutex);
 597 #ifdef CONFIG_ATH9K_DEBUGFS
 598         spin_lock_init(&sc->nodes_lock);
 599         INIT_LIST_HEAD(&sc->nodes);
 600 #endif
 601         tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
 602         tasklet_init(&sc->bcon_tasklet, ath_beacon_tasklet,
 603                      (unsigned long)sc);
 604
 605         /*
 606          * Cache line size is used to size and align various
 607          * structures used to communicate with the hardware.
 608          */
 609         ath_read_cachesize(common, &csz);
 610         common->cachelsz = csz << 2; /* convert to bytes */
 611
 612         /* Initializes the hardware for all supported chipsets */
 613         ret = ath9k_hw_init(ah);
 614         if (ret)
 615                 goto err_hw;
 616
 617         if (pdata && pdata->macaddr)
 618                 memcpy(common->macaddr, pdata->macaddr, ETH_ALEN);
 619
 620         ret = ath9k_init_queues(sc);
 621         if (ret)
 622                 goto err_queues;
 623
 624         ret =  ath9k_init_btcoex(sc);
 625         if (ret)
 626                 goto err_btcoex;
 627
 628         ret = ath9k_init_channels_rates(sc);
 629         if (ret)
 630                 goto err_btcoex;
 631
 632         ath9k_init_crypto(sc);
 633         ath9k_init_misc(sc);
 634
 635         return 0;
 636
 637 err_btcoex:
 638         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
 639                 if (ATH_TXQ_SETUP(sc, i))
 640                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 641 err_queues:
 642         ath9k_hw_deinit(ah);
 643 err_hw:
 644
 645         kfree(ah);
 646         sc->sc_ah = NULL;
 647
 648         return ret;
 649 }
 650
 651 static void ath9k_init_band_txpower(struct ath_softc *sc, int band)
 652 {
 653         struct ieee80211_supported_band *sband;
 654         struct ieee80211_channel *chan;
 655         struct ath_hw *ah = sc->sc_ah;
 656         struct ath_regulatory *reg = ath9k_hw_regulatory(ah);
 657         int i;
 658
 659         sband = &sc->sbands[band];
 660         for (i = 0; i < sband->n_channels; i++) {
 661                 chan = &sband->channels[i];
 662                 ah->curchan = &ah->channels[chan->hw_value];
 663                 ath9k_cmn_update_ichannel(ah->curchan, chan, NL80211_CHAN_HT20);
 664                 ath9k_hw_set_txpowerlimit(ah, MAX_RATE_POWER, true);
 665                 chan->max_power = reg->max_power_level / 2;
 666         }
 667 }
 668
 669 static void ath9k_init_txpower_limits(struct ath_softc *sc)
 670 {
 671         struct ath_hw *ah = sc->sc_ah;
 672         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 673         struct ath9k_channel *curchan = ah->curchan;
 674
 675         ah->txchainmask = common->tx_chainmask;
 676         if (ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
 677                 ath9k_init_band_txpower(sc, IEEE80211_BAND_2GHZ);
 678         if (ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
 679                 ath9k_init_band_txpower(sc, IEEE80211_BAND_5GHZ);
 680
 681         ah->curchan = curchan;
 682 }
 683
 684 void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
 685 {
 686         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 687
 688         hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
 689                 IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
 690                 IEEE80211_HW_SIGNAL_DBM |
 691                 IEEE80211_HW_SUPPORTS_PS |
 692                 IEEE80211_HW_PS_NULLFUNC_STACK |
 693                 IEEE80211_HW_SPECTRUM_MGMT |
 694                 IEEE80211_HW_REPORTS_TX_ACK_STATUS;
 695
 696         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
 697                  hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
 698
 699         if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || ath9k_modparam_nohwcrypt)
 700                 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
 701
 702         hw->wiphy->interface_modes =
 703                 BIT(NL80211_IFTYPE_P2P_GO) |
 704                 BIT(NL80211_IFTYPE_P2P_CLIENT) |
 705                 BIT(NL80211_IFTYPE_AP) |
 706                 BIT(NL80211_IFTYPE_WDS) |
 707                 BIT(NL80211_IFTYPE_STATION) |
 708                 BIT(NL80211_IFTYPE_ADHOC) |
 709                 BIT(NL80211_IFTYPE_MESH_POINT);
 710
 711         if (AR_SREV_5416(sc->sc_ah))
 712                 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
 713
 714         hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
 715
 716         hw->queues = 4;
 717         hw->max_rates = 4;
 718         hw->channel_change_time = 5000;
 719         hw->max_listen_interval = 10;
 720         hw->max_rate_tries = 10;
 721         hw->sta_data_size = sizeof(struct ath_node);
 722         hw->vif_data_size = sizeof(struct ath_vif);
 723
 724 #ifdef CONFIG_ATH9K_RATE_CONTROL
 725         hw->rate_control_algorithm = "ath9k_rate_control";
 726 #endif
 727
 728         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
 729                 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
 730                         &sc->sbands[IEEE80211_BAND_2GHZ];
 731         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
 732                 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
 733                         &sc->sbands[IEEE80211_BAND_5GHZ];
 734
 735         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
 736                 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
 737                         setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_2GHZ].ht_cap);
 738                 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
 739                         setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_5GHZ].ht_cap);
 740         }
 741
 742         SET_IEEE80211_PERM_ADDR(hw, common->macaddr);
 743 }
 744
 745 int ath9k_init_device(u16 devid, struct ath_softc *sc, u16 subsysid,
 746                     const struct ath_bus_ops *bus_ops)
 747 {
 748         struct ieee80211_hw *hw = sc->hw;
 749         struct ath_common *common;
 750         struct ath_hw *ah;
 751         int error = 0;
 752         struct ath_regulatory *reg;
 753
 754         /* Bring up device */
 755         error = ath9k_init_softc(devid, sc, subsysid, bus_ops);
 756         if (error != 0)
 757                 goto error_init;
 758
 759         ah = sc->sc_ah;
 760         common = ath9k_hw_common(ah);
 761         ath9k_set_hw_capab(sc, hw);
 762
 763         /* Initialize regulatory */
 764         error = ath_regd_init(&common->regulatory, sc->hw->wiphy,
 765                               ath9k_reg_notifier);
 766         if (error)
 767                 goto error_regd;
 768
 769         reg = &common->regulatory;
 770
 771         /* Setup TX DMA */
 772         error = ath_tx_init(sc, ATH_TXBUF);
 773         if (error != 0)
 774                 goto error_tx;
 775
 776         /* Setup RX DMA */
 777         error = ath_rx_init(sc, ATH_RXBUF);
 778         if (error != 0)
 779                 goto error_rx;
 780
 781         ath9k_init_txpower_limits(sc);
 782
 783 #ifdef CONFIG_MAC80211_LEDS
 784         /* must be initialized before ieee80211_register_hw */
 785         sc->led_cdev.default_trigger = ieee80211_create_tpt_led_trigger(sc->hw,
 786                 IEEE80211_TPT_LEDTRIG_FL_RADIO, ath9k_tpt_blink,
 787                 ARRAY_SIZE(ath9k_tpt_blink));
 788 #endif
 789
 790         /* Register with mac80211 */
 791         error = ieee80211_register_hw(hw);
 792         if (error)
 793                 goto error_register;
 794
 795         error = ath9k_init_debug(ah);
 796         if (error) {
 797                 ath_err(common, "Unable to create debugfs files\n");
 798                 goto error_world;
 799         }
 800
 801         /* Handle world regulatory */
 802         if (!ath_is_world_regd(reg)) {
 803                 error = regulatory_hint(hw->wiphy, reg->alpha2);
 804                 if (error)
 805                         goto error_world;
 806         }
 807
 808         INIT_WORK(&sc->hw_check_work, ath_hw_check);
 809         INIT_WORK(&sc->paprd_work, ath_paprd_calibrate);
 810         INIT_DELAYED_WORK(&sc->hw_pll_work, ath_hw_pll_work);
 811         sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
 812
 813         ath_init_leds(sc);
 814         ath_start_rfkill_poll(sc);
 815
 816         return 0;
 817
 818 error_world:
 819         ieee80211_unregister_hw(hw);
 820 error_register:
 821         ath_rx_cleanup(sc);
 822 error_rx:
 823         ath_tx_cleanup(sc);
 824 error_tx:
 825         /* Nothing */
 826 error_regd:
 827         ath9k_deinit_softc(sc);
 828 error_init:
 829         return error;
 830 }
 831
 832 /*****************************/
 833 /*     De-Initialization     */
 834 /*****************************/
 835
 836 static void ath9k_deinit_softc(struct ath_softc *sc)
 837 {
 838         int i = 0;
 839
 840         if (sc->sbands[IEEE80211_BAND_2GHZ].channels)
 841                 kfree(sc->sbands[IEEE80211_BAND_2GHZ].channels);
 842
 843         if (sc->sbands[IEEE80211_BAND_5GHZ].channels)
 844                 kfree(sc->sbands[IEEE80211_BAND_5GHZ].channels);
 845
 846         if ((sc->btcoex.no_stomp_timer) &&
 847             sc->sc_ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
 848                 ath_gen_timer_free(sc->sc_ah, sc->btcoex.no_stomp_timer);
 849
 850         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
 851                 if (ATH_TXQ_SETUP(sc, i))
 852                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 853
 854         ath9k_hw_deinit(sc->sc_ah);
 855
 856         kfree(sc->sc_ah);
 857         sc->sc_ah = NULL;
 858 }
 859
 860 void ath9k_deinit_device(struct ath_softc *sc)
 861 {
 862         struct ieee80211_hw *hw = sc->hw;
 863
 864         ath9k_ps_wakeup(sc);
 865
 866         wiphy_rfkill_stop_polling(sc->hw->wiphy);
 867         ath_deinit_leds(sc);
 868
 869         ath9k_ps_restore(sc);
 870
 871         ieee80211_unregister_hw(hw);
 872         ath_rx_cleanup(sc);
 873         ath_tx_cleanup(sc);
 874         ath9k_deinit_softc(sc);
 875 }
 876
 877 void ath_descdma_cleanup(struct ath_softc *sc,
 878                          struct ath_descdma *dd,
 879                          struct list_head *head)
 880 {
 881         dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
 882                           dd->dd_desc_paddr);
 883
 884         INIT_LIST_HEAD(head);
 885         kfree(dd->dd_bufptr);
 886         memset(dd, 0, sizeof(*dd));
 887 }
 888
 889 /************************/
 890 /*     Module Hooks     */
 891 /************************/
 892
 893 static int __init ath9k_init(void)
 894 {
 895         int error;
 896
 897         /* Register rate control algorithm */
 898         error = ath_rate_control_register();
 899         if (error != 0) {
 900                 printk(KERN_ERR
 901                         "ath9k: Unable to register rate control "
 902                         "algorithm: %d\n",
 903                         error);
 904                 goto err_out;
 905         }
 906
 907         error = ath_pci_init();
 908         if (error < 0) {
 909                 printk(KERN_ERR
 910                         "ath9k: No PCI devices found, driver not installed.\n");
 911                 error = -ENODEV;
 912                 goto err_rate_unregister;
 913         }
 914
 915         error = ath_ahb_init();
 916         if (error < 0) {
 917                 error = -ENODEV;
 918                 goto err_pci_exit;
 919         }
 920
 921         return 0;
 922
 923  err_pci_exit:
 924         ath_pci_exit();
 925
 926  err_rate_unregister:
 927         ath_rate_control_unregister();
 928  err_out:
 929         return error;
 930 }
 931 module_init(ath9k_init);
 932
 933 static void __exit ath9k_exit(void)
 934 {
 935         is_ath9k_unloaded = true;
 936         ath_ahb_exit();
 937         ath_pci_exit();
 938         ath_rate_control_unregister();
 939         printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
 940 }
 941 module_exit(ath9k_exit);