linux/drivers/net/wireless/iwlwifi/dvm/main.c
<<
>>
Prefs
   1/******************************************************************************
   2 *
   3 * Copyright(c) 2003 - 2014 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#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  31
  32#include <linux/kernel.h>
  33#include <linux/module.h>
  34#include <linux/init.h>
  35#include <linux/slab.h>
  36#include <linux/delay.h>
  37#include <linux/sched.h>
  38#include <linux/skbuff.h>
  39#include <linux/netdevice.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#include "iwl-eeprom-read.h"
  48#include "iwl-eeprom-parse.h"
  49#include "iwl-io.h"
  50#include "iwl-trans.h"
  51#include "iwl-op-mode.h"
  52#include "iwl-drv.h"
  53#include "iwl-modparams.h"
  54#include "iwl-prph.h"
  55
  56#include "dev.h"
  57#include "calib.h"
  58#include "agn.h"
  59
  60
  61/******************************************************************************
  62 *
  63 * module boiler plate
  64 *
  65 ******************************************************************************/
  66
  67#define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
  68MODULE_DESCRIPTION(DRV_DESCRIPTION);
  69MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
  70MODULE_LICENSE("GPL");
  71
  72static const struct iwl_op_mode_ops iwl_dvm_ops;
  73
  74void iwl_update_chain_flags(struct iwl_priv *priv)
  75{
  76        struct iwl_rxon_context *ctx;
  77
  78        for_each_context(priv, ctx) {
  79                iwlagn_set_rxon_chain(priv, ctx);
  80                if (ctx->active.rx_chain != ctx->staging.rx_chain)
  81                        iwlagn_commit_rxon(priv, ctx);
  82        }
  83}
  84
  85/* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
  86static void iwl_set_beacon_tim(struct iwl_priv *priv,
  87                               struct iwl_tx_beacon_cmd *tx_beacon_cmd,
  88                               u8 *beacon, u32 frame_size)
  89{
  90        u16 tim_idx;
  91        struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
  92
  93        /*
  94         * The index is relative to frame start but we start looking at the
  95         * variable-length part of the beacon.
  96         */
  97        tim_idx = mgmt->u.beacon.variable - beacon;
  98
  99        /* Parse variable-length elements of beacon to find WLAN_EID_TIM */
 100        while ((tim_idx < (frame_size - 2)) &&
 101                        (beacon[tim_idx] != WLAN_EID_TIM))
 102                tim_idx += beacon[tim_idx+1] + 2;
 103
 104        /* If TIM field was found, set variables */
 105        if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
 106                tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
 107                tx_beacon_cmd->tim_size = beacon[tim_idx+1];
 108        } else
 109                IWL_WARN(priv, "Unable to find TIM Element in beacon\n");
 110}
 111
 112int iwlagn_send_beacon_cmd(struct iwl_priv *priv)
 113{
 114        struct iwl_tx_beacon_cmd *tx_beacon_cmd;
 115        struct iwl_host_cmd cmd = {
 116                .id = REPLY_TX_BEACON,
 117        };
 118        struct ieee80211_tx_info *info;
 119        u32 frame_size;
 120        u32 rate_flags;
 121        u32 rate;
 122
 123        /*
 124         * We have to set up the TX command, the TX Beacon command, and the
 125         * beacon contents.
 126         */
 127
 128        lockdep_assert_held(&priv->mutex);
 129
 130        if (!priv->beacon_ctx) {
 131                IWL_ERR(priv, "trying to build beacon w/o beacon context!\n");
 132                return 0;
 133        }
 134
 135        if (WARN_ON(!priv->beacon_skb))
 136                return -EINVAL;
 137
 138        /* Allocate beacon command */
 139        if (!priv->beacon_cmd)
 140                priv->beacon_cmd = kzalloc(sizeof(*tx_beacon_cmd), GFP_KERNEL);
 141        tx_beacon_cmd = priv->beacon_cmd;
 142        if (!tx_beacon_cmd)
 143                return -ENOMEM;
 144
 145        frame_size = priv->beacon_skb->len;
 146
 147        /* Set up TX command fields */
 148        tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
 149        tx_beacon_cmd->tx.sta_id = priv->beacon_ctx->bcast_sta_id;
 150        tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
 151        tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
 152                TX_CMD_FLG_TSF_MSK | TX_CMD_FLG_STA_RATE_MSK;
 153
 154        /* Set up TX beacon command fields */
 155        iwl_set_beacon_tim(priv, tx_beacon_cmd, priv->beacon_skb->data,
 156                           frame_size);
 157
 158        /* Set up packet rate and flags */
 159        info = IEEE80211_SKB_CB(priv->beacon_skb);
 160
 161        /*
 162         * Let's set up the rate at least somewhat correctly;
 163         * it will currently not actually be used by the uCode,
 164         * it uses the broadcast station's rate instead.
 165         */
 166        if (info->control.rates[0].idx < 0 ||
 167            info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
 168                rate = 0;
 169        else
 170                rate = info->control.rates[0].idx;
 171
 172        priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
 173                                              priv->nvm_data->valid_tx_ant);
 174        rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
 175
 176        /* In mac80211, rates for 5 GHz start at 0 */
 177        if (info->band == IEEE80211_BAND_5GHZ)
 178                rate += IWL_FIRST_OFDM_RATE;
 179        else if (rate >= IWL_FIRST_CCK_RATE && rate <= IWL_LAST_CCK_RATE)
 180                rate_flags |= RATE_MCS_CCK_MSK;
 181
 182        tx_beacon_cmd->tx.rate_n_flags =
 183                        iwl_hw_set_rate_n_flags(rate, rate_flags);
 184
 185        /* Submit command */
 186        cmd.len[0] = sizeof(*tx_beacon_cmd);
 187        cmd.data[0] = tx_beacon_cmd;
 188        cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
 189        cmd.len[1] = frame_size;
 190        cmd.data[1] = priv->beacon_skb->data;
 191        cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
 192
 193        return iwl_dvm_send_cmd(priv, &cmd);
 194}
 195
 196static void iwl_bg_beacon_update(struct work_struct *work)
 197{
 198        struct iwl_priv *priv =
 199                container_of(work, struct iwl_priv, beacon_update);
 200        struct sk_buff *beacon;
 201
 202        mutex_lock(&priv->mutex);
 203        if (!priv->beacon_ctx) {
 204                IWL_ERR(priv, "updating beacon w/o beacon context!\n");
 205                goto out;
 206        }
 207
 208        if (priv->beacon_ctx->vif->type != NL80211_IFTYPE_AP) {
 209                /*
 210                 * The ucode will send beacon notifications even in
 211                 * IBSS mode, but we don't want to process them. But
 212                 * we need to defer the type check to here due to
 213                 * requiring locking around the beacon_ctx access.
 214                 */
 215                goto out;
 216        }
 217
 218        /* Pull updated AP beacon from mac80211. will fail if not in AP mode */
 219        beacon = ieee80211_beacon_get(priv->hw, priv->beacon_ctx->vif);
 220        if (!beacon) {
 221                IWL_ERR(priv, "update beacon failed -- keeping old\n");
 222                goto out;
 223        }
 224
 225        /* new beacon skb is allocated every time; dispose previous.*/
 226        dev_kfree_skb(priv->beacon_skb);
 227
 228        priv->beacon_skb = beacon;
 229
 230        iwlagn_send_beacon_cmd(priv);
 231 out:
 232        mutex_unlock(&priv->mutex);
 233}
 234
 235static void iwl_bg_bt_runtime_config(struct work_struct *work)
 236{
 237        struct iwl_priv *priv =
 238                container_of(work, struct iwl_priv, bt_runtime_config);
 239
 240        mutex_lock(&priv->mutex);
 241        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 242                goto out;
 243
 244        /* dont send host command if rf-kill is on */
 245        if (!iwl_is_ready_rf(priv))
 246                goto out;
 247
 248        iwlagn_send_advance_bt_config(priv);
 249out:
 250        mutex_unlock(&priv->mutex);
 251}
 252
 253static void iwl_bg_bt_full_concurrency(struct work_struct *work)
 254{
 255        struct iwl_priv *priv =
 256                container_of(work, struct iwl_priv, bt_full_concurrency);
 257        struct iwl_rxon_context *ctx;
 258
 259        mutex_lock(&priv->mutex);
 260
 261        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 262                goto out;
 263
 264        /* dont send host command if rf-kill is on */
 265        if (!iwl_is_ready_rf(priv))
 266                goto out;
 267
 268        IWL_DEBUG_INFO(priv, "BT coex in %s mode\n",
 269                       priv->bt_full_concurrent ?
 270                       "full concurrency" : "3-wire");
 271
 272        /*
 273         * LQ & RXON updated cmds must be sent before BT Config cmd
 274         * to avoid 3-wire collisions
 275         */
 276        for_each_context(priv, ctx) {
 277                iwlagn_set_rxon_chain(priv, ctx);
 278                iwlagn_commit_rxon(priv, ctx);
 279        }
 280
 281        iwlagn_send_advance_bt_config(priv);
 282out:
 283        mutex_unlock(&priv->mutex);
 284}
 285
 286int iwl_send_statistics_request(struct iwl_priv *priv, u8 flags, bool clear)
 287{
 288        struct iwl_statistics_cmd statistics_cmd = {
 289                .configuration_flags =
 290                        clear ? IWL_STATS_CONF_CLEAR_STATS : 0,
 291        };
 292
 293        if (flags & CMD_ASYNC)
 294                return iwl_dvm_send_cmd_pdu(priv, REPLY_STATISTICS_CMD,
 295                                        CMD_ASYNC,
 296                                        sizeof(struct iwl_statistics_cmd),
 297                                        &statistics_cmd);
 298        else
 299                return iwl_dvm_send_cmd_pdu(priv, REPLY_STATISTICS_CMD, 0,
 300                                        sizeof(struct iwl_statistics_cmd),
 301                                        &statistics_cmd);
 302}
 303
 304/**
 305 * iwl_bg_statistics_periodic - Timer callback to queue statistics
 306 *
 307 * This callback is provided in order to send a statistics request.
 308 *
 309 * This timer function is continually reset to execute within
 310 * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
 311 * was received.  We need to ensure we receive the statistics in order
 312 * to update the temperature used for calibrating the TXPOWER.
 313 */
 314static void iwl_bg_statistics_periodic(unsigned long data)
 315{
 316        struct iwl_priv *priv = (struct iwl_priv *)data;
 317
 318        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 319                return;
 320
 321        /* dont send host command if rf-kill is on */
 322        if (!iwl_is_ready_rf(priv))
 323                return;
 324
 325        iwl_send_statistics_request(priv, CMD_ASYNC, false);
 326}
 327
 328
 329static void iwl_print_cont_event_trace(struct iwl_priv *priv, u32 base,
 330                                        u32 start_idx, u32 num_events,
 331                                        u32 capacity, u32 mode)
 332{
 333        u32 i;
 334        u32 ptr;        /* SRAM byte address of log data */
 335        u32 ev, time, data; /* event log data */
 336        unsigned long reg_flags;
 337
 338        if (mode == 0)
 339                ptr = base + (4 * sizeof(u32)) + (start_idx * 2 * sizeof(u32));
 340        else
 341                ptr = base + (4 * sizeof(u32)) + (start_idx * 3 * sizeof(u32));
 342
 343        /* Make sure device is powered up for SRAM reads */
 344        if (!iwl_trans_grab_nic_access(priv->trans, false, &reg_flags))
 345                return;
 346
 347        /* Set starting address; reads will auto-increment */
 348        iwl_write32(priv->trans, HBUS_TARG_MEM_RADDR, ptr);
 349
 350        /*
 351         * Refuse to read more than would have fit into the log from
 352         * the current start_idx. This used to happen due to the race
 353         * described below, but now WARN because the code below should
 354         * prevent it from happening here.
 355         */
 356        if (WARN_ON(num_events > capacity - start_idx))
 357                num_events = capacity - start_idx;
 358
 359        /*
 360         * "time" is actually "data" for mode 0 (no timestamp).
 361         * place event id # at far right for easier visual parsing.
 362         */
 363        for (i = 0; i < num_events; i++) {
 364                ev = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
 365                time = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
 366                if (mode == 0) {
 367                        trace_iwlwifi_dev_ucode_cont_event(
 368                                        priv->trans->dev, 0, time, ev);
 369                } else {
 370                        data = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
 371                        trace_iwlwifi_dev_ucode_cont_event(
 372                                        priv->trans->dev, time, data, ev);
 373                }
 374        }
 375        /* Allow device to power down */
 376        iwl_trans_release_nic_access(priv->trans, &reg_flags);
 377}
 378
 379static void iwl_continuous_event_trace(struct iwl_priv *priv)
 380{
 381        u32 capacity;   /* event log capacity in # entries */
 382        struct {
 383                u32 capacity;
 384                u32 mode;
 385                u32 wrap_counter;
 386                u32 write_counter;
 387        } __packed read;
 388        u32 base;       /* SRAM byte address of event log header */
 389        u32 mode;       /* 0 - no timestamp, 1 - timestamp recorded */
 390        u32 num_wraps;  /* # times uCode wrapped to top of log */
 391        u32 next_entry; /* index of next entry to be written by uCode */
 392
 393        base = priv->device_pointers.log_event_table;
 394        if (iwlagn_hw_valid_rtc_data_addr(base)) {
 395                iwl_trans_read_mem_bytes(priv->trans, base,
 396                                         &read, sizeof(read));
 397                capacity = read.capacity;
 398                mode = read.mode;
 399                num_wraps = read.wrap_counter;
 400                next_entry = read.write_counter;
 401        } else
 402                return;
 403
 404        /*
 405         * Unfortunately, the uCode doesn't use temporary variables.
 406         * Therefore, it can happen that we read next_entry == capacity,
 407         * which really means next_entry == 0.
 408         */
 409        if (unlikely(next_entry == capacity))
 410                next_entry = 0;
 411        /*
 412         * Additionally, the uCode increases the write pointer before
 413         * the wraps counter, so if the write pointer is smaller than
 414         * the old write pointer (wrap occurred) but we read that no
 415         * wrap occurred, we actually read between the next_entry and
 416         * num_wraps update (this does happen in practice!!) -- take
 417         * that into account by increasing num_wraps.
 418         */
 419        if (unlikely(next_entry < priv->event_log.next_entry &&
 420                     num_wraps == priv->event_log.num_wraps))
 421                num_wraps++;
 422
 423        if (num_wraps == priv->event_log.num_wraps) {
 424                iwl_print_cont_event_trace(
 425                        priv, base, priv->event_log.next_entry,
 426                        next_entry - priv->event_log.next_entry,
 427                        capacity, mode);
 428
 429                priv->event_log.non_wraps_count++;
 430        } else {
 431                if (num_wraps - priv->event_log.num_wraps > 1)
 432                        priv->event_log.wraps_more_count++;
 433                else
 434                        priv->event_log.wraps_once_count++;
 435
 436                trace_iwlwifi_dev_ucode_wrap_event(priv->trans->dev,
 437                                num_wraps - priv->event_log.num_wraps,
 438                                next_entry, priv->event_log.next_entry);
 439
 440                if (next_entry < priv->event_log.next_entry) {
 441                        iwl_print_cont_event_trace(
 442                                priv, base, priv->event_log.next_entry,
 443                                capacity - priv->event_log.next_entry,
 444                                capacity, mode);
 445
 446                        iwl_print_cont_event_trace(
 447                                priv, base, 0, next_entry, capacity, mode);
 448                } else {
 449                        iwl_print_cont_event_trace(
 450                                priv, base, next_entry,
 451                                capacity - next_entry,
 452                                capacity, mode);
 453
 454                        iwl_print_cont_event_trace(
 455                                priv, base, 0, next_entry, capacity, mode);
 456                }
 457        }
 458
 459        priv->event_log.num_wraps = num_wraps;
 460        priv->event_log.next_entry = next_entry;
 461}
 462
 463/**
 464 * iwl_bg_ucode_trace - Timer callback to log ucode event
 465 *
 466 * The timer is continually set to execute every
 467 * UCODE_TRACE_PERIOD milliseconds after the last timer expired
 468 * this function is to perform continuous uCode event logging operation
 469 * if enabled
 470 */
 471static void iwl_bg_ucode_trace(unsigned long data)
 472{
 473        struct iwl_priv *priv = (struct iwl_priv *)data;
 474
 475        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 476                return;
 477
 478        if (priv->event_log.ucode_trace) {
 479                iwl_continuous_event_trace(priv);
 480                /* Reschedule the timer to occur in UCODE_TRACE_PERIOD */
 481                mod_timer(&priv->ucode_trace,
 482                         jiffies + msecs_to_jiffies(UCODE_TRACE_PERIOD));
 483        }
 484}
 485
 486static void iwl_bg_tx_flush(struct work_struct *work)
 487{
 488        struct iwl_priv *priv =
 489                container_of(work, struct iwl_priv, tx_flush);
 490
 491        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 492                return;
 493
 494        /* do nothing if rf-kill is on */
 495        if (!iwl_is_ready_rf(priv))
 496                return;
 497
 498        IWL_DEBUG_INFO(priv, "device request: flush all tx frames\n");
 499        iwlagn_dev_txfifo_flush(priv);
 500}
 501
 502/*
 503 * queue/FIFO/AC mapping definitions
 504 */
 505
 506static const u8 iwlagn_bss_ac_to_fifo[] = {
 507        IWL_TX_FIFO_VO,
 508        IWL_TX_FIFO_VI,
 509        IWL_TX_FIFO_BE,
 510        IWL_TX_FIFO_BK,
 511};
 512
 513static const u8 iwlagn_bss_ac_to_queue[] = {
 514        0, 1, 2, 3,
 515};
 516
 517static const u8 iwlagn_pan_ac_to_fifo[] = {
 518        IWL_TX_FIFO_VO_IPAN,
 519        IWL_TX_FIFO_VI_IPAN,
 520        IWL_TX_FIFO_BE_IPAN,
 521        IWL_TX_FIFO_BK_IPAN,
 522};
 523
 524static const u8 iwlagn_pan_ac_to_queue[] = {
 525        7, 6, 5, 4,
 526};
 527
 528static void iwl_init_context(struct iwl_priv *priv, u32 ucode_flags)
 529{
 530        int i;
 531
 532        /*
 533         * The default context is always valid,
 534         * the PAN context depends on uCode.
 535         */
 536        priv->valid_contexts = BIT(IWL_RXON_CTX_BSS);
 537        if (ucode_flags & IWL_UCODE_TLV_FLAGS_PAN)
 538                priv->valid_contexts |= BIT(IWL_RXON_CTX_PAN);
 539
 540        for (i = 0; i < NUM_IWL_RXON_CTX; i++)
 541                priv->contexts[i].ctxid = i;
 542
 543        priv->contexts[IWL_RXON_CTX_BSS].always_active = true;
 544        priv->contexts[IWL_RXON_CTX_BSS].is_active = true;
 545        priv->contexts[IWL_RXON_CTX_BSS].rxon_cmd = REPLY_RXON;
 546        priv->contexts[IWL_RXON_CTX_BSS].rxon_timing_cmd = REPLY_RXON_TIMING;
 547        priv->contexts[IWL_RXON_CTX_BSS].rxon_assoc_cmd = REPLY_RXON_ASSOC;
 548        priv->contexts[IWL_RXON_CTX_BSS].qos_cmd = REPLY_QOS_PARAM;
 549        priv->contexts[IWL_RXON_CTX_BSS].ap_sta_id = IWL_AP_ID;
 550        priv->contexts[IWL_RXON_CTX_BSS].wep_key_cmd = REPLY_WEPKEY;
 551        priv->contexts[IWL_RXON_CTX_BSS].bcast_sta_id = IWLAGN_BROADCAST_ID;
 552        priv->contexts[IWL_RXON_CTX_BSS].exclusive_interface_modes =
 553                BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_MONITOR);
 554        priv->contexts[IWL_RXON_CTX_BSS].interface_modes =
 555                BIT(NL80211_IFTYPE_STATION);
 556        priv->contexts[IWL_RXON_CTX_BSS].ap_devtype = RXON_DEV_TYPE_AP;
 557        priv->contexts[IWL_RXON_CTX_BSS].ibss_devtype = RXON_DEV_TYPE_IBSS;
 558        priv->contexts[IWL_RXON_CTX_BSS].station_devtype = RXON_DEV_TYPE_ESS;
 559        priv->contexts[IWL_RXON_CTX_BSS].unused_devtype = RXON_DEV_TYPE_ESS;
 560        memcpy(priv->contexts[IWL_RXON_CTX_BSS].ac_to_queue,
 561               iwlagn_bss_ac_to_queue, sizeof(iwlagn_bss_ac_to_queue));
 562        memcpy(priv->contexts[IWL_RXON_CTX_BSS].ac_to_fifo,
 563               iwlagn_bss_ac_to_fifo, sizeof(iwlagn_bss_ac_to_fifo));
 564
 565        priv->contexts[IWL_RXON_CTX_PAN].rxon_cmd = REPLY_WIPAN_RXON;
 566        priv->contexts[IWL_RXON_CTX_PAN].rxon_timing_cmd =
 567                REPLY_WIPAN_RXON_TIMING;
 568        priv->contexts[IWL_RXON_CTX_PAN].rxon_assoc_cmd =
 569                REPLY_WIPAN_RXON_ASSOC;
 570        priv->contexts[IWL_RXON_CTX_PAN].qos_cmd = REPLY_WIPAN_QOS_PARAM;
 571        priv->contexts[IWL_RXON_CTX_PAN].ap_sta_id = IWL_AP_ID_PAN;
 572        priv->contexts[IWL_RXON_CTX_PAN].wep_key_cmd = REPLY_WIPAN_WEPKEY;
 573        priv->contexts[IWL_RXON_CTX_PAN].bcast_sta_id = IWLAGN_PAN_BCAST_ID;
 574        priv->contexts[IWL_RXON_CTX_PAN].station_flags = STA_FLG_PAN_STATION;
 575        priv->contexts[IWL_RXON_CTX_PAN].interface_modes =
 576                BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP);
 577
 578        priv->contexts[IWL_RXON_CTX_PAN].ap_devtype = RXON_DEV_TYPE_CP;
 579        priv->contexts[IWL_RXON_CTX_PAN].station_devtype = RXON_DEV_TYPE_2STA;
 580        priv->contexts[IWL_RXON_CTX_PAN].unused_devtype = RXON_DEV_TYPE_P2P;
 581        memcpy(priv->contexts[IWL_RXON_CTX_PAN].ac_to_queue,
 582               iwlagn_pan_ac_to_queue, sizeof(iwlagn_pan_ac_to_queue));
 583        memcpy(priv->contexts[IWL_RXON_CTX_PAN].ac_to_fifo,
 584               iwlagn_pan_ac_to_fifo, sizeof(iwlagn_pan_ac_to_fifo));
 585        priv->contexts[IWL_RXON_CTX_PAN].mcast_queue = IWL_IPAN_MCAST_QUEUE;
 586
 587        BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
 588}
 589
 590static void iwl_rf_kill_ct_config(struct iwl_priv *priv)
 591{
 592        struct iwl_ct_kill_config cmd;
 593        struct iwl_ct_kill_throttling_config adv_cmd;
 594        int ret = 0;
 595
 596        iwl_write32(priv->trans, CSR_UCODE_DRV_GP1_CLR,
 597                    CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 598
 599        priv->thermal_throttle.ct_kill_toggle = false;
 600
 601        if (priv->lib->support_ct_kill_exit) {
 602                adv_cmd.critical_temperature_enter =
 603                        cpu_to_le32(priv->hw_params.ct_kill_threshold);
 604                adv_cmd.critical_temperature_exit =
 605                        cpu_to_le32(priv->hw_params.ct_kill_exit_threshold);
 606
 607                ret = iwl_dvm_send_cmd_pdu(priv,
 608                                       REPLY_CT_KILL_CONFIG_CMD,
 609                                       0, sizeof(adv_cmd), &adv_cmd);
 610                if (ret)
 611                        IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
 612                else
 613                        IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
 614                                "succeeded, critical temperature enter is %d,"
 615                                "exit is %d\n",
 616                                priv->hw_params.ct_kill_threshold,
 617                                priv->hw_params.ct_kill_exit_threshold);
 618        } else {
 619                cmd.critical_temperature_R =
 620                        cpu_to_le32(priv->hw_params.ct_kill_threshold);
 621
 622                ret = iwl_dvm_send_cmd_pdu(priv,
 623                                       REPLY_CT_KILL_CONFIG_CMD,
 624                                       0, sizeof(cmd), &cmd);
 625                if (ret)
 626                        IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
 627                else
 628                        IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
 629                                "succeeded, "
 630                                "critical temperature is %d\n",
 631                                priv->hw_params.ct_kill_threshold);
 632        }
 633}
 634
 635static int iwlagn_send_calib_cfg_rt(struct iwl_priv *priv, u32 cfg)
 636{
 637        struct iwl_calib_cfg_cmd calib_cfg_cmd;
 638        struct iwl_host_cmd cmd = {
 639                .id = CALIBRATION_CFG_CMD,
 640                .len = { sizeof(struct iwl_calib_cfg_cmd), },
 641                .data = { &calib_cfg_cmd, },
 642        };
 643
 644        memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
 645        calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_RT_CFG_ALL;
 646        calib_cfg_cmd.ucd_calib_cfg.once.start = cpu_to_le32(cfg);
 647
 648        return iwl_dvm_send_cmd(priv, &cmd);
 649}
 650
 651
 652static int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
 653{
 654        struct iwl_tx_ant_config_cmd tx_ant_cmd = {
 655          .valid = cpu_to_le32(valid_tx_ant),
 656        };
 657
 658        if (IWL_UCODE_API(priv->fw->ucode_ver) > 1) {
 659                IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
 660                return iwl_dvm_send_cmd_pdu(priv, TX_ANT_CONFIGURATION_CMD, 0,
 661                                        sizeof(struct iwl_tx_ant_config_cmd),
 662                                        &tx_ant_cmd);
 663        } else {
 664                IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
 665                return -EOPNOTSUPP;
 666        }
 667}
 668
 669static void iwl_send_bt_config(struct iwl_priv *priv)
 670{
 671        struct iwl_bt_cmd bt_cmd = {
 672                .lead_time = BT_LEAD_TIME_DEF,
 673                .max_kill = BT_MAX_KILL_DEF,
 674                .kill_ack_mask = 0,
 675                .kill_cts_mask = 0,
 676        };
 677
 678        if (!iwlwifi_mod_params.bt_coex_active)
 679                bt_cmd.flags = BT_COEX_DISABLE;
 680        else
 681                bt_cmd.flags = BT_COEX_ENABLE;
 682
 683        priv->bt_enable_flag = bt_cmd.flags;
 684        IWL_DEBUG_INFO(priv, "BT coex %s\n",
 685                (bt_cmd.flags == BT_COEX_DISABLE) ? "disable" : "active");
 686
 687        if (iwl_dvm_send_cmd_pdu(priv, REPLY_BT_CONFIG,
 688                             0, sizeof(struct iwl_bt_cmd), &bt_cmd))
 689                IWL_ERR(priv, "failed to send BT Coex Config\n");
 690}
 691
 692/**
 693 * iwl_alive_start - called after REPLY_ALIVE notification received
 694 *                   from protocol/runtime uCode (initialization uCode's
 695 *                   Alive gets handled by iwl_init_alive_start()).
 696 */
 697int iwl_alive_start(struct iwl_priv *priv)
 698{
 699        int ret = 0;
 700        struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
 701
 702        IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
 703
 704        /* After the ALIVE response, we can send host commands to the uCode */
 705        set_bit(STATUS_ALIVE, &priv->status);
 706
 707        if (iwl_is_rfkill(priv))
 708                return -ERFKILL;
 709
 710        if (priv->event_log.ucode_trace) {
 711                /* start collecting data now */
 712                mod_timer(&priv->ucode_trace, jiffies);
 713        }
 714
 715        /* download priority table before any calibration request */
 716        if (priv->lib->bt_params &&
 717            priv->lib->bt_params->advanced_bt_coexist) {
 718                /* Configure Bluetooth device coexistence support */
 719                if (priv->lib->bt_params->bt_sco_disable)
 720                        priv->bt_enable_pspoll = false;
 721                else
 722                        priv->bt_enable_pspoll = true;
 723
 724                priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
 725                priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
 726                priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
 727                iwlagn_send_advance_bt_config(priv);
 728                priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS;
 729                priv->cur_rssi_ctx = NULL;
 730
 731                iwl_send_prio_tbl(priv);
 732
 733                /* FIXME: w/a to force change uCode BT state machine */
 734                ret = iwl_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
 735                                         BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 736                if (ret)
 737                        return ret;
 738                ret = iwl_send_bt_env(priv, IWL_BT_COEX_ENV_CLOSE,
 739                                         BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 740                if (ret)
 741                        return ret;
 742        } else if (priv->lib->bt_params) {
 743                /*
 744                 * default is 2-wire BT coexexistence support
 745                 */
 746                iwl_send_bt_config(priv);
 747        }
 748
 749        /*
 750         * Perform runtime calibrations, including DC calibration.
 751         */
 752        iwlagn_send_calib_cfg_rt(priv, IWL_CALIB_CFG_DC_IDX);
 753
 754        ieee80211_wake_queues(priv->hw);
 755
 756        /* Configure Tx antenna selection based on H/W config */
 757        iwlagn_send_tx_ant_config(priv, priv->nvm_data->valid_tx_ant);
 758
 759        if (iwl_is_associated_ctx(ctx) && !priv->wowlan) {
 760                struct iwl_rxon_cmd *active_rxon =
 761                                (struct iwl_rxon_cmd *)&ctx->active;
 762                /* apply any changes in staging */
 763                ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
 764                active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 765        } else {
 766                struct iwl_rxon_context *tmp;
 767                /* Initialize our rx_config data */
 768                for_each_context(priv, tmp)
 769                        iwl_connection_init_rx_config(priv, tmp);
 770
 771                iwlagn_set_rxon_chain(priv, ctx);
 772        }
 773
 774        if (!priv->wowlan) {
 775                /* WoWLAN ucode will not reply in the same way, skip it */
 776                iwl_reset_run_time_calib(priv);
 777        }
 778
 779        set_bit(STATUS_READY, &priv->status);
 780
 781        /* Configure the adapter for unassociated operation */
 782        ret = iwlagn_commit_rxon(priv, ctx);
 783        if (ret)
 784                return ret;
 785
 786        /* At this point, the NIC is initialized and operational */
 787        iwl_rf_kill_ct_config(priv);
 788
 789        IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
 790
 791        return iwl_power_update_mode(priv, true);
 792}
 793
 794/**
 795 * iwl_clear_driver_stations - clear knowledge of all stations from driver
 796 * @priv: iwl priv struct
 797 *
 798 * This is called during iwl_down() to make sure that in the case
 799 * we're coming there from a hardware restart mac80211 will be
 800 * able to reconfigure stations -- if we're getting there in the
 801 * normal down flow then the stations will already be cleared.
 802 */
 803static void iwl_clear_driver_stations(struct iwl_priv *priv)
 804{
 805        struct iwl_rxon_context *ctx;
 806
 807        spin_lock_bh(&priv->sta_lock);
 808        memset(priv->stations, 0, sizeof(priv->stations));
 809        priv->num_stations = 0;
 810
 811        priv->ucode_key_table = 0;
 812
 813        for_each_context(priv, ctx) {
 814                /*
 815                 * Remove all key information that is not stored as part
 816                 * of station information since mac80211 may not have had
 817                 * a chance to remove all the keys. When device is
 818                 * reconfigured by mac80211 after an error all keys will
 819                 * be reconfigured.
 820                 */
 821                memset(ctx->wep_keys, 0, sizeof(ctx->wep_keys));
 822                ctx->key_mapping_keys = 0;
 823        }
 824
 825        spin_unlock_bh(&priv->sta_lock);
 826}
 827
 828void iwl_down(struct iwl_priv *priv)
 829{
 830        int exit_pending;
 831
 832        IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
 833
 834        lockdep_assert_held(&priv->mutex);
 835
 836        iwl_scan_cancel_timeout(priv, 200);
 837
 838        exit_pending =
 839                test_and_set_bit(STATUS_EXIT_PENDING, &priv->status);
 840
 841        iwl_clear_ucode_stations(priv, NULL);
 842        iwl_dealloc_bcast_stations(priv);
 843        iwl_clear_driver_stations(priv);
 844
 845        /* reset BT coex data */
 846        priv->bt_status = 0;
 847        priv->cur_rssi_ctx = NULL;
 848        priv->bt_is_sco = 0;
 849        if (priv->lib->bt_params)
 850                priv->bt_traffic_load =
 851                         priv->lib->bt_params->bt_init_traffic_load;
 852        else
 853                priv->bt_traffic_load = 0;
 854        priv->bt_full_concurrent = false;
 855        priv->bt_ci_compliance = 0;
 856
 857        /* Wipe out the EXIT_PENDING status bit if we are not actually
 858         * exiting the module */
 859        if (!exit_pending)
 860                clear_bit(STATUS_EXIT_PENDING, &priv->status);
 861
 862        if (priv->mac80211_registered)
 863                ieee80211_stop_queues(priv->hw);
 864
 865        priv->ucode_loaded = false;
 866        iwl_trans_stop_device(priv->trans);
 867
 868        /* Set num_aux_in_flight must be done after the transport is stopped */
 869        atomic_set(&priv->num_aux_in_flight, 0);
 870
 871        /* Clear out all status bits but a few that are stable across reset */
 872        priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
 873                                STATUS_RF_KILL_HW |
 874                        test_bit(STATUS_FW_ERROR, &priv->status) <<
 875                                STATUS_FW_ERROR |
 876                        test_bit(STATUS_EXIT_PENDING, &priv->status) <<
 877                                STATUS_EXIT_PENDING;
 878
 879        dev_kfree_skb(priv->beacon_skb);
 880        priv->beacon_skb = NULL;
 881}
 882
 883/*****************************************************************************
 884 *
 885 * Workqueue callbacks
 886 *
 887 *****************************************************************************/
 888
 889static void iwl_bg_run_time_calib_work(struct work_struct *work)
 890{
 891        struct iwl_priv *priv = container_of(work, struct iwl_priv,
 892                        run_time_calib_work);
 893
 894        mutex_lock(&priv->mutex);
 895
 896        if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
 897            test_bit(STATUS_SCANNING, &priv->status)) {
 898                mutex_unlock(&priv->mutex);
 899                return;
 900        }
 901
 902        if (priv->start_calib) {
 903                iwl_chain_noise_calibration(priv);
 904                iwl_sensitivity_calibration(priv);
 905        }
 906
 907        mutex_unlock(&priv->mutex);
 908}
 909
 910void iwlagn_prepare_restart(struct iwl_priv *priv)
 911{
 912        bool bt_full_concurrent;
 913        u8 bt_ci_compliance;
 914        u8 bt_load;
 915        u8 bt_status;
 916        bool bt_is_sco;
 917        int i;
 918
 919        lockdep_assert_held(&priv->mutex);
 920
 921        priv->is_open = 0;
 922
 923        /*
 924         * __iwl_down() will clear the BT status variables,
 925         * which is correct, but when we restart we really
 926         * want to keep them so restore them afterwards.
 927         *
 928         * The restart process will later pick them up and
 929         * re-configure the hw when we reconfigure the BT
 930         * command.
 931         */
 932        bt_full_concurrent = priv->bt_full_concurrent;
 933        bt_ci_compliance = priv->bt_ci_compliance;
 934        bt_load = priv->bt_traffic_load;
 935        bt_status = priv->bt_status;
 936        bt_is_sco = priv->bt_is_sco;
 937
 938        iwl_down(priv);
 939
 940        priv->bt_full_concurrent = bt_full_concurrent;
 941        priv->bt_ci_compliance = bt_ci_compliance;
 942        priv->bt_traffic_load = bt_load;
 943        priv->bt_status = bt_status;
 944        priv->bt_is_sco = bt_is_sco;
 945
 946        /* reset aggregation queues */
 947        for (i = IWLAGN_FIRST_AMPDU_QUEUE; i < IWL_MAX_HW_QUEUES; i++)
 948                priv->queue_to_mac80211[i] = IWL_INVALID_MAC80211_QUEUE;
 949        /* and stop counts */
 950        for (i = 0; i < IWL_MAX_HW_QUEUES; i++)
 951                atomic_set(&priv->queue_stop_count[i], 0);
 952
 953        memset(priv->agg_q_alloc, 0, sizeof(priv->agg_q_alloc));
 954}
 955
 956static void iwl_bg_restart(struct work_struct *data)
 957{
 958        struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
 959
 960        if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 961                return;
 962
 963        if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
 964                mutex_lock(&priv->mutex);
 965                iwlagn_prepare_restart(priv);
 966                mutex_unlock(&priv->mutex);
 967                iwl_cancel_deferred_work(priv);
 968                if (priv->mac80211_registered)
 969                        ieee80211_restart_hw(priv->hw);
 970                else
 971                        IWL_ERR(priv,
 972                                "Cannot request restart before registrating with mac80211\n");
 973        } else {
 974                WARN_ON(1);
 975        }
 976}
 977
 978/*****************************************************************************
 979 *
 980 * driver setup and teardown
 981 *
 982 *****************************************************************************/
 983
 984static void iwl_setup_deferred_work(struct iwl_priv *priv)
 985{
 986        priv->workqueue = create_singlethread_workqueue(DRV_NAME);
 987
 988        INIT_WORK(&priv->restart, iwl_bg_restart);
 989        INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
 990        INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
 991        INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);
 992        INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);
 993        INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);
 994
 995        iwl_setup_scan_deferred_work(priv);
 996
 997        if (priv->lib->bt_params)
 998                iwlagn_bt_setup_deferred_work(priv);
 999
