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