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