1000        setup_timer(&priv->statistics_periodic, iwl_bg_statistics_periodic,
1001                    (unsigned long)priv);
1002
1003        setup_timer(&priv->ucode_trace, iwl_bg_ucode_trace,
1004                    (unsigned long)priv);
1005}
1006
1007void iwl_cancel_deferred_work(struct iwl_priv *priv)
1008{
1009        if (priv->lib->bt_params)
1010                iwlagn_bt_cancel_deferred_work(priv);
1011
1012        cancel_work_sync(&priv->run_time_calib_work);
1013        cancel_work_sync(&priv->beacon_update);
1014
1015        iwl_cancel_scan_deferred_work(priv);
1016
1017        cancel_work_sync(&priv->bt_full_concurrency);
1018        cancel_work_sync(&priv->bt_runtime_config);
1019
1020        del_timer_sync(&priv->statistics_periodic);
1021        del_timer_sync(&priv->ucode_trace);
1022}
1023
1024static int iwl_init_drv(struct iwl_priv *priv)
1025{
1026        spin_lock_init(&priv->sta_lock);
1027
1028        mutex_init(&priv->mutex);
1029
1030        INIT_LIST_HEAD(&priv->calib_results);
1031
1032        priv->band = IEEE80211_BAND_2GHZ;
1033
1034        priv->plcp_delta_threshold = priv->lib->plcp_delta_threshold;
1035
1036        priv->iw_mode = NL80211_IFTYPE_STATION;
1037        priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
1038        priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
1039        priv->agg_tids_count = 0;
1040
1041        priv->rx_statistics_jiffies = jiffies;
1042
1043        /* Choose which receivers/antennas to use */
1044        iwlagn_set_rxon_chain(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
1045
1046        iwl_init_scan_params(priv);
1047
1048        /* init bt coex */
1049        if (priv->lib->bt_params &&
1050            priv->lib->bt_params->advanced_bt_coexist) {
1051                priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
1052                priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
1053                priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
1054                priv->bt_on_thresh = BT_ON_THRESHOLD_DEF;
1055                priv->bt_duration = BT_DURATION_LIMIT_DEF;
1056                priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF;
1057        }
1058
1059        return 0;
1060}
1061
1062static void iwl_uninit_drv(struct iwl_priv *priv)
1063{
1064        kfree(priv->scan_cmd);
1065        kfree(priv->beacon_cmd);
1066        kfree(rcu_dereference_raw(priv->noa_data));
1067        iwl_calib_free_results(priv);
1068#ifdef CONFIG_IWLWIFI_DEBUGFS
1069        kfree(priv->wowlan_sram);
1070#endif
1071}
1072
1073static void iwl_set_hw_params(struct iwl_priv *priv)
1074{
1075        if (priv->cfg->ht_params)
1076                priv->hw_params.use_rts_for_aggregation =
1077                        priv->cfg->ht_params->use_rts_for_aggregation;
1078
1079        /* Device-specific setup */
1080        priv->lib->set_hw_params(priv);
1081}
1082
1083
1084
1085/* show what optional capabilities we have */
1086static void iwl_option_config(struct iwl_priv *priv)
1087{
1088#ifdef CONFIG_IWLWIFI_DEBUG
1089        IWL_INFO(priv, "CONFIG_IWLWIFI_DEBUG enabled\n");
1090#else
1091        IWL_INFO(priv, "CONFIG_IWLWIFI_DEBUG disabled\n");
1092#endif
1093
1094#ifdef CONFIG_IWLWIFI_DEBUGFS
1095        IWL_INFO(priv, "CONFIG_IWLWIFI_DEBUGFS enabled\n");
1096#else
1097        IWL_INFO(priv, "CONFIG_IWLWIFI_DEBUGFS disabled\n");
1098#endif
1099
1100#ifdef CONFIG_IWLWIFI_DEVICE_TRACING
1101        IWL_INFO(priv, "CONFIG_IWLWIFI_DEVICE_TRACING enabled\n");
1102#else
1103        IWL_INFO(priv, "CONFIG_IWLWIFI_DEVICE_TRACING disabled\n");
1104#endif
1105}
1106
1107static int iwl_eeprom_init_hw_params(struct iwl_priv *priv)
1108{
1109        struct iwl_nvm_data *data = priv->nvm_data;
1110
1111        if (data->sku_cap_11n_enable &&
1112            !priv->cfg->ht_params) {
1113                IWL_ERR(priv, "Invalid 11n configuration\n");
1114                return -EINVAL;
1115        }
1116
1117        if (!data->sku_cap_11n_enable && !data->sku_cap_band_24GHz_enable &&
1118            !data->sku_cap_band_52GHz_enable) {
1119                IWL_ERR(priv, "Invalid device sku\n");
1120                return -EINVAL;
1121        }
1122
1123        IWL_DEBUG_INFO(priv,
1124                       "Device SKU: 24GHz %s %s, 52GHz %s %s, 11.n %s %s\n",
1125                       data->sku_cap_band_24GHz_enable ? "" : "NOT", "enabled",
1126                       data->sku_cap_band_52GHz_enable ? "" : "NOT", "enabled",
1127                       data->sku_cap_11n_enable ? "" : "NOT", "enabled");
1128
1129        priv->hw_params.tx_chains_num =
1130                num_of_ant(data->valid_tx_ant);
1131        if (priv->cfg->rx_with_siso_diversity)
1132                priv->hw_params.rx_chains_num = 1;
1133        else
1134                priv->hw_params.rx_chains_num =
1135                        num_of_ant(data->valid_rx_ant);
1136
1137        IWL_DEBUG_INFO(priv, "Valid Tx ant: 0x%X, Valid Rx ant: 0x%X\n",
1138                       data->valid_tx_ant,
1139                       data->valid_rx_ant);
1140
1141        return 0;
1142}
1143
1144static struct iwl_op_mode *iwl_op_mode_dvm_start(struct iwl_trans *trans,
1145                                                 const struct iwl_cfg *cfg,
1146                                                 const struct iwl_fw *fw,
1147                                                 struct dentry *dbgfs_dir)
1148{
1149        struct iwl_priv *priv;
1150        struct ieee80211_hw *hw;
1151        struct iwl_op_mode *op_mode;
1152        u16 num_mac;
1153        u32 ucode_flags;
1154        struct iwl_trans_config trans_cfg = {};
1155        static const u8 no_reclaim_cmds[] = {
1156                REPLY_RX_PHY_CMD,
1157                REPLY_RX_MPDU_CMD,
1158                REPLY_COMPRESSED_BA,
1159                STATISTICS_NOTIFICATION,
1160                REPLY_TX,
1161        };
1162        int i;
1163
1164        /************************
1165         * 1. Allocating HW data
1166         ************************/
1167        hw = iwl_alloc_all();
1168        if (!hw) {
1169                pr_err("%s: Cannot allocate network device\n", cfg->name);
1170                goto out;
1171        }
1172
1173        op_mode = hw->priv;
1174        op_mode->ops = &iwl_dvm_ops;
1175        priv = IWL_OP_MODE_GET_DVM(op_mode);
1176        priv->trans = trans;
1177        priv->dev = trans->dev;
1178        priv->cfg = cfg;
1179        priv->fw = fw;
1180
1181        switch (priv->cfg->device_family) {
1182        case IWL_DEVICE_FAMILY_1000:
1183        case IWL_DEVICE_FAMILY_100:
1184                priv->lib = &iwl_dvm_1000_cfg;
1185                break;
1186        case IWL_DEVICE_FAMILY_2000:
1187                priv->lib = &iwl_dvm_2000_cfg;
1188                break;
1189        case IWL_DEVICE_FAMILY_105:
1190                priv->lib = &iwl_dvm_105_cfg;
1191                break;
1192        case IWL_DEVICE_FAMILY_2030:
1193        case IWL_DEVICE_FAMILY_135:
1194                priv->lib = &iwl_dvm_2030_cfg;
1195                break;
1196        case IWL_DEVICE_FAMILY_5000:
1197                priv->lib = &iwl_dvm_5000_cfg;
1198                break;
1199        case IWL_DEVICE_FAMILY_5150:
1200                priv->lib = &iwl_dvm_5150_cfg;
1201                break;
1202        case IWL_DEVICE_FAMILY_6000:
1203        case IWL_DEVICE_FAMILY_6000i:
1204                priv->lib = &iwl_dvm_6000_cfg;
1205                break;
1206        case IWL_DEVICE_FAMILY_6005:
1207                priv->lib = &iwl_dvm_6005_cfg;
1208                break;
1209        case IWL_DEVICE_FAMILY_6050:
1210        case IWL_DEVICE_FAMILY_6150:
1211                priv->lib = &iwl_dvm_6050_cfg;
1212                break;
1213        case IWL_DEVICE_FAMILY_6030:
1214                priv->lib = &iwl_dvm_6030_cfg;
1215                break;
1216        default:
1217                break;
1218        }
1219
1220        if (WARN_ON(!priv->lib))
1221                goto out_free_hw;
1222
1223        /*
1224         * Populate the state variables that the transport layer needs
1225         * to know about.
1226         */
1227        trans_cfg.op_mode = op_mode;
1228        trans_cfg.no_reclaim_cmds = no_reclaim_cmds;
1229        trans_cfg.n_no_reclaim_cmds = ARRAY_SIZE(no_reclaim_cmds);
1230        trans_cfg.rx_buf_size_8k = iwlwifi_mod_params.amsdu_size_8K;
1231        trans_cfg.cmd_q_wdg_timeout = IWL_WATCHDOG_DISABLED;
1232
1233        trans_cfg.command_names = iwl_dvm_cmd_strings;
1234        trans_cfg.cmd_fifo = IWLAGN_CMD_FIFO_NUM;
1235
1236        WARN_ON(sizeof(priv->transport_queue_stop) * BITS_PER_BYTE <
1237                priv->cfg->base_params->num_of_queues);
1238
1239        ucode_flags = fw->ucode_capa.flags;
1240
1241        if (ucode_flags & IWL_UCODE_TLV_FLAGS_PAN) {
1242                priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
1243                trans_cfg.cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
1244        } else {
1245                priv->sta_key_max_num = STA_KEY_MAX_NUM;
1246                trans_cfg.cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
1247        }
1248
1249        /* Configure transport layer */
1250        iwl_trans_configure(priv->trans, &trans_cfg);
1251
1252        trans->rx_mpdu_cmd = REPLY_RX_MPDU_CMD;
1253        trans->rx_mpdu_cmd_hdr_size = sizeof(struct iwl_rx_mpdu_res_start);
1254
1255        /* At this point both hw and priv are allocated. */
1256
1257        SET_IEEE80211_DEV(priv->hw, priv->trans->dev);
1258
1259        iwl_option_config(priv);
1260
1261        IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
1262
1263        /* is antenna coupling more than 35dB ? */
1264        priv->bt_ant_couple_ok =
1265                (iwlwifi_mod_params.ant_coupling >
1266                        IWL_BT_ANTENNA_COUPLING_THRESHOLD) ?
1267                        true : false;
1268
1269        /* bt channel inhibition enabled*/
1270        priv->bt_ch_announce = true;
1271        IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n",
1272                       (priv->bt_ch_announce) ? "On" : "Off");
1273
1274        /* these spin locks will be used in apm_ops.init and EEPROM access
1275         * we should init now
1276         */
1277        spin_lock_init(&priv->statistics.lock);
1278
1279        /***********************
1280         * 2. Read REV register
1281         ***********************/
1282        IWL_INFO(priv, "Detected %s, REV=0x%X\n",
1283                priv->cfg->name, priv->trans->hw_rev);
1284
1285        if (iwl_trans_start_hw(priv->trans))
1286                goto out_free_hw;
1287
1288        /* Read the EEPROM */
1289        if (iwl_read_eeprom(priv->trans, &priv->eeprom_blob,
1290                            &priv->eeprom_blob_size)) {
1291                IWL_ERR(priv, "Unable to init EEPROM\n");
1292                goto out_free_hw;
1293        }
1294
1295        /* Reset chip to save power until we load uCode during "up". */
1296        iwl_trans_stop_device(priv->trans);
1297
1298        priv->nvm_data = iwl_parse_eeprom_data(priv->trans->dev, priv->cfg,
1299                                                  priv->eeprom_blob,
1300                                                  priv->eeprom_blob_size);
1301        if (!priv->nvm_data)
1302                goto out_free_eeprom_blob;
1303
1304        if (iwl_nvm_check_version(priv->nvm_data, priv->trans))
1305                goto out_free_eeprom;
1306
1307        if (iwl_eeprom_init_hw_params(priv))
1308                goto out_free_eeprom;
1309
1310        /* extract MAC Address */
1311        memcpy(priv->addresses[0].addr, priv->nvm_data->hw_addr, ETH_ALEN);
1312        IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr);
1313        priv->hw->wiphy->addresses = priv->addresses;
1314        priv->hw->wiphy->n_addresses = 1;
1315        num_mac = priv->nvm_data->n_hw_addrs;
1316        if (num_mac > 1) {
1317                memcpy(priv->addresses[1].addr, priv->addresses[0].addr,
1318                       ETH_ALEN);
1319                priv->addresses[1].addr[5]++;
1320                priv->hw->wiphy->n_addresses++;
1321        }
1322
1323        /************************
1324         * 4. Setup HW constants
1325         ************************/
1326        iwl_set_hw_params(priv);
1327
1328        if (!(priv->nvm_data->sku_cap_ipan_enable)) {
1329                IWL_DEBUG_INFO(priv, "Your EEPROM disabled PAN\n");
1330                ucode_flags &= ~IWL_UCODE_TLV_FLAGS_PAN;
1331                /*
1332                 * if not PAN, then don't support P2P -- might be a uCode
1333                 * packaging bug or due to the eeprom check above
1334                 */
1335                priv->sta_key_max_num = STA_KEY_MAX_NUM;
1336                trans_cfg.cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
1337
1338                /* Configure transport layer again*/
1339                iwl_trans_configure(priv->trans, &trans_cfg);
1340        }
1341
1342        /*******************
1343         * 5. Setup priv
1344         *******************/
1345        for (i = 0; i < IWL_MAX_HW_QUEUES; i++) {
1346                priv->queue_to_mac80211[i] = IWL_INVALID_MAC80211_QUEUE;
1347                if (i < IWLAGN_FIRST_AMPDU_QUEUE &&
1348                    i != IWL_DEFAULT_CMD_QUEUE_NUM &&
1349                    i != IWL_IPAN_CMD_QUEUE_NUM)
1350                        priv->queue_to_mac80211[i] = i;
1351                atomic_set(&priv->queue_stop_count[i], 0);
1352        }
1353
1354        if (iwl_init_drv(priv))
1355                goto out_free_eeprom;
1356
1357        /* At this point both hw and priv are initialized. */
1358
1359        /********************
1360         * 6. Setup services
1361         ********************/
1362        iwl_setup_deferred_work(priv);
1363        iwl_setup_rx_handlers(priv);
1364
1365        iwl_power_initialize(priv);
1366        iwl_tt_initialize(priv);
1367
1368        snprintf(priv->hw->wiphy->fw_version,
1369                 sizeof(priv->hw->wiphy->fw_version),
1370                 "%s", fw->fw_version);
1371
1372        priv->new_scan_threshold_behaviour =
1373                !!(ucode_flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
1374
1375        priv->phy_calib_chain_noise_reset_cmd =
1376                fw->ucode_capa.standard_phy_calibration_size;
1377        priv->phy_calib_chain_noise_gain_cmd =
1378                fw->ucode_capa.standard_phy_calibration_size + 1;
1379
1380        /* initialize all valid contexts */
1381        iwl_init_context(priv, ucode_flags);
1382
1383        /**************************************************
1384         * This is still part of probe() in a sense...
1385         *
1386         * 7. Setup and register with mac80211 and debugfs
1387         **************************************************/
1388        if (iwlagn_mac_setup_register(priv, &fw->ucode_capa))
1389                goto out_destroy_workqueue;
1390
1391        if (iwl_dbgfs_register(priv, dbgfs_dir))
1392                goto out_mac80211_unregister;
1393
1394        return op_mode;
1395
1396out_mac80211_unregister:
1397        iwlagn_mac_unregister(priv);
1398out_destroy_workqueue:
1399        iwl_tt_exit(priv);
1400        iwl_cancel_deferred_work(priv);
1401        destroy_workqueue(priv->workqueue);
1402        priv->workqueue = NULL;
1403        iwl_uninit_drv(priv);
1404out_free_eeprom_blob:
1405        kfree(priv->eeprom_blob);
1406out_free_eeprom:
1407        iwl_free_nvm_data(priv->nvm_data);
1408out_free_hw:
1409        ieee80211_free_hw(priv->hw);
1410out:
1411        op_mode = NULL;
1412        return op_mode;
1413}
1414
1415static void iwl_op_mode_dvm_stop(struct iwl_op_mode *op_mode)
1416{
1417        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
1418
1419        IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
1420
1421        iwlagn_mac_unregister(priv);
1422
1423        iwl_tt_exit(priv);
1424
1425        kfree(priv->eeprom_blob);
1426        iwl_free_nvm_data(priv->nvm_data);
1427
1428        /*netif_stop_queue(dev); */
1429        flush_workqueue(priv->workqueue);
1430
1431        /* ieee80211_unregister_hw calls iwlagn_mac_stop, which flushes
1432         * priv->workqueue... so we can't take down the workqueue
1433         * until now... */
1434        destroy_workqueue(priv->workqueue);
1435        priv->workqueue = NULL;
1436
1437        iwl_uninit_drv(priv);
1438
1439        dev_kfree_skb(priv->beacon_skb);
1440
1441        iwl_trans_op_mode_leave(priv->trans);
1442        ieee80211_free_hw(priv->hw);
1443}
1444
1445static const char * const desc_lookup_text[] = {
1446        "OK",
1447        "FAIL",
1448        "BAD_PARAM",
1449        "BAD_CHECKSUM",
1450        "NMI_INTERRUPT_WDG",
1451        "SYSASSERT",
1452        "FATAL_ERROR",
1453        "BAD_COMMAND",
1454        "HW_ERROR_TUNE_LOCK",
1455        "HW_ERROR_TEMPERATURE",
1456        "ILLEGAL_CHAN_FREQ",
1457        "VCC_NOT_STABLE",
1458        "FH_ERROR",
1459        "NMI_INTERRUPT_HOST",
1460        "NMI_INTERRUPT_ACTION_PT",
1461        "NMI_INTERRUPT_UNKNOWN",
1462        "UCODE_VERSION_MISMATCH",
1463        "HW_ERROR_ABS_LOCK",
1464        "HW_ERROR_CAL_LOCK_FAIL",
1465        "NMI_INTERRUPT_INST_ACTION_PT",
1466        "NMI_INTERRUPT_DATA_ACTION_PT",
1467        "NMI_TRM_HW_ER",
1468        "NMI_INTERRUPT_TRM",
1469        "NMI_INTERRUPT_BREAK_POINT",
1470        "DEBUG_0",
1471        "DEBUG_1",
1472        "DEBUG_2",
1473        "DEBUG_3",
1474};
1475
1476static struct { char *name; u8 num; } advanced_lookup[] = {
1477        { "NMI_INTERRUPT_WDG", 0x34 },
1478        { "SYSASSERT", 0x35 },
1479        { "UCODE_VERSION_MISMATCH", 0x37 },
1480        { "BAD_COMMAND", 0x38 },
1481        { "NMI_INTERRUPT_DATA_ACTION_PT", 0x3C },
1482        { "FATAL_ERROR", 0x3D },
1483        { "NMI_TRM_HW_ERR", 0x46 },
1484        { "NMI_INTERRUPT_TRM", 0x4C },
1485        { "NMI_INTERRUPT_BREAK_POINT", 0x54 },
1486        { "NMI_INTERRUPT_WDG_RXF_FULL", 0x5C },
1487        { "NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64 },
1488        { "NMI_INTERRUPT_HOST", 0x66 },
1489        { "NMI_INTERRUPT_ACTION_PT", 0x7C },
1490        { "NMI_INTERRUPT_UNKNOWN", 0x84 },
1491        { "NMI_INTERRUPT_INST_ACTION_PT", 0x86 },
1492        { "ADVANCED_SYSASSERT", 0 },
1493};
1494
1495static const char *desc_lookup(u32 num)
1496{
1497        int i;
1498        int max = ARRAY_SIZE(desc_lookup_text);
1499
1500        if (num < max)
1501                return desc_lookup_text[num];
1502
1503        max = ARRAY_SIZE(advanced_lookup) - 1;
1504        for (i = 0; i < max; i++) {
1505                if (advanced_lookup[i].num == num)
1506                        break;
1507        }
1508        return advanced_lookup[i].name;
1509}
1510
1511#define ERROR_START_OFFSET  (1 * sizeof(u32))
1512#define ERROR_ELEM_SIZE     (7 * sizeof(u32))
1513
1514static void iwl_dump_nic_error_log(struct iwl_priv *priv)
1515{
1516        struct iwl_trans *trans = priv->trans;
1517        u32 base;
1518        struct iwl_error_event_table table;
1519
1520        base = priv->device_pointers.error_event_table;
1521        if (priv->cur_ucode == IWL_UCODE_INIT) {
1522                if (!base)
1523                        base = priv->fw->init_errlog_ptr;
1524        } else {
1525                if (!base)
1526                        base = priv->fw->inst_errlog_ptr;
1527        }
1528
1529        if (!iwlagn_hw_valid_rtc_data_addr(base)) {
1530                IWL_ERR(priv,
1531                        "Not valid error log pointer 0x%08X for %s uCode\n",
1532                        base,
1533                        (priv->cur_ucode == IWL_UCODE_INIT)
1534                                        ? "Init" : "RT");
1535                return;
1536        }
1537
1538        /*TODO: Update dbgfs with ISR error stats obtained below */
1539        iwl_trans_read_mem_bytes(trans, base, &table, sizeof(table));
1540
1541        if (ERROR_START_OFFSET <= table.valid * ERROR_ELEM_SIZE) {
1542                IWL_ERR(trans, "Start IWL Error Log Dump:\n");
1543                IWL_ERR(trans, "Status: 0x%08lX, count: %d\n",
1544                        priv->status, table.valid);
1545        }
1546
1547        trace_iwlwifi_dev_ucode_error(trans->dev, table.error_id, table.tsf_low,
1548                                      table.data1, table.data2, table.line,
1549                                      table.blink1, table.blink2, table.ilink1,
1550                                      table.ilink2, table.bcon_time, table.gp1,
1551                                      table.gp2, table.gp3, table.ucode_ver,
1552                                      table.hw_ver, table.brd_ver);
1553        IWL_ERR(priv, "0x%08X | %-28s\n", table.error_id,
1554                desc_lookup(table.error_id));
1555        IWL_ERR(priv, "0x%08X | uPc\n", table.pc);
1556        IWL_ERR(priv, "0x%08X | branchlink1\n", table.blink1);
1557        IWL_ERR(priv, "0x%08X | branchlink2\n", table.blink2);
1558        IWL_ERR(priv, "0x%08X | interruptlink1\n", table.ilink1);
1559        IWL_ERR(priv, "0x%08X | interruptlink2\n", table.ilink2);
1560        IWL_ERR(priv, "0x%08X | data1\n", table.data1);
1561        IWL_ERR(priv, "0x%08X | data2\n", table.data2);
1562        IWL_ERR(priv, "0x%08X | line\n", table.line);
1563        IWL_ERR(priv, "0x%08X | beacon time\n", table.bcon_time);
1564        IWL_ERR(priv, "0x%08X | tsf low\n", table.tsf_low);
1565        IWL_ERR(priv, "0x%08X | tsf hi\n", table.tsf_hi);
1566        IWL_ERR(priv, "0x%08X | time gp1\n", table.gp1);
1567        IWL_ERR(priv, "0x%08X | time gp2\n", table.gp2);
1568        IWL_ERR(priv, "0x%08X | time gp3\n", table.gp3);
1569        IWL_ERR(priv, "0x%08X | uCode version\n", table.ucode_ver);
1570        IWL_ERR(priv, "0x%08X | hw version\n", table.hw_ver);
1571        IWL_ERR(priv, "0x%08X | board version\n", table.brd_ver);
1572        IWL_ERR(priv, "0x%08X | hcmd\n", table.hcmd);
1573        IWL_ERR(priv, "0x%08X | isr0\n", table.isr0);
1574        IWL_ERR(priv, "0x%08X | isr1\n", table.isr1);
1575        IWL_ERR(priv, "0x%08X | isr2\n", table.isr2);
1576        IWL_ERR(priv, "0x%08X | isr3\n", table.isr3);
1577        IWL_ERR(priv, "0x%08X | isr4\n", table.isr4);
1578        IWL_ERR(priv, "0x%08X | isr_pref\n", table.isr_pref);
1579        IWL_ERR(priv, "0x%08X | wait_event\n", table.wait_event);
1580        IWL_ERR(priv, "0x%08X | l2p_control\n", table.l2p_control);
1581        IWL_ERR(priv, "0x%08X | l2p_duration\n", table.l2p_duration);
1582        IWL_ERR(priv, "0x%08X | l2p_mhvalid\n", table.l2p_mhvalid);
1583        IWL_ERR(priv, "0x%08X | l2p_addr_match\n", table.l2p_addr_match);
1584        IWL_ERR(priv, "0x%08X | lmpm_pmg_sel\n", table.lmpm_pmg_sel);
1585        IWL_ERR(priv, "0x%08X | timestamp\n", table.u_timestamp);
1586        IWL_ERR(priv, "0x%08X | flow_handler\n", table.flow_handler);
1587}
1588
1589#define EVENT_START_OFFSET  (4 * sizeof(u32))
1590
1591/**
1592 * iwl_print_event_log - Dump error event log to syslog
1593 *
1594 */
1595static int iwl_print_event_log(struct iwl_priv *priv, u32 start_idx,
1596                               u32 num_events, u32 mode,
1597                               int pos, char **buf, size_t bufsz)
1598{
1599        u32 i;
1600        u32 base;       /* SRAM byte address of event log header */
1601        u32 event_size; /* 2 u32s, or 3 u32s if timestamp recorded */
1602        u32 ptr;        /* SRAM byte address of log data */
1603        u32 ev, time, data; /* event log data */
1604        unsigned long reg_flags;
1605
1606        struct iwl_trans *trans = priv->trans;
1607
1608        if (num_events == 0)
1609                return pos;
1610
1611        base = priv->device_pointers.log_event_table;
1612        if (priv->cur_ucode == IWL_UCODE_INIT) {
1613                if (!base)
1614                        base = priv->fw->init_evtlog_ptr;
1615        } else {
1616                if (!base)
1617                        base = priv->fw->inst_evtlog_ptr;
1618        }
1619
1620        if (mode == 0)
1621                event_size = 2 * sizeof(u32);
1622        else
1623                event_size = 3 * sizeof(u32);
1624
1625        ptr = base + EVENT_START_OFFSET + (start_idx * event_size);
1626
1627        /* Make sure device is powered up for SRAM reads */
1628        if (!iwl_trans_grab_nic_access(trans, false, &reg_flags))
1629                return pos;
1630
1631        /* Set starting address; reads will auto-increment */
1632        iwl_write32(trans, HBUS_TARG_MEM_RADDR, ptr);
1633
1634        /* "time" is actually "data" for mode 0 (no timestamp).
1635        * place event id # at far right for easier visual parsing. */
1636        for (i = 0; i < num_events; i++) {
1637                ev = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
1638                time = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
1639                if (mode == 0) {
1640                        /* data, ev */
1641                        if (bufsz) {
1642                                pos += scnprintf(*buf + pos, bufsz - pos,
1643                                                "EVT_LOG:0x%08x:%04u\n",
1644                                                time, ev);
1645                        } else {
1646                                trace_iwlwifi_dev_ucode_event(trans->dev, 0,
1647                                        time, ev);
1648                                IWL_ERR(priv, "EVT_LOG:0x%08x:%04u\n",
1649                                        time, ev);
1650                        }
1651                } else {
1652                        data = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
1653                        if (bufsz) {
1654                                pos += scnprintf(*buf + pos, bufsz - pos,
1655                                                "EVT_LOGT:%010u:0x%08x:%04u\n",
1656                                                 time, data, ev);
1657                        } else {
1658                                IWL_ERR(priv, "EVT_LOGT:%010u:0x%08x:%04u\n",
1659                                        time, data, ev);
1660                                trace_iwlwifi_dev_ucode_event(trans->dev, time,
1661                                        data, ev);
1662                        }
1663                }
1664        }
1665
1666        /* Allow device to power down */
1667        iwl_trans_release_nic_access(trans, &reg_flags);
1668        return pos;
1669}
1670
1671/**
1672 * iwl_print_last_event_logs - Dump the newest # of event log to syslog
1673 */
1674static int iwl_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
1675                                    u32 num_wraps, u32 next_entry,
1676                                    u32 size, u32 mode,
1677                                    int pos, char **buf, size_t bufsz)
1678{
1679        /*
1680         * display the newest DEFAULT_LOG_ENTRIES entries
1681         * i.e the entries just before the next ont that uCode would fill.
1682         */
1683        if (num_wraps) {
1684                if (next_entry < size) {
1685                        pos = iwl_print_event_log(priv,
1686                                                capacity - (size - next_entry),
1687                                                size - next_entry, mode,
1688                                                pos, buf, bufsz);
1689                        pos = iwl_print_event_log(priv, 0,
1690                                                  next_entry, mode,
1691                                                  pos, buf, bufsz);
1692                } else
1693                        pos = iwl_print_event_log(priv, next_entry - size,
1694                                                  size, mode, pos, buf, bufsz);
1695        } else {
1696                if (next_entry < size) {
1697                        pos = iwl_print_event_log(priv, 0, next_entry,
1698                                                  mode, pos, buf, bufsz);
1699                } else {
1700                        pos = iwl_print_event_log(priv, next_entry - size,
1701                                                  size, mode, pos, buf, bufsz);
1702                }
1703        }
1704        return pos;
1705}
1706
1707#define DEFAULT_DUMP_EVENT_LOG_ENTRIES (20)
1708
1709int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
1710                            char **buf)
1711{
1712        u32 base;       /* SRAM byte address of event log header */
1713        u32 capacity;   /* event log capacity in # entries */
1714        u32 mode;       /* 0 - no timestamp, 1 - timestamp recorded */
1715        u32 num_wraps;  /* # times uCode wrapped to top of log */
1716        u32 next_entry; /* index of next entry to be written by uCode */
1717        u32 size;       /* # entries that we'll print */
1718        u32 logsize;
1719        int pos = 0;
1720        size_t bufsz = 0;
1721        struct iwl_trans *trans = priv->trans;
1722
1723        base = priv->device_pointers.log_event_table;
1724        if (priv->cur_ucode == IWL_UCODE_INIT) {
1725                logsize = priv->fw->init_evtlog_size;
1726                if (!base)
1727                        base = priv->fw->init_evtlog_ptr;
1728        } else {
1729                logsize = priv->fw->inst_evtlog_size;
1730                if (!base)
1731                        base = priv->fw->inst_evtlog_ptr;
1732        }
1733
1734        if (!iwlagn_hw_valid_rtc_data_addr(base)) {
1735                IWL_ERR(priv,
1736                        "Invalid event log pointer 0x%08X for %s uCode\n",
1737                        base,
1738                        (priv->cur_ucode == IWL_UCODE_INIT)
1739                                        ? "Init" : "RT");
1740                return -EINVAL;
1741        }
1742
1743        /* event log header */
1744        capacity = iwl_trans_read_mem32(trans, base);
1745        mode = iwl_trans_read_mem32(trans, base + (1 * sizeof(u32)));
1746        num_wraps = iwl_trans_read_mem32(trans, base + (2 * sizeof(u32)));
1747        next_entry = iwl_trans_read_mem32(trans, base + (3 * sizeof(u32)));
1748
1749        if (capacity > logsize) {
1750                IWL_ERR(priv, "Log capacity %d is bogus, limit to %d "
1751                        "entries\n", capacity, logsize);
1752                capacity = logsize;
1753        }
1754
1755        if (next_entry > logsize) {
1756                IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
1757                        next_entry, logsize);
1758                next_entry = logsize;
1759        }
1760
1761        size = num_wraps ? capacity : next_entry;
1762
1763        /* bail out if nothing in log */
1764        if (size == 0) {
1765                IWL_ERR(trans, "Start IWL Event Log Dump: nothing in log\n");
1766                return pos;
1767        }
1768
1769        if (!(iwl_have_debug_level(IWL_DL_FW_ERRORS)) && !full_log)
1770                size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
1771                        ? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
1772        IWL_ERR(priv, "Start IWL Event Log Dump: display last %u entries\n",
1773                size);
1774
1775#ifdef CONFIG_IWLWIFI_DEBUG
1776        if (buf) {
1777                if (full_log)
1778                        bufsz = capacity * 48;
1779                else
1780                        bufsz = size * 48;
1781                *buf = kmalloc(bufsz, GFP_KERNEL);
1782                if (!*buf)
1783                        return -ENOMEM;
1784        }
1785        if (iwl_have_debug_level(IWL_DL_FW_ERRORS) || full_log) {
1786                /*
1787                 * if uCode has wrapped back to top of log,
1788                 * start at the oldest entry,
1789                 * i.e the next one that uCode would fill.
1790                 */
1791                if (num_wraps)
1792                        pos = iwl_print_event_log(priv, next_entry,
1793                                                capacity - next_entry, mode,
1794                                                pos, buf, bufsz);
1795                /* (then/else) start at top of log */
1796                pos = iwl_print_event_log(priv, 0,
1797                                          next_entry, mode, pos, buf, bufsz);
1798        } else
1799                pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
1800                                                next_entry, size, mode,
1801                                                pos, buf, bufsz);
1802#else
1803        pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
1804                                        next_entry, size, mode,
1805                                        pos, buf, bufsz);
1806#endif
1807        return pos;
1808}
1809
1810static void iwlagn_fw_error(struct iwl_priv *priv, bool ondemand)
1811{
1812        unsigned int reload_msec;
1813        unsigned long reload_jiffies;
1814
1815        if (iwl_have_debug_level(IWL_DL_FW_ERRORS))
1816                iwl_print_rx_config_cmd(priv, IWL_RXON_CTX_BSS);
1817
1818        /* uCode is no longer loaded. */
1819        priv->ucode_loaded = false;
1820
1821        /* Set the FW error flag -- cleared on iwl_down */
1822        set_bit(STATUS_FW_ERROR, &priv->status);
1823
1824        iwl_abort_notification_waits(&priv->notif_wait);
1825
1826        /* Keep the restart process from trying to send host
1827         * commands by clearing the ready bit */
1828        clear_bit(STATUS_READY, &priv->status);
1829
1830        if (!ondemand) {
1831                /*
1832                 * If firmware keep reloading, then it indicate something
1833                 * serious wrong and firmware having problem to recover
1834                 * from it. Instead of keep trying which will fill the syslog
1835                 * and hang the system, let's just stop it
1836                 */
1837                reload_jiffies = jiffies;
1838                reload_msec = jiffies_to_msecs((long) reload_jiffies -
1839                                        (long) priv->reload_jiffies);
1840                priv->reload_jiffies = reload_jiffies;
1841                if (reload_msec <= IWL_MIN_RELOAD_DURATION) {
1842                        priv->reload_count++;
1843                        if (priv->reload_count >= IWL_MAX_CONTINUE_RELOAD_CNT) {
1844                                IWL_ERR(priv, "BUG_ON, Stop restarting\n");
1845                                return;
1846                        }
1847                } else
1848                        priv->reload_count = 0;
1849        }
1850
1851        if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
1852                if (iwlwifi_mod_params.restart_fw) {
1853                        IWL_DEBUG_FW_ERRORS(priv,
1854                                  "Restarting adapter due to uCode error.\n");
1855                        queue_work(priv->workqueue, &priv->restart);
1856                } else
1857                        IWL_DEBUG_FW_ERRORS(priv,
1858                                  "Detected FW error, but not restarting\n");
1859        }
1860}
1861
1862static void iwl_nic_error(struct iwl_op_mode *op_mode)
1863{
1864        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
1865
1866        IWL_ERR(priv, "Loaded firmware version: %s\n",
1867                priv->fw->fw_version);
1868
1869        iwl_dump_nic_error_log(priv);
1870        iwl_dump_nic_event_log(priv, false, NULL);
1871
1872        iwlagn_fw_error(priv, false);
1873}
1874
1875static void iwl_cmd_queue_full(struct iwl_op_mode *op_mode)
1876{
1877        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
1878
1879        if (!iwl_check_for_ct_kill(priv)) {
1880                IWL_ERR(priv, "Restarting adapter queue is full\n");
1881                iwlagn_fw_error(priv, false);
1882        }
1883}
1884
1885#define EEPROM_RF_CONFIG_TYPE_MAX      0x3
1886
1887static void iwl_nic_config(struct iwl_op_mode *op_mode)
1888{
1889        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
1890
1891        /* SKU Control */
1892        iwl_trans_set_bits_mask(priv->trans, CSR_HW_IF_CONFIG_REG,
1893                                CSR_HW_IF_CONFIG_REG_MSK_MAC_DASH |
1894                                CSR_HW_IF_CONFIG_REG_MSK_MAC_STEP,
1895                                (CSR_HW_REV_STEP(priv->trans->hw_rev) <<
1896                                        CSR_HW_IF_CONFIG_REG_POS_MAC_STEP) |
1897                                (CSR_HW_REV_DASH(priv->trans->hw_rev) <<
1898                                        CSR_HW_IF_CONFIG_REG_POS_MAC_DASH));
1899
1900        /* write radio config values to register */
1901        if (priv->nvm_data->radio_cfg_type <= EEPROM_RF_CONFIG_TYPE_MAX) {
1902                u32 reg_val =
1903                        priv->nvm_data->radio_cfg_type <<
1904                                CSR_HW_IF_CONFIG_REG_POS_PHY_TYPE |
1905                        priv->nvm_data->radio_cfg_step <<
1906                                CSR_HW_IF_CONFIG_REG_POS_PHY_STEP |
1907                        priv->nvm_data->radio_cfg_dash <<
1908                                CSR_HW_IF_CONFIG_REG_POS_PHY_DASH;
1909
1910                iwl_trans_set_bits_mask(priv->trans, CSR_HW_IF_CONFIG_REG,
1911                                        CSR_HW_IF_CONFIG_REG_MSK_PHY_TYPE |
1912                                        CSR_HW_IF_CONFIG_REG_MSK_PHY_STEP |
1913                                        CSR_HW_IF_CONFIG_REG_MSK_PHY_DASH,
1914                                        reg_val);
1915
1916                IWL_INFO(priv, "Radio type=0x%x-0x%x-0x%x\n",
1917                         priv->nvm_data->radio_cfg_type,
1918                         priv->nvm_data->radio_cfg_step,
1919                         priv->nvm_data->radio_cfg_dash);
1920        } else {
1921                WARN_ON(1);
1922        }
1923
1924        /* set CSR_HW_CONFIG_REG for uCode use */
1925        iwl_set_bit(priv->trans, CSR_HW_IF_CONFIG_REG,
1926                    CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |
1927                    CSR_HW_IF_CONFIG_REG_BIT_MAC_SI);
1928
1929        /* W/A : NIC is stuck in a reset state after Early PCIe power off
1930         * (PCIe power is lost before PERST# is asserted),
1931         * causing ME FW to lose ownership and not being able to obtain it back.
1932         */
1933        iwl_set_bits_mask_prph(priv->trans, APMG_PS_CTRL_REG,
1934                               APMG_PS_CTRL_EARLY_PWR_OFF_RESET_DIS,
1935                               ~APMG_PS_CTRL_EARLY_PWR_OFF_RESET_DIS);
1936
1937        if (priv->lib->nic_config)
1938                priv->lib->nic_config(priv);
1939}
1940
1941static void iwl_wimax_active(struct iwl_op_mode *op_mode)
1942{
1943        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
1944
1945        clear_bit(STATUS_READY, &priv->status);
1946        IWL_ERR(priv, "RF is used by WiMAX\n");
1947}
1948
1949static void iwl_stop_sw_queue(struct iwl_op_mode *op_mode, int queue)
1950{
1951        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
1952        int mq = priv->queue_to_mac80211[queue];
1953
1954        if (WARN_ON_ONCE(mq == IWL_INVALID_MAC80211_QUEUE))
1955                return;
1956
1957        if (atomic_inc_return(&priv->queue_stop_count[mq]) > 1) {
1958                IWL_DEBUG_TX_QUEUES(priv,
1959                        "queue %d (mac80211 %d) already stopped\n",
1960                        queue, mq);
1961                return;
1962        }
1963
1964        set_bit(mq, &priv->transport_queue_stop);
1965        ieee80211_stop_queue(priv->hw, mq);
1966}
1967
1968static void iwl_wake_sw_queue(struct iwl_op_mode *op_mode, int queue)
1969{
1970        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
1971        int mq = priv->queue_to_mac80211[queue];
1972
1973        if (WARN_ON_ONCE(mq == IWL_INVALID_MAC80211_QUEUE))
1974                return;
1975
1976        if (atomic_dec_return(&priv->queue_stop_count[mq]) > 0) {
1977                IWL_DEBUG_TX_QUEUES(priv,
1978                        "queue %d (mac80211 %d) already awake\n",
1979                        queue, mq);
1980                return;
1981        }
1982
1983        clear_bit(mq, &priv->transport_queue_stop);
1984
1985        if (!priv->passive_no_rx)
1986                ieee80211_wake_queue(priv->hw, mq);
1987}
1988
1989void iwlagn_lift_passive_no_rx(struct iwl_priv *priv)
1990{
1991        int mq;
1992
1993        if (!priv->passive_no_rx)
1994                return;
1995
1996        for (mq = 0; mq < IWLAGN_FIRST_AMPDU_QUEUE; mq++) {
1997                if (!test_bit(mq, &priv->transport_queue_stop)) {
1998                        IWL_DEBUG_TX_QUEUES(priv, "Wake queue %d\n", mq);
1999                        ieee80211_wake_queue(priv->hw, mq);
2000                } else {
2001                        IWL_DEBUG_TX_QUEUES(priv, "Don't wake queue %d\n", mq);
2002                }
2003        }
2004
2005        priv->passive_no_rx = false;
2006}
2007
2008static void iwl_free_skb(struct iwl_op_mode *op_mode, struct sk_buff *skb)
2009{
2010        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
2011        struct ieee80211_tx_info *info;
2012
2013        info = IEEE80211_SKB_CB(skb);
2014        iwl_trans_free_tx_cmd(priv->trans, info->driver_data[1]);
2015        ieee80211_free_txskb(priv->hw, skb);
2016}
2017
2018static bool iwl_set_hw_rfkill_state(struct iwl_op_mode *op_mode, bool state)
2019{
2020        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
2021
2022        if (state)
2023                set_bit(STATUS_RF_KILL_HW, &priv->status);
2024        else
2025                clear_bit(STATUS_RF_KILL_HW, &priv->status);
2026
2027        wiphy_rfkill_set_hw_state(priv->hw->wiphy, state);
2028
2029        return false;
2030}
2031
2032static void iwl_napi_add(struct iwl_op_mode *op_mode,
2033                         struct napi_struct *napi,
2034                         struct net_device *napi_dev,
2035                         int (*poll)(struct napi_struct *, int),
2036                         int weight)
2037{
2038        struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
2039
2040        ieee80211_napi_add(priv->hw, napi, napi_dev, poll, weight);
2041}
2042
2043static const struct iwl_op_mode_ops iwl_dvm_ops = {
2044        .start = iwl_op_mode_dvm_start,
2045        .stop = iwl_op_mode_dvm_stop,
2046        .rx = iwl_rx_dispatch,
2047        .queue_full = iwl_stop_sw_queue,
2048        .queue_not_full = iwl_wake_sw_queue,
2049        .hw_rf_kill = iwl_set_hw_rfkill_state,
2050        .free_skb = iwl_free_skb,
2051        .nic_error = iwl_nic_error,
2052        .cmd_queue_full = iwl_cmd_queue_full,
2053        .nic_config = iwl_nic_config,
2054        .wimax_active = iwl_wimax_active,
2055        .napi_add = iwl_napi_add,
2056};
2057
2058/*****************************************************************************
2059 *
2060 * driver and module entry point
2061 *
2062 *****************************************************************************/
2063static int __init iwl_init(void)
2064{
2065
2066        int ret;
2067
2068        ret = iwlagn_rate_control_register();
2069        if (ret) {
2070                pr_err("Unable to register rate control algorithm: %d\n", ret);
2071                return ret;
2072        }
2073
2074        ret = iwl_opmode_register("iwldvm", &iwl_dvm_ops);
2075        if (ret) {
2076                pr_err("Unable to register op_mode: %d\n", ret);
2077                iwlagn_rate_control_unregister();
2078        }
2079
2080        return ret;
2081}
2082module_init(iwl_init);
2083
2084static void __exit iwl_exit(void)
2085{
2086        iwl_opmode_deregister("iwldvm");
2087        iwlagn_rate_control_unregister();
2088}
2089module_exit(iwl_exit);
2090