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