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