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 "ath9k.h"
  18
  19 static char *dev_info = "ath9k";
  20
  21 MODULE_AUTHOR("Atheros Communications");
  22 MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
  23 MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
  24 MODULE_LICENSE("Dual BSD/GPL");
  25
  26 static unsigned int ath9k_debug = ATH_DBG_DEFAULT;
  27 module_param_named(debug, ath9k_debug, uint, 0);
  28 MODULE_PARM_DESC(debug, "Debugging mask");
  29
  30 int modparam_nohwcrypt;
  31 module_param_named(nohwcrypt, modparam_nohwcrypt, int, 0444);
  32 MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption");
  33
  34 /* We use the hw_value as an index into our private channel structure */
  35
  36 #define CHAN2G(_freq, _idx)  { \
  37         .center_freq = (_freq), \
  38         .hw_value = (_idx), \
  39         .max_power = 20, \
  40 }
  41
  42 #define CHAN5G(_freq, _idx) { \
  43         .band = IEEE80211_BAND_5GHZ, \
  44         .center_freq = (_freq), \
  45         .hw_value = (_idx), \
  46         .max_power = 20, \
  47 }
  48
  49 /* Some 2 GHz radios are actually tunable on 2312-2732
  50  * on 5 MHz steps, we support the channels which we know
  51  * we have calibration data for all cards though to make
  52  * this static */
  53 static struct ieee80211_channel ath9k_2ghz_chantable[] = {
  54         CHAN2G(2412, 0), /* Channel 1 */
  55         CHAN2G(2417, 1), /* Channel 2 */
  56         CHAN2G(2422, 2), /* Channel 3 */
  57         CHAN2G(2427, 3), /* Channel 4 */
  58         CHAN2G(2432, 4), /* Channel 5 */
  59         CHAN2G(2437, 5), /* Channel 6 */
  60         CHAN2G(2442, 6), /* Channel 7 */
  61         CHAN2G(2447, 7), /* Channel 8 */
  62         CHAN2G(2452, 8), /* Channel 9 */
  63         CHAN2G(2457, 9), /* Channel 10 */
  64         CHAN2G(2462, 10), /* Channel 11 */
  65         CHAN2G(2467, 11), /* Channel 12 */
  66         CHAN2G(2472, 12), /* Channel 13 */
  67         CHAN2G(2484, 13), /* Channel 14 */
  68 };
  69
  70 /* Some 5 GHz radios are actually tunable on XXXX-YYYY
  71  * on 5 MHz steps, we support the channels which we know
  72  * we have calibration data for all cards though to make
  73  * this static */
  74 static struct ieee80211_channel ath9k_5ghz_chantable[] = {
  75         /* _We_ call this UNII 1 */
  76         CHAN5G(5180, 14), /* Channel 36 */
  77         CHAN5G(5200, 15), /* Channel 40 */
  78         CHAN5G(5220, 16), /* Channel 44 */
  79         CHAN5G(5240, 17), /* Channel 48 */
  80         /* _We_ call this UNII 2 */
  81         CHAN5G(5260, 18), /* Channel 52 */
  82         CHAN5G(5280, 19), /* Channel 56 */
  83         CHAN5G(5300, 20), /* Channel 60 */
  84         CHAN5G(5320, 21), /* Channel 64 */
  85         /* _We_ call this "Middle band" */
  86         CHAN5G(5500, 22), /* Channel 100 */
  87         CHAN5G(5520, 23), /* Channel 104 */
  88         CHAN5G(5540, 24), /* Channel 108 */
  89         CHAN5G(5560, 25), /* Channel 112 */
  90         CHAN5G(5580, 26), /* Channel 116 */
  91         CHAN5G(5600, 27), /* Channel 120 */
  92         CHAN5G(5620, 28), /* Channel 124 */
  93         CHAN5G(5640, 29), /* Channel 128 */
  94         CHAN5G(5660, 30), /* Channel 132 */
  95         CHAN5G(5680, 31), /* Channel 136 */
  96         CHAN5G(5700, 32), /* Channel 140 */
  97         /* _We_ call this UNII 3 */
  98         CHAN5G(5745, 33), /* Channel 149 */
  99         CHAN5G(5765, 34), /* Channel 153 */
 100         CHAN5G(5785, 35), /* Channel 157 */
 101         CHAN5G(5805, 36), /* Channel 161 */
 102         CHAN5G(5825, 37), /* Channel 165 */
 103 };
 104
 105 /* Atheros hardware rate code addition for short premble */
 106 #define SHPCHECK(__hw_rate, __flags) \
 107         ((__flags & IEEE80211_RATE_SHORT_PREAMBLE) ? (__hw_rate | 0x04 ) : 0)
 108
 109 #define RATE(_bitrate, _hw_rate, _flags) {              \
 110         .bitrate        = (_bitrate),                   \
 111         .flags          = (_flags),                     \
 112         .hw_value       = (_hw_rate),                   \
 113         .hw_value_short = (SHPCHECK(_hw_rate, _flags))  \
 114 }
 115
 116 static struct ieee80211_rate ath9k_legacy_rates[] = {
 117         RATE(10, 0x1b, 0),
 118         RATE(20, 0x1a, IEEE80211_RATE_SHORT_PREAMBLE),
 119         RATE(55, 0x19, IEEE80211_RATE_SHORT_PREAMBLE),
 120         RATE(110, 0x18, IEEE80211_RATE_SHORT_PREAMBLE),
 121         RATE(60, 0x0b, 0),
 122         RATE(90, 0x0f, 0),
 123         RATE(120, 0x0a, 0),
 124         RATE(180, 0x0e, 0),
 125         RATE(240, 0x09, 0),
 126         RATE(360, 0x0d, 0),
 127         RATE(480, 0x08, 0),
 128         RATE(540, 0x0c, 0),
 129 };
 130
 131 static void ath9k_deinit_softc(struct ath_softc *sc);
 132
 133 /*
 134  * Read and write, they both share the same lock. We do this to serialize
 135  * reads and writes on Atheros 802.11n PCI devices only. This is required
 136  * as the FIFO on these devices can only accept sanely 2 requests.
 137  */
 138
 139 static void ath9k_iowrite32(void *hw_priv, u32 val, u32 reg_offset)
 140 {
 141         struct ath_hw *ah = (struct ath_hw *) hw_priv;
 142         struct ath_common *common = ath9k_hw_common(ah);
 143         struct ath_softc *sc = (struct ath_softc *) common->priv;
 144
 145         if (ah->config.serialize_regmode == SER_REG_MODE_ON) {
 146                 unsigned long flags;
 147                 spin_lock_irqsave(&sc->sc_serial_rw, flags);
 148                 iowrite32(val, sc->mem + reg_offset);
 149                 spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
 150         } else
 151                 iowrite32(val, sc->mem + reg_offset);
 152 }
 153
 154 static unsigned int ath9k_ioread32(void *hw_priv, u32 reg_offset)
 155 {
 156         struct ath_hw *ah = (struct ath_hw *) hw_priv;
 157         struct ath_common *common = ath9k_hw_common(ah);
 158         struct ath_softc *sc = (struct ath_softc *) common->priv;
 159         u32 val;
 160
 161         if (ah->config.serialize_regmode == SER_REG_MODE_ON) {
 162                 unsigned long flags;
 163                 spin_lock_irqsave(&sc->sc_serial_rw, flags);
 164                 val = ioread32(sc->mem + reg_offset);
 165                 spin_unlock_irqrestore(&sc->sc_serial_rw, flags);
 166         } else
 167                 val = ioread32(sc->mem + reg_offset);
 168         return val;
 169 }
 170
 171 static const struct ath_ops ath9k_common_ops = {
 172         .read = ath9k_ioread32,
 173         .write = ath9k_iowrite32,
 174 };
 175
 176 /**************************/
 177 /*     Initialization     */
 178 /**************************/
 179
 180 static void setup_ht_cap(struct ath_softc *sc,
 181                          struct ieee80211_sta_ht_cap *ht_info)
 182 {
 183         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 184         u8 tx_streams, rx_streams;
 185
 186         ht_info->ht_supported = true;
 187         ht_info->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
 188                        IEEE80211_HT_CAP_SM_PS |
 189                        IEEE80211_HT_CAP_SGI_40 |
 190                        IEEE80211_HT_CAP_DSSSCCK40;
 191
 192         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_LDPC)
 193                 ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;
 194
 195         ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
 196         ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
 197
 198         /* set up supported mcs set */
 199         memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
 200         tx_streams = !(common->tx_chainmask & (common->tx_chainmask - 1)) ?
 201                      1 : 2;
 202         rx_streams = !(common->rx_chainmask & (common->rx_chainmask - 1)) ?
 203                      1 : 2;
 204
 205         if (tx_streams != rx_streams) {
 206                 ath_print(common, ATH_DBG_CONFIG,
 207                           "TX streams %d, RX streams: %d\n",
 208                           tx_streams, rx_streams);
 209                 ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
 210                 ht_info->mcs.tx_params |= ((tx_streams - 1) <<
 211                                 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
 212         }
 213
 214         ht_info->mcs.rx_mask[0] = 0xff;
 215         if (rx_streams >= 2)
 216                 ht_info->mcs.rx_mask[1] = 0xff;
 217
 218         ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
 219 }
 220
 221 static int ath9k_reg_notifier(struct wiphy *wiphy,
 222                               struct regulatory_request *request)
 223 {
 224         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
 225         struct ath_wiphy *aphy = hw->priv;
 226         struct ath_softc *sc = aphy->sc;
 227         struct ath_regulatory *reg = ath9k_hw_regulatory(sc->sc_ah);
 228
 229         return ath_reg_notifier_apply(wiphy, request, reg);
 230 }
 231
 232 /*
 233  *  This function will allocate both the DMA descriptor structure, and the
 234  *  buffers it contains.  These are used to contain the descriptors used
 235  *  by the system.
 236 */
 237 int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
 238                       struct list_head *head, const char *name,
 239                       int nbuf, int ndesc, bool is_tx)
 240 {
 241 #define DS2PHYS(_dd, _ds)                                               \
 242         ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
 243 #define ATH_DESC_4KB_BOUND_CHECK(_daddr) ((((_daddr) & 0xFFF) > 0xF7F) ? 1 : 0)
 244 #define ATH_DESC_4KB_BOUND_NUM_SKIPPED(_len) ((_len) / 4096)
 245         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 246         u8 *ds;
 247         struct ath_buf *bf;
 248         int i, bsize, error, desc_len;
 249
 250         ath_print(common, ATH_DBG_CONFIG, "%s DMA: %u buffers %u desc/buf\n",
 251                   name, nbuf, ndesc);
 252
 253         INIT_LIST_HEAD(head);
 254
 255         if (is_tx)
 256                 desc_len = sc->sc_ah->caps.tx_desc_len;
 257         else
 258                 desc_len = sizeof(struct ath_desc);
 259
 260         /* ath_desc must be a multiple of DWORDs */
 261         if ((desc_len % 4) != 0) {
 262                 ath_print(common, ATH_DBG_FATAL,
 263                           "ath_desc not DWORD aligned\n");
 264                 BUG_ON((desc_len % 4) != 0);
 265                 error = -ENOMEM;
 266                 goto fail;
 267         }
 268
 269         dd->dd_desc_len = desc_len * nbuf * ndesc;
 270
 271         /*
 272          * Need additional DMA memory because we can't use
 273          * descriptors that cross the 4K page boundary. Assume
 274          * one skipped descriptor per 4K page.
 275          */
 276         if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_4KB_SPLITTRANS)) {
 277                 u32 ndesc_skipped =
 278                         ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd->dd_desc_len);
 279                 u32 dma_len;
 280
 281                 while (ndesc_skipped) {
 282                         dma_len = ndesc_skipped * desc_len;
 283                         dd->dd_desc_len += dma_len;
 284
 285                         ndesc_skipped = ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len);
 286                 };
 287         }
 288
 289         /* allocate descriptors */
 290         dd->dd_desc = dma_alloc_coherent(sc->dev, dd->dd_desc_len,
 291                                          &dd->dd_desc_paddr, GFP_KERNEL);
 292         if (dd->dd_desc == NULL) {
 293                 error = -ENOMEM;
 294                 goto fail;
 295         }
 296         ds = (u8 *) dd->dd_desc;
 297         ath_print(common, ATH_DBG_CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
 298                   name, ds, (u32) dd->dd_desc_len,
 299                   ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
 300
 301         /* allocate buffers */
 302         bsize = sizeof(struct ath_buf) * nbuf;
 303         bf = kzalloc(bsize, GFP_KERNEL);
 304         if (bf == NULL) {
 305                 error = -ENOMEM;
 306                 goto fail2;
 307         }
 308         dd->dd_bufptr = bf;
 309
 310         for (i = 0; i < nbuf; i++, bf++, ds += (desc_len * ndesc)) {
 311                 bf->bf_desc = ds;
 312                 bf->bf_daddr = DS2PHYS(dd, ds);
 313
 314                 if (!(sc->sc_ah->caps.hw_caps &
 315                       ATH9K_HW_CAP_4KB_SPLITTRANS)) {
 316                         /*
 317                          * Skip descriptor addresses which can cause 4KB
 318                          * boundary crossing (addr + length) with a 32 dword
 319                          * descriptor fetch.
 320                          */
 321                         while (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr)) {
 322                                 BUG_ON((caddr_t) bf->bf_desc >=
 323                                        ((caddr_t) dd->dd_desc +
 324                                         dd->dd_desc_len));
 325
 326                                 ds += (desc_len * ndesc);
 327                                 bf->bf_desc = ds;
 328                                 bf->bf_daddr = DS2PHYS(dd, ds);
 329                         }
 330                 }
 331                 list_add_tail(&bf->list, head);
 332         }
 333         return 0;
 334 fail2:
 335         dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
 336                           dd->dd_desc_paddr);
 337 fail:
 338         memset(dd, 0, sizeof(*dd));
 339         return error;
 340 #undef ATH_DESC_4KB_BOUND_CHECK
 341 #undef ATH_DESC_4KB_BOUND_NUM_SKIPPED
 342 #undef DS2PHYS
 343 }
 344
 345 static void ath9k_init_crypto(struct ath_softc *sc)
 346 {
 347         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 348         int i = 0;
 349
 350         /* Get the hardware key cache size. */
 351         common->keymax = sc->sc_ah->caps.keycache_size;
 352         if (common->keymax > ATH_KEYMAX) {
 353                 ath_print(common, ATH_DBG_ANY,
 354                           "Warning, using only %u entries in %u key cache\n",
 355                           ATH_KEYMAX, common->keymax);
 356                 common->keymax = ATH_KEYMAX;
 357         }
 358
 359         /*
 360          * Reset the key cache since some parts do not
 361          * reset the contents on initial power up.
 362          */
 363         for (i = 0; i < common->keymax; i++)
 364                 ath9k_hw_keyreset(sc->sc_ah, (u16) i);
 365
 366         if (ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_CIPHER,
 367                                    ATH9K_CIPHER_TKIP, NULL)) {
 368                 /*
 369                  * Whether we should enable h/w TKIP MIC.
 370                  * XXX: if we don't support WME TKIP MIC, then we wouldn't
 371                  * report WMM capable, so it's always safe to turn on
 372                  * TKIP MIC in this case.
 373                  */
 374                 ath9k_hw_setcapability(sc->sc_ah, ATH9K_CAP_TKIP_MIC, 0, 1, NULL);
 375         }
 376
 377         /*
 378          * Check whether the separate key cache entries
 379          * are required to handle both tx+rx MIC keys.
 380          * With split mic keys the number of stations is limited
 381          * to 27 otherwise 59.
 382          */
 383         if (ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_CIPHER,
 384                                    ATH9K_CIPHER_TKIP, NULL)
 385             && ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_CIPHER,
 386                                       ATH9K_CIPHER_MIC, NULL)
 387             && ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_TKIP_SPLIT,
 388                                       0, NULL))
 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 = ath_tx_get_qnum(sc, ATH9K_TX_QUEUE_DATA, ATH9K_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, ATH9K_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, ATH9K_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, ATH9K_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, ATH9K_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->chan_work, ath9k_wiphy_chan_work);
 724         INIT_DELAYED_WORK(&sc->wiphy_work, ath9k_wiphy_work);
 725         sc->wiphy_scheduler_int = msecs_to_jiffies(500);
 726
 727         ath_init_leds(sc);
 728         ath_start_rfkill_poll(sc);
 729
 730         return 0;
 731
 732 error_world:
 733         ieee80211_unregister_hw(hw);
 734 error_register:
 735         ath_rx_cleanup(sc);
 736 error_rx:
 737         ath_tx_cleanup(sc);
 738 error_tx:
 739         /* Nothing */
 740 error_regd:
 741         ath9k_deinit_softc(sc);
 742 error_init:
 743         return error;
 744 }
 745
 746 /*****************************/
 747 /*     De-Initialization     */
 748 /*****************************/
 749
 750 static void ath9k_deinit_softc(struct ath_softc *sc)
 751 {
 752         int i = 0;
 753
 754         if ((sc->btcoex.no_stomp_timer) &&
 755             sc->sc_ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
 756                 ath_gen_timer_free(sc->sc_ah, sc->btcoex.no_stomp_timer);
 757
 758         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
 759                 if (ATH_TXQ_SETUP(sc, i))
 760                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 761
 762         ath9k_exit_debug(sc->sc_ah);
 763         ath9k_hw_deinit(sc->sc_ah);
 764
 765         tasklet_kill(&sc->intr_tq);
 766         tasklet_kill(&sc->bcon_tasklet);
 767
 768         kfree(sc->sc_ah);
 769         sc->sc_ah = NULL;
 770 }
 771
 772 void ath9k_deinit_device(struct ath_softc *sc)
 773 {
 774         struct ieee80211_hw *hw = sc->hw;
 775         int i = 0;
 776
 777         ath9k_ps_wakeup(sc);
 778
 779         wiphy_rfkill_stop_polling(sc->hw->wiphy);
 780         ath_deinit_leds(sc);
 781
 782         for (i = 0; i < sc->num_sec_wiphy; i++) {
 783                 struct ath_wiphy *aphy = sc->sec_wiphy[i];
 784                 if (aphy == NULL)
 785                         continue;
 786                 sc->sec_wiphy[i] = NULL;
 787                 ieee80211_unregister_hw(aphy->hw);
 788                 ieee80211_free_hw(aphy->hw);
 789         }
 790         kfree(sc->sec_wiphy);
 791
 792         ieee80211_unregister_hw(hw);
 793         ath_rx_cleanup(sc);
 794         ath_tx_cleanup(sc);
 795         ath9k_deinit_softc(sc);
 796 }
 797
 798 void ath_descdma_cleanup(struct ath_softc *sc,
 799                          struct ath_descdma *dd,
 800                          struct list_head *head)
 801 {
 802         dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
 803                           dd->dd_desc_paddr);
 804
 805         INIT_LIST_HEAD(head);
 806         kfree(dd->dd_bufptr);
 807         memset(dd, 0, sizeof(*dd));
 808 }
 809
 810 /************************/
 811 /*     Module Hooks     */
 812 /************************/
 813
 814 static int __init ath9k_init(void)
 815 {
 816         int error;
 817
 818         /* Register rate control algorithm */
 819         error = ath_rate_control_register();
 820         if (error != 0) {
 821                 printk(KERN_ERR
 822                         "ath9k: Unable to register rate control "
 823                         "algorithm: %d\n",
 824                         error);
 825                 goto err_out;
 826         }
 827
 828         error = ath9k_debug_create_root();
 829         if (error) {
 830                 printk(KERN_ERR
 831                         "ath9k: Unable to create debugfs root: %d\n",
 832                         error);
 833                 goto err_rate_unregister;
 834         }
 835
 836         error = ath_pci_init();
 837         if (error < 0) {
 838                 printk(KERN_ERR
 839                         "ath9k: No PCI devices found, driver not installed.\n");
 840                 error = -ENODEV;
 841                 goto err_remove_root;
 842         }
 843
 844         error = ath_ahb_init();
 845         if (error < 0) {
 846                 error = -ENODEV;
 847                 goto err_pci_exit;
 848         }
 849
 850         return 0;
 851
 852  err_pci_exit:
 853         ath_pci_exit();
 854
 855  err_remove_root:
 856         ath9k_debug_remove_root();
 857  err_rate_unregister:
 858         ath_rate_control_unregister();
 859  err_out:
 860         return error;
 861 }
 862 module_init(ath9k_init);
 863
 864 static void __exit ath9k_exit(void)
 865 {
 866         ath_ahb_exit();
 867         ath_pci_exit();
 868         ath9k_debug_remove_root();
 869         ath_rate_control_unregister();
 870         printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
 871 }
 872 module_exit(ath9k_exit);