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