drivers/net/wireless/iwlwifi/iwl-agn.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2003 - 2009 Intel Corporation. All rights reserved.
   4  *
   5  * Portions of this file are derived from the ipw3945 project, as well
   6  * as portions of the ieee80211 subsystem header files.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of version 2 of the GNU General Public License as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  20  *
  21  * The full GNU General Public License is included in this distribution in the
  22  * file called LICENSE.
  23  *
  24  * Contact Information:
  25  *  Intel Linux Wireless <ilw@linux.intel.com>
  26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27  *
  28  *****************************************************************************/
  29
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32 #include <linux/init.h>
  33 #include <linux/pci.h>
  34 #include <linux/dma-mapping.h>
  35 #include <linux/delay.h>
  36 #include <linux/skbuff.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/wireless.h>
  39 #include <linux/firmware.h>
  40 #include <linux/etherdevice.h>
  41 #include <linux/if_arp.h>
  42
  43 #include <net/mac80211.h>
  44
  45 #include <asm/div64.h>
  46
  47 #define DRV_NAME        "iwlagn"
  48
  49 #include "iwl-eeprom.h"
  50 #include "iwl-dev.h"
  51 #include "iwl-core.h"
  52 #include "iwl-io.h"
  53 #include "iwl-helpers.h"
  54 #include "iwl-sta.h"
  55 #include "iwl-calib.h"
  56
  57
  58 /******************************************************************************
  59  *
  60  * module boiler plate
  61  *
  62  ******************************************************************************/
  63
  64 /*
  65  * module name, copyright, version, etc.
  66  */
  67 #define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
  68
  69 #ifdef CONFIG_IWLWIFI_DEBUG
  70 #define VD "d"
  71 #else
  72 #define VD
  73 #endif
  74
  75 #ifdef CONFIG_IWLAGN_SPECTRUM_MEASUREMENT
  76 #define VS "s"
  77 #else
  78 #define VS
  79 #endif
  80
  81 #define DRV_VERSION     IWLWIFI_VERSION VD VS
  82
  83
  84 MODULE_DESCRIPTION(DRV_DESCRIPTION);
  85 MODULE_VERSION(DRV_VERSION);
  86 MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
  87 MODULE_LICENSE("GPL");
  88 MODULE_ALIAS("iwl4965");
  89
  90 /*************** STATION TABLE MANAGEMENT ****
  91  * mac80211 should be examined to determine if sta_info is duplicating
  92  * the functionality provided here
  93  */
  94
  95 /**************************************************************/
  96
  97
  98
  99 static void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
 100 {
 101         struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
 102
 103         if (hw_decrypt)
 104                 rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
 105         else
 106                 rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;
 107
 108 }
 109
 110 /**
 111  * iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
 112  * @priv: staging_rxon is compared to active_rxon
 113  *
 114  * If the RXON structure is changing enough to require a new tune,
 115  * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
 116  * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
 117  */
 118 static int iwl_full_rxon_required(struct iwl_priv *priv)
 119 {
 120
 121         /* These items are only settable from the full RXON command */
 122         if (!(iwl_is_associated(priv)) ||
 123             compare_ether_addr(priv->staging_rxon.bssid_addr,
 124                                priv->active_rxon.bssid_addr) ||
 125             compare_ether_addr(priv->staging_rxon.node_addr,
 126                                priv->active_rxon.node_addr) ||
 127             compare_ether_addr(priv->staging_rxon.wlap_bssid_addr,
 128                                priv->active_rxon.wlap_bssid_addr) ||
 129             (priv->staging_rxon.dev_type != priv->active_rxon.dev_type) ||
 130             (priv->staging_rxon.channel != priv->active_rxon.channel) ||
 131             (priv->staging_rxon.air_propagation !=
 132              priv->active_rxon.air_propagation) ||
 133             (priv->staging_rxon.ofdm_ht_single_stream_basic_rates !=
 134              priv->active_rxon.ofdm_ht_single_stream_basic_rates) ||
 135             (priv->staging_rxon.ofdm_ht_dual_stream_basic_rates !=
 136              priv->active_rxon.ofdm_ht_dual_stream_basic_rates) ||
 137             (priv->staging_rxon.assoc_id != priv->active_rxon.assoc_id))
 138                 return 1;
 139
 140         /* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
 141          * be updated with the RXON_ASSOC command -- however only some
 142          * flag transitions are allowed using RXON_ASSOC */
 143
 144         /* Check if we are not switching bands */
 145         if ((priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
 146             (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK))
 147                 return 1;
 148
 149         /* Check if we are switching association toggle */
 150         if ((priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
 151                 (priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
 152                 return 1;
 153
 154         return 0;
 155 }
 156
 157 /**
 158  * iwl_commit_rxon - commit staging_rxon to hardware
 159  *
 160  * The RXON command in staging_rxon is committed to the hardware and
 161  * the active_rxon structure is updated with the new data.  This
 162  * function correctly transitions out of the RXON_ASSOC_MSK state if
 163  * a HW tune is required based on the RXON structure changes.
 164  */
 165 static int iwl_commit_rxon(struct iwl_priv *priv)
 166 {
 167         /* cast away the const for active_rxon in this function */
 168         struct iwl_rxon_cmd *active_rxon = (void *)&priv->active_rxon;
 169         int ret;
 170         bool new_assoc =
 171                 !!(priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK);
 172
 173         if (!iwl_is_alive(priv))
 174                 return -EBUSY;
 175
 176         /* always get timestamp with Rx frame */
 177         priv->staging_rxon.flags |= RXON_FLG_TSF2HOST_MSK;
 178         /* allow CTS-to-self if possible. this is relevant only for
 179          * 5000, but will not damage 4965 */
 180         priv->staging_rxon.flags |= RXON_FLG_SELF_CTS_EN;
 181
 182         ret = iwl_agn_check_rxon_cmd(priv);
 183         if (ret) {
 184                 IWL_ERR(priv, "Invalid RXON configuration.  Not committing.\n");
 185                 return -EINVAL;
 186         }
 187
 188         /* If we don't need to send a full RXON, we can use
 189          * iwl_rxon_assoc_cmd which is used to reconfigure filter
 190          * and other flags for the current radio configuration. */
 191         if (!iwl_full_rxon_required(priv)) {
 192                 ret = iwl_send_rxon_assoc(priv);
 193                 if (ret) {
 194                         IWL_ERR(priv, "Error setting RXON_ASSOC (%d)\n", ret);
 195                         return ret;
 196                 }
 197
 198                 memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
 199                 return 0;
 200         }
 201
 202         /* station table will be cleared */
 203         priv->assoc_station_added = 0;
 204
 205         /* If we are currently associated and the new config requires
 206          * an RXON_ASSOC and the new config wants the associated mask enabled,
 207          * we must clear the associated from the active configuration
 208          * before we apply the new config */
 209         if (iwl_is_associated(priv) && new_assoc) {
 210                 IWL_DEBUG_INFO("Toggling associated bit on current RXON\n");
 211                 active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 212
 213                 ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
 214                                       sizeof(struct iwl_rxon_cmd),
 215                                       &priv->active_rxon);
 216
 217                 /* If the mask clearing failed then we set
 218                  * active_rxon back to what it was previously */
 219                 if (ret) {
 220                         active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
 221                         IWL_ERR(priv, "Error clearing ASSOC_MSK (%d)\n", ret);
 222                         return ret;
 223                 }
 224         }
 225
 226         IWL_DEBUG_INFO("Sending RXON\n"
 227                        "* with%s RXON_FILTER_ASSOC_MSK\n"
 228                        "* channel = %d\n"
 229                        "* bssid = %pM\n",
 230                        (new_assoc ? "" : "out"),
 231                        le16_to_cpu(priv->staging_rxon.channel),
 232                        priv->staging_rxon.bssid_addr);
 233
 234         iwl_set_rxon_hwcrypto(priv, !priv->hw_params.sw_crypto);
 235
 236         /* Apply the new configuration
 237          * RXON unassoc clears the station table in uCode, send it before
 238          * we add the bcast station. If assoc bit is set, we will send RXON
 239          * after having added the bcast and bssid station.
 240          */
 241         if (!new_assoc) {
 242                 ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
 243                               sizeof(struct iwl_rxon_cmd), &priv->staging_rxon);
 244                 if (ret) {
 245                         IWL_ERR(priv, "Error setting new RXON (%d)\n", ret);
 246                         return ret;
 247                 }
 248                 memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
 249         }
 250
 251         iwl_clear_stations_table(priv);
 252
 253         if (!priv->error_recovering)
 254                 priv->start_calib = 0;
 255
 256         /* Add the broadcast address so we can send broadcast frames */
 257         if (iwl_rxon_add_station(priv, iwl_bcast_addr, 0) ==
 258                                                 IWL_INVALID_STATION) {
 259                 IWL_ERR(priv, "Error adding BROADCAST address for transmit.\n");
 260                 return -EIO;
 261         }
 262
 263         /* If we have set the ASSOC_MSK and we are in BSS mode then
 264          * add the IWL_AP_ID to the station rate table */
 265         if (new_assoc) {
 266                 if (priv->iw_mode == NL80211_IFTYPE_STATION) {
 267                         ret = iwl_rxon_add_station(priv,
 268                                            priv->active_rxon.bssid_addr, 1);
 269                         if (ret == IWL_INVALID_STATION) {
 270                                 IWL_ERR(priv,
 271                                         "Error adding AP address for TX.\n");
 272                                 return -EIO;
 273                         }
 274                         priv->assoc_station_added = 1;
 275                         if (priv->default_wep_key &&
 276                             iwl_send_static_wepkey_cmd(priv, 0))
 277                                 IWL_ERR(priv,
 278                                         "Could not send WEP static key.\n");
 279                 }
 280
 281                 /* Apply the new configuration
 282                  * RXON assoc doesn't clear the station table in uCode,
 283                  */
 284                 ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
 285                               sizeof(struct iwl_rxon_cmd), &priv->staging_rxon);
 286                 if (ret) {
 287                         IWL_ERR(priv, "Error setting new RXON (%d)\n", ret);
 288                         return ret;
 289                 }
 290                 memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
 291         }
 292
 293         iwl_init_sensitivity(priv);
 294
 295         /* If we issue a new RXON command which required a tune then we must
 296          * send a new TXPOWER command or we won't be able to Tx any frames */
 297         ret = iwl_set_tx_power(priv, priv->tx_power_user_lmt, true);
 298         if (ret) {
 299                 IWL_ERR(priv, "Error sending TX power (%d)\n", ret);
 300                 return ret;
 301         }
 302
 303         return 0;
 304 }
 305
 306 void iwl_update_chain_flags(struct iwl_priv *priv)
 307 {
 308
 309         iwl_set_rxon_chain(priv);
 310         iwl_commit_rxon(priv);
 311 }
 312
 313 static int iwl_send_bt_config(struct iwl_priv *priv)
 314 {
 315         struct iwl_bt_cmd bt_cmd = {
 316                 .flags = 3,
 317                 .lead_time = 0xAA,
 318                 .max_kill = 1,
 319                 .kill_ack_mask = 0,
 320                 .kill_cts_mask = 0,
 321         };
 322
 323         return iwl_send_cmd_pdu(priv, REPLY_BT_CONFIG,
 324                                 sizeof(struct iwl_bt_cmd), &bt_cmd);
 325 }
 326
 327 static void iwl_clear_free_frames(struct iwl_priv *priv)
 328 {
 329         struct list_head *element;
 330
 331         IWL_DEBUG_INFO("%d frames on pre-allocated heap on clear.\n",
 332                        priv->frames_count);
 333
 334         while (!list_empty(&priv->free_frames)) {
 335                 element = priv->free_frames.next;
 336                 list_del(element);
 337                 kfree(list_entry(element, struct iwl_frame, list));
 338                 priv->frames_count--;
 339         }
 340
 341         if (priv->frames_count) {
 342                 IWL_WARN(priv, "%d frames still in use.  Did we lose one?\n",
 343                             priv->frames_count);
 344                 priv->frames_count = 0;
 345         }
 346 }
 347
 348 static struct iwl_frame *iwl_get_free_frame(struct iwl_priv *priv)
 349 {
 350         struct iwl_frame *frame;
 351         struct list_head *element;
 352         if (list_empty(&priv->free_frames)) {
 353                 frame = kzalloc(sizeof(*frame), GFP_KERNEL);
 354                 if (!frame) {
 355                         IWL_ERR(priv, "Could not allocate frame!\n");
 356                         return NULL;
 357                 }
 358
 359                 priv->frames_count++;
 360                 return frame;
 361         }
 362
 363         element = priv->free_frames.next;
 364         list_del(element);
 365         return list_entry(element, struct iwl_frame, list);
 366 }
 367
 368 static void iwl_free_frame(struct iwl_priv *priv, struct iwl_frame *frame)
 369 {
 370         memset(frame, 0, sizeof(*frame));
 371         list_add(&frame->list, &priv->free_frames);
 372 }
 373
 374 static unsigned int iwl_fill_beacon_frame(struct iwl_priv *priv,
 375                                           struct ieee80211_hdr *hdr,
 376                                           int left)
 377 {
 378         if (!iwl_is_associated(priv) || !priv->ibss_beacon ||
 379             ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
 380              (priv->iw_mode != NL80211_IFTYPE_AP)))
 381                 return 0;
 382
 383         if (priv->ibss_beacon->len > left)
 384                 return 0;
 385
 386         memcpy(hdr, priv->ibss_beacon->data, priv->ibss_beacon->len);
 387
 388         return priv->ibss_beacon->len;
 389 }
 390
 391 static u8 iwl_rate_get_lowest_plcp(struct iwl_priv *priv)
 392 {
 393         int i;
 394         int rate_mask;
 395
 396         /* Set rate mask*/
 397         if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
 398                 rate_mask = priv->active_rate_basic & IWL_CCK_RATES_MASK;
 399         else
 400                 rate_mask = priv->active_rate_basic & IWL_OFDM_RATES_MASK;
 401
 402         /* Find lowest valid rate */
 403         for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
 404                                         i = iwl_rates[i].next_ieee) {
 405                 if (rate_mask & (1 << i))
 406                         return iwl_rates[i].plcp;
 407         }
 408
 409         /* No valid rate was found. Assign the lowest one */
 410         if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
 411                 return IWL_RATE_1M_PLCP;
 412         else
 413                 return IWL_RATE_6M_PLCP;
 414 }
 415
 416 static unsigned int iwl_hw_get_beacon_cmd(struct iwl_priv *priv,
 417                                        struct iwl_frame *frame, u8 rate)
 418 {
 419         struct iwl_tx_beacon_cmd *tx_beacon_cmd;
 420         unsigned int frame_size;
 421
 422         tx_beacon_cmd = &frame->u.beacon;
 423         memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
 424
 425         tx_beacon_cmd->tx.sta_id = priv->hw_params.bcast_sta_id;
 426         tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
 427
 428         frame_size = iwl_fill_beacon_frame(priv, tx_beacon_cmd->frame,
 429                                 sizeof(frame->u) - sizeof(*tx_beacon_cmd));
 430
 431         BUG_ON(frame_size > MAX_MPDU_SIZE);
 432         tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
 433
 434         if ((rate == IWL_RATE_1M_PLCP) || (rate >= IWL_RATE_2M_PLCP))
 435                 tx_beacon_cmd->tx.rate_n_flags =
 436                         iwl_hw_set_rate_n_flags(rate, RATE_MCS_CCK_MSK);
 437         else
 438                 tx_beacon_cmd->tx.rate_n_flags =
 439                         iwl_hw_set_rate_n_flags(rate, 0);
 440
 441         tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
 442                                      TX_CMD_FLG_TSF_MSK |
 443                                      TX_CMD_FLG_STA_RATE_MSK;
 444
 445         return sizeof(*tx_beacon_cmd) + frame_size;
 446 }
 447 static int iwl_send_beacon_cmd(struct iwl_priv *priv)
 448 {
 449         struct iwl_frame *frame;
 450         unsigned int frame_size;
 451         int rc;
 452         u8 rate;
 453
 454         frame = iwl_get_free_frame(priv);
 455
 456         if (!frame) {
 457                 IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
 458                           "command.\n");
 459                 return -ENOMEM;
 460         }
 461
 462         rate = iwl_rate_get_lowest_plcp(priv);
 463
 464         frame_size = iwl_hw_get_beacon_cmd(priv, frame, rate);
 465
 466         rc = iwl_send_cmd_pdu(priv, REPLY_TX_BEACON, frame_size,
 467                               &frame->u.cmd[0]);
 468
 469         iwl_free_frame(priv, frame);
 470
 471         return rc;
 472 }
 473
 474 static inline dma_addr_t iwl_tfd_tb_get_addr(struct iwl_tfd *tfd, u8 idx)
 475 {
 476         struct iwl_tfd_tb *tb = &tfd->tbs[idx];
 477
 478         dma_addr_t addr = get_unaligned_le32(&tb->lo);
 479         if (sizeof(dma_addr_t) > sizeof(u32))
 480                 addr |=
 481                 ((dma_addr_t)(le16_to_cpu(tb->hi_n_len) & 0xF) << 16) << 16;
 482
 483         return addr;
 484 }
 485
 486 static inline u16 iwl_tfd_tb_get_len(struct iwl_tfd *tfd, u8 idx)
 487 {
 488         struct iwl_tfd_tb *tb = &tfd->tbs[idx];
 489
 490         return le16_to_cpu(tb->hi_n_len) >> 4;
 491 }
 492
 493 static inline void iwl_tfd_set_tb(struct iwl_tfd *tfd, u8 idx,
 494                                   dma_addr_t addr, u16 len)
 495 {
 496         struct iwl_tfd_tb *tb = &tfd->tbs[idx];
 497         u16 hi_n_len = len << 4;
 498
 499         put_unaligned_le32(addr, &tb->lo);
 500         if (sizeof(dma_addr_t) > sizeof(u32))
 501                 hi_n_len |= ((addr >> 16) >> 16) & 0xF;
 502
 503         tb->hi_n_len = cpu_to_le16(hi_n_len);
 504
 505         tfd->num_tbs = idx + 1;
 506 }
 507
 508 static inline u8 iwl_tfd_get_num_tbs(struct iwl_tfd *tfd)
 509 {
 510         return tfd->num_tbs & 0x1f;
 511 }
 512
 513 /**
 514  * iwl_hw_txq_free_tfd - Free all chunks referenced by TFD [txq->q.read_ptr]
 515  * @priv - driver private data
 516  * @txq - tx queue
 517  *
 518  * Does NOT advance any TFD circular buffer read/write indexes
 519  * Does NOT free the TFD itself (which is within circular buffer)
 520  */
 521 void iwl_hw_txq_free_tfd(struct iwl_priv *priv, struct iwl_tx_queue *txq)
 522 {
 523         struct iwl_tfd *tfd_tmp = (struct iwl_tfd *)txq->tfds;
 524         struct iwl_tfd *tfd;
 525         struct pci_dev *dev = priv->pci_dev;
 526         int index = txq->q.read_ptr;
 527         int i;
 528         int num_tbs;
 529
 530         tfd = &tfd_tmp[index];
 531
 532         /* Sanity check on number of chunks */
 533         num_tbs = iwl_tfd_get_num_tbs(tfd);
 534
 535         if (num_tbs >= IWL_NUM_OF_TBS) {
 536                 IWL_ERR(priv, "Too many chunks: %i\n", num_tbs);
 537                 /* @todo issue fatal error, it is quite serious situation */
 538                 return;
 539         }
 540
 541         /* Unmap tx_cmd */
 542         if (num_tbs)
 543                 pci_unmap_single(dev,
 544                                 pci_unmap_addr(&txq->cmd[index]->meta, mapping),
 545                                 pci_unmap_len(&txq->cmd[index]->meta, len),
 546                                 PCI_DMA_TODEVICE);
 547
 548         /* Unmap chunks, if any. */
 549         for (i = 1; i < num_tbs; i++) {
 550                 pci_unmap_single(dev, iwl_tfd_tb_get_addr(tfd, i),
 551                                 iwl_tfd_tb_get_len(tfd, i), PCI_DMA_TODEVICE);
 552
 553                 if (txq->txb) {
 554                         dev_kfree_skb(txq->txb[txq->q.read_ptr].skb[i - 1]);
 555                         txq->txb[txq->q.read_ptr].skb[i - 1] = NULL;
 556                 }
 557         }
 558 }
 559
 560 int iwl_hw_txq_attach_buf_to_tfd(struct iwl_priv *priv,
 561                                  struct iwl_tx_queue *txq,
 562                                  dma_addr_t addr, u16 len,
 563                                  u8 reset, u8 pad)
 564 {
 565         struct iwl_queue *q;
 566         struct iwl_tfd *tfd, *tfd_tmp;
 567         u32 num_tbs;
 568
 569         q = &txq->q;
 570         tfd_tmp = (struct iwl_tfd *)txq->tfds;
 571         tfd = &tfd_tmp[q->write_ptr];
 572
 573         if (reset)
 574                 memset(tfd, 0, sizeof(*tfd));
 575
 576         num_tbs = iwl_tfd_get_num_tbs(tfd);
 577
 578         /* Each TFD can point to a maximum 20 Tx buffers */
 579         if (num_tbs >= IWL_NUM_OF_TBS) {
 580                 IWL_ERR(priv, "Error can not send more than %d chunks\n",
 581                           IWL_NUM_OF_TBS);
 582                 return -EINVAL;
 583         }
 584
 585         BUG_ON(addr & ~DMA_BIT_MASK(36));
 586         if (unlikely(addr & ~IWL_TX_DMA_MASK))
 587                 IWL_ERR(priv, "Unaligned address = %llx\n",
 588                           (unsigned long long)addr);
 589
 590         iwl_tfd_set_tb(tfd, num_tbs, addr, len);
 591
 592         return 0;
 593 }
 594
 595 /*
 596  * Tell nic where to find circular buffer of Tx Frame Descriptors for
 597  * given Tx queue, and enable the DMA channel used for that queue.
 598  *
 599  * 4965 supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
 600  * channels supported in hardware.
 601  */
 602 int iwl_hw_tx_queue_init(struct iwl_priv *priv,
 603                          struct iwl_tx_queue *txq)
 604 {
 605         int ret;
 606         unsigned long flags;
 607         int txq_id = txq->q.id;
 608
 609         spin_lock_irqsave(&priv->lock, flags);
 610         ret = iwl_grab_nic_access(priv);
 611         if (ret) {
 612                 spin_unlock_irqrestore(&priv->lock, flags);
 613                 return ret;
 614         }
 615
 616         /* Circular buffer (TFD queue in DRAM) physical base address */
 617         iwl_write_direct32(priv, FH_MEM_CBBC_QUEUE(txq_id),
 618                              txq->q.dma_addr >> 8);
 619
 620         iwl_release_nic_access(priv);
 621         spin_unlock_irqrestore(&priv->lock, flags);
 622
 623         return 0;
 624 }
 625
 626
 627 /******************************************************************************
 628  *
 629  * Misc. internal state and helper functions
 630  *
 631  ******************************************************************************/
 632
 633 static void iwl_ht_conf(struct iwl_priv *priv,
 634                             struct ieee80211_bss_conf *bss_conf)
 635 {
 636         struct ieee80211_sta_ht_cap *ht_conf;
 637         struct iwl_ht_info *iwl_conf = &priv->current_ht_config;
 638         struct ieee80211_sta *sta;
 639
 640         IWL_DEBUG_MAC80211("enter: \n");
 641
 642         if (!iwl_conf->is_ht)
 643                 return;
 644
 645
 646         /*
 647          * It is totally wrong to base global information on something
 648          * that is valid only when associated, alas, this driver works
 649          * that way and I don't know how to fix it.
 650          */
 651
 652         rcu_read_lock();
 653         sta = ieee80211_find_sta(priv->hw, priv->bssid);
 654         if (!sta) {
 655                 rcu_read_unlock();
 656                 return;
 657         }
 658         ht_conf = &sta->ht_cap;
 659
 660         if (ht_conf->cap & IEEE80211_HT_CAP_SGI_20)
 661                 iwl_conf->sgf |= HT_SHORT_GI_20MHZ;
 662         if (ht_conf->cap & IEEE80211_HT_CAP_SGI_40)
 663                 iwl_conf->sgf |= HT_SHORT_GI_40MHZ;
 664
 665         iwl_conf->is_green_field = !!(ht_conf->cap & IEEE80211_HT_CAP_GRN_FLD);
 666         iwl_conf->max_amsdu_size =
 667                 !!(ht_conf->cap & IEEE80211_HT_CAP_MAX_AMSDU);
 668
 669         iwl_conf->supported_chan_width =
 670                 !!(ht_conf->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40);
 671
 672         /*
 673          * XXX: The HT configuration needs to be moved into iwl_mac_config()
 674          *      to be done there correctly.
 675          */
 676
 677         iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
 678         if (conf_is_ht40_minus(&priv->hw->conf))
 679                 iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
 680         else if (conf_is_ht40_plus(&priv->hw->conf))
 681                 iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
 682
 683         /* If no above or below channel supplied disable FAT channel */
 684         if (iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_ABOVE &&
 685             iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_BELOW)
 686                 iwl_conf->supported_chan_width = 0;
 687
 688         iwl_conf->sm_ps = (u8)((ht_conf->cap & IEEE80211_HT_CAP_SM_PS) >> 2);
 689
 690         memcpy(&iwl_conf->mcs, &ht_conf->mcs, 16);
 691
 692         iwl_conf->tx_chan_width = iwl_conf->supported_chan_width != 0;
 693         iwl_conf->ht_protection =
 694                 bss_conf->ht.operation_mode & IEEE80211_HT_OP_MODE_PROTECTION;
 695         iwl_conf->non_GF_STA_present =
 696                 !!(bss_conf->ht.operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
 697
 698         rcu_read_unlock();
 699
 700         IWL_DEBUG_MAC80211("leave\n");
 701 }
 702
 703 /*
 704  * QoS  support
 705 */
 706 static void iwl_activate_qos(struct iwl_priv *priv, u8 force)
 707 {
 708         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 709                 return;
 710
 711         priv->qos_data.def_qos_parm.qos_flags = 0;
 712
 713         if (priv->qos_data.qos_cap.q_AP.queue_request &&
 714             !priv->qos_data.qos_cap.q_AP.txop_request)
 715                 priv->qos_data.def_qos_parm.qos_flags |=
 716                         QOS_PARAM_FLG_TXOP_TYPE_MSK;
 717         if (priv->qos_data.qos_active)
 718                 priv->qos_data.def_qos_parm.qos_flags |=
 719                         QOS_PARAM_FLG_UPDATE_EDCA_MSK;
 720
 721         if (priv->current_ht_config.is_ht)
 722                 priv->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK;
 723
 724         if (force || iwl_is_associated(priv)) {
 725                 IWL_DEBUG_QOS("send QoS cmd with Qos active=%d FLAGS=0x%X\n",
 726                                 priv->qos_data.qos_active,
 727                                 priv->qos_data.def_qos_parm.qos_flags);
 728
 729                 iwl_send_cmd_pdu_async(priv, REPLY_QOS_PARAM,
 730                                        sizeof(struct iwl_qosparam_cmd),
 731                                        &priv->qos_data.def_qos_parm, NULL);
 732         }
 733 }
 734
 735 #define MAX_UCODE_BEACON_INTERVAL       4096
 736
 737 static u16 iwl_adjust_beacon_interval(u16 beacon_val)
 738 {
 739         u16 new_val = 0;
 740         u16 beacon_factor = 0;
 741
 742         beacon_factor = (beacon_val + MAX_UCODE_BEACON_INTERVAL)
 743                                         / MAX_UCODE_BEACON_INTERVAL;
 744         new_val = beacon_val / beacon_factor;
 745
 746         return new_val;
 747 }
 748
 749 static void iwl_setup_rxon_timing(struct iwl_priv *priv)
 750 {
 751         u64 tsf;
 752         s32 interval_tm, rem;
 753         unsigned long flags;
 754         struct ieee80211_conf *conf = NULL;
 755         u16 beacon_int = 0;
 756
 757         conf = ieee80211_get_hw_conf(priv->hw);
 758
 759         spin_lock_irqsave(&priv->lock, flags);
 760         priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
 761         priv->rxon_timing.listen_interval = cpu_to_le16(conf->listen_interval);
 762
 763         if (priv->iw_mode == NL80211_IFTYPE_STATION) {
 764                 beacon_int = iwl_adjust_beacon_interval(priv->beacon_int);
 765                 priv->rxon_timing.atim_window = 0;
 766         } else {
 767                 beacon_int = iwl_adjust_beacon_interval(conf->beacon_int);
 768
 769                 /* TODO: we need to get atim_window from upper stack
 770                  * for now we set to 0 */
 771                 priv->rxon_timing.atim_window = 0;
 772         }
 773
 774         priv->rxon_timing.beacon_interval = cpu_to_le16(beacon_int);
 775
 776         tsf = priv->timestamp; /* tsf is modifed by do_div: copy it */
 777         interval_tm = beacon_int * 1024;
 778         rem = do_div(tsf, interval_tm);
 779         priv->rxon_timing.beacon_init_val = cpu_to_le32(interval_tm - rem);
 780
 781         spin_unlock_irqrestore(&priv->lock, flags);
 782         IWL_DEBUG_ASSOC("beacon interval %d beacon timer %d beacon tim %d\n",
 783                         le16_to_cpu(priv->rxon_timing.beacon_interval),
 784                         le32_to_cpu(priv->rxon_timing.beacon_init_val),
 785                         le16_to_cpu(priv->rxon_timing.atim_window));
 786 }
 787
 788 static void iwl_set_flags_for_band(struct iwl_priv *priv,
 789                                    enum ieee80211_band band)
 790 {
 791         if (band == IEEE80211_BAND_5GHZ) {
 792                 priv->staging_rxon.flags &=
 793                     ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
 794                       | RXON_FLG_CCK_MSK);
 795                 priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
 796         } else {
 797                 /* Copied from iwl_post_associate() */
 798                 if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
 799                         priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
 800                 else
 801                         priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 802
 803                 if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
 804                         priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 805
 806                 priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
 807                 priv->staging_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
 808                 priv->staging_rxon.flags &= ~RXON_FLG_CCK_MSK;
 809         }
 810 }
 811
 812 /*
 813  * initialize rxon structure with default values from eeprom
 814  */
 815 static void iwl_connection_init_rx_config(struct iwl_priv *priv, int mode)
 816 {
 817         const struct iwl_channel_info *ch_info;
 818
 819         memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
 820
 821         switch (mode) {
 822         case NL80211_IFTYPE_AP:
 823                 priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
 824                 break;
 825
 826         case NL80211_IFTYPE_STATION:
 827                 priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
 828                 priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
 829                 break;
 830
 831         case NL80211_IFTYPE_ADHOC:
 832                 priv->staging_rxon.dev_type = RXON_DEV_TYPE_IBSS;
 833                 priv->staging_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
 834                 priv->staging_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
 835                                                   RXON_FILTER_ACCEPT_GRP_MSK;
 836                 break;
 837
 838         case NL80211_IFTYPE_MONITOR:
 839                 priv->staging_rxon.dev_type = RXON_DEV_TYPE_SNIFFER;
 840                 priv->staging_rxon.filter_flags = RXON_FILTER_PROMISC_MSK |
 841                     RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
 842                 break;
 843         default:
 844                 IWL_ERR(priv, "Unsupported interface type %d\n", mode);
 845                 break;
 846         }
 847
 848 #if 0
 849         /* TODO:  Figure out when short_preamble would be set and cache from
 850          * that */
 851         if (!hw_to_local(priv->hw)->short_preamble)
 852                 priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
 853         else
 854                 priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
 855 #endif
 856
 857         ch_info = iwl_get_channel_info(priv, priv->band,
 858                                        le16_to_cpu(priv->active_rxon.channel));
 859
 860         if (!ch_info)
 861                 ch_info = &priv->channel_info[0];
 862
 863         /*
 864          * in some case A channels are all non IBSS
 865          * in this case force B/G channel
 866          */
 867         if ((priv->iw_mode == NL80211_IFTYPE_ADHOC) &&
 868             !(is_channel_ibss(ch_info)))
 869                 ch_info = &priv->channel_info[0];
 870
 871         priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
 872         priv->band = ch_info->band;
 873
 874         iwl_set_flags_for_band(priv, priv->band);
 875
 876         priv->staging_rxon.ofdm_basic_rates =
 877             (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
 878         priv->staging_rxon.cck_basic_rates =
 879             (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
 880
 881         priv->staging_rxon.flags &= ~(RXON_FLG_CHANNEL_MODE_MIXED_MSK |
 882                                         RXON_FLG_CHANNEL_MODE_PURE_40_MSK);
 883         memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
 884         memcpy(priv->staging_rxon.wlap_bssid_addr, priv->mac_addr, ETH_ALEN);
 885         priv->staging_rxon.ofdm_ht_single_stream_basic_rates = 0xff;
 886         priv->staging_rxon.ofdm_ht_dual_stream_basic_rates = 0xff;
 887         iwl_set_rxon_chain(priv);
 888 }
 889
 890 static int iwl_set_mode(struct iwl_priv *priv, int mode)
 891 {
 892         iwl_connection_init_rx_config(priv, mode);
 893         memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
 894
 895         iwl_clear_stations_table(priv);
 896
 897         /* dont commit rxon if rf-kill is on*/
 898         if (!iwl_is_ready_rf(priv))
 899                 return -EAGAIN;
 900
 901         cancel_delayed_work(&priv->scan_check);
 902         if (iwl_scan_cancel_timeout(priv, 100)) {
 903                 IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
 904                 IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
 905                 return -EAGAIN;
 906         }
 907
 908         iwl_commit_rxon(priv);
 909
 910         return 0;
 911 }
 912
 913 static void iwl_set_rate(struct iwl_priv *priv)
 914 {
 915         const struct ieee80211_supported_band *hw = NULL;
 916         struct ieee80211_rate *rate;
 917         int i;
 918
 919         hw = iwl_get_hw_mode(priv, priv->band);
 920         if (!hw) {
 921                 IWL_ERR(priv, "Failed to set rate: unable to get hw mode\n");
 922                 return;
 923         }
 924
 925         priv->active_rate = 0;
 926         priv->active_rate_basic = 0;
 927
 928         for (i = 0; i < hw->n_bitrates; i++) {
 929                 rate = &(hw->bitrates[i]);
 930                 if (rate->hw_value < IWL_RATE_COUNT)
 931                         priv->active_rate |= (1 << rate->hw_value);
 932         }
 933
 934         IWL_DEBUG_RATE("Set active_rate = %0x, active_rate_basic = %0x\n",
 935                        priv->active_rate, priv->active_rate_basic);
 936
 937         /*
 938          * If a basic rate is configured, then use it (adding IWL_RATE_1M_MASK)
 939          * otherwise set it to the default of all CCK rates and 6, 12, 24 for
 940          * OFDM
 941          */
 942         if (priv->active_rate_basic & IWL_CCK_BASIC_RATES_MASK)
 943                 priv->staging_rxon.cck_basic_rates =
 944                     ((priv->active_rate_basic &
 945                       IWL_CCK_RATES_MASK) >> IWL_FIRST_CCK_RATE) & 0xF;
 946         else
 947                 priv->staging_rxon.cck_basic_rates =
 948                     (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
 949
 950         if (priv->active_rate_basic & IWL_OFDM_BASIC_RATES_MASK)
 951                 priv->staging_rxon.ofdm_basic_rates =
 952                     ((priv->active_rate_basic &
 953                       (IWL_OFDM_BASIC_RATES_MASK | IWL_RATE_6M_MASK)) >>
 954                       IWL_FIRST_OFDM_RATE) & 0xFF;
 955         else
 956                 priv->staging_rxon.ofdm_basic_rates =
 957                    (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
 958 }
 959
 960
 961 /******************************************************************************
 962  *
 963  * Generic RX handler implementations
 964  *
 965  ******************************************************************************/
 966 static void iwl_rx_reply_alive(struct iwl_priv *priv,
 967                                 struct iwl_rx_mem_buffer *rxb)
 968 {
 969         struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
 970         struct iwl_alive_resp *palive;
 971         struct delayed_work *pwork;
 972
 973         palive = &pkt->u.alive_frame;
 974
 975         IWL_DEBUG_INFO("Alive ucode status 0x%08X revision "
 976                        "0x%01X 0x%01X\n",
 977                        palive->is_valid, palive->ver_type,
 978                        palive->ver_subtype);
 979
 980         if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
 981                 IWL_DEBUG_INFO("Initialization Alive received.\n");
 982                 memcpy(&priv->card_alive_init,
 983                        &pkt->u.alive_frame,
 984                        sizeof(struct iwl_init_alive_resp));
 985                 pwork = &priv->init_alive_start;
 986         } else {
 987                 IWL_DEBUG_INFO("Runtime Alive received.\n");
 988                 memcpy(&priv->card_alive, &pkt->u.alive_frame,
 989                        sizeof(struct iwl_alive_resp));
 990                 pwork = &priv->alive_start;
 991         }
 992
 993         /* We delay the ALIVE response by 5ms to
 994          * give the HW RF Kill time to activate... */
 995         if (palive->is_valid == UCODE_VALID_OK)
 996                 queue_delayed_work(priv->workqueue, pwork,
 997                                    msecs_to_jiffies(5));
 998         else
 999                 IWL_WARN(priv, "uCode did not respond OK.\n");
1000 }
1001
1002 static void iwl_rx_reply_error(struct iwl_priv *priv,
1003                                    struct iwl_rx_mem_buffer *rxb)
1004 {
1005         struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
1006
1007         IWL_ERR(priv, "Error Reply type 0x%08X cmd %s (0x%02X) "
1008                 "seq 0x%04X ser 0x%08X\n",
1009                 le32_to_cpu(pkt->u.err_resp.error_type),
1010                 get_cmd_string(pkt->u.err_resp.cmd_id),
1011                 pkt->u.err_resp.cmd_id,
1012                 le16_to_cpu(pkt->u.err_resp.bad_cmd_seq_num),
1013                 le32_to_cpu(pkt->u.err_resp.error_info));
1014 }
1015
1016 #define TX_STATUS_ENTRY(x) case TX_STATUS_FAIL_ ## x: return #x
1017
1018 static void iwl_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
1019 {
1020         struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
1021         struct iwl_rxon_cmd *rxon = (void *)&priv->active_rxon;
1022         struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
1023         IWL_DEBUG_11H("CSA notif: channel %d, status %d\n",
1024                       le16_to_cpu(csa->channel), le32_to_cpu(csa->status));
1025         rxon->channel = csa->channel;
1026         priv->staging_rxon.channel = csa->channel;
1027 }
1028
1029 static void iwl_rx_pm_sleep_notif(struct iwl_priv *priv,
1030                                       struct iwl_rx_mem_buffer *rxb)
1031 {
1032 #ifdef CONFIG_IWLWIFI_DEBUG
1033         struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
1034         struct iwl_sleep_notification *sleep = &(pkt->u.sleep_notif);
1035         IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
1036                      sleep->pm_sleep_mode, sleep->pm_wakeup_src);
1037 #endif
1038 }
1039
1040 static void iwl_rx_pm_debug_statistics_notif(struct iwl_priv *priv,
1041                                              struct iwl_rx_mem_buffer *rxb)
1042 {
1043         struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
1044         IWL_DEBUG_RADIO("Dumping %d bytes of unhandled "
1045                         "notification for %s:\n",
1046                         le32_to_cpu(pkt->len), get_cmd_string(pkt->hdr.cmd));
1047         iwl_print_hex_dump(priv, IWL_DL_RADIO, pkt->u.raw, le32_to_cpu(pkt->len));
1048 }
1049
1050 static void iwl_bg_beacon_update(struct work_struct *work)
1051 {
1052         struct iwl_priv *priv =
1053                 container_of(work, struct iwl_priv, beacon_update);
1054         struct sk_buff *beacon;
1055
1056         /* Pull updated AP beacon from mac80211. will fail if not in AP mode */
1057         beacon = ieee80211_beacon_get(priv->hw, priv->vif);
1058
1059         if (!beacon) {
1060                 IWL_ERR(priv, "update beacon failed\n");
1061                 return;
1062         }
1063
1064         mutex_lock(&priv->mutex);
1065         /* new beacon skb is allocated every time; dispose previous.*/
1066         if (priv->ibss_beacon)
1067                 dev_kfree_skb(priv->ibss_beacon);
1068
1069         priv->ibss_beacon = beacon;
1070         mutex_unlock(&priv->mutex);
1071
1072         iwl_send_beacon_cmd(priv);
1073 }
1074
1075 /**
1076  * iwl_bg_statistics_periodic - Timer callback to queue statistics
1077  *
1078  * This callback is provided in order to send a statistics request.
1079  *
1080  * This timer function is continually reset to execute within
1081  * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
1082  * was received.  We need to ensure we receive the statistics in order
1083  * to update the temperature used for calibrating the TXPOWER.
1084  */
1085 static void iwl_bg_statistics_periodic(unsigned long data)
1086 {
1087         struct iwl_priv *priv = (struct iwl_priv *)data;
1088
1089         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
1090                 return;
1091
1092         /* dont send host command if rf-kill is on */
1093         if (!iwl_is_ready_rf(priv))
1094                 return;
1095
1096         iwl_send_statistics_request(priv, CMD_ASYNC);
1097 }
1098
1099 static void iwl_rx_beacon_notif(struct iwl_priv *priv,
1100                                 struct iwl_rx_mem_buffer *rxb)
1101 {
1102 #ifdef CONFIG_IWLWIFI_DEBUG
1103         struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
1104         struct iwl4965_beacon_notif *beacon =
1105                 (struct iwl4965_beacon_notif *)pkt->u.raw;
1106         u8 rate = iwl_hw_get_rate(beacon->beacon_notify_hdr.rate_n_flags);
1107
1108         IWL_DEBUG_RX("beacon status %x retries %d iss %d "
1109                 "tsf %d %d rate %d\n",
1110                 le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
1111                 beacon->beacon_notify_hdr.failure_frame,
1112                 le32_to_cpu(beacon->ibss_mgr_status),
1113                 le32_to_cpu(beacon->high_tsf),
1114                 le32_to_cpu(beacon->low_tsf), rate);
1115 #endif
1116
1117         if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
1118             (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
1119                 queue_work(priv->workqueue, &priv->beacon_update);
1120 }
1121
1122 /* Handle notification from uCode that card's power state is changing
1123  * due to software, hardware, or critical temperature RFKILL */
1124 static void iwl_rx_card_state_notif(struct iwl_priv *priv,
1125                                     struct iwl_rx_mem_buffer *rxb)
1126 {
1127         struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
1128         u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
1129         unsigned long status = priv->status;
1130
1131         IWL_DEBUG_RF_KILL("Card state received: HW:%s SW:%s\n",
1132                           (flags & HW_CARD_DISABLED) ? "Kill" : "On",
1133                           (flags & SW_CARD_DISABLED) ? "Kill" : "On");
1134
1135         if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED |
1136                      RF_CARD_DISABLED)) {
1137
1138                 iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
1139                             CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
1140
1141                 if (!iwl_grab_nic_access(priv)) {
1142                         iwl_write_direct32(
1143                                 priv, HBUS_TARG_MBX_C,
1144                                 HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
1145
1146                         iwl_release_nic_access(priv);
1147                 }
1148
1149                 if (!(flags & RXON_CARD_DISABLED)) {
1150                         iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
1151                                     CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
1152                         if (!iwl_grab_nic_access(priv)) {
1153                                 iwl_write_direct32(
1154                                         priv, HBUS_TARG_MBX_C,
1155                                         HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
1156
1157                                 iwl_release_nic_access(priv);
1158                         }
1159                 }
1160
1161                 if (flags & RF_CARD_DISABLED) {
1162                         iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
1163                                     CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
1164                         iwl_read32(priv, CSR_UCODE_DRV_GP1);
1165                         if (!iwl_grab_nic_access(priv))
1166                                 iwl_release_nic_access(priv);
1167                 }
1168         }
1169
1170         if (flags & HW_CARD_DISABLED)
1171                 set_bit(STATUS_RF_KILL_HW, &priv->status);
1172         else
1173                 clear_bit(STATUS_RF_KILL_HW, &priv->status);
1174
1175
1176         if (flags & SW_CARD_DISABLED)
1177                 set_bit(STATUS_RF_KILL_SW, &priv->status);
1178         else
1179                 clear_bit(STATUS_RF_KILL_SW, &priv->status);
1180
1181         if (!(flags & RXON_CARD_DISABLED))
1182                 iwl_scan_cancel(priv);
1183
1184         if ((test_bit(STATUS_RF_KILL_HW, &status) !=
1185              test_bit(STATUS_RF_KILL_HW, &priv->status)) ||
1186             (test_bit(STATUS_RF_KILL_SW, &status) !=
1187              test_bit(STATUS_RF_KILL_SW, &priv->status)))
1188                 queue_work(priv->workqueue, &priv->rf_kill);
1189         else
1190                 wake_up_interruptible(&priv->wait_command_queue);
1191 }
1192
1193 int iwl_set_pwr_src(struct iwl_priv *priv, enum iwl_pwr_src src)
1194 {
1195         int ret;
1196         unsigned long flags;
1197
1198         spin_lock_irqsave(&priv->lock, flags);
1199         ret = iwl_grab_nic_access(priv);
1200         if (ret)
1201                 goto err;
1202
1203         if (src == IWL_PWR_SRC_VAUX) {
1204                 u32 val;
1205                 ret = pci_read_config_dword(priv->pci_dev, PCI_CFG_POWER_SOURCE,
1206                                             &val);
1207
1208                 if (val & PCI_CFG_PMC_PME_FROM_D3COLD_SUPPORT)
1209                         iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
1210                                                APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
1211                                                ~APMG_PS_CTRL_MSK_PWR_SRC);
1212         } else {
1213                 iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
1214                                        APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
1215                                        ~APMG_PS_CTRL_MSK_PWR_SRC);
1216         }
1217
1218         iwl_release_nic_access(priv);
1219 err:
1220         spin_unlock_irqrestore(&priv->lock, flags);
1221         return ret;
1222 }
1223
1224 /**
1225  * iwl_setup_rx_handlers - Initialize Rx handler callbacks
1226  *
1227  * Setup the RX handlers for each of the reply types sent from the uCode
1228  * to the host.
1229  *
1230  * This function chains into the hardware specific files for them to setup
1231  * any hardware specific handlers as well.
1232  */
1233 static void iwl_setup_rx_handlers(struct iwl_priv *priv)
1234 {
1235         priv->rx_handlers[REPLY_ALIVE] = iwl_rx_reply_alive;
1236         priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
1237         priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
1238         priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
1239         priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
1240             iwl_rx_pm_debug_statistics_notif;
1241         priv->rx_handlers[BEACON_NOTIFICATION] = iwl_rx_beacon_notif;
1242
1243         /*
1244          * The same handler is used for both the REPLY to a discrete
1245          * statistics request from the host as well as for the periodic
1246          * statistics notifications (after received beacons) from the uCode.
1247          */
1248         priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl_rx_statistics;
1249         priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl_rx_statistics;
1250
1251         iwl_setup_spectrum_handlers(priv);
1252         iwl_setup_rx_scan_handlers(priv);
1253
1254         /* status change handler */
1255         priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl_rx_card_state_notif;
1256
1257         priv->rx_handlers[MISSED_BEACONS_NOTIFICATION] =
1258             iwl_rx_missed_beacon_notif;
1259         /* Rx handlers */
1260         priv->rx_handlers[REPLY_RX_PHY_CMD] = iwl_rx_reply_rx_phy;
1261         priv->rx_handlers[REPLY_RX_MPDU_CMD] = iwl_rx_reply_rx;
1262         /* block ack */
1263         priv->rx_handlers[REPLY_COMPRESSED_BA] = iwl_rx_reply_compressed_ba;
1264         /* Set up hardware specific Rx handlers */
1265         priv->cfg->ops->lib->rx_handler_setup(priv);
1266 }
1267
1268 /**
1269  * iwl_rx_handle - Main entry function for receiving responses from uCode
1270  *
1271  * Uses the priv->rx_handlers callback function array to invoke
1272  * the appropriate handlers, including command responses,
1273  * frame-received notifications, and other notifications.
1274  */
1275 void iwl_rx_handle(struct iwl_priv *priv)
1276 {
1277         struct iwl_rx_mem_buffer *rxb;
1278         struct iwl_rx_packet *pkt;
1279         struct iwl_rx_queue *rxq = &priv->rxq;
1280         u32 r, i;
1281         int reclaim;
1282         unsigned long flags;
1283         u8 fill_rx = 0;
1284         u32 count = 8;
1285
1286         /* uCode's read index (stored in shared DRAM) indicates the last Rx
1287          * buffer that the driver may process (last buffer filled by ucode). */
1288         r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
1289         i = rxq->read;
1290
1291         /* Rx interrupt, but nothing sent from uCode */
1292         if (i == r)
1293                 IWL_DEBUG(IWL_DL_RX, "r = %d, i = %d\n", r, i);
1294
1295         if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
1296                 fill_rx = 1;
1297
1298         while (i != r) {
1299                 rxb = rxq->queue[i];
1300
1301                 /* If an RXB doesn't have a Rx queue slot associated with it,
1302                  * then a bug has been introduced in the queue refilling
1303                  * routines -- catch it here */
1304                 BUG_ON(rxb == NULL);
1305
1306                 rxq->queue[i] = NULL;
1307
1308                 dma_sync_single_range_for_cpu(
1309                                 &priv->pci_dev->dev, rxb->real_dma_addr,
1310                                 rxb->aligned_dma_addr - rxb->real_dma_addr,
1311                                 priv->hw_params.rx_buf_size,
1312                                 PCI_DMA_FROMDEVICE);
1313                 pkt = (struct iwl_rx_packet *)rxb->skb->data;
1314
1315                 /* Reclaim a command buffer only if this packet is a response
1316                  *   to a (driver-originated) command.
1317                  * If the packet (e.g. Rx frame) originated from uCode,
1318                  *   there is no command buffer to reclaim.
1319                  * Ucode should set SEQ_RX_FRAME bit if ucode-originated,
1320                  *   but apparently a few don't get set; catch them here. */
1321                 reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
1322                         (pkt->hdr.cmd != REPLY_RX_PHY_CMD) &&
1323                         (pkt->hdr.cmd != REPLY_RX) &&
1324                         (pkt->hdr.cmd != REPLY_RX_MPDU_CMD) &&
1325                         (pkt->hdr.cmd != REPLY_COMPRESSED_BA) &&
1326                         (pkt->hdr.cmd != STATISTICS_NOTIFICATION) &&
1327                         (pkt->hdr.cmd != REPLY_TX);
1328
1329                 /* Based on type of command response or notification,
1330                  *   handle those that need handling via function in
1331                  *   rx_handlers table.  See iwl_setup_rx_handlers() */
1332                 if (priv->rx_handlers[pkt->hdr.cmd]) {
1333                         IWL_DEBUG(IWL_DL_RX, "r = %d, i = %d, %s, 0x%02x\n", r,
1334                                 i, get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
1335                         priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
1336                 } else {
1337                         /* No handling needed */
1338                         IWL_DEBUG(IWL_DL_RX,
1339                                 "r %d i %d No handler needed for %s, 0x%02x\n",
1340                                 r, i, get_cmd_string(pkt->hdr.cmd),
1341                                 pkt->hdr.cmd);
1342                 }
1343
1344                 if (reclaim) {
1345                         /* Invoke any callbacks, transfer the skb to caller, and
1346                          * fire off the (possibly) blocking iwl_send_cmd()
1347                          * as we reclaim the driver command queue */
1348                         if (rxb && rxb->skb)
1349                                 iwl_tx_cmd_complete(priv, rxb);
1350                         else
1351                                 IWL_WARN(priv, "Claim null rxb?\n");
1352                 }
1353
1354                 /* For now we just don't re-use anything.  We can tweak this
1355                  * later to try and re-use notification packets and SKBs that
1356                  * fail to Rx correctly */
1357                 if (rxb->skb != NULL) {
1358                         priv->alloc_rxb_skb--;
1359                         dev_kfree_skb_any(rxb->skb);
1360                         rxb->skb = NULL;
1361                 }
1362
1363                 pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
1364                                  priv->hw_params.rx_buf_size + 256,
1365                                  PCI_DMA_FROMDEVICE);
1366                 spin_lock_irqsave(&rxq->lock, flags);
1367                 list_add_tail(&rxb->list, &priv->rxq.rx_used);
1368                 spin_unlock_irqrestore(&rxq->lock, flags);
1369                 i = (i + 1) & RX_QUEUE_MASK;
1370                 /* If there are a lot of unused frames,
1371                  * restock the Rx queue so ucode wont assert. */
1372                 if (fill_rx) {
1373                         count++;
1374                         if (count >= 8) {
1375                                 priv->rxq.read = i;
1376                                 iwl_rx_queue_restock(priv);
1377                                 count = 0;
1378                         }
1379                 }
1380         }
1381
1382         /* Backtrack one entry */
1383         priv->rxq.read = i;
1384         iwl_rx_queue_restock(priv);
1385 }
1386
1387 #ifdef CONFIG_IWLWIFI_DEBUG
1388 static void iwl_print_rx_config_cmd(struct iwl_priv *priv)
1389 {
1390         struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
1391
1392         IWL_DEBUG_RADIO("RX CONFIG:\n");
1393         iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
1394         IWL_DEBUG_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
1395         IWL_DEBUG_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
1396         IWL_DEBUG_RADIO("u32 filter_flags: 0x%08x\n",
1397                         le32_to_cpu(rxon->filter_flags));
1398         IWL_DEBUG_RADIO("u8 dev_type: 0x%x\n", rxon->dev_type);
1399         IWL_DEBUG_RADIO("u8 ofdm_basic_rates: 0x%02x\n",
1400                         rxon->ofdm_basic_rates);
1401         IWL_DEBUG_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
1402         IWL_DEBUG_RADIO("u8[6] node_addr: %pM\n", rxon->node_addr);
1403         IWL_DEBUG_RADIO("u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
1404         IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
1405 }
1406 #endif
1407
1408 /* call this function to flush any scheduled tasklet */
1409 static inline void iwl_synchronize_irq(struct iwl_priv *priv)
1410 {
1411         /* wait to make sure we flush pending tasklet*/
1412         synchronize_irq(priv->pci_dev->irq);
1413         tasklet_kill(&priv->irq_tasklet);
1414 }
1415
1416 /**
1417  * iwl_irq_handle_error - called for HW or SW error interrupt from card
1418  */
1419 static void iwl_irq_handle_error(struct iwl_priv *priv)
1420 {
1421         /* Set the FW error flag -- cleared on iwl_down */
1422         set_bit(STATUS_FW_ERROR, &priv->status);
1423
1424         /* Cancel currently queued command. */
1425         clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
1426
1427 #ifdef CONFIG_IWLWIFI_DEBUG
1428         if (priv->debug_level & IWL_DL_FW_ERRORS) {
1429                 iwl_dump_nic_error_log(priv);
1430                 iwl_dump_nic_event_log(priv);
1431                 iwl_print_rx_config_cmd(priv);
1432         }
1433 #endif
1434
1435         wake_up_interruptible(&priv->wait_command_queue);
1436
1437         /* Keep the restart process from trying to send host
1438          * commands by clearing the INIT status bit */
1439         clear_bit(STATUS_READY, &priv->status);
1440
1441         if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
1442                 IWL_DEBUG(IWL_DL_FW_ERRORS,
1443                           "Restarting adapter due to uCode error.\n");
1444
1445                 if (iwl_is_associated(priv)) {
1446                         memcpy(&priv->recovery_rxon, &priv->active_rxon,
1447                                sizeof(priv->recovery_rxon));
1448                         priv->error_recovering = 1;
1449                 }
1450                 if (priv->cfg->mod_params->restart_fw)
1451                         queue_work(priv->workqueue, &priv->restart);
1452         }
1453 }
1454
1455 static void iwl_error_recovery(struct iwl_priv *priv)
1456 {
1457         unsigned long flags;
1458
1459         memcpy(&priv->staging_rxon, &priv->recovery_rxon,
1460                sizeof(priv->staging_rxon));
1461         priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
1462         iwl_commit_rxon(priv);
1463
1464         iwl_rxon_add_station(priv, priv->bssid, 1);
1465
1466         spin_lock_irqsave(&priv->lock, flags);
1467         priv->assoc_id = le16_to_cpu(priv->staging_rxon.assoc_id);
1468         priv->error_recovering = 0;
1469         spin_unlock_irqrestore(&priv->lock, flags);
1470 }
1471
1472 static void iwl_irq_tasklet(struct iwl_priv *priv)
1473 {
1474         u32 inta, handled = 0;
1475         u32 inta_fh;
1476         unsigned long flags;
1477 #ifdef CONFIG_IWLWIFI_DEBUG
1478         u32 inta_mask;
1479 #endif
1480
1481         spin_lock_irqsave(&priv->lock, flags);
1482
1483         /* Ack/clear/reset pending uCode interrupts.
1484          * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
1485          *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
1486         inta = iwl_read32(priv, CSR_INT);
1487         iwl_write32(priv, CSR_INT, inta);
1488
1489         /* Ack/clear/reset pending flow-handler (DMA) interrupts.
1490          * Any new interrupts that happen after this, either while we're
1491          * in this tasklet, or later, will show up in next ISR/tasklet. */
1492         inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1493         iwl_write32(priv, CSR_FH_INT_STATUS, inta_fh);
1494
1495 #ifdef CONFIG_IWLWIFI_DEBUG
1496         if (priv->debug_level & IWL_DL_ISR) {
1497                 /* just for debug */
1498                 inta_mask = iwl_read32(priv, CSR_INT_MASK);
1499                 IWL_DEBUG_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
1500                               inta, inta_mask, inta_fh);
1501         }
1502 #endif
1503
1504         /* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
1505          * atomic, make sure that inta covers all the interrupts that
1506          * we've discovered, even if FH interrupt came in just after
1507          * reading CSR_INT. */
1508         if (inta_fh & CSR49_FH_INT_RX_MASK)
1509                 inta |= CSR_INT_BIT_FH_RX;
1510         if (inta_fh & CSR49_FH_INT_TX_MASK)
1511                 inta |= CSR_INT_BIT_FH_TX;
1512
1513         /* Now service all interrupt bits discovered above. */
1514         if (inta & CSR_INT_BIT_HW_ERR) {
1515                 IWL_ERR(priv, "Microcode HW error detected.  Restarting.\n");
1516
1517                 /* Tell the device to stop sending interrupts */
1518                 iwl_disable_interrupts(priv);
1519
1520                 iwl_irq_handle_error(priv);
1521
1522                 handled |= CSR_INT_BIT_HW_ERR;
1523
1524                 spin_unlock_irqrestore(&priv->lock, flags);
1525
1526                 return;
1527         }
1528
1529 #ifdef CONFIG_IWLWIFI_DEBUG
1530         if (priv->debug_level & (IWL_DL_ISR)) {
1531                 /* NIC fires this, but we don't use it, redundant with WAKEUP */
1532                 if (inta & CSR_INT_BIT_SCD)
1533                         IWL_DEBUG_ISR("Scheduler finished to transmit "
1534                                       "the frame/frames.\n");
1535
1536                 /* Alive notification via Rx interrupt will do the real work */
1537                 if (inta & CSR_INT_BIT_ALIVE)
1538                         IWL_DEBUG_ISR("Alive interrupt\n");
1539         }
1540 #endif
1541         /* Safely ignore these bits for debug checks below */
1542         inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
1543
1544         /* HW RF KILL switch toggled */
1545         if (inta & CSR_INT_BIT_RF_KILL) {
1546                 int hw_rf_kill = 0;
1547                 if (!(iwl_read32(priv, CSR_GP_CNTRL) &
1548                                 CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
1549                         hw_rf_kill = 1;
1550
1551                 IWL_DEBUG(IWL_DL_RF_KILL, "RF_KILL bit toggled to %s.\n",
1552                                 hw_rf_kill ? "disable radio" : "enable radio");
1553
1554                 /* driver only loads ucode once setting the interface up.
1555                  * the driver allows loading the ucode even if the radio
1556                  * is killed. Hence update the killswitch state here. The
1557                  * rfkill handler will care about restarting if needed.
1558                  */
1559                 if (!test_bit(STATUS_ALIVE, &priv->status)) {
1560                         if (hw_rf_kill)
1561                                 set_bit(STATUS_RF_KILL_HW, &priv->status);
1562                         else
1563                                 clear_bit(STATUS_RF_KILL_HW, &priv->status);
1564                         queue_work(priv->workqueue, &priv->rf_kill);
1565                 }
1566
1567                 handled |= CSR_INT_BIT_RF_KILL;
1568         }
1569
1570         /* Chip got too hot and stopped itself */
1571         if (inta & CSR_INT_BIT_CT_KILL) {
1572                 IWL_ERR(priv, "Microcode CT kill error detected.\n");
1573                 handled |= CSR_INT_BIT_CT_KILL;
1574         }
1575
1576         /* Error detected by uCode */
1577         if (inta & CSR_INT_BIT_SW_ERR) {
1578                 IWL_ERR(priv, "Microcode SW error detected. "
1579                         " Restarting 0x%X.\n", inta);
1580                 iwl_irq_handle_error(priv);
1581                 handled |= CSR_INT_BIT_SW_ERR;
1582         }
1583
1584         /* uCode wakes up after power-down sleep */
1585         if (inta & CSR_INT_BIT_WAKEUP) {
1586                 IWL_DEBUG_ISR("Wakeup interrupt\n");
1587                 iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
1588                 iwl_txq_update_write_ptr(priv, &priv->txq[0]);
1589                 iwl_txq_update_write_ptr(priv, &priv->txq[1]);
1590                 iwl_txq_update_write_ptr(priv, &priv->txq[2]);
1591                 iwl_txq_update_write_ptr(priv, &priv->txq[3]);
1592                 iwl_txq_update_write_ptr(priv, &priv->txq[4]);
1593                 iwl_txq_update_write_ptr(priv, &priv->txq[5]);
1594
1595                 handled |= CSR_INT_BIT_WAKEUP;
1596         }
1597
1598         /* All uCode command responses, including Tx command responses,
1599          * Rx "responses" (frame-received notification), and other
1600          * notifications from uCode come through here*/
1601         if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
1602                 iwl_rx_handle(priv);
1603                 handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
1604         }
1605
1606         if (inta & CSR_INT_BIT_FH_TX) {
1607                 IWL_DEBUG_ISR("Tx interrupt\n");
1608                 handled |= CSR_INT_BIT_FH_TX;
1609                 /* FH finished to write, send event */
1610                 priv->ucode_write_complete = 1;
1611                 wake_up_interruptible(&priv->wait_command_queue);
1612         }
1613
1614         if (inta & ~handled)
1615                 IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
1616
1617         if (inta & ~CSR_INI_SET_MASK) {
1618                 IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
1619                          inta & ~CSR_INI_SET_MASK);
1620                 IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
1621         }
1622
1623         /* Re-enable all interrupts */
1624         /* only Re-enable if diabled by irq */
1625         if (test_bit(STATUS_INT_ENABLED, &priv->status))
1626                 iwl_enable_interrupts(priv);
1627
1628 #ifdef CONFIG_IWLWIFI_DEBUG
1629         if (priv->debug_level & (IWL_DL_ISR)) {
1630                 inta = iwl_read32(priv, CSR_INT);
1631                 inta_mask = iwl_read32(priv, CSR_INT_MASK);
1632                 inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1633                 IWL_DEBUG_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
1634                         "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
1635         }
1636 #endif
1637         spin_unlock_irqrestore(&priv->lock, flags);
1638 }
1639
1640 static irqreturn_t iwl_isr(int irq, void *data)
1641 {
1642         struct iwl_priv *priv = data;
1643         u32 inta, inta_mask;
1644         u32 inta_fh;
1645         if (!priv)
1646                 return IRQ_NONE;
1647
1648         spin_lock(&priv->lock);
1649
1650         /* Disable (but don't clear!) interrupts here to avoid
1651          *    back-to-back ISRs and sporadic interrupts from our NIC.
1652          * If we have something to service, the tasklet will re-enable ints.
1653          * If we *don't* have something, we'll re-enable before leaving here. */
1654         inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
1655         iwl_write32(priv, CSR_INT_MASK, 0x00000000);
1656
1657         /* Discover which interrupts are active/pending */
1658         inta = iwl_read32(priv, CSR_INT);
1659         inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1660
1661         /* Ignore interrupt if there's nothing in NIC to service.
1662          * This may be due to IRQ shared with another device,
1663          * or due to sporadic interrupts thrown from our NIC. */
1664         if (!inta && !inta_fh) {
1665                 IWL_DEBUG_ISR("Ignore interrupt, inta == 0, inta_fh == 0\n");
1666                 goto none;
1667         }
1668
1669         if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
1670                 /* Hardware disappeared. It might have already raised
1671                  * an interrupt */
1672                 IWL_WARN(priv, "HARDWARE GONE?? INTA == 0x%08x\n", inta);
1673                 goto unplugged;
1674         }
1675
1676         IWL_DEBUG_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
1677                       inta, inta_mask, inta_fh);
1678
1679         inta &= ~CSR_INT_BIT_SCD;
1680
1681         /* iwl_irq_tasklet() will service interrupts and re-enable them */
1682         if (likely(inta || inta_fh))
1683                 tasklet_schedule(&priv->irq_tasklet);
1684
1685  unplugged:
1686         spin_unlock(&priv->lock);
1687         return IRQ_HANDLED;
1688
1689  none:
1690         /* re-enable interrupts here since we don't have anything to service. */
1691         /* only Re-enable if diabled by irq */
1692         if (test_bit(STATUS_INT_ENABLED, &priv->status))
1693                 iwl_enable_interrupts(priv);
1694         spin_unlock(&priv->lock);
1695         return IRQ_NONE;
1696 }
1697
1698 /******************************************************************************
1699  *
1700  * uCode download functions
1701  *
1702  ******************************************************************************/
1703
1704 static void iwl_dealloc_ucode_pci(struct iwl_priv *priv)
1705 {
1706         iwl_free_fw_desc(priv->pci_dev, &priv->ucode_code);
1707         iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data);
1708         iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
1709         iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init);
1710         iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init_data);
1711         iwl_free_fw_desc(priv->pci_dev, &priv->ucode_boot);
1712 }
1713
1714 static void iwl_nic_start(struct iwl_priv *priv)
1715 {
1716         /* Remove all resets to allow NIC to operate */
1717         iwl_write32(priv, CSR_RESET, 0);
1718 }
1719
1720
1721 /**
1722  * iwl_read_ucode - Read uCode images from disk file.
1723  *
1724  * Copy into buffers for card to fetch via bus-mastering
1725  */
1726 static int iwl_read_ucode(struct iwl_priv *priv)
1727 {
1728         struct iwl_ucode *ucode;
1729         int ret = -EINVAL, index;
1730         const struct firmware *ucode_raw;
1731         const char *name_pre = priv->cfg->fw_name_pre;
1732         const unsigned int api_max = priv->cfg->ucode_api_max;
1733         const unsigned int api_min = priv->cfg->ucode_api_min;
1734         char buf[25];
1735         u8 *src;
1736         size_t len;
1737         u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
1738
1739         /* Ask kernel firmware_class module to get the boot firmware off disk.
1740          * request_firmware() is synchronous, file is in memory on return. */
1741         for (index = api_max; index >= api_min; index--) {
1742                 sprintf(buf, "%s%d%s", name_pre, index, ".ucode");
1743                 ret = request_firmware(&ucode_raw, buf, &priv->pci_dev->dev);
1744                 if (ret < 0) {
1745                         IWL_ERR(priv, "%s firmware file req failed: %d\n",
1746                                   buf, ret);
1747                         if (ret == -ENOENT)
1748                                 continue;
1749                         else
1750                                 goto error;
1751                 } else {
1752                         if (index < api_max)
1753                                 IWL_ERR(priv, "Loaded firmware %s, "
1754                                         "which is deprecated. "
1755                                         "Please use API v%u instead.\n",
1756                                           buf, api_max);
1757
1758                         IWL_DEBUG_INFO("Got firmware '%s' file (%zd bytes) from disk\n",
1759                                        buf, ucode_raw->size);
1760                         break;
1761                 }
1762         }
1763
1764         if (ret < 0)
1765                 goto error;
1766
1767         /* Make sure that we got at least our header! */
1768         if (ucode_raw->size < sizeof(*ucode)) {
1769                 IWL_ERR(priv, "File size way too small!\n");
1770                 ret = -EINVAL;
1771                 goto err_release;
1772         }
1773
1774         /* Data from ucode file:  header followed by uCode images */
1775         ucode = (void *)ucode_raw->data;
1776
1777         priv->ucode_ver = le32_to_cpu(ucode->ver);
1778         api_ver = IWL_UCODE_API(priv->ucode_ver);
1779         inst_size = le32_to_cpu(ucode->inst_size);
1780         data_size = le32_to_cpu(ucode->data_size);
1781         init_size = le32_to_cpu(ucode->init_size);
1782         init_data_size = le32_to_cpu(ucode->init_data_size);
1783         boot_size = le32_to_cpu(ucode->boot_size);
1784
1785         /* api_ver should match the api version forming part of the
1786          * firmware filename ... but we don't check for that and only rely
1787          * on the API version read from firware header from here on forward */
1788
1789         if (api_ver < api_min || api_ver > api_max) {
1790                 IWL_ERR(priv, "Driver unable to support your firmware API. "
1791                           "Driver supports v%u, firmware is v%u.\n",
1792                           api_max, api_ver);
1793                 priv->ucode_ver = 0;
1794                 ret = -EINVAL;
1795                 goto err_release;
1796         }
1797         if (api_ver != api_max)
1798                 IWL_ERR(priv, "Firmware has old API version. Expected v%u, "
1799                           "got v%u. New firmware can be obtained "
1800                           "from http://www.intellinuxwireless.org.\n",
1801                           api_max, api_ver);
1802
1803         IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u\n",
1804                IWL_UCODE_MAJOR(priv->ucode_ver),
1805                IWL_UCODE_MINOR(priv->ucode_ver),
1806                IWL_UCODE_API(priv->ucode_ver),
1807                IWL_UCODE_SERIAL(priv->ucode_ver));
1808
1809         IWL_DEBUG_INFO("f/w package hdr ucode version raw = 0x%x\n",
1810                        priv->ucode_ver);
1811         IWL_DEBUG_INFO("f/w package hdr runtime inst size = %u\n",
1812                        inst_size);
1813         IWL_DEBUG_INFO("f/w package hdr runtime data size = %u\n",
1814                        data_size);
1815         IWL_DEBUG_INFO("f/w package hdr init inst size = %u\n",
1816                        init_size);
1817         IWL_DEBUG_INFO("f/w package hdr init data size = %u\n",
1818                        init_data_size);
1819         IWL_DEBUG_INFO("f/w package hdr boot inst size = %u\n",
1820                        boot_size);
1821
1822         /* Verify size of file vs. image size info in file's header */
1823         if (ucode_raw->size < sizeof(*ucode) +
1824                 inst_size + data_size + init_size +
1825                 init_data_size + boot_size) {
1826
1827                 IWL_DEBUG_INFO("uCode file size %d too small\n",
1828                                (int)ucode_raw->size);
1829                 ret = -EINVAL;
1830                 goto err_release;
1831         }
1832
1833         /* Verify that uCode images will fit in card's SRAM */
1834         if (inst_size > priv->hw_params.max_inst_size) {
1835                 IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
1836                                inst_size);
1837                 ret = -EINVAL;
1838                 goto err_release;
1839         }
1840
1841         if (data_size > priv->hw_params.max_data_size) {
1842                 IWL_DEBUG_INFO("uCode data len %d too large to fit in\n",
1843                                 data_size);
1844                 ret = -EINVAL;
1845                 goto err_release;
1846         }
1847         if (init_size > priv->hw_params.max_inst_size) {
1848                 IWL_DEBUG_INFO
1849                     ("uCode init instr len %d too large to fit in\n",
1850                       init_size);
1851                 ret = -EINVAL;
1852                 goto err_release;
1853         }
1854         if (init_data_size > priv->hw_params.max_data_size) {
1855                 IWL_DEBUG_INFO
1856                     ("uCode init data len %d too large to fit in\n",
1857                       init_data_size);
1858                 ret = -EINVAL;
1859                 goto err_release;
1860         }
1861         if (boot_size > priv->hw_params.max_bsm_size) {
1862                 IWL_DEBUG_INFO
1863                     ("uCode boot instr len %d too large to fit in\n",
1864                       boot_size);
1865                 ret = -EINVAL;
1866                 goto err_release;
1867         }
1868
1869         /* Allocate ucode buffers for card's bus-master loading ... */
1870
1871         /* Runtime instructions and 2 copies of data:
1872          * 1) unmodified from disk
1873          * 2) backup cache for save/restore during power-downs */
1874         priv->ucode_code.len = inst_size;
1875         iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
1876
1877         priv->ucode_data.len = data_size;
1878         iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
1879
1880         priv->ucode_data_backup.len = data_size;
1881         iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
1882
1883         /* Initialization instructions and data */
1884         if (init_size && init_data_size) {
1885                 priv->ucode_init.len = init_size;
1886                 iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
1887
1888                 priv->ucode_init_data.len = init_data_size;
1889                 iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
1890
1891                 if (!priv->ucode_init.v_addr || !priv->ucode_init_data.v_addr)
1892                         goto err_pci_alloc;
1893         }
1894
1895         /* Bootstrap (instructions only, no data) */
1896         if (boot_size) {
1897                 priv->ucode_boot.len = boot_size;
1898                 iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
1899
1900                 if (!priv->ucode_boot.v_addr)
1901                         goto err_pci_alloc;
1902         }
1903
1904         /* Copy images into buffers for card's bus-master reads ... */
1905
1906         /* Runtime instructions (first block of data in file) */
1907         src = &ucode->data[0];
1908         len = priv->ucode_code.len;
1909         IWL_DEBUG_INFO("Copying (but not loading) uCode instr len %Zd\n", len);
1910         memcpy(priv->ucode_code.v_addr, src, len);
1911         IWL_DEBUG_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
1912                 priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);
1913
1914         /* Runtime data (2nd block)
1915          * NOTE:  Copy into backup buffer will be done in iwl_up()  */
1916         src = &ucode->data[inst_size];
1917         len = priv->ucode_data.len;
1918         IWL_DEBUG_INFO("Copying (but not loading) uCode data len %Zd\n", len);
1919         memcpy(priv->ucode_data.v_addr, src, len);
1920         memcpy(priv->ucode_data_backup.v_addr, src, len);
1921
1922         /* Initialization instructions (3rd block) */
1923         if (init_size) {
1924                 src = &ucode->data[inst_size + data_size];
1925                 len = priv->ucode_init.len;
1926                 IWL_DEBUG_INFO("Copying (but not loading) init instr len %Zd\n",
1927                                 len);
1928                 memcpy(priv->ucode_init.v_addr, src, len);
1929         }
1930
1931         /* Initialization data (4th block) */
1932         if (init_data_size) {
1933                 src = &ucode->data[inst_size + data_size + init_size];
1934                 len = priv->ucode_init_data.len;
1935                 IWL_DEBUG_INFO("Copying (but not loading) init data len %Zd\n",
1936                                len);
1937                 memcpy(priv->ucode_init_data.v_addr, src, len);
1938         }
1939
1940         /* Bootstrap instructions (5th block) */
1941         src = &ucode->data[inst_size + data_size + init_size + init_data_size];
1942         len = priv->ucode_boot.len;
1943         IWL_DEBUG_INFO("Copying (but not loading) boot instr len %Zd\n", len);
1944         memcpy(priv->ucode_boot.v_addr, src, len);
1945
1946         /* We have our copies now, allow OS release its copies */
1947         release_firmware(ucode_raw);
1948         return 0;
1949
1950  err_pci_alloc:
1951         IWL_ERR(priv, "failed to allocate pci memory\n");
1952         ret = -ENOMEM;
1953         iwl_dealloc_ucode_pci(priv);
1954
1955  err_release:
1956         release_firmware(ucode_raw);
1957
1958  error:
1959         return ret;
1960 }
1961
1962 /* temporary */
1963 static int iwl_mac_beacon_update(struct ieee80211_hw *hw,
1964                                  struct sk_buff *skb);
1965
1966 /**
1967  * iwl_alive_start - called after REPLY_ALIVE notification received
1968  *                   from protocol/runtime uCode (initialization uCode's
1969  *                   Alive gets handled by iwl_init_alive_start()).
1970  */
1971 static void iwl_alive_start(struct iwl_priv *priv)
1972 {
1973         int ret = 0;
1974
1975         IWL_DEBUG_INFO("Runtime Alive received.\n");
1976
1977         if (priv->card_alive.is_valid != UCODE_VALID_OK) {
1978                 /* We had an error bringing up the hardware, so take it
1979                  * all the way back down so we can try again */
1980                 IWL_DEBUG_INFO("Alive failed.\n");
1981                 goto restart;
1982         }
1983
1984         /* Initialize uCode has loaded Runtime uCode ... verify inst image.
1985          * This is a paranoid check, because we would not have gotten the
1986          * "runtime" alive if code weren't properly loaded.  */
1987         if (iwl_verify_ucode(priv)) {
1988                 /* Runtime instruction load was bad;
1989                  * take it all the way back down so we can try again */
1990                 IWL_DEBUG_INFO("Bad runtime uCode load.\n");
1991                 goto restart;
1992         }
1993
1994         iwl_clear_stations_table(priv);
1995         ret = priv->cfg->ops->lib->alive_notify(priv);
1996         if (ret) {
1997                 IWL_WARN(priv,
1998                         "Could not complete ALIVE transition [ntf]: %d\n", ret);
1999                 goto restart;
2000         }
2001
2002         /* After the ALIVE response, we can send host commands to the uCode */
2003         set_bit(STATUS_ALIVE, &priv->status);
2004
2005         if (iwl_is_rfkill(priv))
2006                 return;
2007
2008         ieee80211_wake_queues(priv->hw);
2009
2010         priv->active_rate = priv->rates_mask;
2011         priv->active_rate_basic = priv->rates_mask & IWL_BASIC_RATES_MASK;
2012
2013         if (iwl_is_associated(priv)) {
2014                 struct iwl_rxon_cmd *active_rxon =
2015                                 (struct iwl_rxon_cmd *)&priv->active_rxon;
2016
2017                 memcpy(&priv->staging_rxon, &priv->active_rxon,
2018                        sizeof(priv->staging_rxon));
2019                 active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
2020         } else {
2021                 /* Initialize our rx_config data */
2022                 iwl_connection_init_rx_config(priv, priv->iw_mode);
2023                 memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
2024         }
2025
2026         /* Configure Bluetooth device coexistence support */
2027         iwl_send_bt_config(priv);
2028
2029         iwl_reset_run_time_calib(priv);
2030
2031         /* Configure the adapter for unassociated operation */
2032         iwl_commit_rxon(priv);
2033
2034         /* At this point, the NIC is initialized and operational */
2035         iwl_rf_kill_ct_config(priv);
2036
2037         iwl_leds_register(priv);
2038
2039         IWL_DEBUG_INFO("ALIVE processing complete.\n");
2040         set_bit(STATUS_READY, &priv->status);
2041         wake_up_interruptible(&priv->wait_command_queue);
2042
2043         if (priv->error_recovering)
2044                 iwl_error_recovery(priv);
2045
2046         iwl_power_update_mode(priv, 1);
2047
2048         /* reassociate for ADHOC mode */
2049         if (priv->vif && (priv->iw_mode == NL80211_IFTYPE_ADHOC)) {
2050                 struct sk_buff *beacon = ieee80211_beacon_get(priv->hw,
2051                                                                 priv->vif);
2052                 if (beacon)
2053                         iwl_mac_beacon_update(priv->hw, beacon);
2054         }
2055
2056
2057         if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
2058                 iwl_set_mode(priv, priv->iw_mode);
2059
2060         return;
2061
2062  restart:
2063         queue_work(priv->workqueue, &priv->restart);
2064 }
2065
2066 static void iwl_cancel_deferred_work(struct iwl_priv *priv);
2067
2068 static void __iwl_down(struct iwl_priv *priv)
2069 {
2070         unsigned long flags;
2071         int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
2072
2073         IWL_DEBUG_INFO(DRV_NAME " is going down\n");
2074
2075         if (!exit_pending)
2076                 set_bit(STATUS_EXIT_PENDING, &priv->status);
2077
2078         iwl_leds_unregister(priv);
2079
2080         iwl_clear_stations_table(priv);
2081
2082         /* Unblock any waiting calls */
2083         wake_up_interruptible_all(&priv->wait_command_queue);
2084
2085         /* Wipe out the EXIT_PENDING status bit if we are not actually
2086          * exiting the module */
2087         if (!exit_pending)
2088                 clear_bit(STATUS_EXIT_PENDING, &priv->status);
2089
2090         /* stop and reset the on-board processor */
2091         iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
2092
2093         /* tell the device to stop sending interrupts */
2094         spin_lock_irqsave(&priv->lock, flags);
2095         iwl_disable_interrupts(priv);
2096         spin_unlock_irqrestore(&priv->lock, flags);
2097         iwl_synchronize_irq(priv);
2098
2099         if (priv->mac80211_registered)
2100                 ieee80211_stop_queues(priv->hw);
2101
2102         /* If we have not previously called iwl_init() then
2103          * clear all bits but the RF Kill and SUSPEND bits and return */
2104         if (!iwl_is_init(priv)) {
2105                 priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
2106                                         STATUS_RF_KILL_HW |
2107                                test_bit(STATUS_RF_KILL_SW, &priv->status) <<
2108                                         STATUS_RF_KILL_SW |
2109                                test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
2110                                         STATUS_GEO_CONFIGURED |
2111                                test_bit(STATUS_IN_SUSPEND, &priv->status) <<
2112                                         STATUS_IN_SUSPEND |
2113                                test_bit(STATUS_EXIT_PENDING, &priv->status) <<
2114                                         STATUS_EXIT_PENDING;
2115                 goto exit;
2116         }
2117
2118         /* ...otherwise clear out all the status bits but the RF Kill and
2119          * SUSPEND bits and continue taking the NIC down. */
2120         priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
2121                                 STATUS_RF_KILL_HW |
2122                         test_bit(STATUS_RF_KILL_SW, &priv->status) <<
2123                                 STATUS_RF_KILL_SW |
2124                         test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
2125                                 STATUS_GEO_CONFIGURED |
2126                         test_bit(STATUS_IN_SUSPEND, &priv->status) <<
2127                                 STATUS_IN_SUSPEND |
2128                         test_bit(STATUS_FW_ERROR, &priv->status) <<
2129                                 STATUS_FW_ERROR |
2130                        test_bit(STATUS_EXIT_PENDING, &priv->status) <<
2131                                 STATUS_EXIT_PENDING;
2132
2133         spin_lock_irqsave(&priv->lock, flags);
2134         iwl_clear_bit(priv, CSR_GP_CNTRL,
2135                          CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
2136         spin_unlock_irqrestore(&priv->lock, flags);
2137
2138         iwl_txq_ctx_stop(priv);
2139         iwl_rxq_stop(priv);
2140
2141         spin_lock_irqsave(&priv->lock, flags);
2142         if (!iwl_grab_nic_access(priv)) {
2143                 iwl_write_prph(priv, APMG_CLK_DIS_REG,
2144                                          APMG_CLK_VAL_DMA_CLK_RQT);
2145                 iwl_release_nic_access(priv);
2146         }
2147         spin_unlock_irqrestore(&priv->lock, flags);
2148
2149         udelay(5);
2150
2151         /* FIXME: apm_ops.suspend(priv) */
2152         if (exit_pending || test_bit(STATUS_IN_SUSPEND, &priv->status))
2153                 priv->cfg->ops->lib->apm_ops.stop(priv);
2154         else
2155                 priv->cfg->ops->lib->apm_ops.reset(priv);
2156  exit:
2157         memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
2158
2159         if (priv->ibss_beacon)
2160                 dev_kfree_skb(priv->ibss_beacon);
2161         priv->ibss_beacon = NULL;
2162
2163         /* clear out any free frames */
2164         iwl_clear_free_frames(priv);
2165 }
2166
2167 static void iwl_down(struct iwl_priv *priv)
2168 {
2169         mutex_lock(&priv->mutex);
2170         __iwl_down(priv);
2171         mutex_unlock(&priv->mutex);
2172
2173         iwl_cancel_deferred_work(priv);
2174 }
2175
2176 #define MAX_HW_RESTARTS 5
2177
2178 static int __iwl_up(struct iwl_priv *priv)
2179 {
2180         int i;
2181         int ret;
2182
2183         if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2184                 IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
2185                 return -EIO;
2186         }
2187
2188         if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
2189                 IWL_ERR(priv, "ucode not available for device bringup\n");
2190                 return -EIO;
2191         }
2192
2193         /* If platform's RF_KILL switch is NOT set to KILL */
2194         if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
2195                 clear_bit(STATUS_RF_KILL_HW, &priv->status);
2196         else
2197                 set_bit(STATUS_RF_KILL_HW, &priv->status);
2198
2199         if (iwl_is_rfkill(priv)) {
2200                 iwl_enable_interrupts(priv);
2201                 IWL_WARN(priv, "Radio disabled by %s RF Kill switch\n",
2202                     test_bit(STATUS_RF_KILL_HW, &priv->status) ? "HW" : "SW");
2203                 return 0;
2204         }
2205
2206         iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2207
2208         ret = iwl_hw_nic_init(priv);
2209         if (ret) {
2210                 IWL_ERR(priv, "Unable to init nic\n");
2211                 return ret;
2212         }
2213
2214         /* make sure rfkill handshake bits are cleared */
2215         iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
2216         iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
2217                     CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
2218
2219         /* clear (again), then enable host interrupts */
2220         iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2221         iwl_enable_interrupts(priv);
2222
2223         /* really make sure rfkill handshake bits are cleared */
2224         iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
2225         iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
2226
2227         /* Copy original ucode data image from disk into backup cache.
2228          * This will be used to initialize the on-board processor's
2229          * data SRAM for a clean start when the runtime program first loads. */
2230         memcpy(priv->ucode_data_backup.v_addr, priv->ucode_data.v_addr,
2231                priv->ucode_data.len);
2232
2233         for (i = 0; i < MAX_HW_RESTARTS; i++) {
2234
2235                 iwl_clear_stations_table(priv);
2236
2237                 /* load bootstrap state machine,
2238                  * load bootstrap program into processor's memory,
2239                  * prepare to load the "initialize" uCode */
2240                 ret = priv->cfg->ops->lib->load_ucode(priv);
2241
2242                 if (ret) {
2243                         IWL_ERR(priv, "Unable to set up bootstrap uCode: %d\n",
2244                                 ret);
2245                         continue;
2246                 }
2247
2248                 /* Clear out the uCode error bit if it is set */
2249                 clear_bit(STATUS_FW_ERROR, &priv->status);
2250
2251                 /* start card; "initialize" will load runtime ucode */
2252                 iwl_nic_start(priv);
2253
2254                 IWL_DEBUG_INFO(DRV_NAME " is coming up\n");
2255
2256                 return 0;
2257         }
2258
2259         set_bit(STATUS_EXIT_PENDING, &priv->status);
2260         __iwl_down(priv);
2261         clear_bit(STATUS_EXIT_PENDING, &priv->status);
2262
2263         /* tried to restart and config the device for as long as our
2264          * patience could withstand */
2265         IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
2266         return -EIO;
2267 }
2268
2269
2270 /*****************************************************************************
2271  *
2272  * Workqueue callbacks
2273  *
2274  *****************************************************************************/
2275
2276 static void iwl_bg_init_alive_start(struct work_struct *data)
2277 {
2278         struct iwl_priv *priv =
2279             container_of(data, struct iwl_priv, init_alive_start.work);
2280
2281         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2282                 return;
2283
2284         mutex_lock(&priv->mutex);
2285         priv->cfg->ops->lib->init_alive_start(priv);
2286         mutex_unlock(&priv->mutex);
2287 }
2288
2289 static void iwl_bg_alive_start(struct work_struct *data)
2290 {
2291         struct iwl_priv *priv =
2292             container_of(data, struct iwl_priv, alive_start.work);
2293
2294         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2295                 return;
2296
2297         mutex_lock(&priv->mutex);
2298         iwl_alive_start(priv);
2299         mutex_unlock(&priv->mutex);
2300 }
2301
2302 static void iwl_bg_run_time_calib_work(struct work_struct *work)
2303 {
2304         struct iwl_priv *priv = container_of(work, struct iwl_priv,
2305                         run_time_calib_work);
2306
2307         mutex_lock(&priv->mutex);
2308
2309         if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
2310             test_bit(STATUS_SCANNING, &priv->status)) {
2311                 mutex_unlock(&priv->mutex);
2312                 return;
2313         }
2314
2315         if (priv->start_calib) {
2316                 iwl_chain_noise_calibration(priv, &priv->statistics);
2317
2318                 iwl_sensitivity_calibration(priv, &priv->statistics);
2319         }
2320
2321         mutex_unlock(&priv->mutex);
2322         return;
2323 }
2324
2325 static void iwl_bg_up(struct work_struct *data)
2326 {
2327         struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
2328
2329         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2330                 return;
2331
2332         mutex_lock(&priv->mutex);
2333         __iwl_up(priv);
2334         mutex_unlock(&priv->mutex);
2335         iwl_rfkill_set_hw_state(priv);
2336 }
2337
2338 static void iwl_bg_restart(struct work_struct *data)
2339 {
2340         struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
2341
2342         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2343                 return;
2344
2345         iwl_down(priv);
2346         queue_work(priv->workqueue, &priv->up);
2347 }
2348
2349 static void iwl_bg_rx_replenish(struct work_struct *data)
2350 {
2351         struct iwl_priv *priv =
2352             container_of(data, struct iwl_priv, rx_replenish);
2353
2354         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2355                 return;
2356
2357         mutex_lock(&priv->mutex);
2358         iwl_rx_replenish(priv);
2359         mutex_unlock(&priv->mutex);
2360 }
2361
2362 #define IWL_DELAY_NEXT_SCAN (HZ*2)
2363
2364 static void iwl_post_associate(struct iwl_priv *priv)
2365 {
2366         struct ieee80211_conf *conf = NULL;
2367         int ret = 0;
2368         unsigned long flags;
2369
2370         if (priv->iw_mode == NL80211_IFTYPE_AP) {
2371                 IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
2372                 return;
2373         }
2374
2375         IWL_DEBUG_ASSOC("Associated as %d to: %pM\n",
2376                         priv->assoc_id, priv->active_rxon.bssid_addr);
2377
2378
2379         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2380                 return;
2381
2382
2383         if (!priv->vif || !priv->is_open)
2384                 return;
2385
2386         iwl_power_cancel_timeout(priv);
2387         iwl_scan_cancel_timeout(priv, 200);
2388
2389         conf = ieee80211_get_hw_conf(priv->hw);
2390
2391         priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
2392         iwl_commit_rxon(priv);
2393
2394         iwl_setup_rxon_timing(priv);
2395         ret = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
2396                               sizeof(priv->rxon_timing), &priv->rxon_timing);
2397         if (ret)
2398                 IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
2399                             "Attempting to continue.\n");
2400
2401         priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
2402
2403         iwl_set_rxon_ht(priv, &priv->current_ht_config);
2404
2405         iwl_set_rxon_chain(priv);
2406         priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
2407
2408         IWL_DEBUG_ASSOC("assoc id %d beacon interval %d\n",
2409                         priv->assoc_id, priv->beacon_int);
2410
2411         if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
2412                 priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
2413         else
2414                 priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
2415
2416         if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
2417                 if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
2418                         priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
2419                 else
2420                         priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
2421
2422                 if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
2423                         priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
2424
2425         }
2426
2427         iwl_commit_rxon(priv);
2428
2429         switch (priv->iw_mode) {
2430         case NL80211_IFTYPE_STATION:
2431                 break;
2432
2433         case NL80211_IFTYPE_ADHOC:
2434
2435                 /* assume default assoc id */
2436                 priv->assoc_id = 1;
2437
2438                 iwl_rxon_add_station(priv, priv->bssid, 0);
2439                 iwl_send_beacon_cmd(priv);
2440
2441                 break;
2442
2443         default:
2444                 IWL_ERR(priv, "%s Should not be called in %d mode\n",
2445                           __func__, priv->iw_mode);
2446                 break;
2447         }
2448
2449         if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
2450                 priv->assoc_station_added = 1;
2451
2452         spin_lock_irqsave(&priv->lock, flags);
2453         iwl_activate_qos(priv, 0);
2454         spin_unlock_irqrestore(&priv->lock, flags);
2455
2456         /* the chain noise calibration will enabled PM upon completion
2457          * If chain noise has already been run, then we need to enable
2458          * power management here */
2459         if (priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE)
2460                 iwl_power_enable_management(priv);
2461
2462         /* Enable Rx differential gain and sensitivity calibrations */
2463         iwl_chain_noise_reset(priv);
2464         priv->start_calib = 1;
2465
2466 }
2467
2468 /*****************************************************************************
2469  *
2470  * mac80211 entry point functions
2471  *
2472  *****************************************************************************/
2473
2474 #define UCODE_READY_TIMEOUT     (4 * HZ)
2475
2476 static int iwl_mac_start(struct ieee80211_hw *hw)
2477 {
2478         struct iwl_priv *priv = hw->priv;
2479         int ret;
2480
2481         IWL_DEBUG_MAC80211("enter\n");
2482
2483         /* we should be verifying the device is ready to be opened */
2484         mutex_lock(&priv->mutex);
2485
2486         memset(&priv->staging_rxon, 0, sizeof(struct iwl_rxon_cmd));
2487         /* fetch ucode file from disk, alloc and copy to bus-master buffers ...
2488          * ucode filename and max sizes are card-specific. */
2489
2490         if (!priv->ucode_code.len) {
2491                 ret = iwl_read_ucode(priv);
2492                 if (ret) {
2493                         IWL_ERR(priv, "Could not read microcode: %d\n", ret);
2494                         mutex_unlock(&priv->mutex);
2495                         return ret;
2496                 }
2497         }
2498
2499         ret = __iwl_up(priv);
2500
2501         mutex_unlock(&priv->mutex);
2502
2503         iwl_rfkill_set_hw_state(priv);
2504
2505         if (ret)
2506                 return ret;
2507
2508         if (iwl_is_rfkill(priv))
2509                 goto out;
2510
2511         IWL_DEBUG_INFO("Start UP work done.\n");
2512
2513         if (test_bit(STATUS_IN_SUSPEND, &priv->status))
2514                 return 0;
2515
2516         /* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
2517          * mac80211 will not be run successfully. */
2518         ret = wait_event_interruptible_timeout(priv->wait_command_queue,
2519                         test_bit(STATUS_READY, &priv->status),
2520                         UCODE_READY_TIMEOUT);
2521         if (!ret) {
2522                 if (!test_bit(STATUS_READY, &priv->status)) {
2523                         IWL_ERR(priv, "START_ALIVE timeout after %dms.\n",
2524                                 jiffies_to_msecs(UCODE_READY_TIMEOUT));
2525                         return -ETIMEDOUT;
2526                 }
2527         }
2528
2529 out:
2530         priv->is_open = 1;
2531         IWL_DEBUG_MAC80211("leave\n");
2532         return 0;
2533 }
2534
2535 static void iwl_mac_stop(struct ieee80211_hw *hw)
2536 {
2537         struct iwl_priv *priv = hw->priv;
2538
2539         IWL_DEBUG_MAC80211("enter\n");
2540
2541         if (!priv->is_open) {
2542                 IWL_DEBUG_MAC80211("leave - skip\n");
2543                 return;
2544         }
2545
2546         priv->is_open = 0;
2547
2548         if (iwl_is_ready_rf(priv)) {
2549                 /* stop mac, cancel any scan request and clear
2550                  * RXON_FILTER_ASSOC_MSK BIT
2551                  */
2552                 mutex_lock(&priv->mutex);
2553                 iwl_scan_cancel_timeout(priv, 100);
2554                 mutex_unlock(&priv->mutex);
2555         }
2556
2557         iwl_down(priv);
2558
2559         flush_workqueue(priv->workqueue);
2560
2561         /* enable interrupts again in order to receive rfkill changes */
2562         iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2563         iwl_enable_interrupts(priv);
2564
2565         IWL_DEBUG_MAC80211("leave\n");
2566 }
2567
2568 static int iwl_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
2569 {
2570         struct iwl_priv *priv = hw->priv;
2571
2572         IWL_DEBUG_MACDUMP("enter\n");
2573
2574         IWL_DEBUG_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
2575                      ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
2576
2577         if (iwl_tx_skb(priv, skb))
2578                 dev_kfree_skb_any(skb);
2579
2580         IWL_DEBUG_MACDUMP("leave\n");
2581         return NETDEV_TX_OK;
2582 }
2583
2584 static int iwl_mac_add_interface(struct ieee80211_hw *hw,
2585                                  struct ieee80211_if_init_conf *conf)
2586 {
2587         struct iwl_priv *priv = hw->priv;
2588         unsigned long flags;
2589
2590         IWL_DEBUG_MAC80211("enter: type %d\n", conf->type);
2591
2592         if (priv->vif) {
2593                 IWL_DEBUG_MAC80211("leave - vif != NULL\n");
2594                 return -EOPNOTSUPP;
2595         }
2596
2597         spin_lock_irqsave(&priv->lock, flags);
2598         priv->vif = conf->vif;
2599         priv->iw_mode = conf->type;
2600
2601         spin_unlock_irqrestore(&priv->lock, flags);
2602
2603         mutex_lock(&priv->mutex);
2604
2605         if (conf->mac_addr) {
2606                 IWL_DEBUG_MAC80211("Set %pM\n", conf->mac_addr);
2607                 memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
2608         }
2609
2610         if (iwl_set_mode(priv, conf->type) == -EAGAIN)
2611                 /* we are not ready, will run again when ready */
2612                 set_bit(STATUS_MODE_PENDING, &priv->status);
2613
2614         mutex_unlock(&priv->mutex);
2615
2616         IWL_DEBUG_MAC80211("leave\n");
2617         return 0;
2618 }
2619
2620 /**
2621  * iwl_mac_config - mac80211 config callback
2622  *
2623  * We ignore conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME since it seems to
2624  * be set inappropriately and the driver currently sets the hardware up to
2625  * use it whenever needed.
2626  */
2627 static int iwl_mac_config(struct ieee80211_hw *hw, u32 changed)
2628 {
2629         struct iwl_priv *priv = hw->priv;
2630         const struct iwl_channel_info *ch_info;
2631         struct ieee80211_conf *conf = &hw->conf;
2632         unsigned long flags;
2633         int ret = 0;
2634         u16 channel;
2635
2636         mutex_lock(&priv->mutex);
2637         IWL_DEBUG_MAC80211("enter to channel %d\n", conf->channel->hw_value);
2638
2639         priv->current_ht_config.is_ht = conf_is_ht(conf);
2640
2641         if (conf->radio_enabled && iwl_radio_kill_sw_enable_radio(priv)) {
2642                 IWL_DEBUG_MAC80211("leave - RF-KILL - waiting for uCode\n");
2643                 goto out;
2644         }
2645
2646         if (!conf->radio_enabled)
2647                 iwl_radio_kill_sw_disable_radio(priv);
2648
2649         if (!iwl_is_ready(priv)) {
2650                 IWL_DEBUG_MAC80211("leave - not ready\n");
2651                 ret = -EIO;
2652                 goto out;
2653         }
2654
2655         if (unlikely(!priv->cfg->mod_params->disable_hw_scan &&
2656                      test_bit(STATUS_SCANNING, &priv->status))) {
2657                 IWL_DEBUG_MAC80211("leave - scanning\n");
2658                 mutex_unlock(&priv->mutex);
2659                 return 0;
2660         }
2661
2662         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2663         ch_info = iwl_get_channel_info(priv, conf->channel->band, channel);
2664         if (!is_channel_valid(ch_info)) {
2665                 IWL_DEBUG_MAC80211("leave - invalid channel\n");
2666                 ret = -EINVAL;
2667                 goto out;
2668         }
2669
2670         if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
2671             !is_channel_ibss(ch_info)) {
2672                 IWL_ERR(priv, "channel %d in band %d not IBSS channel\n",
2673                         conf->channel->hw_value, conf->channel->band);
2674                 ret = -EINVAL;
2675                 goto out;
2676         }
2677
2678         spin_lock_irqsave(&priv->lock, flags);
2679
2680
2681         /* if we are switching from ht to 2.4 clear flags
2682          * from any ht related info since 2.4 does not
2683          * support ht */
2684         if ((le16_to_cpu(priv->staging_rxon.channel) != channel)
2685 #ifdef IEEE80211_CONF_CHANNEL_SWITCH
2686             && !(conf->flags & IEEE80211_CONF_CHANNEL_SWITCH)
2687 #endif
2688         )
2689                 priv->staging_rxon.flags = 0;
2690
2691         iwl_set_rxon_channel(priv, conf->channel);
2692
2693         iwl_set_flags_for_band(priv, conf->channel->band);
2694
2695         /* The list of supported rates and rate mask can be different
2696          * for each band; since the band may have changed, reset
2697          * the rate mask to what mac80211 lists */
2698         iwl_set_rate(priv);
2699
2700         spin_unlock_irqrestore(&priv->lock, flags);
2701
2702 #ifdef IEEE80211_CONF_CHANNEL_SWITCH
2703         if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
2704                 iwl_hw_channel_switch(priv, conf->channel);
2705                 goto out;
2706         }
2707 #endif
2708
2709         if (!conf->radio_enabled) {
2710                 IWL_DEBUG_MAC80211("leave - radio disabled\n");
2711                 goto out;
2712         }
2713
2714         if (iwl_is_rfkill(priv)) {
2715                 IWL_DEBUG_MAC80211("leave - RF kill\n");
2716                 ret = -EIO;
2717                 goto out;
2718         }
2719
2720         if (conf->flags & IEEE80211_CONF_PS)
2721                 ret = iwl_power_set_user_mode(priv, IWL_POWER_INDEX_3);
2722         else
2723                 ret = iwl_power_set_user_mode(priv, IWL_POWER_MODE_CAM);
2724         if (ret)
2725                 IWL_DEBUG_MAC80211("Error setting power level\n");
2726
2727         IWL_DEBUG_MAC80211("TX Power old=%d new=%d\n",
2728                            priv->tx_power_user_lmt, conf->power_level);
2729
2730         iwl_set_tx_power(priv, conf->power_level, false);
2731
2732         iwl_set_rate(priv);
2733
2734         /* call to ensure that 4965 rx_chain is set properly in monitor mode */
2735         iwl_set_rxon_chain(priv);
2736
2737         if (memcmp(&priv->active_rxon,
2738                    &priv->staging_rxon, sizeof(priv->staging_rxon)))
2739                 iwl_commit_rxon(priv);
2740         else
2741                 IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");
2742
2743         IWL_DEBUG_MAC80211("leave\n");
2744
2745 out:
2746         mutex_unlock(&priv->mutex);
2747         return ret;
2748 }
2749
2750 static void iwl_config_ap(struct iwl_priv *priv)
2751 {
2752         int ret = 0;
2753         unsigned long flags;
2754
2755         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2756                 return;
2757
2758         /* The following should be done only at AP bring up */
2759         if (!iwl_is_associated(priv)) {
2760
2761                 /* RXON - unassoc (to set timing command) */
2762                 priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
2763                 iwl_commit_rxon(priv);
2764
2765                 /* RXON Timing */
2766                 iwl_setup_rxon_timing(priv);
2767                 ret = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
2768                                 sizeof(priv->rxon_timing), &priv->rxon_timing);
2769                 if (ret)
2770                         IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
2771                                         "Attempting to continue.\n");
2772
2773                 iwl_set_rxon_chain(priv);
2774
2775                 /* FIXME: what should be the assoc_id for AP? */
2776                 priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
2777                 if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
2778                         priv->staging_rxon.flags |=
2779                                 RXON_FLG_SHORT_PREAMBLE_MSK;
2780                 else
2781                         priv->staging_rxon.flags &=
2782                                 ~RXON_FLG_SHORT_PREAMBLE_MSK;
2783
2784                 if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
2785                         if (priv->assoc_capability &
2786                                 WLAN_CAPABILITY_SHORT_SLOT_TIME)
2787                                 priv->staging_rxon.flags |=
2788                                         RXON_FLG_SHORT_SLOT_MSK;
2789                         else
2790                                 priv->staging_rxon.flags &=
2791                                         ~RXON_FLG_SHORT_SLOT_MSK;
2792
2793                         if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
2794                                 priv->staging_rxon.flags &=
2795                                         ~RXON_FLG_SHORT_SLOT_MSK;
2796                 }
2797                 /* restore RXON assoc */
2798                 priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
2799                 iwl_commit_rxon(priv);
2800                 spin_lock_irqsave(&priv->lock, flags);
2801                 iwl_activate_qos(priv, 1);
2802                 spin_unlock_irqrestore(&priv->lock, flags);
2803                 iwl_rxon_add_station(priv, iwl_bcast_addr, 0);
2804         }
2805         iwl_send_beacon_cmd(priv);
2806
2807         /* FIXME - we need to add code here to detect a totally new
2808          * configuration, reset the AP, unassoc, rxon timing, assoc,
2809          * clear sta table, add BCAST sta... */
2810 }
2811
2812
2813 static int iwl_mac_config_interface(struct ieee80211_hw *hw,
2814                                         struct ieee80211_vif *vif,
2815                                     struct ieee80211_if_conf *conf)
2816 {
2817         struct iwl_priv *priv = hw->priv;
2818         int rc;
2819
2820         if (conf == NULL)
2821                 return -EIO;
2822
2823         if (priv->vif != vif) {
2824                 IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
2825                 return 0;
2826         }
2827
2828         if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
2829             conf->changed & IEEE80211_IFCC_BEACON) {
2830                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
2831                 if (!beacon)
2832                         return -ENOMEM;
2833                 mutex_lock(&priv->mutex);
2834                 rc = iwl_mac_beacon_update(hw, beacon);
2835                 mutex_unlock(&priv->mutex);
2836                 if (rc)
2837                         return rc;
2838         }
2839
2840         if (!iwl_is_alive(priv))
2841                 return -EAGAIN;
2842
2843         mutex_lock(&priv->mutex);
2844
2845         if (conf->bssid)
2846                 IWL_DEBUG_MAC80211("bssid: %pM\n", conf->bssid);
2847
2848 /*
2849  * very dubious code was here; the probe filtering flag is never set:
2850  *
2851         if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
2852             !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
2853  */
2854
2855         if (priv->iw_mode == NL80211_IFTYPE_AP) {
2856                 if (!conf->bssid) {
2857                         conf->bssid = priv->mac_addr;
2858                         memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
2859                         IWL_DEBUG_MAC80211("bssid was set to: %pM\n",
2860                                            conf->bssid);
2861                 }
2862                 if (priv->ibss_beacon)
2863                         dev_kfree_skb(priv->ibss_beacon);
2864
2865                 priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
2866         }
2867
2868         if (iwl_is_rfkill(priv))
2869                 goto done;
2870
2871         if (conf->bssid && !is_zero_ether_addr(conf->bssid) &&
2872             !is_multicast_ether_addr(conf->bssid)) {
2873                 /* If there is currently a HW scan going on in the background
2874                  * then we need to cancel it else the RXON below will fail. */
2875                 if (iwl_scan_cancel_timeout(priv, 100)) {
2876                         IWL_WARN(priv, "Aborted scan still in progress "
2877                                     "after 100ms\n");
2878                         IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
2879                         mutex_unlock(&priv->mutex);
2880                         return -EAGAIN;
2881                 }
2882                 memcpy(priv->staging_rxon.bssid_addr, conf->bssid, ETH_ALEN);
2883
2884                 /* TODO: Audit driver for usage of these members and see
2885                  * if mac80211 deprecates them (priv->bssid looks like it
2886                  * shouldn't be there, but I haven't scanned the IBSS code
2887                  * to verify) - jpk */
2888                 memcpy(priv->bssid, conf->bssid, ETH_ALEN);
2889
2890                 if (priv->iw_mode == NL80211_IFTYPE_AP)
2891                         iwl_config_ap(priv);
2892                 else {
2893                         rc = iwl_commit_rxon(priv);
2894                         if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
2895                                 iwl_rxon_add_station(
2896                                         priv, priv->active_rxon.bssid_addr, 1);
2897                 }
2898
2899         } else {
2900                 iwl_scan_cancel_timeout(priv, 100);
2901                 priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
2902                 iwl_commit_rxon(priv);
2903         }
2904
2905  done:
2906         IWL_DEBUG_MAC80211("leave\n");
2907         mutex_unlock(&priv->mutex);
2908
2909         return 0;
2910 }
2911
2912 static void iwl_configure_filter(struct ieee80211_hw *hw,
2913                                  unsigned int changed_flags,
2914                                  unsigned int *total_flags,
2915                                  int mc_count, struct dev_addr_list *mc_list)
2916 {
2917         struct iwl_priv *priv = hw->priv;
2918         __le32 *filter_flags = &priv->staging_rxon.filter_flags;
2919
2920         IWL_DEBUG_MAC80211("Enter: changed: 0x%x, total: 0x%x\n",
2921                         changed_flags, *total_flags);
2922
2923         if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
2924                 if (*total_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))
2925                         *filter_flags |= RXON_FILTER_PROMISC_MSK;
2926                 else
2927                         *filter_flags &= ~RXON_FILTER_PROMISC_MSK;
2928         }
2929         if (changed_flags & FIF_ALLMULTI) {
2930                 if (*total_flags & FIF_ALLMULTI)
2931                         *filter_flags |= RXON_FILTER_ACCEPT_GRP_MSK;
2932                 else
2933                         *filter_flags &= ~RXON_FILTER_ACCEPT_GRP_MSK;
2934         }
2935         if (changed_flags & FIF_CONTROL) {
2936                 if (*total_flags & FIF_CONTROL)
2937                         *filter_flags |= RXON_FILTER_CTL2HOST_MSK;
2938                 else
2939                         *filter_flags &= ~RXON_FILTER_CTL2HOST_MSK;
2940         }
2941         if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
2942                 if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
2943                         *filter_flags |= RXON_FILTER_BCON_AWARE_MSK;
2944                 else
2945                         *filter_flags &= ~RXON_FILTER_BCON_AWARE_MSK;
2946         }
2947
2948         /* We avoid iwl_commit_rxon here to commit the new filter flags
2949          * since mac80211 will call ieee80211_hw_config immediately.
2950          * (mc_list is not supported at this time). Otherwise, we need to
2951          * queue a background iwl_commit_rxon work.
2952          */
2953
2954         *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
2955                         FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
2956 }
2957
2958 static void iwl_mac_remove_interface(struct ieee80211_hw *hw,
2959                                      struct ieee80211_if_init_conf *conf)
2960 {
2961         struct iwl_priv *priv = hw->priv;
2962
2963         IWL_DEBUG_MAC80211("enter\n");
2964
2965         mutex_lock(&priv->mutex);
2966
2967         if (iwl_is_ready_rf(priv)) {
2968                 iwl_scan_cancel_timeout(priv, 100);
2969                 priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
2970                 iwl_commit_rxon(priv);
2971         }
2972         if (priv->vif == conf->vif) {
2973                 priv->vif = NULL;
2974                 memset(priv->bssid, 0, ETH_ALEN);
2975         }
2976         mutex_unlock(&priv->mutex);
2977
2978         IWL_DEBUG_MAC80211("leave\n");
2979
2980 }
2981
2982 #define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
2983 static void iwl_bss_info_changed(struct ieee80211_hw *hw,
2984                                      struct ieee80211_vif *vif,
2985                                      struct ieee80211_bss_conf *bss_conf,
2986                                      u32 changes)
2987 {
2988         struct iwl_priv *priv = hw->priv;
2989
2990         IWL_DEBUG_MAC80211("changes = 0x%X\n", changes);
2991
2992         if (changes & BSS_CHANGED_ERP_PREAMBLE) {
2993                 IWL_DEBUG_MAC80211("ERP_PREAMBLE %d\n",
2994                                    bss_conf->use_short_preamble);
2995                 if (bss_conf->use_short_preamble)
2996                         priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
2997                 else
2998                         priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
2999         }
3000
3001         if (changes & BSS_CHANGED_ERP_CTS_PROT) {
3002                 IWL_DEBUG_MAC80211("ERP_CTS %d\n", bss_conf->use_cts_prot);
3003                 if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
3004                         priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
3005                 else
3006                         priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
3007         }
3008
3009         if (changes & BSS_CHANGED_HT) {
3010                 iwl_ht_conf(priv, bss_conf);
3011                 iwl_set_rxon_chain(priv);
3012         }
3013
3014         if (changes & BSS_CHANGED_ASSOC) {
3015                 IWL_DEBUG_MAC80211("ASSOC %d\n", bss_conf->assoc);
3016                 /* This should never happen as this function should
3017                  * never be called from interrupt context. */
3018                 if (WARN_ON_ONCE(in_interrupt()))
3019                         return;
3020                 if (bss_conf->assoc) {
3021                         priv->assoc_id = bss_conf->aid;
3022                         priv->beacon_int = bss_conf->beacon_int;
3023                         priv->power_data.dtim_period = bss_conf->dtim_period;
3024                         priv->timestamp = bss_conf->timestamp;
3025                         priv->assoc_capability = bss_conf->assoc_capability;
3026
3027                         /* we have just associated, don't start scan too early
3028                          * leave time for EAPOL exchange to complete
3029                          */
3030                         priv->next_scan_jiffies = jiffies +
3031                                         IWL_DELAY_NEXT_SCAN_AFTER_ASSOC;
3032                         mutex_lock(&priv->mutex);
3033                         iwl_post_associate(priv);
3034                         mutex_unlock(&priv->mutex);
3035                 } else {
3036                         priv->assoc_id = 0;
3037                         IWL_DEBUG_MAC80211("DISASSOC %d\n", bss_conf->assoc);
3038                 }
3039         } else if (changes && iwl_is_associated(priv) && priv->assoc_id) {
3040                         IWL_DEBUG_MAC80211("Associated Changes %d\n", changes);
3041                         iwl_send_rxon_assoc(priv);
3042         }
3043
3044 }
3045
3046 static int iwl_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t ssid_len)
3047 {
3048         unsigned long flags;
3049         struct iwl_priv *priv = hw->priv;
3050         int ret;
3051
3052         IWL_DEBUG_MAC80211("enter\n");
3053
3054         mutex_lock(&priv->mutex);
3055         spin_lock_irqsave(&priv->lock, flags);
3056
3057         if (!iwl_is_ready_rf(priv)) {
3058                 ret = -EIO;
3059                 IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
3060                 goto out_unlock;
3061         }
3062
3063         /* We don't schedule scan within next_scan_jiffies period.
3064          * Avoid scanning during possible EAPOL exchange, return
3065          * success immediately.
3066          */
3067         if (priv->next_scan_jiffies &&
3068             time_after(priv->next_scan_jiffies, jiffies)) {
3069                 IWL_DEBUG_SCAN("scan rejected: within next scan period\n");
3070                 queue_work(priv->workqueue, &priv->scan_completed);
3071                 ret = 0;
3072                 goto out_unlock;
3073         }
3074
3075         /* if we just finished scan ask for delay */
3076         if (iwl_is_associated(priv) && priv->last_scan_jiffies &&
3077             time_after(priv->last_scan_jiffies + IWL_DELAY_NEXT_SCAN, jiffies)) {
3078                 IWL_DEBUG_SCAN("scan rejected: within previous scan period\n");
3079                 queue_work(priv->workqueue, &priv->scan_completed);
3080                 ret = 0;
3081                 goto out_unlock;
3082         }
3083
3084         if (ssid_len) {
3085                 priv->one_direct_scan = 1;
3086                 priv->direct_ssid_len =  min_t(u8, ssid_len, IW_ESSID_MAX_SIZE);
3087                 memcpy(priv->direct_ssid, ssid, priv->direct_ssid_len);
3088         } else {
3089                 priv->one_direct_scan = 0;
3090         }
3091
3092         ret = iwl_scan_initiate(priv);
3093
3094         IWL_DEBUG_MAC80211("leave\n");
3095
3096 out_unlock:
3097         spin_unlock_irqrestore(&priv->lock, flags);
3098         mutex_unlock(&priv->mutex);
3099
3100         return ret;
3101 }
3102
3103 static void iwl_mac_update_tkip_key(struct ieee80211_hw *hw,
3104                         struct ieee80211_key_conf *keyconf, const u8 *addr,
3105                         u32 iv32, u16 *phase1key)
3106 {
3107
3108         struct iwl_priv *priv = hw->priv;
3109         IWL_DEBUG_MAC80211("enter\n");
3110
3111         iwl_update_tkip_key(priv, keyconf, addr, iv32, phase1key);
3112
3113         IWL_DEBUG_MAC80211("leave\n");
3114 }
3115
3116 static int iwl_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3117                            struct ieee80211_vif *vif,
3118                            struct ieee80211_sta *sta,
3119                            struct ieee80211_key_conf *key)
3120 {
3121         struct iwl_priv *priv = hw->priv;
3122         const u8 *addr;
3123         int ret;
3124         u8 sta_id;
3125         bool is_default_wep_key = false;
3126
3127         IWL_DEBUG_MAC80211("enter\n");
3128
3129         if (priv->hw_params.sw_crypto) {
3130                 IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
3131                 return -EOPNOTSUPP;
3132         }
3133         addr = sta ? sta->addr : iwl_bcast_addr;
3134         sta_id = iwl_find_station(priv, addr);
3135         if (sta_id == IWL_INVALID_STATION) {
3136                 IWL_DEBUG_MAC80211("leave - %pM not in station map.\n",
3137                                    addr);
3138                 return -EINVAL;
3139
3140         }
3141
3142         mutex_lock(&priv->mutex);
3143         iwl_scan_cancel_timeout(priv, 100);
3144         mutex_unlock(&priv->mutex);
3145
3146         /* If we are getting WEP group key and we didn't receive any key mapping
3147          * so far, we are in legacy wep mode (group key only), otherwise we are
3148          * in 1X mode.
3149          * In legacy wep mode, we use another host command to the uCode */
3150         if (key->alg == ALG_WEP && sta_id == priv->hw_params.bcast_sta_id &&
3151                 priv->iw_mode != NL80211_IFTYPE_AP) {
3152                 if (cmd == SET_KEY)
3153                         is_default_wep_key = !priv->key_mapping_key;
3154                 else
3155                         is_default_wep_key =
3156                                         (key->hw_key_idx == HW_KEY_DEFAULT);
3157         }
3158
3159         switch (cmd) {
3160         case SET_KEY:
3161                 if (is_default_wep_key)
3162                         ret = iwl_set_default_wep_key(priv, key);
3163                 else
3164                         ret = iwl_set_dynamic_key(priv, key, sta_id);
3165
3166                 IWL_DEBUG_MAC80211("enable hwcrypto key\n");
3167                 break;
3168         case DISABLE_KEY:
3169                 if (is_default_wep_key)
3170                         ret = iwl_remove_default_wep_key(priv, key);
3171                 else
3172                         ret = iwl_remove_dynamic_key(priv, key, sta_id);
3173
3174                 IWL_DEBUG_MAC80211("disable hwcrypto key\n");
3175                 break;
3176         default:
3177                 ret = -EINVAL;
3178         }
3179
3180         IWL_DEBUG_MAC80211("leave\n");
3181
3182         return ret;
3183 }
3184
3185 static int iwl_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
3186                            const struct ieee80211_tx_queue_params *params)
3187 {
3188         struct iwl_priv *priv = hw->priv;
3189         unsigned long flags;
3190         int q;
3191
3192         IWL_DEBUG_MAC80211("enter\n");
3193
3194         if (!iwl_is_ready_rf(priv)) {
3195                 IWL_DEBUG_MAC80211("leave - RF not ready\n");
3196                 return -EIO;
3197         }
3198
3199         if (queue >= AC_NUM) {
3200                 IWL_DEBUG_MAC80211("leave - queue >= AC_NUM %d\n", queue);
3201                 return 0;
3202         }
3203
3204         q = AC_NUM - 1 - queue;
3205
3206         spin_lock_irqsave(&priv->lock, flags);
3207
3208         priv->qos_data.def_qos_parm.ac[q].cw_min = cpu_to_le16(params->cw_min);
3209         priv->qos_data.def_qos_parm.ac[q].cw_max = cpu_to_le16(params->cw_max);
3210         priv->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
3211         priv->qos_data.def_qos_parm.ac[q].edca_txop =
3212                         cpu_to_le16((params->txop * 32));
3213
3214         priv->qos_data.def_qos_parm.ac[q].reserved1 = 0;
3215         priv->qos_data.qos_active = 1;
3216
3217         if (priv->iw_mode == NL80211_IFTYPE_AP)
3218                 iwl_activate_qos(priv, 1);
3219         else if (priv->assoc_id && iwl_is_associated(priv))
3220                 iwl_activate_qos(priv, 0);
3221
3222         spin_unlock_irqrestore(&priv->lock, flags);
3223
3224         IWL_DEBUG_MAC80211("leave\n");
3225         return 0;
3226 }
3227
3228 static int iwl_mac_ampdu_action(struct ieee80211_hw *hw,
3229                              enum ieee80211_ampdu_mlme_action action,
3230                              struct ieee80211_sta *sta, u16 tid, u16 *ssn)
3231 {
3232         struct iwl_priv *priv = hw->priv;
3233
3234         IWL_DEBUG_HT("A-MPDU action on addr %pM tid %d\n",
3235                      sta->addr, tid);
3236
3237         if (!(priv->cfg->sku & IWL_SKU_N))
3238                 return -EACCES;
3239
3240         switch (action) {
3241         case IEEE80211_AMPDU_RX_START:
3242                 IWL_DEBUG_HT("start Rx\n");
3243                 return iwl_sta_rx_agg_start(priv, sta->addr, tid, *ssn);
3244         case IEEE80211_AMPDU_RX_STOP:
3245                 IWL_DEBUG_HT("stop Rx\n");
3246                 return iwl_sta_rx_agg_stop(priv, sta->addr, tid);
3247         case IEEE80211_AMPDU_TX_START:
3248                 IWL_DEBUG_HT("start Tx\n");
3249                 return iwl_tx_agg_start(priv, sta->addr, tid, ssn);
3250         case IEEE80211_AMPDU_TX_STOP:
3251                 IWL_DEBUG_HT("stop Tx\n");
3252                 return iwl_tx_agg_stop(priv, sta->addr, tid);
3253         default:
3254                 IWL_DEBUG_HT("unknown\n");
3255                 return -EINVAL;
3256                 break;
3257         }
3258         return 0;
3259 }
3260
3261 static int iwl_mac_get_tx_stats(struct ieee80211_hw *hw,
3262                                 struct ieee80211_tx_queue_stats *stats)
3263 {
3264         struct iwl_priv *priv = hw->priv;
3265         int i, avail;
3266         struct iwl_tx_queue *txq;
3267         struct iwl_queue *q;
3268         unsigned long flags;
3269
3270         IWL_DEBUG_MAC80211("enter\n");
3271
3272         if (!iwl_is_ready_rf(priv)) {
3273                 IWL_DEBUG_MAC80211("leave - RF not ready\n");
3274                 return -EIO;
3275         }
3276
3277         spin_lock_irqsave(&priv->lock, flags);
3278
3279         for (i = 0; i < AC_NUM; i++) {
3280                 txq = &priv->txq[i];
3281                 q = &txq->q;
3282                 avail = iwl_queue_space(q);
3283
3284                 stats[i].len = q->n_window - avail;
3285                 stats[i].limit = q->n_window - q->high_mark;
3286                 stats[i].count = q->n_window;
3287
3288         }
3289         spin_unlock_irqrestore(&priv->lock, flags);
3290
3291         IWL_DEBUG_MAC80211("leave\n");
3292
3293         return 0;
3294 }
3295
3296 static int iwl_mac_get_stats(struct ieee80211_hw *hw,
3297                              struct ieee80211_low_level_stats *stats)
3298 {
3299         struct iwl_priv *priv = hw->priv;
3300
3301         priv = hw->priv;
3302         IWL_DEBUG_MAC80211("enter\n");
3303         IWL_DEBUG_MAC80211("leave\n");
3304
3305         return 0;
3306 }
3307
3308 static void iwl_mac_reset_tsf(struct ieee80211_hw *hw)
3309 {
3310         struct iwl_priv *priv = hw->priv;
3311         unsigned long flags;
3312
3313         mutex_lock(&priv->mutex);
3314         IWL_DEBUG_MAC80211("enter\n");
3315
3316         spin_lock_irqsave(&priv->lock, flags);
3317         memset(&priv->current_ht_config, 0, sizeof(struct iwl_ht_info));
3318         spin_unlock_irqrestore(&priv->lock, flags);
3319
3320         iwl_reset_qos(priv);
3321
3322         spin_lock_irqsave(&priv->lock, flags);
3323         priv->assoc_id = 0;
3324         priv->assoc_capability = 0;
3325         priv->assoc_station_added = 0;
3326
3327         /* new association get rid of ibss beacon skb */
3328         if (priv->ibss_beacon)
3329                 dev_kfree_skb(priv->ibss_beacon);
3330
3331         priv->ibss_beacon = NULL;
3332
3333         priv->beacon_int = priv->hw->conf.beacon_int;
3334         priv->timestamp = 0;
3335         if ((priv->iw_mode == NL80211_IFTYPE_STATION))
3336                 priv->beacon_int = 0;
3337
3338         spin_unlock_irqrestore(&priv->lock, flags);
3339
3340         if (!iwl_is_ready_rf(priv)) {
3341                 IWL_DEBUG_MAC80211("leave - not ready\n");
3342                 mutex_unlock(&priv->mutex);
3343                 return;
3344         }
3345
3346         /* we are restarting association process
3347          * clear RXON_FILTER_ASSOC_MSK bit
3348          */
3349         if (priv->iw_mode != NL80211_IFTYPE_AP) {
3350                 iwl_scan_cancel_timeout(priv, 100);
3351                 priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
3352                 iwl_commit_rxon(priv);
3353         }
3354
3355         iwl_power_update_mode(priv, 0);
3356
3357         /* Per mac80211.h: This is only used in IBSS mode... */
3358         if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
3359
3360                 /* switch to CAM during association period.
3361                  * the ucode will block any association/authentication
3362                  * frome during assiciation period if it can not hear
3363                  * the AP because of PM. the timer enable PM back is
3364                  * association do not complete
3365                  */
3366                 if (priv->hw->conf.channel->flags & (IEEE80211_CHAN_PASSIVE_SCAN |
3367                                                      IEEE80211_CHAN_RADAR))
3368                                 iwl_power_disable_management(priv, 3000);
3369
3370                 IWL_DEBUG_MAC80211("leave - not in IBSS\n");
3371                 mutex_unlock(&priv->mutex);
3372                 return;
3373         }
3374
3375         iwl_set_rate(priv);
3376
3377         mutex_unlock(&priv->mutex);
3378
3379         IWL_DEBUG_MAC80211("leave\n");
3380 }
3381
3382 static int iwl_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
3383 {
3384         struct iwl_priv *priv = hw->priv;
3385         unsigned long flags;
3386         __le64 timestamp;
3387
3388         IWL_DEBUG_MAC80211("enter\n");
3389
3390         if (!iwl_is_ready_rf(priv)) {
3391                 IWL_DEBUG_MAC80211("leave - RF not ready\n");
3392                 return -EIO;
3393         }
3394
3395         if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
3396                 IWL_DEBUG_MAC80211("leave - not IBSS\n");
3397                 return -EIO;
3398         }
3399
3400         spin_lock_irqsave(&priv->lock, flags);
3401
3402         if (priv->ibss_beacon)
3403                 dev_kfree_skb(priv->ibss_beacon);
3404
3405         priv->ibss_beacon = skb;
3406
3407         priv->assoc_id = 0;
3408         timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
3409         priv->timestamp = le64_to_cpu(timestamp);
3410
3411         IWL_DEBUG_MAC80211("leave\n");
3412         spin_unlock_irqrestore(&priv->lock, flags);
3413
3414         iwl_reset_qos(priv);
3415
3416         iwl_post_associate(priv);
3417
3418
3419         return 0;
3420 }
3421
3422 /*****************************************************************************
3423  *
3424  * sysfs attributes
3425  *
3426  *****************************************************************************/
3427
3428 #ifdef CONFIG_IWLWIFI_DEBUG
3429
3430 /*
3431  * The following adds a new attribute to the sysfs representation
3432  * of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
3433  * used for controlling the debug level.
3434  *
3435  * See the level definitions in iwl for details.
3436  */
3437
3438 static ssize_t show_debug_level(struct device *d,
3439                                 struct device_attribute *attr, char *buf)
3440 {
3441         struct iwl_priv *priv = d->driver_data;
3442
3443         return sprintf(buf, "0x%08X\n", priv->debug_level);
3444 }
3445 static ssize_t store_debug_level(struct device *d,
3446                                 struct device_attribute *attr,
3447                                  const char *buf, size_t count)
3448 {
3449         struct iwl_priv *priv = d->driver_data;
3450         unsigned long val;
3451         int ret;
3452
3453         ret = strict_strtoul(buf, 0, &val);
3454         if (ret)
3455                 IWL_ERR(priv, "%s is not in hex or decimal form.\n", buf);
3456         else
3457                 priv->debug_level = val;
3458
3459         return strnlen(buf, count);
3460 }
3461
3462 static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
3463                         show_debug_level, store_debug_level);
3464
3465
3466 #endif /* CONFIG_IWLWIFI_DEBUG */
3467
3468
3469 static ssize_t show_version(struct device *d,
3470                                 struct device_attribute *attr, char *buf)
3471 {
3472         struct iwl_priv *priv = d->driver_data;
3473         struct iwl_alive_resp *palive = &priv->card_alive;
3474         ssize_t pos = 0;
3475         u16 eeprom_ver;
3476
3477         if (palive->is_valid)
3478                 pos += sprintf(buf + pos,
3479                                 "fw version: 0x%01X.0x%01X.0x%01X.0x%01X\n"
3480                                 "fw type: 0x%01X 0x%01X\n",
3481                                 palive->ucode_major, palive->ucode_minor,
3482                                 palive->sw_rev[0], palive->sw_rev[1],
3483                                 palive->ver_type, palive->ver_subtype);
3484         else
3485                 pos += sprintf(buf + pos, "fw not loaded\n");
3486
3487         if (priv->eeprom) {
3488                 eeprom_ver = iwl_eeprom_query16(priv, EEPROM_VERSION);
3489                 pos += sprintf(buf + pos, "EEPROM version: 0x%x\n",
3490                                  eeprom_ver);
3491         } else {
3492                 pos += sprintf(buf + pos, "EEPROM not initialzed\n");
3493         }
3494
3495         return pos;
3496 }
3497
3498 static DEVICE_ATTR(version, S_IWUSR | S_IRUGO, show_version, NULL);
3499
3500 static ssize_t show_temperature(struct device *d,
3501                                 struct device_attribute *attr, char *buf)
3502 {
3503         struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3504
3505         if (!iwl_is_alive(priv))
3506                 return -EAGAIN;
3507
3508         return sprintf(buf, "%d\n", priv->temperature);
3509 }
3510
3511 static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
3512
3513 static ssize_t show_tx_power(struct device *d,
3514                              struct device_attribute *attr, char *buf)
3515 {
3516         struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3517
3518         if (!iwl_is_ready_rf(priv))
3519                 return sprintf(buf, "off\n");
3520         else
3521                 return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
3522 }
3523
3524 static ssize_t store_tx_power(struct device *d,
3525                               struct device_attribute *attr,
3526                               const char *buf, size_t count)
3527 {
3528         struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3529         unsigned long val;
3530         int ret;
3531
3532         ret = strict_strtoul(buf, 10, &val);
3533         if (ret)
3534                 IWL_INFO(priv, "%s is not in decimal form.\n", buf);
3535         else
3536                 iwl_set_tx_power(priv, val, false);
3537
3538         return count;
3539 }
3540
3541 static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);
3542
3543 static ssize_t show_flags(struct device *d,
3544                           struct device_attribute *attr, char *buf)
3545 {
3546         struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3547
3548         return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
3549 }
3550
3551 static ssize_t store_flags(struct device *d,
3552                            struct device_attribute *attr,
3553                            const char *buf, size_t count)
3554 {
3555         struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3556         unsigned long val;
3557         u32 flags;
3558         int ret = strict_strtoul(buf, 0, &val);
3559         if (ret)
3560                 return ret;
3561         flags = (u32)val;
3562
3563         mutex_lock(&priv->mutex);
3564         if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
3565                 /* Cancel any currently running scans... */
3566                 if (iwl_scan_cancel_timeout(priv, 100))
3567                         IWL_WARN(priv, "Could not cancel scan.\n");
3568                 else {
3569                         IWL_DEBUG_INFO("Commit rxon.flags = 0x%04X\n", flags);
3570                         priv->staging_rxon.flags = cpu_to_le32(flags);
3571                         iwl_commit_rxon(priv);
3572                 }
3573         }
3574         mutex_unlock(&priv->mutex);
3575
3576         return count;
3577 }
3578
3579 static DEVICE_ATTR(flags, S_IWUSR | S_IRUGO, show_flags, store_flags);
3580
3581 static ssize_t show_filter_flags(struct device *d,
3582                                  struct device_attribute *attr, char *buf)
3583 {
3584         struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3585
3586         return sprintf(buf, "0x%04X\n",
3587                 le32_to_cpu(priv->active_rxon.filter_flags));
3588 }
3589
3590 static ssize_t store_filter_flags(struct device *d,
3591                                   struct device_attribute *attr,
3592                                   const char *buf, size_t count)
3593 {
3594         struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3595         unsigned long val;
3596         u32 filter_flags;
3597         int ret = strict_strtoul(buf, 0, &val);
3598         if (ret)
3599                 return ret;
3600         filter_flags = (u32)val;
3601
3602         mutex_lock(&priv->mutex);
3603         if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
3604                 /* Cancel any currently running scans... */
3605                 if (iwl_scan_cancel_timeout(priv, 100))
3606                         IWL_WARN(priv, "Could not cancel scan.\n");
3607                 else {
3608                         IWL_DEBUG_INFO("Committing rxon.filter_flags = "
3609                                        "0x%04X\n", filter_flags);
3610                         priv->staging_rxon.filter_flags =
3611                                 cpu_to_le32(filter_flags);
3612                         iwl_commit_rxon(priv);
3613                 }
3614         }
3615         mutex_unlock(&priv->mutex);
3616
3617         return count;
3618 }
3619
3620 static DEVICE_ATTR(filter_flags, S_IWUSR | S_IRUGO, show_filter_flags,
3621                    store_filter_flags);
3622
3623 static ssize_t store_power_level(struct device *d,
3624                                  struct device_attribute *attr,
3625                                  const char *buf, size_t count)
3626 {
3627         struct iwl_priv *priv = dev_get_drvdata(d);
3628         int ret;
3629         unsigned long mode;
3630
3631
3632         mutex_lock(&priv->mutex);
3633
3634         if (!iwl_is_ready(priv)) {
3635                 ret = -EAGAIN;
3636                 goto out;
3637         }
3638
3639         ret = strict_strtoul(buf, 10, &mode);
3640         if (ret)
3641                 goto out;
3642
3643         ret = iwl_power_set_user_mode(priv, mode);
3644         if (ret) {
3645                 IWL_DEBUG_MAC80211("failed setting power mode.\n");
3646                 goto out;
3647         }
3648         ret = count;
3649
3650  out:
3651         mutex_unlock(&priv->mutex);
3652         return ret;
3653 }
3654
3655 static ssize_t show_power_level(struct device *d,
3656                                 struct device_attribute *attr, char *buf)
3657 {
3658         struct iwl_priv *priv = dev_get_drvdata(d);
3659         int mode = priv->power_data.user_power_setting;
3660         int system = priv->power_data.system_power_setting;
3661         int level = priv->power_data.power_mode;
3662         char *p = buf;
3663
3664         switch (system) {
3665         case IWL_POWER_SYS_AUTO:
3666                 p += sprintf(p, "SYSTEM:auto");
3667                 break;
3668         case IWL_POWER_SYS_AC:
3669                 p += sprintf(p, "SYSTEM:ac");
3670                 break;
3671         case IWL_POWER_SYS_BATTERY:
3672                 p += sprintf(p, "SYSTEM:battery");
3673                 break;
3674         }
3675
3676         p += sprintf(p, "\tMODE:%s", (mode < IWL_POWER_AUTO) ?
3677                         "fixed" : "auto");
3678         p += sprintf(p, "\tINDEX:%d", level);
3679         p += sprintf(p, "\n");
3680         return p - buf + 1;
3681 }
3682
3683 static DEVICE_ATTR(power_level, S_IWUSR | S_IRUSR, show_power_level,
3684                    store_power_level);
3685
3686
3687 static ssize_t show_statistics(struct device *d,
3688                                struct device_attribute *attr, char *buf)
3689 {
3690         struct iwl_priv *priv = dev_get_drvdata(d);
3691         u32 size = sizeof(struct iwl_notif_statistics);
3692         u32 len = 0, ofs = 0;
3693         u8 *data = (u8 *)&priv->statistics;
3694         int rc = 0;
3695
3696         if (!iwl_is_alive(priv))
3697                 return -EAGAIN;
3698
3699         mutex_lock(&priv->mutex);
3700         rc = iwl_send_statistics_request(priv, 0);
3701         mutex_unlock(&priv->mutex);
3702
3703         if (rc) {
3704                 len = sprintf(buf,
3705                               "Error sending statistics request: 0x%08X\n", rc);
3706                 return len;
3707         }
3708
3709         while (size && (PAGE_SIZE - len)) {
3710                 hex_dump_to_buffer(data + ofs, size, 16, 1, buf + len,
3711                                    PAGE_SIZE - len, 1);
3712                 len = strlen(buf);
3713                 if (PAGE_SIZE - len)
3714                         buf[len++] = '\n';
3715
3716                 ofs += 16;
3717                 size -= min(size, 16U);
3718         }
3719
3720         return len;
3721 }
3722
3723 static DEVICE_ATTR(statistics, S_IRUGO, show_statistics, NULL);
3724
3725
3726 /*****************************************************************************
3727  *
3728  * driver setup and teardown
3729  *
3730  *****************************************************************************/
3731
3732 static void iwl_setup_deferred_work(struct iwl_priv *priv)
3733 {
3734         priv->workqueue = create_workqueue(DRV_NAME);
3735
3736         init_waitqueue_head(&priv->wait_command_queue);
3737
3738         INIT_WORK(&priv->up, iwl_bg_up);
3739         INIT_WORK(&priv->restart, iwl_bg_restart);
3740         INIT_WORK(&priv->rx_replenish, iwl_bg_rx_replenish);
3741         INIT_WORK(&priv->rf_kill, iwl_bg_rf_kill);
3742         INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
3743         INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
3744         INIT_DELAYED_WORK(&priv->init_alive_start, iwl_bg_init_alive_start);
3745         INIT_DELAYED_WORK(&priv->alive_start, iwl_bg_alive_start);
3746
3747         iwl_setup_scan_deferred_work(priv);
3748         iwl_setup_power_deferred_work(priv);
3749
3750         if (priv->cfg->ops->lib->setup_deferred_work)
3751                 priv->cfg->ops->lib->setup_deferred_work(priv);
3752
3753         init_timer(&priv->statistics_periodic);
3754         priv->statistics_periodic.data = (unsigned long)priv;
3755         priv->statistics_periodic.function = iwl_bg_statistics_periodic;
3756
3757         tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
3758                      iwl_irq_tasklet, (unsigned long)priv);
3759 }
3760
3761 static void iwl_cancel_deferred_work(struct iwl_priv *priv)
3762 {
3763         if (priv->cfg->ops->lib->cancel_deferred_work)
3764                 priv->cfg->ops->lib->cancel_deferred_work(priv);
3765
3766         cancel_delayed_work_sync(&priv->init_alive_start);
3767         cancel_delayed_work(&priv->scan_check);
3768         cancel_delayed_work_sync(&priv->set_power_save);
3769         cancel_delayed_work(&priv->alive_start);
3770         cancel_work_sync(&priv->beacon_update);
3771         del_timer_sync(&priv->statistics_periodic);
3772 }
3773
3774 static struct attribute *iwl_sysfs_entries[] = {
3775         &dev_attr_flags.attr,
3776         &dev_attr_filter_flags.attr,
3777         &dev_attr_power_level.attr,
3778         &dev_attr_statistics.attr,
3779         &dev_attr_temperature.attr,
3780         &dev_attr_tx_power.attr,
3781 #ifdef CONFIG_IWLWIFI_DEBUG
3782         &dev_attr_debug_level.attr,
3783 #endif
3784         &dev_attr_version.attr,
3785
3786         NULL
3787 };
3788
3789 static struct attribute_group iwl_attribute_group = {
3790         .name = NULL,           /* put in device directory */
3791         .attrs = iwl_sysfs_entries,
3792 };
3793
3794 static struct ieee80211_ops iwl_hw_ops = {
3795         .tx = iwl_mac_tx,
3796         .start = iwl_mac_start,
3797         .stop = iwl_mac_stop,
3798         .add_interface = iwl_mac_add_interface,
3799         .remove_interface = iwl_mac_remove_interface,
3800         .config = iwl_mac_config,
3801         .config_interface = iwl_mac_config_interface,
3802         .configure_filter = iwl_configure_filter,
3803         .set_key = iwl_mac_set_key,
3804         .update_tkip_key = iwl_mac_update_tkip_key,
3805         .get_stats = iwl_mac_get_stats,
3806         .get_tx_stats = iwl_mac_get_tx_stats,
3807         .conf_tx = iwl_mac_conf_tx,
3808         .reset_tsf = iwl_mac_reset_tsf,
3809         .bss_info_changed = iwl_bss_info_changed,
3810         .ampdu_action = iwl_mac_ampdu_action,
3811         .hw_scan = iwl_mac_hw_scan
3812 };
3813
3814 static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
3815 {
3816         int err = 0;
3817         struct iwl_priv *priv;
3818         struct ieee80211_hw *hw;
3819         struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
3820         unsigned long flags;
3821         u16 pci_cmd;
3822
3823         /************************
3824          * 1. Allocating HW data
3825          ************************/
3826
3827         /* Disabling hardware scan means that mac80211 will perform scans
3828          * "the hard way", rather than using device's scan. */
3829         if (cfg->mod_params->disable_hw_scan) {
3830                 if (cfg->mod_params->debug & IWL_DL_INFO)
3831                         dev_printk(KERN_DEBUG, &(pdev->dev),
3832                                    "Disabling hw_scan\n");
3833                 iwl_hw_ops.hw_scan = NULL;
3834         }
3835
3836         hw = iwl_alloc_all(cfg, &iwl_hw_ops);
3837         if (!hw) {
3838                 err = -ENOMEM;
3839                 goto out;
3840         }
3841         priv = hw->priv;
3842         /* At this point both hw and priv are allocated. */
3843
3844         SET_IEEE80211_DEV(hw, &pdev->dev);
3845
3846         IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
3847         priv->cfg = cfg;
3848         priv->pci_dev = pdev;
3849
3850 #ifdef CONFIG_IWLWIFI_DEBUG
3851         priv->debug_level = priv->cfg->mod_params->debug;
3852         atomic_set(&priv->restrict_refcnt, 0);
3853 #endif
3854
3855         /**************************
3856          * 2. Initializing PCI bus
3857          **************************/
3858         if (pci_enable_device(pdev)) {
3859                 err = -ENODEV;
3860                 goto out_ieee80211_free_hw;
3861         }
3862
3863         pci_set_master(pdev);
3864
3865         err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
3866         if (!err)
3867                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
3868         if (err) {
3869                 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
3870                 if (!err)
3871                         err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
3872                 /* both attempts failed: */
3873                 if (err) {
3874                         IWL_WARN(priv, "No suitable DMA available.\n");
3875                         goto out_pci_disable_device;
3876                 }
3877         }
3878
3879         err = pci_request_regions(pdev, DRV_NAME);
3880         if (err)
3881                 goto out_pci_disable_device;
3882
3883         pci_set_drvdata(pdev, priv);
3884
3885
3886         /***********************
3887          * 3. Read REV register
3888          ***********************/
3889         priv->hw_base = pci_iomap(pdev, 0, 0);
3890         if (!priv->hw_base) {
3891                 err = -ENODEV;
3892                 goto out_pci_release_regions;
3893         }
3894
3895         IWL_DEBUG_INFO("pci_resource_len = 0x%08llx\n",
3896                 (unsigned long long) pci_resource_len(pdev, 0));
3897         IWL_DEBUG_INFO("pci_resource_base = %p\n", priv->hw_base);
3898
3899         iwl_hw_detect(priv);
3900         IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s REV=0x%X\n",
3901                 priv->cfg->name, priv->hw_rev);
3902
3903         /* We disable the RETRY_TIMEOUT register (0x41) to keep
3904          * PCI Tx retries from interfering with C3 CPU state */
3905         pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
3906
3907         /* amp init */
3908         err = priv->cfg->ops->lib->apm_ops.init(priv);
3909         if (err < 0) {
3910                 IWL_DEBUG_INFO("Failed to init APMG\n");
3911                 goto out_iounmap;
3912         }
3913         /*****************
3914          * 4. Read EEPROM
3915          *****************/
3916         /* Read the EEPROM */
3917         err = iwl_eeprom_init(priv);
3918         if (err) {
3919                 IWL_ERR(priv, "Unable to init EEPROM\n");
3920                 goto out_iounmap;
3921         }
3922         err = iwl_eeprom_check_version(priv);
3923         if (err)
3924                 goto out_iounmap;
3925
3926         /* extract MAC Address */
3927         iwl_eeprom_get_mac(priv, priv->mac_addr);
3928         IWL_DEBUG_INFO("MAC address: %pM\n", priv->mac_addr);
3929         SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
3930
3931         /************************
3932          * 5. Setup HW constants
3933          ************************/
3934         if (iwl_set_hw_params(priv)) {
3935                 IWL_ERR(priv, "failed to set hw parameters\n");
3936                 goto out_free_eeprom;
3937         }
3938
3939         /*******************
3940          * 6. Setup priv
3941          *******************/
3942
3943         err = iwl_init_drv(priv);
3944         if (err)
3945                 goto out_free_eeprom;
3946         /* At this point both hw and priv are initialized. */
3947
3948         /**********************************
3949          * 7. Initialize module parameters
3950          **********************************/
3951
3952         /* Disable radio (SW RF KILL) via parameter when loading driver */
3953         if (priv->cfg->mod_params->disable) {
3954                 set_bit(STATUS_RF_KILL_SW, &priv->status);
3955                 IWL_DEBUG_INFO("Radio disabled.\n");
3956         }
3957
3958         /********************
3959          * 8. Setup services
3960          ********************/
3961         spin_lock_irqsave(&priv->lock, flags);
3962         iwl_disable_interrupts(priv);
3963         spin_unlock_irqrestore(&priv->lock, flags);
3964
3965         pci_enable_msi(priv->pci_dev);
3966
3967         err = request_irq(priv->pci_dev->irq, iwl_isr, IRQF_SHARED,
3968                           DRV_NAME, priv);
3969         if (err) {
3970                 IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
3971                 goto out_disable_msi;
3972         }
3973         err = sysfs_create_group(&pdev->dev.kobj, &iwl_attribute_group);
3974         if (err) {
3975                 IWL_ERR(priv, "failed to create sysfs device attributes\n");
3976                 goto out_uninit_drv;
3977         }
3978
3979         iwl_setup_deferred_work(priv);
3980         iwl_setup_rx_handlers(priv);
3981
3982         /**********************************
3983          * 9. Setup and register mac80211
3984          **********************************/
3985
3986         /* enable interrupts if needed: hw bug w/a */
3987         pci_read_config_word(priv->pci_dev, PCI_COMMAND, &pci_cmd);
3988         if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
3989                 pci_cmd &= ~PCI_COMMAND_INTX_DISABLE;
3990                 pci_write_config_word(priv->pci_dev, PCI_COMMAND, pci_cmd);
3991         }
3992
3993         iwl_enable_interrupts(priv);
3994
3995         err = iwl_setup_mac(priv);
3996         if (err)
3997                 goto out_remove_sysfs;
3998
3999         err = iwl_dbgfs_register(priv, DRV_NAME);
4000         if (err)
4001                 IWL_ERR(priv, "failed to create debugfs files\n");
4002
4003         /* If platform's RF_KILL switch is NOT set to KILL */
4004         if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
4005                 clear_bit(STATUS_RF_KILL_HW, &priv->status);
4006         else
4007                 set_bit(STATUS_RF_KILL_HW, &priv->status);
4008
4009         err = iwl_rfkill_init(priv);
4010         if (err)
4011                 IWL_ERR(priv, "Unable to initialize RFKILL system. "
4012                                   "Ignoring error: %d\n", err);
4013         else
4014                 iwl_rfkill_set_hw_state(priv);
4015
4016         iwl_power_initialize(priv);
4017         return 0;
4018
4019  out_remove_sysfs:
4020         sysfs_remove_group(&pdev->dev.kobj, &iwl_attribute_group);
4021  out_disable_msi:
4022         pci_disable_msi(priv->pci_dev);
4023         pci_disable_device(priv->pci_dev);
4024  out_uninit_drv:
4025         iwl_uninit_drv(priv);
4026  out_free_eeprom:
4027         iwl_eeprom_free(priv);
4028  out_iounmap:
4029         pci_iounmap(pdev, priv->hw_base);
4030  out_pci_release_regions:
4031         pci_release_regions(pdev);
4032         pci_set_drvdata(pdev, NULL);
4033  out_pci_disable_device:
4034         pci_disable_device(pdev);
4035  out_ieee80211_free_hw:
4036         ieee80211_free_hw(priv->hw);
4037  out:
4038         return err;
4039 }
4040
4041 static void __devexit iwl_pci_remove(struct pci_dev *pdev)
4042 {
4043         struct iwl_priv *priv = pci_get_drvdata(pdev);
4044         unsigned long flags;
4045
4046         if (!priv)
4047                 return;
4048
4049         IWL_DEBUG_INFO("*** UNLOAD DRIVER ***\n");
4050
4051         iwl_dbgfs_unregister(priv);
4052         sysfs_remove_group(&pdev->dev.kobj, &iwl_attribute_group);
4053
4054         /* ieee80211_unregister_hw call wil cause iwl_mac_stop to
4055          * to be called and iwl_down since we are removing the device
4056          * we need to set STATUS_EXIT_PENDING bit.
4057          */
4058         set_bit(STATUS_EXIT_PENDING, &priv->status);
4059         if (priv->mac80211_registered) {
4060                 ieee80211_unregister_hw(priv->hw);
4061                 priv->mac80211_registered = 0;
4062         } else {
4063                 iwl_down(priv);
4064         }
4065
4066         /* make sure we flush any pending irq or
4067          * tasklet for the driver
4068          */
4069         spin_lock_irqsave(&priv->lock, flags);
4070         iwl_disable_interrupts(priv);
4071         spin_unlock_irqrestore(&priv->lock, flags);
4072
4073         iwl_synchronize_irq(priv);
4074
4075         iwl_rfkill_unregister(priv);
4076         iwl_dealloc_ucode_pci(priv);
4077
4078         if (priv->rxq.bd)
4079                 iwl_rx_queue_free(priv, &priv->rxq);
4080         iwl_hw_txq_ctx_free(priv);
4081
4082         iwl_clear_stations_table(priv);
4083         iwl_eeprom_free(priv);
4084
4085
4086         /*netif_stop_queue(dev); */
4087         flush_workqueue(priv->workqueue);
4088
4089         /* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
4090          * priv->workqueue... so we can't take down the workqueue
4091          * until now... */
4092         destroy_workqueue(priv->workqueue);
4093         priv->workqueue = NULL;
4094
4095         free_irq(priv->pci_dev->irq, priv);
4096         pci_disable_msi(priv->pci_dev);
4097         pci_iounmap(pdev, priv->hw_base);
4098         pci_release_regions(pdev);
4099         pci_disable_device(pdev);
4100         pci_set_drvdata(pdev, NULL);
4101
4102         iwl_uninit_drv(priv);
4103
4104         if (priv->ibss_beacon)
4105                 dev_kfree_skb(priv->ibss_beacon);
4106
4107         ieee80211_free_hw(priv->hw);
4108 }
4109
4110 #ifdef CONFIG_PM
4111
4112 static int iwl_pci_suspend(struct pci_dev *pdev, pm_message_t state)
4113 {
4114         struct iwl_priv *priv = pci_get_drvdata(pdev);
4115
4116         if (priv->is_open) {
4117                 set_bit(STATUS_IN_SUSPEND, &priv->status);
4118                 iwl_mac_stop(priv->hw);
4119                 priv->is_open = 1;
4120         }
4121
4122         pci_save_state(pdev);
4123         pci_disable_device(pdev);
4124         pci_set_power_state(pdev, PCI_D3hot);
4125
4126         return 0;
4127 }
4128
4129 static int iwl_pci_resume(struct pci_dev *pdev)
4130 {
4131         struct iwl_priv *priv = pci_get_drvdata(pdev);
4132
4133         pci_set_power_state(pdev, PCI_D0);
4134         pci_enable_device(pdev);
4135         pci_restore_state(pdev);
4136         iwl_enable_interrupts(priv);
4137
4138         if (priv->is_open)
4139                 iwl_mac_start(priv->hw);
4140
4141         clear_bit(STATUS_IN_SUSPEND, &priv->status);
4142         return 0;
4143 }
4144
4145 #endif /* CONFIG_PM */
4146
4147 /*****************************************************************************
4148  *
4149  * driver and module entry point
4150  *
4151  *****************************************************************************/
4152
4153 /* Hardware specific file defines the PCI IDs table for that hardware module */
4154 static struct pci_device_id iwl_hw_card_ids[] = {
4155 #ifdef CONFIG_IWL4965
4156         {IWL_PCI_DEVICE(0x4229, PCI_ANY_ID, iwl4965_agn_cfg)},
4157         {IWL_PCI_DEVICE(0x4230, PCI_ANY_ID, iwl4965_agn_cfg)},
4158 #endif /* CONFIG_IWL4965 */
4159 #ifdef CONFIG_IWL5000
4160         {IWL_PCI_DEVICE(0x4232, 0x1205, iwl5100_bg_cfg)},
4161         {IWL_PCI_DEVICE(0x4232, 0x1305, iwl5100_bg_cfg)},
4162         {IWL_PCI_DEVICE(0x4232, 0x1206, iwl5100_abg_cfg)},
4163         {IWL_PCI_DEVICE(0x4232, 0x1306, iwl5100_abg_cfg)},
4164         {IWL_PCI_DEVICE(0x4232, 0x1326, iwl5100_abg_cfg)},
4165         {IWL_PCI_DEVICE(0x4237, 0x1216, iwl5100_abg_cfg)},
4166         {IWL_PCI_DEVICE(0x4232, PCI_ANY_ID, iwl5100_agn_cfg)},
4167         {IWL_PCI_DEVICE(0x4235, PCI_ANY_ID, iwl5300_agn_cfg)},
4168         {IWL_PCI_DEVICE(0x4236, PCI_ANY_ID, iwl5300_agn_cfg)},
4169         {IWL_PCI_DEVICE(0x4237, PCI_ANY_ID, iwl5100_agn_cfg)},
4170 /* 5350 WiFi/WiMax */
4171         {IWL_PCI_DEVICE(0x423A, 0x1001, iwl5350_agn_cfg)},
4172         {IWL_PCI_DEVICE(0x423A, 0x1021, iwl5350_agn_cfg)},
4173         {IWL_PCI_DEVICE(0x423B, 0x1011, iwl5350_agn_cfg)},
4174 /* 5150 Wifi/WiMax */
4175         {IWL_PCI_DEVICE(0x423C, PCI_ANY_ID, iwl5150_agn_cfg)},
4176         {IWL_PCI_DEVICE(0x423D, PCI_ANY_ID, iwl5150_agn_cfg)},
4177 /* 6000/6050 Series */
4178         {IWL_PCI_DEVICE(0x0082, 0x1102, iwl6000_2ag_cfg)},
4179         {IWL_PCI_DEVICE(0x0085, 0x1112, iwl6000_2ag_cfg)},
4180         {IWL_PCI_DEVICE(0x0082, 0x1122, iwl6000_2ag_cfg)},
4181         {IWL_PCI_DEVICE(0x422B, PCI_ANY_ID, iwl6000_3agn_cfg)},
4182         {IWL_PCI_DEVICE(0x4238, PCI_ANY_ID, iwl6000_3agn_cfg)},
4183         {IWL_PCI_DEVICE(0x0082, PCI_ANY_ID, iwl6000_2agn_cfg)},
4184         {IWL_PCI_DEVICE(0x0085, PCI_ANY_ID, iwl6000_3agn_cfg)},
4185         {IWL_PCI_DEVICE(0x0086, PCI_ANY_ID, iwl6050_3agn_cfg)},
4186         {IWL_PCI_DEVICE(0x0087, PCI_ANY_ID, iwl6050_2agn_cfg)},
4187         {IWL_PCI_DEVICE(0x0088, PCI_ANY_ID, iwl6050_3agn_cfg)},
4188         {IWL_PCI_DEVICE(0x0089, PCI_ANY_ID, iwl6050_2agn_cfg)},
4189 /* 100 Series WiFi */
4190         {IWL_PCI_DEVICE(0x0083, PCI_ANY_ID, iwl100_bgn_cfg)},
4191         {IWL_PCI_DEVICE(0x0084, PCI_ANY_ID, iwl100_bgn_cfg)},
4192 #endif /* CONFIG_IWL5000 */
4193
4194         {0}
4195 };
4196 MODULE_DEVICE_TABLE(pci, iwl_hw_card_ids);
4197
4198 static struct pci_driver iwl_driver = {
4199         .name = DRV_NAME,
4200         .id_table = iwl_hw_card_ids,
4201         .probe = iwl_pci_probe,
4202         .remove = __devexit_p(iwl_pci_remove),
4203 #ifdef CONFIG_PM
4204         .suspend = iwl_pci_suspend,
4205         .resume = iwl_pci_resume,
4206 #endif
4207 };
4208
4209 static int __init iwl_init(void)
4210 {
4211
4212         int ret;
4213         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
4214         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
4215
4216         ret = iwlagn_rate_control_register();
4217         if (ret) {
4218                 printk(KERN_ERR DRV_NAME
4219                        "Unable to register rate control algorithm: %d\n", ret);
4220                 return ret;
4221         }
4222
4223         ret = pci_register_driver(&iwl_driver);
4224         if (ret) {
4225                 printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
4226                 goto error_register;
4227         }
4228
4229         return ret;
4230
4231 error_register:
4232         iwlagn_rate_control_unregister();
4233         return ret;
4234 }
4235
4236 static void __exit iwl_exit(void)
4237 {
4238         pci_unregister_driver(&iwl_driver);
4239         iwlagn_rate_control_unregister();
4240 }
4241
4242 module_exit(iwl_exit);
4243 module_init(iwl_init);