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

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