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         if (ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_CIPHER,
 383                                    ATH9K_CIPHER_TKIP, NULL)) {
 384                 /*
 385                  * Whether we should enable h/w TKIP MIC.
 386                  * XXX: if we don't support WME TKIP MIC, then we wouldn't
 387                  * report WMM capable, so it's always safe to turn on
 388                  * TKIP MIC in this case.
 389                  */
 390                 ath9k_hw_setcapability(sc->sc_ah, ATH9K_CAP_TKIP_MIC, 0, 1, NULL);
 391         }
 392
 393         /*
 394          * Check whether the separate key cache entries
 395          * are required to handle both tx+rx MIC keys.
 396          * With split mic keys the number of stations is limited
 397          * to 27 otherwise 59.
 398          */
 399         if (ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_CIPHER,
 400                                    ATH9K_CIPHER_TKIP, NULL)
 401             && ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_CIPHER,
 402                                       ATH9K_CIPHER_MIC, NULL)
 403             && ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_TKIP_SPLIT,
 404                                       0, NULL))
 405                 common->splitmic = 1;
 406
 407         /* turn on mcast key search if possible */
 408         if (!ath9k_hw_getcapability(sc->sc_ah, ATH9K_CAP_MCAST_KEYSRCH, 0, NULL))
 409                 (void)ath9k_hw_setcapability(sc->sc_ah, ATH9K_CAP_MCAST_KEYSRCH,
 410                                              1, 1, NULL);
 411
 412 }
 413
 414 static int ath9k_init_btcoex(struct ath_softc *sc)
 415 {
 416         int r, qnum;
 417
 418         switch (sc->sc_ah->btcoex_hw.scheme) {
 419         case ATH_BTCOEX_CFG_NONE:
 420                 break;
 421         case ATH_BTCOEX_CFG_2WIRE:
 422                 ath9k_hw_btcoex_init_2wire(sc->sc_ah);
 423                 break;
 424         case ATH_BTCOEX_CFG_3WIRE:
 425                 ath9k_hw_btcoex_init_3wire(sc->sc_ah);
 426                 r = ath_init_btcoex_timer(sc);
 427                 if (r)
 428                         return -1;
 429                 qnum = ath_tx_get_qnum(sc, ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_BE);
 430                 ath9k_hw_init_btcoex_hw(sc->sc_ah, qnum);
 431                 sc->btcoex.bt_stomp_type = ATH_BTCOEX_STOMP_LOW;
 432                 break;
 433         default:
 434                 WARN_ON(1);
 435                 break;
 436         }
 437
 438         return 0;
 439 }
 440
 441 static int ath9k_init_queues(struct ath_softc *sc)
 442 {
 443         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 444         int i = 0;
 445
 446         for (i = 0; i < ARRAY_SIZE(sc->tx.hwq_map); i++)
 447                 sc->tx.hwq_map[i] = -1;
 448
 449         sc->beacon.beaconq = ath9k_hw_beaconq_setup(sc->sc_ah);
 450         if (sc->beacon.beaconq == -1) {
 451                 ath_print(common, ATH_DBG_FATAL,
 452                           "Unable to setup a beacon xmit queue\n");
 453                 goto err;
 454         }
 455
 456         sc->beacon.cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0);
 457         if (sc->beacon.cabq == NULL) {
 458                 ath_print(common, ATH_DBG_FATAL,
 459                           "Unable to setup CAB xmit queue\n");
 460                 goto err;
 461         }
 462
 463         sc->config.cabqReadytime = ATH_CABQ_READY_TIME;
 464         ath_cabq_update(sc);
 465
 466         if (!ath_tx_setup(sc, ATH9K_WME_AC_BK)) {
 467                 ath_print(common, ATH_DBG_FATAL,
 468                           "Unable to setup xmit queue for BK traffic\n");
 469                 goto err;
 470         }
 471
 472         if (!ath_tx_setup(sc, ATH9K_WME_AC_BE)) {
 473                 ath_print(common, ATH_DBG_FATAL,
 474                           "Unable to setup xmit queue for BE traffic\n");
 475                 goto err;
 476         }
 477         if (!ath_tx_setup(sc, ATH9K_WME_AC_VI)) {
 478                 ath_print(common, ATH_DBG_FATAL,
 479                           "Unable to setup xmit queue for VI traffic\n");
 480                 goto err;
 481         }
 482         if (!ath_tx_setup(sc, ATH9K_WME_AC_VO)) {
 483                 ath_print(common, ATH_DBG_FATAL,
 484                           "Unable to setup xmit queue for VO traffic\n");
 485                 goto err;
 486         }
 487
 488         return 0;
 489
 490 err:
 491         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
 492                 if (ATH_TXQ_SETUP(sc, i))
 493                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 494
 495         return -EIO;
 496 }
 497
 498 static void ath9k_init_channels_rates(struct ath_softc *sc)
 499 {
 500         if (test_bit(ATH9K_MODE_11G, sc->sc_ah->caps.wireless_modes)) {
 501                 sc->sbands[IEEE80211_BAND_2GHZ].channels = ath9k_2ghz_chantable;
 502                 sc->sbands[IEEE80211_BAND_2GHZ].band = IEEE80211_BAND_2GHZ;
 503                 sc->sbands[IEEE80211_BAND_2GHZ].n_channels =
 504                         ARRAY_SIZE(ath9k_2ghz_chantable);
 505                 sc->sbands[IEEE80211_BAND_2GHZ].bitrates = ath9k_legacy_rates;
 506                 sc->sbands[IEEE80211_BAND_2GHZ].n_bitrates =
 507                         ARRAY_SIZE(ath9k_legacy_rates);
 508         }
 509
 510         if (test_bit(ATH9K_MODE_11A, sc->sc_ah->caps.wireless_modes)) {
 511                 sc->sbands[IEEE80211_BAND_5GHZ].channels = ath9k_5ghz_chantable;
 512                 sc->sbands[IEEE80211_BAND_5GHZ].band = IEEE80211_BAND_5GHZ;
 513                 sc->sbands[IEEE80211_BAND_5GHZ].n_channels =
 514                         ARRAY_SIZE(ath9k_5ghz_chantable);
 515                 sc->sbands[IEEE80211_BAND_5GHZ].bitrates =
 516                         ath9k_legacy_rates + 4;
 517                 sc->sbands[IEEE80211_BAND_5GHZ].n_bitrates =
 518                         ARRAY_SIZE(ath9k_legacy_rates) - 4;
 519         }
 520 }
 521
 522 static void ath9k_init_misc(struct ath_softc *sc)
 523 {
 524         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 525         int i = 0;
 526
 527         common->ani.noise_floor = ATH_DEFAULT_NOISE_FLOOR;
 528         setup_timer(&common->ani.timer, ath_ani_calibrate, (unsigned long)sc);
 529
 530         sc->config.txpowlimit = ATH_TXPOWER_MAX;
 531
 532         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
 533                 sc->sc_flags |= SC_OP_TXAGGR;
 534                 sc->sc_flags |= SC_OP_RXAGGR;
 535         }
 536
 537         common->tx_chainmask = sc->sc_ah->caps.tx_chainmask;
 538         common->rx_chainmask = sc->sc_ah->caps.rx_chainmask;
 539
 540         ath9k_hw_set_diversity(sc->sc_ah, true);
 541         sc->rx.defant = ath9k_hw_getdefantenna(sc->sc_ah);
 542
 543         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_BSSIDMASK)
 544                 memcpy(common->bssidmask, ath_bcast_mac, ETH_ALEN);
 545
 546         sc->beacon.slottime = ATH9K_SLOT_TIME_9;
 547
 548         for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++) {
 549                 sc->beacon.bslot[i] = NULL;
 550                 sc->beacon.bslot_aphy[i] = NULL;
 551         }
 552 }
 553
 554 static int ath9k_init_softc(u16 devid, struct ath_softc *sc, u16 subsysid,
 555                             const struct ath_bus_ops *bus_ops)
 556 {
 557         struct ath_hw *ah = NULL;
 558         struct ath_common *common;
 559         int ret = 0, i;
 560         int csz = 0;
 561
 562         ah = kzalloc(sizeof(struct ath_hw), GFP_KERNEL);
 563         if (!ah)
 564                 return -ENOMEM;
 565
 566         ah->hw_version.devid = devid;
 567         ah->hw_version.subsysid = subsysid;
 568         sc->sc_ah = ah;
 569
 570         common = ath9k_hw_common(ah);
 571         common->ops = &ath9k_common_ops;
 572         common->bus_ops = bus_ops;
 573         common->ah = ah;
 574         common->hw = sc->hw;
 575         common->priv = sc;
 576         common->debug_mask = ath9k_debug;
 577
 578         spin_lock_init(&sc->wiphy_lock);
 579         spin_lock_init(&sc->sc_resetlock);
 580         spin_lock_init(&sc->sc_serial_rw);
 581         spin_lock_init(&sc->sc_pm_lock);
 582         mutex_init(&sc->mutex);
 583         tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
 584         tasklet_init(&sc->bcon_tasklet, ath_beacon_tasklet,
 585                      (unsigned long)sc);
 586
 587         /*
 588          * Cache line size is used to size and align various
 589          * structures used to communicate with the hardware.
 590          */
 591         ath_read_cachesize(common, &csz);
 592         common->cachelsz = csz << 2; /* convert to bytes */
 593
 594         /* Initializes the hardware for all supported chipsets */
 595         ret = ath9k_hw_init(ah);
 596         if (ret)
 597                 goto err_hw;
 598
 599         ret = ath9k_init_debug(ah);
 600         if (ret) {
 601                 ath_print(common, ATH_DBG_FATAL,
 602                           "Unable to create debugfs files\n");
 603                 goto err_debug;
 604         }
 605
 606         ret = ath9k_init_queues(sc);
 607         if (ret)
 608                 goto err_queues;
 609
 610         ret =  ath9k_init_btcoex(sc);
 611         if (ret)
 612                 goto err_btcoex;
 613
 614         ath9k_init_crypto(sc);
 615         ath9k_init_channels_rates(sc);
 616         ath9k_init_misc(sc);
 617
 618         return 0;
 619
 620 err_btcoex:
 621         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
 622                 if (ATH_TXQ_SETUP(sc, i))
 623                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 624 err_queues:
 625         ath9k_exit_debug(ah);
 626 err_debug:
 627         ath9k_hw_deinit(ah);
 628 err_hw:
 629         tasklet_kill(&sc->intr_tq);
 630         tasklet_kill(&sc->bcon_tasklet);
 631
 632         kfree(ah);
 633         sc->sc_ah = NULL;
 634
 635         return ret;
 636 }
 637
 638 void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
 639 {
 640         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 641
 642         hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
 643                 IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
 644                 IEEE80211_HW_SIGNAL_DBM |
 645                 IEEE80211_HW_SUPPORTS_PS |
 646                 IEEE80211_HW_PS_NULLFUNC_STACK |
 647                 IEEE80211_HW_SPECTRUM_MGMT |
 648                 IEEE80211_HW_REPORTS_TX_ACK_STATUS;
 649
 650         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
 651                  hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
 652
 653         if (AR_SREV_9160_10_OR_LATER(sc->sc_ah) || modparam_nohwcrypt)
 654                 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
 655
 656         hw->wiphy->interface_modes =
 657                 BIT(NL80211_IFTYPE_AP) |
 658                 BIT(NL80211_IFTYPE_STATION) |
 659                 BIT(NL80211_IFTYPE_ADHOC) |
 660                 BIT(NL80211_IFTYPE_MESH_POINT);
 661
 662         hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
 663
 664         hw->queues = 4;
 665         hw->max_rates = 4;
 666         hw->channel_change_time = 5000;
 667         hw->max_listen_interval = 10;
 668         hw->max_rate_tries = 10;
 669         hw->sta_data_size = sizeof(struct ath_node);
 670         hw->vif_data_size = sizeof(struct ath_vif);
 671
 672         hw->rate_control_algorithm = "ath9k_rate_control";
 673
 674         if (test_bit(ATH9K_MODE_11G, sc->sc_ah->caps.wireless_modes))
 675                 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
 676                         &sc->sbands[IEEE80211_BAND_2GHZ];
 677         if (test_bit(ATH9K_MODE_11A, sc->sc_ah->caps.wireless_modes))
 678                 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
 679                         &sc->sbands[IEEE80211_BAND_5GHZ];
 680
 681         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
 682                 if (test_bit(ATH9K_MODE_11G, sc->sc_ah->caps.wireless_modes))
 683                         setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_2GHZ].ht_cap);
 684                 if (test_bit(ATH9K_MODE_11A, sc->sc_ah->caps.wireless_modes))
 685                         setup_ht_cap(sc, &sc->sbands[IEEE80211_BAND_5GHZ].ht_cap);
 686         }
 687
 688         SET_IEEE80211_PERM_ADDR(hw, common->macaddr);
 689 }
 690
 691 int ath9k_init_device(u16 devid, struct ath_softc *sc, u16 subsysid,
 692                     const struct ath_bus_ops *bus_ops)
 693 {
 694         struct ieee80211_hw *hw = sc->hw;
 695         struct ath_common *common;
 696         struct ath_hw *ah;
 697         int error = 0;
 698         struct ath_regulatory *reg;
 699
 700         /* Bring up device */
 701         error = ath9k_init_softc(devid, sc, subsysid, bus_ops);
 702         if (error != 0)
 703                 goto error_init;
 704
 705         ah = sc->sc_ah;
 706         common = ath9k_hw_common(ah);
 707         ath9k_set_hw_capab(sc, hw);
 708
 709         /* Initialize regulatory */
 710         error = ath_regd_init(&common->regulatory, sc->hw->wiphy,
 711                               ath9k_reg_notifier);
 712         if (error)
 713                 goto error_regd;
 714
 715         reg = &common->regulatory;
 716
 717         /* Setup TX DMA */
 718         error = ath_tx_init(sc, ATH_TXBUF);
 719         if (error != 0)
 720                 goto error_tx;
 721
 722         /* Setup RX DMA */
 723         error = ath_rx_init(sc, ATH_RXBUF);
 724         if (error != 0)
 725                 goto error_rx;
 726
 727         /* Register with mac80211 */
 728         error = ieee80211_register_hw(hw);
 729         if (error)
 730                 goto error_register;
 731
 732         /* Handle world regulatory */
 733         if (!ath_is_world_regd(reg)) {
 734                 error = regulatory_hint(hw->wiphy, reg->alpha2);
 735                 if (error)
 736                         goto error_world;
 737         }
 738
 739         INIT_WORK(&sc->chan_work, ath9k_wiphy_chan_work);
 740         INIT_DELAYED_WORK(&sc->wiphy_work, ath9k_wiphy_work);
 741         sc->wiphy_scheduler_int = msecs_to_jiffies(500);
 742
 743         ath_init_leds(sc);
 744         ath_start_rfkill_poll(sc);
 745
 746         return 0;
 747
 748 error_world:
 749         ieee80211_unregister_hw(hw);
 750 error_register:
 751         ath_rx_cleanup(sc);
 752 error_rx:
 753         ath_tx_cleanup(sc);
 754 error_tx:
 755         /* Nothing */
 756 error_regd:
 757         ath9k_deinit_softc(sc);
 758 error_init:
 759         return error;
 760 }
 761
 762 /*****************************/
 763 /*     De-Initialization     */
 764 /*****************************/
 765
 766 static void ath9k_deinit_softc(struct ath_softc *sc)
 767 {
 768         int i = 0;
 769
 770         if ((sc->btcoex.no_stomp_timer) &&
 771             sc->sc_ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
 772                 ath_gen_timer_free(sc->sc_ah, sc->btcoex.no_stomp_timer);
 773
 774         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
 775                 if (ATH_TXQ_SETUP(sc, i))
 776                         ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 777
 778         ath9k_exit_debug(sc->sc_ah);
 779         ath9k_hw_deinit(sc->sc_ah);
 780
 781         tasklet_kill(&sc->intr_tq);
 782         tasklet_kill(&sc->bcon_tasklet);
 783
 784         kfree(sc->sc_ah);
 785         sc->sc_ah = NULL;
 786 }
 787
 788 void ath9k_deinit_device(struct ath_softc *sc)
 789 {
 790         struct ieee80211_hw *hw = sc->hw;
 791         int i = 0;
 792
 793         ath9k_ps_wakeup(sc);
 794
 795         wiphy_rfkill_stop_polling(sc->hw->wiphy);
 796         ath_deinit_leds(sc);
 797
 798         for (i = 0; i < sc->num_sec_wiphy; i++) {
 799                 struct ath_wiphy *aphy = sc->sec_wiphy[i];
 800                 if (aphy == NULL)
 801                         continue;
 802                 sc->sec_wiphy[i] = NULL;
 803                 ieee80211_unregister_hw(aphy->hw);
 804                 ieee80211_free_hw(aphy->hw);
 805         }
 806         kfree(sc->sec_wiphy);
 807
 808         ieee80211_unregister_hw(hw);
 809         ath_rx_cleanup(sc);
 810         ath_tx_cleanup(sc);
 811         ath9k_deinit_softc(sc);
 812 }
 813
 814 void ath_descdma_cleanup(struct ath_softc *sc,
 815                          struct ath_descdma *dd,
 816                          struct list_head *head)
 817 {
 818         dma_free_coherent(sc->dev, dd->dd_desc_len, dd->dd_desc,
 819                           dd->dd_desc_paddr);
 820
 821         INIT_LIST_HEAD(head);
 822         kfree(dd->dd_bufptr);
 823         memset(dd, 0, sizeof(*dd));
 824 }
 825
 826 /************************/
 827 /*     Module Hooks     */
 828 /************************/
 829
 830 static int __init ath9k_init(void)
 831 {
 832         int error;
 833
 834         /* Register rate control algorithm */
 835         error = ath_rate_control_register();
 836         if (error != 0) {
 837                 printk(KERN_ERR
 838                         "ath9k: Unable to register rate control "
 839                         "algorithm: %d\n",
 840                         error);
 841                 goto err_out;
 842         }
 843
 844         error = ath9k_debug_create_root();
 845         if (error) {
 846                 printk(KERN_ERR
 847                         "ath9k: Unable to create debugfs root: %d\n",
 848                         error);
 849                 goto err_rate_unregister;
 850         }
 851
 852         error = ath_pci_init();
 853         if (error < 0) {
 854                 printk(KERN_ERR
 855                         "ath9k: No PCI devices found, driver not installed.\n");
 856                 error = -ENODEV;
 857                 goto err_remove_root;
 858         }
 859
 860         error = ath_ahb_init();
 861         if (error < 0) {
 862                 error = -ENODEV;
 863                 goto err_pci_exit;
 864         }
 865
 866         return 0;
 867
 868  err_pci_exit:
 869         ath_pci_exit();
 870
 871  err_remove_root:
 872         ath9k_debug_remove_root();
 873  err_rate_unregister:
 874         ath_rate_control_unregister();
 875  err_out:
 876         return error;
 877 }
 878 module_init(ath9k_init);
 879
 880 static void __exit ath9k_exit(void)
 881 {
 882         ath_ahb_exit();
 883         ath_pci_exit();
 884         ath9k_debug_remove_root();
 885         ath_rate_control_unregister();
 886         printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
 887 }
 888 module_exit(ath9k_exit);