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

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