2007-09-26 08:54:57 +08:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
2011-04-06 00:42:00 +08:00
|
|
|
* Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
|
2007-09-26 08:54:57 +08:00
|
|
|
*
|
|
|
|
* Portions of this file are derived from the ipw3945 project, as well
|
|
|
|
* as portions of the ieee80211 subsystem header files.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of version 2 of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
|
|
|
|
*
|
|
|
|
* The full GNU General Public License is included in this distribution in the
|
|
|
|
* file called LICENSE.
|
|
|
|
*
|
|
|
|
* Contact Information:
|
2008-12-10 03:28:58 +08:00
|
|
|
* Intel Linux Wireless <ilw@linux.intel.com>
|
2007-09-26 08:54:57 +08:00
|
|
|
* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2007-09-26 08:54:57 +08:00
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/delay.h>
|
2009-10-07 21:09:06 +08:00
|
|
|
#include <linux/sched.h>
|
2007-09-26 08:54:57 +08:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/firmware.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
|
|
|
|
#include <net/mac80211.h>
|
|
|
|
|
|
|
|
#include <asm/div64.h>
|
|
|
|
|
2008-03-12 07:17:18 +08:00
|
|
|
#include "iwl-eeprom.h"
|
2008-04-25 02:55:38 +08:00
|
|
|
#include "iwl-dev.h"
|
2008-04-04 07:05:21 +08:00
|
|
|
#include "iwl-core.h"
|
2008-03-26 07:33:37 +08:00
|
|
|
#include "iwl-io.h"
|
2007-09-26 08:54:57 +08:00
|
|
|
#include "iwl-helpers.h"
|
2008-04-15 12:16:06 +08:00
|
|
|
#include "iwl-sta.h"
|
2010-09-23 00:02:11 +08:00
|
|
|
#include "iwl-agn-calib.h"
|
2010-01-21 22:21:10 +08:00
|
|
|
#include "iwl-agn.h"
|
2011-08-26 14:10:36 +08:00
|
|
|
#include "iwl-shared.h"
|
2011-07-11 15:48:51 +08:00
|
|
|
#include "iwl-bus.h"
|
2011-06-14 15:13:24 +08:00
|
|
|
#include "iwl-trans.h"
|
2007-10-25 17:15:49 +08:00
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* module boiler plate
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* module name, copyright, version, etc.
|
|
|
|
*/
|
2008-07-18 13:53:02 +08:00
|
|
|
#define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-03-13 07:58:49 +08:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2007-09-26 08:54:57 +08:00
|
|
|
#define VD "d"
|
|
|
|
#else
|
|
|
|
#define VD
|
|
|
|
#endif
|
|
|
|
|
2010-01-23 06:22:57 +08:00
|
|
|
#define DRV_VERSION IWLWIFI_VERSION VD
|
2007-09-26 08:54:57 +08:00
|
|
|
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION(DRV_DESCRIPTION);
|
|
|
|
MODULE_VERSION(DRV_VERSION);
|
2008-12-12 02:33:41 +08:00
|
|
|
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
|
2007-09-26 08:54:57 +08:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
void iwl_update_chain_flags(struct iwl_priv *priv)
|
2008-04-22 06:41:51 +08:00
|
|
|
{
|
2010-08-23 16:46:32 +08:00
|
|
|
struct iwl_rxon_context *ctx;
|
2008-04-22 06:41:51 +08:00
|
|
|
|
2011-07-01 22:59:26 +08:00
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
iwlagn_set_rxon_chain(priv, ctx);
|
|
|
|
if (ctx->active.rx_chain != ctx->staging.rx_chain)
|
|
|
|
iwlagn_commit_rxon(priv, ctx);
|
2010-08-23 16:46:32 +08:00
|
|
|
}
|
2008-04-22 06:41:51 +08:00
|
|
|
}
|
|
|
|
|
2009-11-14 03:56:33 +08:00
|
|
|
/* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
|
|
|
|
static void iwl_set_beacon_tim(struct iwl_priv *priv,
|
2010-10-04 20:50:36 +08:00
|
|
|
struct iwl_tx_beacon_cmd *tx_beacon_cmd,
|
|
|
|
u8 *beacon, u32 frame_size)
|
2009-11-14 03:56:33 +08:00
|
|
|
{
|
|
|
|
u16 tim_idx;
|
|
|
|
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The index is relative to frame start but we start looking at the
|
|
|
|
* variable-length part of the beacon.
|
|
|
|
*/
|
|
|
|
tim_idx = mgmt->u.beacon.variable - beacon;
|
|
|
|
|
|
|
|
/* Parse variable-length elements of beacon to find WLAN_EID_TIM */
|
|
|
|
while ((tim_idx < (frame_size - 2)) &&
|
|
|
|
(beacon[tim_idx] != WLAN_EID_TIM))
|
|
|
|
tim_idx += beacon[tim_idx+1] + 2;
|
|
|
|
|
|
|
|
/* If TIM field was found, set variables */
|
|
|
|
if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
|
|
|
|
tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
|
|
|
|
tx_beacon_cmd->tim_size = beacon[tim_idx+1];
|
|
|
|
} else
|
|
|
|
IWL_WARN(priv, "Unable to find TIM Element in beacon\n");
|
|
|
|
}
|
|
|
|
|
2011-04-30 00:48:14 +08:00
|
|
|
int iwlagn_send_beacon_cmd(struct iwl_priv *priv)
|
2008-07-18 13:53:03 +08:00
|
|
|
{
|
|
|
|
struct iwl_tx_beacon_cmd *tx_beacon_cmd;
|
2011-04-30 00:48:14 +08:00
|
|
|
struct iwl_host_cmd cmd = {
|
|
|
|
.id = REPLY_TX_BEACON,
|
2011-07-08 23:46:14 +08:00
|
|
|
.flags = CMD_SYNC,
|
2011-04-30 00:48:14 +08:00
|
|
|
};
|
2011-06-22 21:33:43 +08:00
|
|
|
struct ieee80211_tx_info *info;
|
2009-11-14 03:56:33 +08:00
|
|
|
u32 frame_size;
|
|
|
|
u32 rate_flags;
|
|
|
|
u32 rate;
|
2011-04-30 00:48:14 +08:00
|
|
|
|
2009-11-14 03:56:33 +08:00
|
|
|
/*
|
|
|
|
* We have to set up the TX command, the TX Beacon command, and the
|
|
|
|
* beacon contents.
|
|
|
|
*/
|
2008-07-18 13:53:03 +08:00
|
|
|
|
2010-08-23 16:46:47 +08:00
|
|
|
lockdep_assert_held(&priv->mutex);
|
|
|
|
|
|
|
|
if (!priv->beacon_ctx) {
|
|
|
|
IWL_ERR(priv, "trying to build beacon w/o beacon context!\n");
|
2010-09-06 03:00:26 +08:00
|
|
|
return 0;
|
2010-08-23 16:46:47 +08:00
|
|
|
}
|
|
|
|
|
2011-04-30 00:48:14 +08:00
|
|
|
if (WARN_ON(!priv->beacon_skb))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-05-14 02:57:40 +08:00
|
|
|
/* Allocate beacon command */
|
|
|
|
if (!priv->beacon_cmd)
|
|
|
|
priv->beacon_cmd = kzalloc(sizeof(*tx_beacon_cmd), GFP_KERNEL);
|
|
|
|
tx_beacon_cmd = priv->beacon_cmd;
|
2011-04-30 00:48:14 +08:00
|
|
|
if (!tx_beacon_cmd)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
frame_size = priv->beacon_skb->len;
|
2008-07-18 13:53:03 +08:00
|
|
|
|
2009-11-14 03:56:33 +08:00
|
|
|
/* Set up TX command fields */
|
2008-07-18 13:53:03 +08:00
|
|
|
tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
|
2010-08-23 16:46:47 +08:00
|
|
|
tx_beacon_cmd->tx.sta_id = priv->beacon_ctx->bcast_sta_id;
|
2009-11-14 03:56:33 +08:00
|
|
|
tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
|
|
|
|
tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
|
|
|
|
TX_CMD_FLG_TSF_MSK | TX_CMD_FLG_STA_RATE_MSK;
|
2008-07-18 13:53:03 +08:00
|
|
|
|
2009-11-14 03:56:33 +08:00
|
|
|
/* Set up TX beacon command fields */
|
2011-05-14 02:57:40 +08:00
|
|
|
iwl_set_beacon_tim(priv, tx_beacon_cmd, priv->beacon_skb->data,
|
2010-10-04 20:50:36 +08:00
|
|
|
frame_size);
|
2008-07-18 13:53:03 +08:00
|
|
|
|
2009-11-14 03:56:33 +08:00
|
|
|
/* Set up packet rate and flags */
|
2011-06-22 21:33:43 +08:00
|
|
|
info = IEEE80211_SKB_CB(priv->beacon_skb);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Let's set up the rate at least somewhat correctly;
|
|
|
|
* it will currently not actually be used by the uCode,
|
|
|
|
* it uses the broadcast station's rate instead.
|
|
|
|
*/
|
|
|
|
if (info->control.rates[0].idx < 0 ||
|
|
|
|
info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
|
|
|
|
rate = 0;
|
|
|
|
else
|
|
|
|
rate = info->control.rates[0].idx;
|
|
|
|
|
2010-05-18 17:48:36 +08:00
|
|
|
priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
|
2011-08-26 14:10:39 +08:00
|
|
|
hw_params(priv).valid_tx_ant);
|
2009-11-14 03:56:33 +08:00
|
|
|
rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
|
2011-06-22 21:33:43 +08:00
|
|
|
|
|
|
|
/* In mac80211, rates for 5 GHz start at 0 */
|
|
|
|
if (info->band == IEEE80211_BAND_5GHZ)
|
|
|
|
rate += IWL_FIRST_OFDM_RATE;
|
|
|
|
else if (rate >= IWL_FIRST_CCK_RATE && rate <= IWL_LAST_CCK_RATE)
|
2009-11-14 03:56:33 +08:00
|
|
|
rate_flags |= RATE_MCS_CCK_MSK;
|
2011-06-22 21:33:43 +08:00
|
|
|
|
|
|
|
tx_beacon_cmd->tx.rate_n_flags =
|
|
|
|
iwl_hw_set_rate_n_flags(rate, rate_flags);
|
2008-07-18 13:53:03 +08:00
|
|
|
|
2011-04-30 00:48:14 +08:00
|
|
|
/* Submit command */
|
2011-05-14 02:57:40 +08:00
|
|
|
cmd.len[0] = sizeof(*tx_beacon_cmd);
|
2011-05-04 22:50:38 +08:00
|
|
|
cmd.data[0] = tx_beacon_cmd;
|
2011-05-14 02:57:40 +08:00
|
|
|
cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
|
|
|
|
cmd.len[1] = frame_size;
|
|
|
|
cmd.data[1] = priv->beacon_skb->data;
|
|
|
|
cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
|
2009-01-20 07:30:26 +08:00
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
return trans_send_cmd(&priv->trans, &cmd);
|
2009-01-24 05:45:14 +08:00
|
|
|
}
|
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
static void iwl_bg_beacon_update(struct work_struct *work)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2008-03-13 07:58:50 +08:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, beacon_update);
|
2007-09-26 08:54:57 +08:00
|
|
|
struct sk_buff *beacon;
|
|
|
|
|
2010-08-23 16:46:47 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
if (!priv->beacon_ctx) {
|
|
|
|
IWL_ERR(priv, "updating beacon w/o beacon context!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-08-23 16:46:50 +08:00
|
|
|
if (priv->beacon_ctx->vif->type != NL80211_IFTYPE_AP) {
|
|
|
|
/*
|
|
|
|
* The ucode will send beacon notifications even in
|
|
|
|
* IBSS mode, but we don't want to process them. But
|
|
|
|
* we need to defer the type check to here due to
|
|
|
|
* requiring locking around the beacon_ctx access.
|
|
|
|
*/
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-08-23 16:46:47 +08:00
|
|
|
/* Pull updated AP beacon from mac80211. will fail if not in AP mode */
|
|
|
|
beacon = ieee80211_beacon_get(priv->hw, priv->beacon_ctx->vif);
|
2007-09-26 08:54:57 +08:00
|
|
|
if (!beacon) {
|
2010-10-04 20:50:36 +08:00
|
|
|
IWL_ERR(priv, "update beacon failed -- keeping old\n");
|
2010-08-23 16:46:47 +08:00
|
|
|
goto out;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* new beacon skb is allocated every time; dispose previous.*/
|
2010-10-04 20:50:36 +08:00
|
|
|
dev_kfree_skb(priv->beacon_skb);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-10-04 20:50:06 +08:00
|
|
|
priv->beacon_skb = beacon;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-10-24 00:15:41 +08:00
|
|
|
iwlagn_send_beacon_cmd(priv);
|
2010-08-23 16:46:47 +08:00
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2010-08-23 22:57:10 +08:00
|
|
|
static void iwl_bg_bt_runtime_config(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, bt_runtime_config);
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
|
2010-08-23 22:57:10 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* dont send host command if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return;
|
2011-06-29 02:46:28 +08:00
|
|
|
iwlagn_send_advance_bt_config(priv);
|
2010-08-23 22:57:10 +08:00
|
|
|
}
|
|
|
|
|
2010-08-23 22:57:04 +08:00
|
|
|
static void iwl_bg_bt_full_concurrency(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, bt_full_concurrency);
|
2010-08-23 16:46:32 +08:00
|
|
|
struct iwl_rxon_context *ctx;
|
2010-08-23 22:57:04 +08:00
|
|
|
|
2011-03-31 23:36:27 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
|
2011-03-31 23:36:27 +08:00
|
|
|
goto out;
|
2010-08-23 22:57:04 +08:00
|
|
|
|
|
|
|
/* dont send host command if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
2011-03-31 23:36:27 +08:00
|
|
|
goto out;
|
2010-08-23 22:57:04 +08:00
|
|
|
|
|
|
|
IWL_DEBUG_INFO(priv, "BT coex in %s mode\n",
|
|
|
|
priv->bt_full_concurrent ?
|
|
|
|
"full concurrency" : "3-wire");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* LQ & RXON updated cmds must be sent before BT Config cmd
|
|
|
|
* to avoid 3-wire collisions
|
|
|
|
*/
|
2010-08-23 16:46:32 +08:00
|
|
|
for_each_context(priv, ctx) {
|
2011-07-01 22:59:26 +08:00
|
|
|
iwlagn_set_rxon_chain(priv, ctx);
|
2011-06-03 22:54:16 +08:00
|
|
|
iwlagn_commit_rxon(priv, ctx);
|
2010-08-23 16:46:32 +08:00
|
|
|
}
|
2010-08-23 22:57:04 +08:00
|
|
|
|
2011-06-29 02:46:28 +08:00
|
|
|
iwlagn_send_advance_bt_config(priv);
|
2011-03-31 23:36:27 +08:00
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
2010-08-23 22:57:04 +08:00
|
|
|
}
|
|
|
|
|
2008-06-12 09:46:53 +08:00
|
|
|
/**
|
2008-10-30 05:05:46 +08:00
|
|
|
* iwl_bg_statistics_periodic - Timer callback to queue statistics
|
2008-06-12 09:46:53 +08:00
|
|
|
*
|
|
|
|
* This callback is provided in order to send a statistics request.
|
|
|
|
*
|
|
|
|
* This timer function is continually reset to execute within
|
|
|
|
* REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
|
|
|
|
* was received. We need to ensure we receive the statistics in order
|
|
|
|
* to update the temperature used for calibrating the TXPOWER.
|
|
|
|
*/
|
2008-10-30 05:05:46 +08:00
|
|
|
static void iwl_bg_statistics_periodic(unsigned long data)
|
2008-06-12 09:46:53 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)data;
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
|
2008-06-12 09:46:53 +08:00
|
|
|
return;
|
|
|
|
|
2008-10-30 05:05:49 +08:00
|
|
|
/* dont send host command if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return;
|
|
|
|
|
2009-11-14 03:56:28 +08:00
|
|
|
iwl_send_statistics_request(priv, CMD_ASYNC, false);
|
2008-06-12 09:46:53 +08:00
|
|
|
}
|
|
|
|
|
2009-12-11 06:37:26 +08:00
|
|
|
|
|
|
|
static void iwl_print_cont_event_trace(struct iwl_priv *priv, u32 base,
|
|
|
|
u32 start_idx, u32 num_events,
|
|
|
|
u32 mode)
|
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
u32 ptr; /* SRAM byte address of log data */
|
|
|
|
u32 ev, time, data; /* event log data */
|
|
|
|
unsigned long reg_flags;
|
|
|
|
|
|
|
|
if (mode == 0)
|
|
|
|
ptr = base + (4 * sizeof(u32)) + (start_idx * 2 * sizeof(u32));
|
|
|
|
else
|
|
|
|
ptr = base + (4 * sizeof(u32)) + (start_idx * 3 * sizeof(u32));
|
|
|
|
|
|
|
|
/* Make sure device is powered up for SRAM reads */
|
|
|
|
spin_lock_irqsave(&priv->reg_lock, reg_flags);
|
|
|
|
if (iwl_grab_nic_access(priv)) {
|
|
|
|
spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set starting address; reads will auto-increment */
|
2011-04-06 00:42:12 +08:00
|
|
|
iwl_write32(priv, HBUS_TARG_MEM_RADDR, ptr);
|
2009-12-11 06:37:26 +08:00
|
|
|
rmb();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "time" is actually "data" for mode 0 (no timestamp).
|
|
|
|
* place event id # at far right for easier visual parsing.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < num_events; i++) {
|
2011-04-06 00:42:12 +08:00
|
|
|
ev = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
|
|
|
|
time = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
|
2009-12-11 06:37:26 +08:00
|
|
|
if (mode == 0) {
|
|
|
|
trace_iwlwifi_dev_ucode_cont_event(priv,
|
|
|
|
0, time, ev);
|
|
|
|
} else {
|
2011-04-06 00:42:12 +08:00
|
|
|
data = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
|
2009-12-11 06:37:26 +08:00
|
|
|
trace_iwlwifi_dev_ucode_cont_event(priv,
|
|
|
|
time, data, ev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Allow device to power down */
|
|
|
|
iwl_release_nic_access(priv);
|
|
|
|
spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
|
|
|
|
}
|
|
|
|
|
2010-01-23 06:22:55 +08:00
|
|
|
static void iwl_continuous_event_trace(struct iwl_priv *priv)
|
2009-12-11 06:37:26 +08:00
|
|
|
{
|
|
|
|
u32 capacity; /* event log capacity in # entries */
|
|
|
|
u32 base; /* SRAM byte address of event log header */
|
|
|
|
u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
|
|
|
|
u32 num_wraps; /* # times uCode wrapped to top of log */
|
|
|
|
u32 next_entry; /* index of next entry to be written by uCode */
|
|
|
|
|
2011-04-06 00:42:04 +08:00
|
|
|
base = priv->device_pointers.error_event_table;
|
2011-07-08 06:24:07 +08:00
|
|
|
if (iwlagn_hw_valid_rtc_data_addr(base)) {
|
2009-12-11 06:37:26 +08:00
|
|
|
capacity = iwl_read_targ_mem(priv, base);
|
|
|
|
num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
|
|
|
|
mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
|
|
|
|
next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
|
|
|
|
} else
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (num_wraps == priv->event_log.num_wraps) {
|
|
|
|
iwl_print_cont_event_trace(priv,
|
|
|
|
base, priv->event_log.next_entry,
|
|
|
|
next_entry - priv->event_log.next_entry,
|
|
|
|
mode);
|
|
|
|
priv->event_log.non_wraps_count++;
|
|
|
|
} else {
|
|
|
|
if ((num_wraps - priv->event_log.num_wraps) > 1)
|
|
|
|
priv->event_log.wraps_more_count++;
|
|
|
|
else
|
|
|
|
priv->event_log.wraps_once_count++;
|
|
|
|
trace_iwlwifi_dev_ucode_wrap_event(priv,
|
|
|
|
num_wraps - priv->event_log.num_wraps,
|
|
|
|
next_entry, priv->event_log.next_entry);
|
|
|
|
if (next_entry < priv->event_log.next_entry) {
|
|
|
|
iwl_print_cont_event_trace(priv, base,
|
|
|
|
priv->event_log.next_entry,
|
|
|
|
capacity - priv->event_log.next_entry,
|
|
|
|
mode);
|
|
|
|
|
|
|
|
iwl_print_cont_event_trace(priv, base, 0,
|
|
|
|
next_entry, mode);
|
|
|
|
} else {
|
|
|
|
iwl_print_cont_event_trace(priv, base,
|
|
|
|
next_entry, capacity - next_entry,
|
|
|
|
mode);
|
|
|
|
|
|
|
|
iwl_print_cont_event_trace(priv, base, 0,
|
|
|
|
next_entry, mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
priv->event_log.num_wraps = num_wraps;
|
|
|
|
priv->event_log.next_entry = next_entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_bg_ucode_trace - Timer callback to log ucode event
|
|
|
|
*
|
|
|
|
* The timer is continually set to execute every
|
|
|
|
* UCODE_TRACE_PERIOD milliseconds after the last timer expired
|
|
|
|
* this function is to perform continuous uCode event logging operation
|
|
|
|
* if enabled
|
|
|
|
*/
|
|
|
|
static void iwl_bg_ucode_trace(unsigned long data)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)data;
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
|
2009-12-11 06:37:26 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (priv->event_log.ucode_trace) {
|
|
|
|
iwl_continuous_event_trace(priv);
|
|
|
|
/* Reschedule the timer to occur in UCODE_TRACE_PERIOD */
|
|
|
|
mod_timer(&priv->ucode_trace,
|
|
|
|
jiffies + msecs_to_jiffies(UCODE_TRACE_PERIOD));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-25 04:18:35 +08:00
|
|
|
static void iwl_bg_tx_flush(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, tx_flush);
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
|
2010-06-25 04:18:35 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* do nothing if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return;
|
|
|
|
|
2011-06-18 23:03:18 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "device request: flush all tx frames\n");
|
|
|
|
iwlagn_dev_txfifo_flush(priv, IWL_DROP_ALL);
|
2010-06-25 04:18:35 +08:00
|
|
|
}
|
|
|
|
|
2010-05-23 15:14:08 +08:00
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* sysfs attributes
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following adds a new attribute to the sysfs representation
|
|
|
|
* of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
|
|
|
|
* used for controlling the debug level.
|
|
|
|
*
|
|
|
|
* See the level definitions in iwl for details.
|
|
|
|
*
|
|
|
|
* The debug_level being managed using sysfs below is a per device debug
|
|
|
|
* level that is used instead of the global debug level if it (the per
|
|
|
|
* device debug level) is set.
|
|
|
|
*/
|
|
|
|
static ssize_t show_debug_level(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2011-08-26 14:10:37 +08:00
|
|
|
struct iwl_shared *shrd = dev_get_drvdata(d);
|
2011-08-26 14:10:38 +08:00
|
|
|
return sprintf(buf, "0x%08X\n", iwl_get_debug_level(shrd));
|
2010-05-23 15:14:08 +08:00
|
|
|
}
|
|
|
|
static ssize_t store_debug_level(struct device *d,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2011-08-26 14:10:37 +08:00
|
|
|
struct iwl_shared *shrd = dev_get_drvdata(d);
|
|
|
|
struct iwl_priv *priv = shrd->priv;
|
2010-05-23 15:14:08 +08:00
|
|
|
unsigned long val;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = strict_strtoul(buf, 0, &val);
|
|
|
|
if (ret)
|
|
|
|
IWL_ERR(priv, "%s is not in hex or decimal form.\n", buf);
|
|
|
|
else {
|
2011-08-26 14:10:38 +08:00
|
|
|
shrd->dbg_level_dev = val;
|
2010-05-23 15:14:08 +08:00
|
|
|
if (iwl_alloc_traffic_mem(priv))
|
2011-08-26 14:10:38 +08:00
|
|
|
IWL_ERR(shrd->priv,
|
2010-05-23 15:14:08 +08:00
|
|
|
"Not enough memory to generate traffic log\n");
|
|
|
|
}
|
|
|
|
return strnlen(buf, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
|
|
|
|
show_debug_level, store_debug_level);
|
|
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_IWLWIFI_DEBUG */
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t show_temperature(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2011-08-26 14:10:37 +08:00
|
|
|
struct iwl_shared *shrd = dev_get_drvdata(d);
|
|
|
|
struct iwl_priv *priv = shrd->priv;
|
2010-05-23 15:14:08 +08:00
|
|
|
|
|
|
|
if (!iwl_is_alive(priv))
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", priv->temperature);
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
|
|
|
|
|
|
|
|
static ssize_t show_tx_power(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = dev_get_drvdata(d);
|
|
|
|
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return sprintf(buf, "off\n");
|
|
|
|
else
|
|
|
|
return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t store_tx_power(struct device *d,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = dev_get_drvdata(d);
|
|
|
|
unsigned long val;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = strict_strtoul(buf, 10, &val);
|
|
|
|
if (ret)
|
|
|
|
IWL_INFO(priv, "%s is not in decimal form.\n", buf);
|
|
|
|
else {
|
|
|
|
ret = iwl_set_tx_power(priv, val, false);
|
|
|
|
if (ret)
|
|
|
|
IWL_ERR(priv, "failed setting tx power (0x%d).\n",
|
|
|
|
ret);
|
|
|
|
else
|
|
|
|
ret = count;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);
|
|
|
|
|
|
|
|
static struct attribute *iwl_sysfs_entries[] = {
|
|
|
|
&dev_attr_temperature.attr,
|
|
|
|
&dev_attr_tx_power.attr,
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
|
|
|
&dev_attr_debug_level.attr,
|
|
|
|
#endif
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group iwl_attribute_group = {
|
|
|
|
.name = NULL, /* put in device directory */
|
|
|
|
.attrs = iwl_sysfs_entries,
|
|
|
|
};
|
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* uCode download functions
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2011-05-31 13:52:10 +08:00
|
|
|
static void iwl_free_fw_desc(struct iwl_priv *priv, struct fw_desc *desc)
|
2011-04-16 23:29:24 +08:00
|
|
|
{
|
|
|
|
if (desc->v_addr)
|
2011-07-11 15:48:51 +08:00
|
|
|
dma_free_coherent(priv->bus->dev, desc->len,
|
2011-04-16 23:29:24 +08:00
|
|
|
desc->v_addr, desc->p_addr);
|
|
|
|
desc->v_addr = NULL;
|
|
|
|
desc->len = 0;
|
|
|
|
}
|
|
|
|
|
2011-05-31 13:52:10 +08:00
|
|
|
static void iwl_free_fw_img(struct iwl_priv *priv, struct fw_img *img)
|
2011-04-16 23:29:24 +08:00
|
|
|
{
|
2011-05-31 13:52:10 +08:00
|
|
|
iwl_free_fw_desc(priv, &img->code);
|
|
|
|
iwl_free_fw_desc(priv, &img->data);
|
2011-04-16 23:29:24 +08:00
|
|
|
}
|
|
|
|
|
2011-05-31 13:52:10 +08:00
|
|
|
static void iwl_dealloc_ucode(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
iwl_free_fw_img(priv, &priv->ucode_rt);
|
|
|
|
iwl_free_fw_img(priv, &priv->ucode_init);
|
2011-07-16 04:23:45 +08:00
|
|
|
iwl_free_fw_img(priv, &priv->ucode_wowlan);
|
2011-05-31 13:52:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int iwl_alloc_fw_desc(struct iwl_priv *priv, struct fw_desc *desc,
|
2011-04-16 23:29:24 +08:00
|
|
|
const void *data, size_t len)
|
|
|
|
{
|
|
|
|
if (!len) {
|
|
|
|
desc->v_addr = NULL;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-07-11 15:48:51 +08:00
|
|
|
desc->v_addr = dma_alloc_coherent(priv->bus->dev, len,
|
2011-04-16 23:29:24 +08:00
|
|
|
&desc->p_addr, GFP_KERNEL);
|
|
|
|
if (!desc->v_addr)
|
|
|
|
return -ENOMEM;
|
2011-05-31 13:52:10 +08:00
|
|
|
|
2011-04-16 23:29:24 +08:00
|
|
|
desc->len = len;
|
|
|
|
memcpy(desc->v_addr, data, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-24 01:24:46 +08:00
|
|
|
static void iwl_init_context(struct iwl_priv *priv, u32 ucode_flags)
|
|
|
|
{
|
|
|
|
static const u8 iwlagn_bss_ac_to_fifo[] = {
|
|
|
|
IWL_TX_FIFO_VO,
|
|
|
|
IWL_TX_FIFO_VI,
|
|
|
|
IWL_TX_FIFO_BE,
|
|
|
|
IWL_TX_FIFO_BK,
|
|
|
|
};
|
|
|
|
static const u8 iwlagn_bss_ac_to_queue[] = {
|
|
|
|
0, 1, 2, 3,
|
|
|
|
};
|
|
|
|
static const u8 iwlagn_pan_ac_to_fifo[] = {
|
|
|
|
IWL_TX_FIFO_VO_IPAN,
|
|
|
|
IWL_TX_FIFO_VI_IPAN,
|
|
|
|
IWL_TX_FIFO_BE_IPAN,
|
|
|
|
IWL_TX_FIFO_BK_IPAN,
|
|
|
|
};
|
|
|
|
static const u8 iwlagn_pan_ac_to_queue[] = {
|
|
|
|
7, 6, 5, 4,
|
|
|
|
};
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The default context is always valid,
|
|
|
|
* the PAN context depends on uCode.
|
|
|
|
*/
|
|
|
|
priv->valid_contexts = BIT(IWL_RXON_CTX_BSS);
|
|
|
|
if (ucode_flags & IWL_UCODE_TLV_FLAGS_PAN)
|
|
|
|
priv->valid_contexts |= BIT(IWL_RXON_CTX_PAN);
|
|
|
|
|
|
|
|
for (i = 0; i < NUM_IWL_RXON_CTX; i++)
|
|
|
|
priv->contexts[i].ctxid = i;
|
|
|
|
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].always_active = true;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].is_active = true;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].rxon_cmd = REPLY_RXON;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].rxon_timing_cmd = REPLY_RXON_TIMING;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].rxon_assoc_cmd = REPLY_RXON_ASSOC;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].qos_cmd = REPLY_QOS_PARAM;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].ap_sta_id = IWL_AP_ID;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].wep_key_cmd = REPLY_WEPKEY;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].ac_to_fifo = iwlagn_bss_ac_to_fifo;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].ac_to_queue = iwlagn_bss_ac_to_queue;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].exclusive_interface_modes =
|
|
|
|
BIT(NL80211_IFTYPE_ADHOC);
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].interface_modes =
|
|
|
|
BIT(NL80211_IFTYPE_STATION);
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].ap_devtype = RXON_DEV_TYPE_AP;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].ibss_devtype = RXON_DEV_TYPE_IBSS;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].station_devtype = RXON_DEV_TYPE_ESS;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].unused_devtype = RXON_DEV_TYPE_ESS;
|
|
|
|
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].rxon_cmd = REPLY_WIPAN_RXON;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].rxon_timing_cmd =
|
|
|
|
REPLY_WIPAN_RXON_TIMING;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].rxon_assoc_cmd =
|
|
|
|
REPLY_WIPAN_RXON_ASSOC;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].qos_cmd = REPLY_WIPAN_QOS_PARAM;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].ap_sta_id = IWL_AP_ID_PAN;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].wep_key_cmd = REPLY_WIPAN_WEPKEY;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].bcast_sta_id = IWLAGN_PAN_BCAST_ID;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].station_flags = STA_FLG_PAN_STATION;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].ac_to_fifo = iwlagn_pan_ac_to_fifo;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].ac_to_queue = iwlagn_pan_ac_to_queue;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].mcast_queue = IWL_IPAN_MCAST_QUEUE;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].interface_modes =
|
|
|
|
BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP);
|
2011-07-24 01:24:47 +08:00
|
|
|
|
|
|
|
if (ucode_flags & IWL_UCODE_TLV_FLAGS_P2P)
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].interface_modes |=
|
|
|
|
BIT(NL80211_IFTYPE_P2P_CLIENT) |
|
|
|
|
BIT(NL80211_IFTYPE_P2P_GO);
|
|
|
|
|
2011-07-24 01:24:46 +08:00
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].ap_devtype = RXON_DEV_TYPE_CP;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].station_devtype = RXON_DEV_TYPE_2STA;
|
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].unused_devtype = RXON_DEV_TYPE_P2P;
|
|
|
|
|
|
|
|
BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-29 14:33:10 +08:00
|
|
|
struct iwlagn_ucode_capabilities {
|
|
|
|
u32 max_probe_length;
|
2010-07-14 08:13:15 +08:00
|
|
|
u32 standard_phy_calibration_size;
|
2011-04-06 00:42:02 +08:00
|
|
|
u32 flags;
|
2010-04-29 14:33:10 +08:00
|
|
|
};
|
2008-05-15 13:53:55 +08:00
|
|
|
|
2010-01-30 03:54:56 +08:00
|
|
|
static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
|
2010-04-29 14:33:10 +08:00
|
|
|
static int iwl_mac_setup_register(struct iwl_priv *priv,
|
|
|
|
struct iwlagn_ucode_capabilities *capa);
|
2010-01-30 03:54:56 +08:00
|
|
|
|
2010-08-13 01:24:07 +08:00
|
|
|
#define UCODE_EXPERIMENTAL_INDEX 100
|
|
|
|
#define UCODE_EXPERIMENTAL_TAG "exp"
|
|
|
|
|
2010-01-30 03:54:56 +08:00
|
|
|
static int __must_check iwl_request_firmware(struct iwl_priv *priv, bool first)
|
|
|
|
{
|
|
|
|
const char *name_pre = priv->cfg->fw_name_pre;
|
2010-08-13 01:24:07 +08:00
|
|
|
char tag[8];
|
2010-01-30 03:54:56 +08:00
|
|
|
|
2010-08-13 01:24:07 +08:00
|
|
|
if (first) {
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
|
|
|
|
priv->fw_index = UCODE_EXPERIMENTAL_INDEX;
|
|
|
|
strcpy(tag, UCODE_EXPERIMENTAL_TAG);
|
|
|
|
} else if (priv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
|
|
|
|
#endif
|
2010-01-30 03:54:56 +08:00
|
|
|
priv->fw_index = priv->cfg->ucode_api_max;
|
2010-08-13 01:24:07 +08:00
|
|
|
sprintf(tag, "%d", priv->fw_index);
|
|
|
|
} else {
|
2010-01-30 03:54:56 +08:00
|
|
|
priv->fw_index--;
|
2010-08-13 01:24:07 +08:00
|
|
|
sprintf(tag, "%d", priv->fw_index);
|
|
|
|
}
|
2010-01-30 03:54:56 +08:00
|
|
|
|
|
|
|
if (priv->fw_index < priv->cfg->ucode_api_min) {
|
|
|
|
IWL_ERR(priv, "no suitable firmware found!\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2010-08-13 01:24:07 +08:00
|
|
|
sprintf(priv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
|
2010-01-30 03:54:56 +08:00
|
|
|
|
2010-08-13 01:24:07 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "attempting to load firmware %s'%s'\n",
|
|
|
|
(priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
|
|
|
|
? "EXPERIMENTAL " : "",
|
2010-01-30 03:54:56 +08:00
|
|
|
priv->firmware_name);
|
|
|
|
|
|
|
|
return request_firmware_nowait(THIS_MODULE, 1, priv->firmware_name,
|
2011-07-11 15:48:51 +08:00
|
|
|
priv->bus->dev,
|
2011-05-31 13:52:10 +08:00
|
|
|
GFP_KERNEL, priv, iwl_ucode_callback);
|
2010-01-30 03:54:56 +08:00
|
|
|
}
|
|
|
|
|
2010-04-29 03:09:16 +08:00
|
|
|
struct iwlagn_firmware_pieces {
|
2011-07-16 04:23:45 +08:00
|
|
|
const void *inst, *data, *init, *init_data, *wowlan_inst, *wowlan_data;
|
|
|
|
size_t inst_size, data_size, init_size, init_data_size,
|
|
|
|
wowlan_inst_size, wowlan_data_size;
|
2010-04-29 03:09:16 +08:00
|
|
|
|
|
|
|
u32 build;
|
2010-05-06 14:24:54 +08:00
|
|
|
|
|
|
|
u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
|
|
|
|
u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
|
2010-04-29 03:09:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static int iwlagn_load_legacy_firmware(struct iwl_priv *priv,
|
|
|
|
const struct firmware *ucode_raw,
|
|
|
|
struct iwlagn_firmware_pieces *pieces)
|
|
|
|
{
|
|
|
|
struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
|
|
|
|
u32 api_ver, hdr_size;
|
|
|
|
const u8 *src;
|
|
|
|
|
|
|
|
priv->ucode_ver = le32_to_cpu(ucode->ver);
|
|
|
|
api_ver = IWL_UCODE_API(priv->ucode_ver);
|
|
|
|
|
|
|
|
switch (api_ver) {
|
|
|
|
default:
|
2011-03-22 23:05:37 +08:00
|
|
|
hdr_size = 28;
|
|
|
|
if (ucode_raw->size < hdr_size) {
|
|
|
|
IWL_ERR(priv, "File size too small!\n");
|
|
|
|
return -EINVAL;
|
2010-04-29 03:09:16 +08:00
|
|
|
}
|
2011-03-22 23:05:37 +08:00
|
|
|
pieces->build = le32_to_cpu(ucode->u.v2.build);
|
|
|
|
pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size);
|
|
|
|
pieces->data_size = le32_to_cpu(ucode->u.v2.data_size);
|
|
|
|
pieces->init_size = le32_to_cpu(ucode->u.v2.init_size);
|
|
|
|
pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size);
|
|
|
|
src = ucode->u.v2.data;
|
|
|
|
break;
|
2010-04-29 03:09:16 +08:00
|
|
|
case 0:
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
hdr_size = 24;
|
|
|
|
if (ucode_raw->size < hdr_size) {
|
|
|
|
IWL_ERR(priv, "File size too small!\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
pieces->build = 0;
|
|
|
|
pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size);
|
|
|
|
pieces->data_size = le32_to_cpu(ucode->u.v1.data_size);
|
|
|
|
pieces->init_size = le32_to_cpu(ucode->u.v1.init_size);
|
|
|
|
pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size);
|
|
|
|
src = ucode->u.v1.data;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify size of file vs. image size info in file's header */
|
|
|
|
if (ucode_raw->size != hdr_size + pieces->inst_size +
|
|
|
|
pieces->data_size + pieces->init_size +
|
2011-04-06 00:41:57 +08:00
|
|
|
pieces->init_data_size) {
|
2010-04-29 03:09:16 +08:00
|
|
|
|
|
|
|
IWL_ERR(priv,
|
|
|
|
"uCode file size %d does not match expected size\n",
|
|
|
|
(int)ucode_raw->size);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
pieces->inst = src;
|
|
|
|
src += pieces->inst_size;
|
|
|
|
pieces->data = src;
|
|
|
|
src += pieces->data_size;
|
|
|
|
pieces->init = src;
|
|
|
|
src += pieces->init_size;
|
|
|
|
pieces->init_data = src;
|
|
|
|
src += pieces->init_data_size;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-29 14:33:10 +08:00
|
|
|
static int iwlagn_load_firmware(struct iwl_priv *priv,
|
|
|
|
const struct firmware *ucode_raw,
|
|
|
|
struct iwlagn_firmware_pieces *pieces,
|
|
|
|
struct iwlagn_ucode_capabilities *capa)
|
|
|
|
{
|
|
|
|
struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
|
|
|
|
struct iwl_ucode_tlv *tlv;
|
|
|
|
size_t len = ucode_raw->size;
|
|
|
|
const u8 *data;
|
2011-08-26 14:10:36 +08:00
|
|
|
int wanted_alternative = iwlagn_mod_params.wanted_ucode_alternative;
|
|
|
|
int tmp;
|
2010-04-29 14:33:10 +08:00
|
|
|
u64 alternatives;
|
2010-06-23 05:31:45 +08:00
|
|
|
u32 tlv_len;
|
|
|
|
enum iwl_ucode_tlv_type tlv_type;
|
|
|
|
const u8 *tlv_data;
|
2010-04-29 14:33:10 +08:00
|
|
|
|
2010-06-23 05:31:45 +08:00
|
|
|
if (len < sizeof(*ucode)) {
|
|
|
|
IWL_ERR(priv, "uCode has invalid length: %zd\n", len);
|
2010-04-29 14:33:10 +08:00
|
|
|
return -EINVAL;
|
2010-06-23 05:31:45 +08:00
|
|
|
}
|
2010-04-29 14:33:10 +08:00
|
|
|
|
2010-06-23 05:31:45 +08:00
|
|
|
if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
|
|
|
|
IWL_ERR(priv, "invalid uCode magic: 0X%x\n",
|
|
|
|
le32_to_cpu(ucode->magic));
|
2010-04-29 14:33:10 +08:00
|
|
|
return -EINVAL;
|
2010-06-23 05:31:45 +08:00
|
|
|
}
|
2010-04-29 14:33:10 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check which alternatives are present, and "downgrade"
|
|
|
|
* when the chosen alternative is not present, warning
|
|
|
|
* the user when that happens. Some files may not have
|
|
|
|
* any alternatives, so don't warn in that case.
|
|
|
|
*/
|
|
|
|
alternatives = le64_to_cpu(ucode->alternatives);
|
|
|
|
tmp = wanted_alternative;
|
|
|
|
if (wanted_alternative > 63)
|
|
|
|
wanted_alternative = 63;
|
|
|
|
while (wanted_alternative && !(alternatives & BIT(wanted_alternative)))
|
|
|
|
wanted_alternative--;
|
|
|
|
if (wanted_alternative && wanted_alternative != tmp)
|
|
|
|
IWL_WARN(priv,
|
|
|
|
"uCode alternative %d not available, choosing %d\n",
|
|
|
|
tmp, wanted_alternative);
|
|
|
|
|
|
|
|
priv->ucode_ver = le32_to_cpu(ucode->ver);
|
|
|
|
pieces->build = le32_to_cpu(ucode->build);
|
|
|
|
data = ucode->data;
|
|
|
|
|
|
|
|
len -= sizeof(*ucode);
|
|
|
|
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
while (len >= sizeof(*tlv)) {
|
2010-04-29 14:33:10 +08:00
|
|
|
u16 tlv_alt;
|
|
|
|
|
|
|
|
len -= sizeof(*tlv);
|
|
|
|
tlv = (void *)data;
|
|
|
|
|
|
|
|
tlv_len = le32_to_cpu(tlv->length);
|
|
|
|
tlv_type = le16_to_cpu(tlv->type);
|
|
|
|
tlv_alt = le16_to_cpu(tlv->alternative);
|
|
|
|
tlv_data = tlv->data;
|
|
|
|
|
2010-06-23 05:31:45 +08:00
|
|
|
if (len < tlv_len) {
|
|
|
|
IWL_ERR(priv, "invalid TLV len: %zd/%u\n",
|
|
|
|
len, tlv_len);
|
2010-04-29 14:33:10 +08:00
|
|
|
return -EINVAL;
|
2010-06-23 05:31:45 +08:00
|
|
|
}
|
2010-04-29 14:33:10 +08:00
|
|
|
len -= ALIGN(tlv_len, 4);
|
|
|
|
data += sizeof(*tlv) + ALIGN(tlv_len, 4);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Alternative 0 is always valid.
|
|
|
|
*
|
|
|
|
* Skip alternative TLVs that are not selected.
|
|
|
|
*/
|
|
|
|
if (tlv_alt != 0 && tlv_alt != wanted_alternative)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (tlv_type) {
|
|
|
|
case IWL_UCODE_TLV_INST:
|
|
|
|
pieces->inst = tlv_data;
|
|
|
|
pieces->inst_size = tlv_len;
|
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_DATA:
|
|
|
|
pieces->data = tlv_data;
|
|
|
|
pieces->data_size = tlv_len;
|
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_INIT:
|
|
|
|
pieces->init = tlv_data;
|
|
|
|
pieces->init_size = tlv_len;
|
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_INIT_DATA:
|
|
|
|
pieces->init_data = tlv_data;
|
|
|
|
pieces->init_data_size = tlv_len;
|
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_BOOT:
|
2011-04-06 00:41:57 +08:00
|
|
|
IWL_ERR(priv, "Found unexpected BOOT ucode\n");
|
2010-04-29 14:33:10 +08:00
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_PROBE_MAX_LEN:
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
capa->max_probe_length =
|
2010-06-23 05:31:45 +08:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-04-29 14:33:10 +08:00
|
|
|
break;
|
2010-08-23 16:46:49 +08:00
|
|
|
case IWL_UCODE_TLV_PAN:
|
|
|
|
if (tlv_len)
|
|
|
|
goto invalid_tlv_len;
|
2011-04-06 00:42:02 +08:00
|
|
|
capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
|
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_FLAGS:
|
|
|
|
/* must be at least one u32 */
|
|
|
|
if (tlv_len < sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
/* and a proper number of u32s */
|
|
|
|
if (tlv_len % sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
/*
|
|
|
|
* This driver only reads the first u32 as
|
|
|
|
* right now no more features are defined,
|
|
|
|
* if that changes then either the driver
|
|
|
|
* will not work with the new firmware, or
|
|
|
|
* it'll not take advantage of new features.
|
|
|
|
*/
|
|
|
|
capa->flags = le32_to_cpup((__le32 *)tlv_data);
|
2010-08-23 16:46:49 +08:00
|
|
|
break;
|
2010-05-06 14:24:54 +08:00
|
|
|
case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->init_evtlog_ptr =
|
2010-06-23 05:31:45 +08:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 14:24:54 +08:00
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->init_evtlog_size =
|
2010-06-23 05:31:45 +08:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 14:24:54 +08:00
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->init_errlog_ptr =
|
2010-06-23 05:31:45 +08:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 14:24:54 +08:00
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->inst_evtlog_ptr =
|
2010-06-23 05:31:45 +08:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 14:24:54 +08:00
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->inst_evtlog_size =
|
2010-06-23 05:31:45 +08:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 14:24:54 +08:00
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->inst_errlog_ptr =
|
2010-06-23 05:31:45 +08:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 14:24:54 +08:00
|
|
|
break;
|
2010-06-29 04:05:17 +08:00
|
|
|
case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
|
|
|
|
if (tlv_len)
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
goto invalid_tlv_len;
|
|
|
|
priv->enhance_sensitivity_table = true;
|
2010-06-29 04:05:17 +08:00
|
|
|
break;
|
2011-07-16 04:23:45 +08:00
|
|
|
case IWL_UCODE_TLV_WOWLAN_INST:
|
|
|
|
pieces->wowlan_inst = tlv_data;
|
|
|
|
pieces->wowlan_inst_size = tlv_len;
|
|
|
|
break;
|
|
|
|
case IWL_UCODE_TLV_WOWLAN_DATA:
|
|
|
|
pieces->wowlan_data = tlv_data;
|
|
|
|
pieces->wowlan_data_size = tlv_len;
|
|
|
|
break;
|
2010-07-14 08:13:15 +08:00
|
|
|
case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
capa->standard_phy_calibration_size =
|
2010-07-14 08:13:15 +08:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
|
|
|
break;
|
2010-04-29 14:33:10 +08:00
|
|
|
default:
|
2011-04-04 21:16:29 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "unknown TLV: %d\n", tlv_type);
|
2010-04-29 14:33:10 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-23 05:31:45 +08:00
|
|
|
if (len) {
|
|
|
|
IWL_ERR(priv, "invalid TLV after parsing: %zd\n", len);
|
|
|
|
iwl_print_hex_dump(priv, IWL_DL_FW, (u8 *)data, len);
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
return -EINVAL;
|
2010-06-23 05:31:45 +08:00
|
|
|
}
|
2010-04-29 14:33:10 +08:00
|
|
|
|
iwlagn: fix firmware loading TLV error path
gcc complains about the firmware loading:
iwl-agn.c: In function ‘iwlagn_load_firmware’:
iwl-agn.c:1860: warning: ‘tlv_len’ may be used uninitialized in this function
iwl-agn.c:1861: warning: ‘tlv_type’ may be used uninitialized in this function
iwl-agn.c:1862: warning: ‘tlv_data’ may be used uninitialized in this function
This is almost correct but we do do break out of the TLV
parsing loop when setting ret. However, the code is hard
to follow, and clearly even the compiler is having issues
with it too.
Additionally, however, the current code is wrong. If there
is a TLV length check error, the code will report
invalid TLV after parsing: ...
because "len" will still be non-zero as we broke out of
the loop.
So to remove the warning and fix that issue, make the code
easier to read by doing length checking with an error label.
As a result, we can completely remove the "ret" variable.
Also, while at it, remove the "fixed_tlv_size" variable
since each TLV type has its own specified length, it just
happens that we have only variable length, flags (0 length)
and u32 TLVs right now. It should still be checked with more
explicit length checks to make it easier to understand.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2010-07-15 00:34:50 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
invalid_tlv_len:
|
|
|
|
IWL_ERR(priv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
|
|
|
|
iwl_print_hex_dump(priv, IWL_DL_FW, tlv_data, tlv_len);
|
|
|
|
|
|
|
|
return -EINVAL;
|
2010-04-29 14:33:10 +08:00
|
|
|
}
|
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/**
|
2010-01-30 03:54:56 +08:00
|
|
|
* iwl_ucode_callback - callback when firmware was loaded
|
2007-09-26 08:54:57 +08:00
|
|
|
*
|
2010-01-30 03:54:56 +08:00
|
|
|
* If loaded successfully, copies the firmware into buffers
|
|
|
|
* for the card to fetch (via DMA).
|
2007-09-26 08:54:57 +08:00
|
|
|
*/
|
2010-01-30 03:54:56 +08:00
|
|
|
static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2010-01-30 03:54:56 +08:00
|
|
|
struct iwl_priv *priv = context;
|
2009-07-18 00:30:16 +08:00
|
|
|
struct iwl_ucode_header *ucode;
|
2010-04-29 03:09:16 +08:00
|
|
|
int err;
|
|
|
|
struct iwlagn_firmware_pieces pieces;
|
2008-12-03 04:14:06 +08:00
|
|
|
const unsigned int api_max = priv->cfg->ucode_api_max;
|
2011-07-24 01:24:44 +08:00
|
|
|
unsigned int api_ok = priv->cfg->ucode_api_ok;
|
2008-12-03 04:14:06 +08:00
|
|
|
const unsigned int api_min = priv->cfg->ucode_api_min;
|
2010-04-29 03:09:16 +08:00
|
|
|
u32 api_ver;
|
2010-04-29 03:09:12 +08:00
|
|
|
char buildstr[25];
|
2010-04-29 03:09:16 +08:00
|
|
|
u32 build;
|
2010-04-29 14:33:10 +08:00
|
|
|
struct iwlagn_ucode_capabilities ucode_capa = {
|
|
|
|
.max_probe_length = 200,
|
2010-07-14 08:13:15 +08:00
|
|
|
.standard_phy_calibration_size =
|
2010-09-22 03:06:18 +08:00
|
|
|
IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE,
|
2010-04-29 14:33:10 +08:00
|
|
|
};
|
2010-04-29 03:09:16 +08:00
|
|
|
|
2011-07-24 01:24:44 +08:00
|
|
|
if (!api_ok)
|
|
|
|
api_ok = api_max;
|
|
|
|
|
2010-04-29 03:09:16 +08:00
|
|
|
memset(&pieces, 0, sizeof(pieces));
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-01-30 03:54:56 +08:00
|
|
|
if (!ucode_raw) {
|
2011-07-24 01:24:44 +08:00
|
|
|
if (priv->fw_index <= api_ok)
|
2010-08-13 01:24:07 +08:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"request for firmware file '%s' failed.\n",
|
|
|
|
priv->firmware_name);
|
2010-01-30 03:54:56 +08:00
|
|
|
goto try_again;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2010-01-30 03:54:56 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "Loaded firmware file '%s' (%zd bytes).\n",
|
|
|
|
priv->firmware_name, ucode_raw->size);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-04-29 03:09:14 +08:00
|
|
|
/* Make sure that we got at least the API version number */
|
|
|
|
if (ucode_raw->size < 4) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "File size way too small!\n");
|
2010-01-30 03:54:56 +08:00
|
|
|
goto try_again;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Data from ucode file: header followed by uCode images */
|
2009-07-18 00:30:16 +08:00
|
|
|
ucode = (struct iwl_ucode_header *)ucode_raw->data;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-04-29 03:09:16 +08:00
|
|
|
if (ucode->ver)
|
|
|
|
err = iwlagn_load_legacy_firmware(priv, ucode_raw, &pieces);
|
|
|
|
else
|
2010-04-29 14:33:10 +08:00
|
|
|
err = iwlagn_load_firmware(priv, ucode_raw, &pieces,
|
|
|
|
&ucode_capa);
|
2010-04-29 03:09:14 +08:00
|
|
|
|
2010-04-29 03:09:16 +08:00
|
|
|
if (err)
|
|
|
|
goto try_again;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-12-03 04:14:06 +08:00
|
|
|
api_ver = IWL_UCODE_API(priv->ucode_ver);
|
2010-04-29 03:09:16 +08:00
|
|
|
build = pieces.build;
|
2008-12-03 04:14:06 +08:00
|
|
|
|
2010-04-29 03:09:16 +08:00
|
|
|
/*
|
|
|
|
* api_ver should match the api version forming part of the
|
|
|
|
* firmware filename ... but we don't check for that and only rely
|
|
|
|
* on the API version read from firmware header from here on forward
|
|
|
|
*/
|
2010-09-22 07:15:58 +08:00
|
|
|
/* no api version check required for experimental uCode */
|
|
|
|
if (priv->fw_index != UCODE_EXPERIMENTAL_INDEX) {
|
|
|
|
if (api_ver < api_min || api_ver > api_max) {
|
|
|
|
IWL_ERR(priv,
|
|
|
|
"Driver unable to support your firmware API. "
|
|
|
|
"Driver supports v%u, firmware is v%u.\n",
|
|
|
|
api_max, api_ver);
|
|
|
|
goto try_again;
|
|
|
|
}
|
2010-01-30 03:54:56 +08:00
|
|
|
|
2011-07-24 01:24:44 +08:00
|
|
|
if (api_ver < api_ok) {
|
|
|
|
if (api_ok != api_max)
|
|
|
|
IWL_ERR(priv, "Firmware has old API version, "
|
|
|
|
"expected v%u through v%u, got v%u.\n",
|
|
|
|
api_ok, api_max, api_ver);
|
|
|
|
else
|
|
|
|
IWL_ERR(priv, "Firmware has old API version, "
|
|
|
|
"expected v%u, got v%u.\n",
|
|
|
|
api_max, api_ver);
|
|
|
|
IWL_ERR(priv, "New firmware can be obtained from "
|
|
|
|
"http://www.intellinuxwireless.org/.\n");
|
|
|
|
}
|
2010-09-22 07:15:58 +08:00
|
|
|
}
|
2008-12-03 04:14:06 +08:00
|
|
|
|
2010-04-29 03:09:12 +08:00
|
|
|
if (build)
|
2010-08-13 01:24:07 +08:00
|
|
|
sprintf(buildstr, " build %u%s", build,
|
|
|
|
(priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
|
|
|
|
? " (EXP)" : "");
|
2010-04-29 03:09:12 +08:00
|
|
|
else
|
|
|
|
buildstr[0] = '\0';
|
|
|
|
|
|
|
|
IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u%s\n",
|
|
|
|
IWL_UCODE_MAJOR(priv->ucode_ver),
|
|
|
|
IWL_UCODE_MINOR(priv->ucode_ver),
|
|
|
|
IWL_UCODE_API(priv->ucode_ver),
|
|
|
|
IWL_UCODE_SERIAL(priv->ucode_ver),
|
|
|
|
buildstr);
|
2008-12-03 04:14:06 +08:00
|
|
|
|
2009-10-31 05:36:04 +08:00
|
|
|
snprintf(priv->hw->wiphy->fw_version,
|
|
|
|
sizeof(priv->hw->wiphy->fw_version),
|
2010-04-29 03:09:12 +08:00
|
|
|
"%u.%u.%u.%u%s",
|
2009-10-31 05:36:04 +08:00
|
|
|
IWL_UCODE_MAJOR(priv->ucode_ver),
|
|
|
|
IWL_UCODE_MINOR(priv->ucode_ver),
|
|
|
|
IWL_UCODE_API(priv->ucode_ver),
|
2010-04-29 03:09:12 +08:00
|
|
|
IWL_UCODE_SERIAL(priv->ucode_ver),
|
|
|
|
buildstr);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-01-30 03:54:56 +08:00
|
|
|
/*
|
|
|
|
* For any of the failures below (before allocating pci memory)
|
|
|
|
* we will try to load a version with a smaller API -- maybe the
|
|
|
|
* user just got a corrupted version of the latest API.
|
|
|
|
*/
|
|
|
|
|
2010-04-29 03:09:16 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
|
|
|
|
priv->ucode_ver);
|
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %Zd\n",
|
|
|
|
pieces.inst_size);
|
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %Zd\n",
|
|
|
|
pieces.data_size);
|
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %Zd\n",
|
|
|
|
pieces.init_size);
|
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %Zd\n",
|
|
|
|
pieces.init_data_size);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
|
|
|
/* Verify that uCode images will fit in card's SRAM */
|
2011-08-26 14:10:39 +08:00
|
|
|
if (pieces.inst_size > hw_params(priv).max_inst_size) {
|
2010-04-29 03:09:16 +08:00
|
|
|
IWL_ERR(priv, "uCode instr len %Zd too large to fit in\n",
|
|
|
|
pieces.inst_size);
|
2010-01-30 03:54:56 +08:00
|
|
|
goto try_again;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2011-08-26 14:10:39 +08:00
|
|
|
if (pieces.data_size > hw_params(priv).max_data_size) {
|
2010-04-29 03:09:16 +08:00
|
|
|
IWL_ERR(priv, "uCode data len %Zd too large to fit in\n",
|
|
|
|
pieces.data_size);
|
2010-01-30 03:54:56 +08:00
|
|
|
goto try_again;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
2010-04-29 03:09:16 +08:00
|
|
|
|
2011-08-26 14:10:39 +08:00
|
|
|
if (pieces.init_size > hw_params(priv).max_inst_size) {
|
2010-04-29 03:09:16 +08:00
|
|
|
IWL_ERR(priv, "uCode init instr len %Zd too large to fit in\n",
|
|
|
|
pieces.init_size);
|
2010-01-30 03:54:56 +08:00
|
|
|
goto try_again;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
2010-04-29 03:09:16 +08:00
|
|
|
|
2011-08-26 14:10:39 +08:00
|
|
|
if (pieces.init_data_size > hw_params(priv).max_data_size) {
|
2010-04-29 03:09:16 +08:00
|
|
|
IWL_ERR(priv, "uCode init data len %Zd too large to fit in\n",
|
|
|
|
pieces.init_data_size);
|
2010-01-30 03:54:56 +08:00
|
|
|
goto try_again;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
2010-04-29 03:09:16 +08:00
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/* Allocate ucode buffers for card's bus-master loading ... */
|
|
|
|
|
|
|
|
/* Runtime instructions and 2 copies of data:
|
|
|
|
* 1) unmodified from disk
|
|
|
|
* 2) backup cache for save/restore during power-downs */
|
2011-05-31 13:52:10 +08:00
|
|
|
if (iwl_alloc_fw_desc(priv, &priv->ucode_rt.code,
|
2011-04-16 23:29:24 +08:00
|
|
|
pieces.inst, pieces.inst_size))
|
|
|
|
goto err_pci_alloc;
|
2011-05-31 13:52:10 +08:00
|
|
|
if (iwl_alloc_fw_desc(priv, &priv->ucode_rt.data,
|
2011-04-16 23:29:24 +08:00
|
|
|
pieces.data, pieces.data_size))
|
2009-01-24 05:45:22 +08:00
|
|
|
goto err_pci_alloc;
|
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/* Initialization instructions and data */
|
2010-04-29 03:09:16 +08:00
|
|
|
if (pieces.init_size && pieces.init_data_size) {
|
2011-05-31 13:52:10 +08:00
|
|
|
if (iwl_alloc_fw_desc(priv, &priv->ucode_init.code,
|
2011-04-16 23:29:24 +08:00
|
|
|
pieces.init, pieces.init_size))
|
|
|
|
goto err_pci_alloc;
|
2011-05-31 13:52:10 +08:00
|
|
|
if (iwl_alloc_fw_desc(priv, &priv->ucode_init.data,
|
2011-04-16 23:29:24 +08:00
|
|
|
pieces.init_data, pieces.init_data_size))
|
2007-11-29 11:09:41 +08:00
|
|
|
goto err_pci_alloc;
|
|
|
|
}
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-07-16 04:23:45 +08:00
|
|
|
/* WoWLAN instructions and data */
|
|
|
|
if (pieces.wowlan_inst_size && pieces.wowlan_data_size) {
|
|
|
|
if (iwl_alloc_fw_desc(priv, &priv->ucode_wowlan.code,
|
|
|
|
pieces.wowlan_inst,
|
|
|
|
pieces.wowlan_inst_size))
|
|
|
|
goto err_pci_alloc;
|
|
|
|
if (iwl_alloc_fw_desc(priv, &priv->ucode_wowlan.data,
|
|
|
|
pieces.wowlan_data,
|
|
|
|
pieces.wowlan_data_size))
|
|
|
|
goto err_pci_alloc;
|
|
|
|
}
|
|
|
|
|
2010-05-06 14:24:54 +08:00
|
|
|
/* Now that we can no longer fail, copy information */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The (size - 16) / 12 formula is based on the information recorded
|
|
|
|
* for each event, which is of mode 1 (including timestamp) for all
|
|
|
|
* new microcodes that include this information.
|
|
|
|
*/
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->init_evtlog_ptr = pieces.init_evtlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
if (pieces.init_evtlog_size)
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
|
2010-05-06 14:24:54 +08:00
|
|
|
else
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->init_evtlog_size =
|
2010-10-06 23:10:00 +08:00
|
|
|
priv->cfg->base_params->max_event_log_size;
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->init_errlog_ptr = pieces.init_errlog_ptr;
|
|
|
|
priv->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
if (pieces.inst_evtlog_size)
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
|
2010-05-06 14:24:54 +08:00
|
|
|
else
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->inst_evtlog_size =
|
2010-10-06 23:10:00 +08:00
|
|
|
priv->cfg->base_params->max_event_log_size;
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->inst_errlog_ptr = pieces.inst_errlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
|
2011-04-21 00:10:39 +08:00
|
|
|
priv->new_scan_threshold_behaviour =
|
|
|
|
!!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
|
|
|
|
|
2011-07-24 01:24:46 +08:00
|
|
|
if (!(priv->cfg->sku & EEPROM_SKU_CAP_IPAN_ENABLE))
|
|
|
|
ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_PAN;
|
2010-08-23 16:46:43 +08:00
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
/*
|
|
|
|
* if not PAN, then don't support P2P -- might be a uCode
|
|
|
|
* packaging bug or due to the eeprom check above
|
|
|
|
*/
|
|
|
|
if (!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN))
|
|
|
|
ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_P2P;
|
|
|
|
|
2011-07-24 01:24:46 +08:00
|
|
|
if (ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN) {
|
|
|
|
priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
|
2011-08-26 14:10:40 +08:00
|
|
|
priv->shrd->cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
|
2011-07-24 01:24:46 +08:00
|
|
|
} else {
|
|
|
|
priv->sta_key_max_num = STA_KEY_MAX_NUM;
|
2011-08-26 14:10:40 +08:00
|
|
|
priv->shrd->cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
|
2011-07-24 01:24:46 +08:00
|
|
|
}
|
2011-04-06 00:42:05 +08:00
|
|
|
|
2010-07-14 08:13:15 +08:00
|
|
|
/*
|
|
|
|
* figure out the offset of chain noise reset and gain commands
|
|
|
|
* base on the size of standard phy calibration commands table size
|
|
|
|
*/
|
|
|
|
if (ucode_capa.standard_phy_calibration_size >
|
|
|
|
IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
|
|
|
|
ucode_capa.standard_phy_calibration_size =
|
|
|
|
IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
|
|
|
|
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->phy_calib_chain_noise_reset_cmd =
|
2010-07-14 08:13:15 +08:00
|
|
|
ucode_capa.standard_phy_calibration_size;
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->phy_calib_chain_noise_gain_cmd =
|
2010-07-14 08:13:15 +08:00
|
|
|
ucode_capa.standard_phy_calibration_size + 1;
|
|
|
|
|
2011-07-24 01:24:46 +08:00
|
|
|
/* initialize all valid contexts */
|
|
|
|
iwl_init_context(priv, ucode_capa.flags);
|
|
|
|
|
2010-01-30 03:54:56 +08:00
|
|
|
/**************************************************
|
|
|
|
* This is still part of probe() in a sense...
|
|
|
|
*
|
|
|
|
* 9. Setup and register with mac80211 and debugfs
|
|
|
|
**************************************************/
|
2010-04-29 14:33:10 +08:00
|
|
|
err = iwl_mac_setup_register(priv, &ucode_capa);
|
2010-01-30 03:54:56 +08:00
|
|
|
if (err)
|
|
|
|
goto out_unbind;
|
|
|
|
|
|
|
|
err = iwl_dbgfs_register(priv, DRV_NAME);
|
|
|
|
if (err)
|
|
|
|
IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);
|
|
|
|
|
2011-07-11 15:48:51 +08:00
|
|
|
err = sysfs_create_group(&(priv->bus->dev->kobj),
|
2010-05-23 15:14:08 +08:00
|
|
|
&iwl_attribute_group);
|
|
|
|
if (err) {
|
|
|
|
IWL_ERR(priv, "failed to create sysfs device attributes\n");
|
|
|
|
goto out_unbind;
|
|
|
|
}
|
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/* We have our copies now, allow OS release its copies */
|
|
|
|
release_firmware(ucode_raw);
|
2011-07-13 23:38:57 +08:00
|
|
|
complete(&priv->firmware_loading_complete);
|
2010-01-30 03:54:56 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
try_again:
|
|
|
|
/* try next, if any */
|
|
|
|
if (iwl_request_firmware(priv, false))
|
|
|
|
goto out_unbind;
|
|
|
|
release_firmware(ucode_raw);
|
|
|
|
return;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
|
|
|
err_pci_alloc:
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "failed to allocate pci memory\n");
|
2011-05-31 13:52:10 +08:00
|
|
|
iwl_dealloc_ucode(priv);
|
2010-01-30 03:54:56 +08:00
|
|
|
out_unbind:
|
2011-07-13 23:38:57 +08:00
|
|
|
complete(&priv->firmware_loading_complete);
|
2011-07-11 15:48:51 +08:00
|
|
|
device_release_driver(priv->bus->dev);
|
2007-09-26 08:54:57 +08:00
|
|
|
release_firmware(ucode_raw);
|
|
|
|
}
|
|
|
|
|
2011-07-09 14:20:25 +08:00
|
|
|
static const char * const desc_lookup_text[] = {
|
2009-09-26 05:24:23 +08:00
|
|
|
"OK",
|
|
|
|
"FAIL",
|
|
|
|
"BAD_PARAM",
|
|
|
|
"BAD_CHECKSUM",
|
|
|
|
"NMI_INTERRUPT_WDG",
|
|
|
|
"SYSASSERT",
|
|
|
|
"FATAL_ERROR",
|
|
|
|
"BAD_COMMAND",
|
|
|
|
"HW_ERROR_TUNE_LOCK",
|
|
|
|
"HW_ERROR_TEMPERATURE",
|
|
|
|
"ILLEGAL_CHAN_FREQ",
|
|
|
|
"VCC_NOT_STABLE",
|
|
|
|
"FH_ERROR",
|
|
|
|
"NMI_INTERRUPT_HOST",
|
|
|
|
"NMI_INTERRUPT_ACTION_PT",
|
|
|
|
"NMI_INTERRUPT_UNKNOWN",
|
|
|
|
"UCODE_VERSION_MISMATCH",
|
|
|
|
"HW_ERROR_ABS_LOCK",
|
|
|
|
"HW_ERROR_CAL_LOCK_FAIL",
|
|
|
|
"NMI_INTERRUPT_INST_ACTION_PT",
|
|
|
|
"NMI_INTERRUPT_DATA_ACTION_PT",
|
|
|
|
"NMI_TRM_HW_ER",
|
|
|
|
"NMI_INTERRUPT_TRM",
|
2011-07-09 14:20:25 +08:00
|
|
|
"NMI_INTERRUPT_BREAK_POINT",
|
2009-09-26 05:24:23 +08:00
|
|
|
"DEBUG_0",
|
|
|
|
"DEBUG_1",
|
|
|
|
"DEBUG_2",
|
|
|
|
"DEBUG_3",
|
|
|
|
};
|
|
|
|
|
2010-07-03 06:49:10 +08:00
|
|
|
static struct { char *name; u8 num; } advanced_lookup[] = {
|
|
|
|
{ "NMI_INTERRUPT_WDG", 0x34 },
|
|
|
|
{ "SYSASSERT", 0x35 },
|
|
|
|
{ "UCODE_VERSION_MISMATCH", 0x37 },
|
|
|
|
{ "BAD_COMMAND", 0x38 },
|
|
|
|
{ "NMI_INTERRUPT_DATA_ACTION_PT", 0x3C },
|
|
|
|
{ "FATAL_ERROR", 0x3D },
|
|
|
|
{ "NMI_TRM_HW_ERR", 0x46 },
|
|
|
|
{ "NMI_INTERRUPT_TRM", 0x4C },
|
|
|
|
{ "NMI_INTERRUPT_BREAK_POINT", 0x54 },
|
|
|
|
{ "NMI_INTERRUPT_WDG_RXF_FULL", 0x5C },
|
|
|
|
{ "NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64 },
|
|
|
|
{ "NMI_INTERRUPT_HOST", 0x66 },
|
|
|
|
{ "NMI_INTERRUPT_ACTION_PT", 0x7C },
|
|
|
|
{ "NMI_INTERRUPT_UNKNOWN", 0x84 },
|
|
|
|
{ "NMI_INTERRUPT_INST_ACTION_PT", 0x86 },
|
|
|
|
{ "ADVANCED_SYSASSERT", 0 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *desc_lookup(u32 num)
|
2009-09-26 05:24:23 +08:00
|
|
|
{
|
2010-07-03 06:49:10 +08:00
|
|
|
int i;
|
|
|
|
int max = ARRAY_SIZE(desc_lookup_text);
|
2009-09-26 05:24:23 +08:00
|
|
|
|
2010-07-03 06:49:10 +08:00
|
|
|
if (num < max)
|
|
|
|
return desc_lookup_text[num];
|
2009-09-26 05:24:23 +08:00
|
|
|
|
2010-07-03 06:49:10 +08:00
|
|
|
max = ARRAY_SIZE(advanced_lookup) - 1;
|
|
|
|
for (i = 0; i < max; i++) {
|
|
|
|
if (advanced_lookup[i].num == num)
|
2011-04-09 10:49:08 +08:00
|
|
|
break;
|
2010-07-03 06:49:10 +08:00
|
|
|
}
|
|
|
|
return advanced_lookup[i].name;
|
2009-09-26 05:24:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define ERROR_START_OFFSET (1 * sizeof(u32))
|
|
|
|
#define ERROR_ELEM_SIZE (7 * sizeof(u32))
|
|
|
|
|
|
|
|
void iwl_dump_nic_error_log(struct iwl_priv *priv)
|
|
|
|
{
|
2011-05-05 07:56:52 +08:00
|
|
|
u32 base;
|
2011-04-13 18:14:43 +08:00
|
|
|
struct iwl_error_event_table table;
|
2009-09-26 05:24:23 +08:00
|
|
|
|
2011-04-06 00:42:04 +08:00
|
|
|
base = priv->device_pointers.error_event_table;
|
2011-06-07 00:41:15 +08:00
|
|
|
if (priv->ucode_type == IWL_UCODE_INIT) {
|
2010-05-06 14:24:54 +08:00
|
|
|
if (!base)
|
2011-07-13 23:38:57 +08:00
|
|
|
base = priv->init_errlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
} else {
|
|
|
|
if (!base)
|
2011-07-13 23:38:57 +08:00
|
|
|
base = priv->inst_errlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
}
|
2009-09-26 05:24:23 +08:00
|
|
|
|
2011-07-08 06:24:07 +08:00
|
|
|
if (!iwlagn_hw_valid_rtc_data_addr(base)) {
|
2009-12-03 04:53:00 +08:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"Not valid error log pointer 0x%08X for %s uCode\n",
|
2011-04-23 01:15:23 +08:00
|
|
|
base,
|
2011-06-07 00:41:15 +08:00
|
|
|
(priv->ucode_type == IWL_UCODE_INIT)
|
2011-04-23 01:15:23 +08:00
|
|
|
? "Init" : "RT");
|
2009-09-26 05:24:23 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-04-13 18:14:43 +08:00
|
|
|
iwl_read_targ_mem_words(priv, base, &table, sizeof(table));
|
|
|
|
|
2011-05-05 07:56:52 +08:00
|
|
|
if (ERROR_START_OFFSET <= table.valid * ERROR_ELEM_SIZE) {
|
2009-09-26 05:24:23 +08:00
|
|
|
IWL_ERR(priv, "Start IWL Error Log Dump:\n");
|
|
|
|
IWL_ERR(priv, "Status: 0x%08lX, count: %d\n",
|
2011-08-26 14:10:42 +08:00
|
|
|
priv->shrd->status, table.valid);
|
2009-09-26 05:24:23 +08:00
|
|
|
}
|
|
|
|
|
2011-05-05 07:56:52 +08:00
|
|
|
priv->isr_stats.err_code = table.error_id;
|
|
|
|
|
|
|
|
trace_iwlwifi_dev_ucode_error(priv, table.error_id, table.tsf_low,
|
|
|
|
table.data1, table.data2, table.line,
|
|
|
|
table.blink1, table.blink2, table.ilink1,
|
|
|
|
table.ilink2, table.bcon_time, table.gp1,
|
|
|
|
table.gp2, table.gp3, table.ucode_ver,
|
|
|
|
table.hw_ver, table.brd_ver);
|
|
|
|
IWL_ERR(priv, "0x%08X | %-28s\n", table.error_id,
|
|
|
|
desc_lookup(table.error_id));
|
|
|
|
IWL_ERR(priv, "0x%08X | uPc\n", table.pc);
|
|
|
|
IWL_ERR(priv, "0x%08X | branchlink1\n", table.blink1);
|
|
|
|
IWL_ERR(priv, "0x%08X | branchlink2\n", table.blink2);
|
|
|
|
IWL_ERR(priv, "0x%08X | interruptlink1\n", table.ilink1);
|
|
|
|
IWL_ERR(priv, "0x%08X | interruptlink2\n", table.ilink2);
|
|
|
|
IWL_ERR(priv, "0x%08X | data1\n", table.data1);
|
|
|
|
IWL_ERR(priv, "0x%08X | data2\n", table.data2);
|
|
|
|
IWL_ERR(priv, "0x%08X | line\n", table.line);
|
|
|
|
IWL_ERR(priv, "0x%08X | beacon time\n", table.bcon_time);
|
|
|
|
IWL_ERR(priv, "0x%08X | tsf low\n", table.tsf_low);
|
|
|
|
IWL_ERR(priv, "0x%08X | tsf hi\n", table.tsf_hi);
|
|
|
|
IWL_ERR(priv, "0x%08X | time gp1\n", table.gp1);
|
|
|
|
IWL_ERR(priv, "0x%08X | time gp2\n", table.gp2);
|
|
|
|
IWL_ERR(priv, "0x%08X | time gp3\n", table.gp3);
|
|
|
|
IWL_ERR(priv, "0x%08X | uCode version\n", table.ucode_ver);
|
|
|
|
IWL_ERR(priv, "0x%08X | hw version\n", table.hw_ver);
|
|
|
|
IWL_ERR(priv, "0x%08X | board version\n", table.brd_ver);
|
|
|
|
IWL_ERR(priv, "0x%08X | hcmd\n", table.hcmd);
|
2009-09-26 05:24:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define EVENT_START_OFFSET (4 * sizeof(u32))
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_print_event_log - Dump error event log to syslog
|
|
|
|
*
|
|
|
|
*/
|
2009-12-15 06:12:20 +08:00
|
|
|
static int iwl_print_event_log(struct iwl_priv *priv, u32 start_idx,
|
|
|
|
u32 num_events, u32 mode,
|
|
|
|
int pos, char **buf, size_t bufsz)
|
2009-09-26 05:24:23 +08:00
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
u32 base; /* SRAM byte address of event log header */
|
|
|
|
u32 event_size; /* 2 u32s, or 3 u32s if timestamp recorded */
|
|
|
|
u32 ptr; /* SRAM byte address of log data */
|
|
|
|
u32 ev, time, data; /* event log data */
|
2009-11-07 06:52:58 +08:00
|
|
|
unsigned long reg_flags;
|
2009-09-26 05:24:23 +08:00
|
|
|
|
|
|
|
if (num_events == 0)
|
2009-12-15 06:12:20 +08:00
|
|
|
return pos;
|
2010-05-06 14:24:54 +08:00
|
|
|
|
2011-04-06 00:42:04 +08:00
|
|
|
base = priv->device_pointers.log_event_table;
|
2011-06-07 00:41:15 +08:00
|
|
|
if (priv->ucode_type == IWL_UCODE_INIT) {
|
2010-05-06 14:24:54 +08:00
|
|
|
if (!base)
|
2011-07-13 23:38:57 +08:00
|
|
|
base = priv->init_evtlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
} else {
|
|
|
|
if (!base)
|
2011-07-13 23:38:57 +08:00
|
|
|
base = priv->inst_evtlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
}
|
2009-09-26 05:24:23 +08:00
|
|
|
|
|
|
|
if (mode == 0)
|
|
|
|
event_size = 2 * sizeof(u32);
|
|
|
|
else
|
|
|
|
event_size = 3 * sizeof(u32);
|
|
|
|
|
|
|
|
ptr = base + EVENT_START_OFFSET + (start_idx * event_size);
|
|
|
|
|
2009-11-07 06:52:58 +08:00
|
|
|
/* Make sure device is powered up for SRAM reads */
|
|
|
|
spin_lock_irqsave(&priv->reg_lock, reg_flags);
|
|
|
|
iwl_grab_nic_access(priv);
|
|
|
|
|
|
|
|
/* Set starting address; reads will auto-increment */
|
2011-04-06 00:42:12 +08:00
|
|
|
iwl_write32(priv, HBUS_TARG_MEM_RADDR, ptr);
|
2009-11-07 06:52:58 +08:00
|
|
|
rmb();
|
|
|
|
|
2009-09-26 05:24:23 +08:00
|
|
|
/* "time" is actually "data" for mode 0 (no timestamp).
|
|
|
|
* place event id # at far right for easier visual parsing. */
|
|
|
|
for (i = 0; i < num_events; i++) {
|
2011-04-06 00:42:12 +08:00
|
|
|
ev = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
|
|
|
|
time = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
|
2009-09-26 05:24:23 +08:00
|
|
|
if (mode == 0) {
|
|
|
|
/* data, ev */
|
2009-12-15 06:12:20 +08:00
|
|
|
if (bufsz) {
|
|
|
|
pos += scnprintf(*buf + pos, bufsz - pos,
|
|
|
|
"EVT_LOG:0x%08x:%04u\n",
|
|
|
|
time, ev);
|
|
|
|
} else {
|
|
|
|
trace_iwlwifi_dev_ucode_event(priv, 0,
|
|
|
|
time, ev);
|
|
|
|
IWL_ERR(priv, "EVT_LOG:0x%08x:%04u\n",
|
|
|
|
time, ev);
|
|
|
|
}
|
2009-09-26 05:24:23 +08:00
|
|
|
} else {
|
2011-04-06 00:42:12 +08:00
|
|
|
data = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
|
2009-12-15 06:12:20 +08:00
|
|
|
if (bufsz) {
|
|
|
|
pos += scnprintf(*buf + pos, bufsz - pos,
|
|
|
|
"EVT_LOGT:%010u:0x%08x:%04u\n",
|
|
|
|
time, data, ev);
|
|
|
|
} else {
|
|
|
|
IWL_ERR(priv, "EVT_LOGT:%010u:0x%08x:%04u\n",
|
2009-09-26 05:24:23 +08:00
|
|
|
time, data, ev);
|
2009-12-15 06:12:20 +08:00
|
|
|
trace_iwlwifi_dev_ucode_event(priv, time,
|
|
|
|
data, ev);
|
|
|
|
}
|
2009-09-26 05:24:23 +08:00
|
|
|
}
|
|
|
|
}
|
2009-11-07 06:52:58 +08:00
|
|
|
|
|
|
|
/* Allow device to power down */
|
|
|
|
iwl_release_nic_access(priv);
|
|
|
|
spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
|
2009-12-15 06:12:20 +08:00
|
|
|
return pos;
|
2009-09-26 05:24:23 +08:00
|
|
|
}
|
|
|
|
|
2009-11-21 04:05:07 +08:00
|
|
|
/**
|
|
|
|
* iwl_print_last_event_logs - Dump the newest # of event log to syslog
|
|
|
|
*/
|
2009-12-15 06:12:20 +08:00
|
|
|
static int iwl_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
|
|
|
|
u32 num_wraps, u32 next_entry,
|
|
|
|
u32 size, u32 mode,
|
|
|
|
int pos, char **buf, size_t bufsz)
|
2009-11-21 04:05:07 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* display the newest DEFAULT_LOG_ENTRIES entries
|
|
|
|
* i.e the entries just before the next ont that uCode would fill.
|
|
|
|
*/
|
|
|
|
if (num_wraps) {
|
|
|
|
if (next_entry < size) {
|
2009-12-15 06:12:20 +08:00
|
|
|
pos = iwl_print_event_log(priv,
|
|
|
|
capacity - (size - next_entry),
|
|
|
|
size - next_entry, mode,
|
|
|
|
pos, buf, bufsz);
|
|
|
|
pos = iwl_print_event_log(priv, 0,
|
|
|
|
next_entry, mode,
|
|
|
|
pos, buf, bufsz);
|
2009-11-21 04:05:07 +08:00
|
|
|
} else
|
2009-12-15 06:12:20 +08:00
|
|
|
pos = iwl_print_event_log(priv, next_entry - size,
|
|
|
|
size, mode, pos, buf, bufsz);
|
2009-11-21 04:05:07 +08:00
|
|
|
} else {
|
2009-12-15 06:12:20 +08:00
|
|
|
if (next_entry < size) {
|
|
|
|
pos = iwl_print_event_log(priv, 0, next_entry,
|
|
|
|
mode, pos, buf, bufsz);
|
|
|
|
} else {
|
|
|
|
pos = iwl_print_event_log(priv, next_entry - size,
|
|
|
|
size, mode, pos, buf, bufsz);
|
|
|
|
}
|
2009-11-21 04:05:07 +08:00
|
|
|
}
|
2009-12-15 06:12:20 +08:00
|
|
|
return pos;
|
2009-11-21 04:05:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define DEFAULT_DUMP_EVENT_LOG_ENTRIES (20)
|
|
|
|
|
2009-12-15 06:12:20 +08:00
|
|
|
int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
|
|
|
|
char **buf, bool display)
|
2009-09-26 05:24:23 +08:00
|
|
|
{
|
|
|
|
u32 base; /* SRAM byte address of event log header */
|
|
|
|
u32 capacity; /* event log capacity in # entries */
|
|
|
|
u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
|
|
|
|
u32 num_wraps; /* # times uCode wrapped to top of log */
|
|
|
|
u32 next_entry; /* index of next entry to be written by uCode */
|
|
|
|
u32 size; /* # entries that we'll print */
|
2010-05-06 14:24:54 +08:00
|
|
|
u32 logsize;
|
2009-12-15 06:12:20 +08:00
|
|
|
int pos = 0;
|
|
|
|
size_t bufsz = 0;
|
2009-09-26 05:24:23 +08:00
|
|
|
|
2011-04-06 00:42:04 +08:00
|
|
|
base = priv->device_pointers.log_event_table;
|
2011-06-07 00:41:15 +08:00
|
|
|
if (priv->ucode_type == IWL_UCODE_INIT) {
|
2011-07-13 23:38:57 +08:00
|
|
|
logsize = priv->init_evtlog_size;
|
2010-05-06 14:24:54 +08:00
|
|
|
if (!base)
|
2011-07-13 23:38:57 +08:00
|
|
|
base = priv->init_evtlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
} else {
|
2011-07-13 23:38:57 +08:00
|
|
|
logsize = priv->inst_evtlog_size;
|
2010-05-06 14:24:54 +08:00
|
|
|
if (!base)
|
2011-07-13 23:38:57 +08:00
|
|
|
base = priv->inst_evtlog_ptr;
|
2010-05-06 14:24:54 +08:00
|
|
|
}
|
2009-09-26 05:24:23 +08:00
|
|
|
|
2011-07-08 06:24:07 +08:00
|
|
|
if (!iwlagn_hw_valid_rtc_data_addr(base)) {
|
2009-12-03 04:53:00 +08:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"Invalid event log pointer 0x%08X for %s uCode\n",
|
2011-04-23 01:15:23 +08:00
|
|
|
base,
|
2011-06-07 00:41:15 +08:00
|
|
|
(priv->ucode_type == IWL_UCODE_INIT)
|
2011-04-23 01:15:23 +08:00
|
|
|
? "Init" : "RT");
|
2010-01-16 05:43:36 +08:00
|
|
|
return -EINVAL;
|
2009-09-26 05:24:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* event log header */
|
|
|
|
capacity = iwl_read_targ_mem(priv, base);
|
|
|
|
mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
|
|
|
|
num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
|
|
|
|
next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
|
|
|
|
|
2010-05-06 14:24:54 +08:00
|
|
|
if (capacity > logsize) {
|
2009-11-07 06:52:57 +08:00
|
|
|
IWL_ERR(priv, "Log capacity %d is bogus, limit to %d entries\n",
|
2010-05-06 14:24:54 +08:00
|
|
|
capacity, logsize);
|
|
|
|
capacity = logsize;
|
2009-11-07 06:52:57 +08:00
|
|
|
}
|
|
|
|
|
2010-05-06 14:24:54 +08:00
|
|
|
if (next_entry > logsize) {
|
2009-11-07 06:52:57 +08:00
|
|
|
IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
|
2010-05-06 14:24:54 +08:00
|
|
|
next_entry, logsize);
|
|
|
|
next_entry = logsize;
|
2009-11-07 06:52:57 +08:00
|
|
|
}
|
|
|
|
|
2009-09-26 05:24:23 +08:00
|
|
|
size = num_wraps ? capacity : next_entry;
|
|
|
|
|
|
|
|
/* bail out if nothing in log */
|
|
|
|
if (size == 0) {
|
|
|
|
IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
|
2009-12-15 06:12:20 +08:00
|
|
|
return pos;
|
2009-09-26 05:24:23 +08:00
|
|
|
}
|
|
|
|
|
2010-11-27 05:24:19 +08:00
|
|
|
/* enable/disable bt channel inhibition */
|
2011-08-26 14:10:36 +08:00
|
|
|
priv->bt_ch_announce = iwlagn_mod_params.bt_ch_announce;
|
2010-08-23 22:57:12 +08:00
|
|
|
|
2009-11-21 04:05:07 +08:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2011-08-26 14:10:38 +08:00
|
|
|
if (!(iwl_get_debug_level(priv->shrd) & IWL_DL_FW_ERRORS) && !full_log)
|
2009-11-21 04:05:07 +08:00
|
|
|
size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
|
|
|
|
? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
|
|
|
|
#else
|
|
|
|
size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
|
|
|
|
? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
|
|
|
|
#endif
|
|
|
|
IWL_ERR(priv, "Start IWL Event Log Dump: display last %u entries\n",
|
|
|
|
size);
|
2009-09-26 05:24:23 +08:00
|
|
|
|
2009-11-21 04:05:07 +08:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-12-15 06:12:20 +08:00
|
|
|
if (display) {
|
|
|
|
if (full_log)
|
|
|
|
bufsz = capacity * 48;
|
|
|
|
else
|
|
|
|
bufsz = size * 48;
|
|
|
|
*buf = kmalloc(bufsz, GFP_KERNEL);
|
|
|
|
if (!*buf)
|
2010-01-16 05:43:36 +08:00
|
|
|
return -ENOMEM;
|
2009-12-15 06:12:20 +08:00
|
|
|
}
|
2011-08-26 14:10:38 +08:00
|
|
|
if ((iwl_get_debug_level(priv->shrd) & IWL_DL_FW_ERRORS) || full_log) {
|
2009-11-21 04:05:07 +08:00
|
|
|
/*
|
|
|
|
* if uCode has wrapped back to top of log,
|
|
|
|
* start at the oldest entry,
|
|
|
|
* i.e the next one that uCode would fill.
|
|
|
|
*/
|
|
|
|
if (num_wraps)
|
2009-12-15 06:12:20 +08:00
|
|
|
pos = iwl_print_event_log(priv, next_entry,
|
|
|
|
capacity - next_entry, mode,
|
|
|
|
pos, buf, bufsz);
|
2009-11-21 04:05:07 +08:00
|
|
|
/* (then/else) start at top of log */
|
2009-12-15 06:12:20 +08:00
|
|
|
pos = iwl_print_event_log(priv, 0,
|
|
|
|
next_entry, mode, pos, buf, bufsz);
|
2009-11-21 04:05:07 +08:00
|
|
|
} else
|
2009-12-15 06:12:20 +08:00
|
|
|
pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
|
|
|
|
next_entry, size, mode,
|
|
|
|
pos, buf, bufsz);
|
2009-11-21 04:05:07 +08:00
|
|
|
#else
|
2009-12-15 06:12:20 +08:00
|
|
|
pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
|
|
|
|
next_entry, size, mode,
|
|
|
|
pos, buf, bufsz);
|
2009-09-26 05:24:23 +08:00
|
|
|
#endif
|
2009-12-15 06:12:20 +08:00
|
|
|
return pos;
|
2009-11-21 04:05:07 +08:00
|
|
|
}
|
2009-09-26 05:24:23 +08:00
|
|
|
|
2010-07-31 23:34:07 +08:00
|
|
|
static void iwl_rf_kill_ct_config(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
struct iwl_ct_kill_config cmd;
|
|
|
|
struct iwl_ct_kill_throttling_config adv_cmd;
|
|
|
|
unsigned long flags;
|
|
|
|
int ret = 0;
|
|
|
|
|
2011-08-26 14:10:43 +08:00
|
|
|
spin_lock_irqsave(&priv->shrd->lock, flags);
|
2010-07-31 23:34:07 +08:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
|
|
|
|
CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
|
2011-08-26 14:10:43 +08:00
|
|
|
spin_unlock_irqrestore(&priv->shrd->lock, flags);
|
2010-07-31 23:34:07 +08:00
|
|
|
priv->thermal_throttle.ct_kill_toggle = false;
|
|
|
|
|
2010-10-06 23:10:00 +08:00
|
|
|
if (priv->cfg->base_params->support_ct_kill_exit) {
|
2010-07-31 23:34:07 +08:00
|
|
|
adv_cmd.critical_temperature_enter =
|
2011-08-26 14:10:39 +08:00
|
|
|
cpu_to_le32(hw_params(priv).ct_kill_threshold);
|
2010-07-31 23:34:07 +08:00
|
|
|
adv_cmd.critical_temperature_exit =
|
2011-08-26 14:10:39 +08:00
|
|
|
cpu_to_le32(hw_params(priv).ct_kill_exit_threshold);
|
2010-07-31 23:34:07 +08:00
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
ret = trans_send_cmd_pdu(&priv->trans,
|
2011-07-08 23:46:14 +08:00
|
|
|
REPLY_CT_KILL_CONFIG_CMD,
|
|
|
|
CMD_SYNC, sizeof(adv_cmd), &adv_cmd);
|
2010-07-31 23:34:07 +08:00
|
|
|
if (ret)
|
|
|
|
IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
|
|
|
|
else
|
|
|
|
IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
|
2011-08-26 14:10:39 +08:00
|
|
|
"succeeded, critical temperature enter is %d,"
|
|
|
|
"exit is %d\n",
|
|
|
|
hw_params(priv).ct_kill_threshold,
|
|
|
|
hw_params(priv).ct_kill_exit_threshold);
|
2010-07-31 23:34:07 +08:00
|
|
|
} else {
|
|
|
|
cmd.critical_temperature_R =
|
2011-08-26 14:10:39 +08:00
|
|
|
cpu_to_le32(hw_params(priv).ct_kill_threshold);
|
2010-07-31 23:34:07 +08:00
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
ret = trans_send_cmd_pdu(&priv->trans,
|
2011-07-08 23:46:14 +08:00
|
|
|
REPLY_CT_KILL_CONFIG_CMD,
|
|
|
|
CMD_SYNC, sizeof(cmd), &cmd);
|
2010-07-31 23:34:07 +08:00
|
|
|
if (ret)
|
|
|
|
IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
|
|
|
|
else
|
|
|
|
IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
|
2011-08-26 14:10:39 +08:00
|
|
|
"succeeded, "
|
|
|
|
"critical temperature is %d\n",
|
|
|
|
hw_params(priv).ct_kill_threshold);
|
2010-07-31 23:34:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-15 09:13:31 +08:00
|
|
|
static int iwlagn_send_calib_cfg_rt(struct iwl_priv *priv, u32 cfg)
|
|
|
|
{
|
|
|
|
struct iwl_calib_cfg_cmd calib_cfg_cmd;
|
|
|
|
struct iwl_host_cmd cmd = {
|
|
|
|
.id = CALIBRATION_CFG_CMD,
|
2011-05-04 22:50:38 +08:00
|
|
|
.len = { sizeof(struct iwl_calib_cfg_cmd), },
|
|
|
|
.data = { &calib_cfg_cmd, },
|
2010-09-15 09:13:31 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
|
|
|
|
calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL;
|
2010-10-06 23:10:00 +08:00
|
|
|
calib_cfg_cmd.ucd_calib_cfg.once.start = cpu_to_le32(cfg);
|
2010-09-15 09:13:31 +08:00
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
return trans_send_cmd(&priv->trans, &cmd);
|
2010-09-15 09:13:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-07 23:27:41 +08:00
|
|
|
static int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
|
|
|
|
{
|
|
|
|
struct iwl_tx_ant_config_cmd tx_ant_cmd = {
|
|
|
|
.valid = cpu_to_le32(valid_tx_ant),
|
|
|
|
};
|
|
|
|
|
|
|
|
if (IWL_UCODE_API(priv->ucode_ver) > 1) {
|
|
|
|
IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
|
2011-07-11 13:51:04 +08:00
|
|
|
return trans_send_cmd_pdu(&priv->trans,
|
2011-07-07 23:27:41 +08:00
|
|
|
TX_ANT_CONFIGURATION_CMD,
|
|
|
|
CMD_SYNC,
|
|
|
|
sizeof(struct iwl_tx_ant_config_cmd),
|
|
|
|
&tx_ant_cmd);
|
|
|
|
} else {
|
|
|
|
IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/**
|
2008-05-29 16:34:54 +08:00
|
|
|
* iwl_alive_start - called after REPLY_ALIVE notification received
|
2007-09-26 08:54:57 +08:00
|
|
|
* from protocol/runtime uCode (initialization uCode's
|
2008-05-29 16:34:54 +08:00
|
|
|
* Alive gets handled by iwl_init_alive_start()).
|
2007-09-26 08:54:57 +08:00
|
|
|
*/
|
iwlwifi: support the svtool messages interactions through nl80211 test mode
This patch adds the feature to support the test mode operation through
the generic netlink channel NL80211_CMD_TESTMODE between intel
wireless device iwlwifi and the user space application svtool.
The main purpose is to create a transportation layer between the iwlwifi
device and the user space application so that the interaction between the
user space application svtool and the iwlwifi device in the kernel space is
in a way of generic netlink messaging.
The detail specific functions are:
1. The function iwl_testmode_cmd() is added to digest the svtool test command
from the user space application. The svtool test commands are categorized to
three types : commands to be processed by the device ucode, commands to access
the registers, and commands to be processed at the driver level(such as reload
the ucode). iwl_testmode_cmd() dispatches the commands the corresponding handlers
and reply to user space regarding the command execution status. Extra data is
returned to the user space application if there's any.
2. The function iwl_testmode_ucode_rx_pkt() is added to multicast all the spontaneous
messages from the iwlwifi device to the user space. Regardless the message types,
whenever there is a valid spontaneous message received by the iwlwifi ISR,
iwl_testmode_ucode_rx_pkt() is invoked to multicast the message content to user
space. The message content is not attacked and the message parsing is left to
the user space application.
Implementation guidelines:
1. The generic netlink messaging for iwliwif test mode is through NL80211_CMD_TESTMODE
channel, therefore, the codes need to follow the regulations set by cfg80211.ko
to get the actual device instance ieee80211_ops via cfg80211.ko, so that the iwlwifi
device is indicated with ieee80211_ops and can be actually accessed.
Therefore, a callback iwl_testmode_cmd() is added to the structure
iwlagn_hw_ops in iwl-agn.c.
2. It intends to utilize those low level device access APIs from iwlwifi device driver
(ie. iwlagn.ko) rather than creating it's own set of device access functions.
For example, iwl_send_cmd(), iwl_read32(), iwl_write8(), and iwl_write32() are reused.
3. The main functions are maintained in new files instead of spreading all over the
existing iwlwifi driver files.
The new files added are :
drivers/net/wireless/iwlwifi/iwl-sv-open.c
- to handle the user space test mode application command
and reply the respective command status to the user space application.
- to multicast the spontaneous messages from device to user space.
drivers/net/wireless/iwlwifi/iwl-testmode.h
- the commonly referenced definitions for the TLVs used in
the generic netlink messages
Signed-off-by: Cindy H. Kao <cindy.h.kao@intel.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-05-07 01:40:15 +08:00
|
|
|
int iwl_alive_start(struct iwl_priv *priv)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2008-04-15 12:16:03 +08:00
|
|
|
int ret = 0;
|
2010-08-23 16:46:32 +08:00
|
|
|
struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-07-11 22:44:57 +08:00
|
|
|
/*TODO: this should go to the transport layer */
|
2011-04-23 01:15:23 +08:00
|
|
|
iwl_reset_ict(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-04-23 01:15:23 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
|
2010-09-15 09:13:31 +08:00
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
/* After the ALIVE response, we can send host commands to the uCode */
|
2011-08-26 14:10:42 +08:00
|
|
|
set_bit(STATUS_ALIVE, &priv->shrd->status);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-12-03 22:41:48 +08:00
|
|
|
/* Enable watchdog to monitor the driver tx queues */
|
|
|
|
iwl_setup_watchdog(priv);
|
2010-03-02 09:23:50 +08:00
|
|
|
|
2008-04-04 07:05:21 +08:00
|
|
|
if (iwl_is_rfkill(priv))
|
2011-04-23 01:15:23 +08:00
|
|
|
return -ERFKILL;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-10-12 05:24:05 +08:00
|
|
|
/* download priority table before any calibration request */
|
2010-10-06 23:10:00 +08:00
|
|
|
if (priv->cfg->bt_params &&
|
|
|
|
priv->cfg->bt_params->advanced_bt_coexist) {
|
2010-08-24 06:24:49 +08:00
|
|
|
/* Configure Bluetooth device coexistence support */
|
2011-07-08 23:46:23 +08:00
|
|
|
if (priv->cfg->bt_params->bt_sco_disable)
|
|
|
|
priv->bt_enable_pspoll = false;
|
|
|
|
else
|
|
|
|
priv->bt_enable_pspoll = true;
|
|
|
|
|
2010-08-24 06:24:49 +08:00
|
|
|
priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
|
|
|
|
priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
|
|
|
|
priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
|
2011-06-29 02:46:28 +08:00
|
|
|
iwlagn_send_advance_bt_config(priv);
|
2010-08-24 06:24:49 +08:00
|
|
|
priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS;
|
2011-07-08 23:46:23 +08:00
|
|
|
priv->cur_rssi_ctx = NULL;
|
|
|
|
|
2010-09-24 00:56:51 +08:00
|
|
|
iwlagn_send_prio_tbl(priv);
|
2010-08-24 06:24:49 +08:00
|
|
|
|
|
|
|
/* FIXME: w/a to force change uCode BT state machine */
|
2011-04-23 01:15:23 +08:00
|
|
|
ret = iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
|
|
|
|
BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
ret = iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_CLOSE,
|
|
|
|
BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-06-29 02:46:28 +08:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* default is 2-wire BT coexexistence support
|
|
|
|
*/
|
|
|
|
iwl_send_bt_config(priv);
|
2010-08-24 06:24:49 +08:00
|
|
|
}
|
2011-06-29 02:46:28 +08:00
|
|
|
|
2011-08-26 14:10:39 +08:00
|
|
|
if (hw_params(priv).calib_rt_cfg)
|
|
|
|
iwlagn_send_calib_cfg_rt(priv,
|
|
|
|
hw_params(priv).calib_rt_cfg);
|
2010-10-12 05:24:05 +08:00
|
|
|
|
2008-05-15 18:55:26 +08:00
|
|
|
ieee80211_wake_queues(priv->hw);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-01-22 03:23:30 +08:00
|
|
|
priv->active_rate = IWL_RATES_MASK;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-09-18 01:43:51 +08:00
|
|
|
/* Configure Tx antenna selection based on H/W config */
|
2011-07-01 22:59:26 +08:00
|
|
|
iwlagn_send_tx_ant_config(priv, priv->cfg->valid_tx_ant);
|
2009-09-18 01:43:51 +08:00
|
|
|
|
2011-07-16 04:23:45 +08:00
|
|
|
if (iwl_is_associated_ctx(ctx) && !priv->wowlan) {
|
2008-05-15 13:53:59 +08:00
|
|
|
struct iwl_rxon_cmd *active_rxon =
|
2010-08-23 16:46:32 +08:00
|
|
|
(struct iwl_rxon_cmd *)&ctx->active;
|
2009-03-18 12:59:18 +08:00
|
|
|
/* apply any changes in staging */
|
2010-08-23 16:46:32 +08:00
|
|
|
ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
|
2007-09-26 08:54:57 +08:00
|
|
|
active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
} else {
|
2010-08-23 16:46:58 +08:00
|
|
|
struct iwl_rxon_context *tmp;
|
2007-09-26 08:54:57 +08:00
|
|
|
/* Initialize our rx_config data */
|
2010-08-23 16:46:58 +08:00
|
|
|
for_each_context(priv, tmp)
|
|
|
|
iwl_connection_init_rx_config(priv, tmp);
|
2009-04-09 02:26:44 +08:00
|
|
|
|
2011-07-01 22:59:26 +08:00
|
|
|
iwlagn_set_rxon_chain(priv, ctx);
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2011-07-16 04:23:45 +08:00
|
|
|
if (!priv->wowlan) {
|
|
|
|
/* WoWLAN ucode will not reply in the same way, skip it */
|
|
|
|
iwl_reset_run_time_calib(priv);
|
|
|
|
}
|
2008-05-29 16:34:54 +08:00
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
set_bit(STATUS_READY, &priv->shrd->status);
|
2010-11-13 05:52:37 +08:00
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/* Configure the adapter for unassociated operation */
|
2011-06-03 22:54:16 +08:00
|
|
|
ret = iwlagn_commit_rxon(priv, ctx);
|
2011-04-23 01:15:23 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
|
|
|
/* At this point, the NIC is initialized and operational */
|
2008-06-12 09:47:13 +08:00
|
|
|
iwl_rf_kill_ct_config(priv);
|
2008-01-15 09:46:18 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
|
2008-06-12 09:47:05 +08:00
|
|
|
|
2011-04-23 01:15:23 +08:00
|
|
|
return iwl_power_update_mode(priv, true);
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2008-06-12 09:46:53 +08:00
|
|
|
static void iwl_cancel_deferred_work(struct iwl_priv *priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
static void __iwl_down(struct iwl_priv *priv)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2011-03-15 15:03:24 +08:00
|
|
|
int exit_pending;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-09-13 20:46:35 +08:00
|
|
|
iwl_scan_cancel_timeout(priv, 200);
|
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
/*
|
|
|
|
* If active, scanning won't cancel it, so say it expired.
|
|
|
|
* No race since we hold the mutex here and a new one
|
|
|
|
* can't come in at this time.
|
|
|
|
*/
|
|
|
|
ieee80211_remain_on_channel_expired(priv->hw);
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
exit_pending =
|
|
|
|
test_and_set_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-08-20 21:23:47 +08:00
|
|
|
/* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set
|
|
|
|
* to prevent rearm timer */
|
2010-12-03 22:41:48 +08:00
|
|
|
del_timer_sync(&priv->watchdog);
|
2010-08-20 21:23:47 +08:00
|
|
|
|
2010-08-27 23:55:52 +08:00
|
|
|
iwl_clear_ucode_stations(priv, NULL);
|
2010-08-27 23:53:46 +08:00
|
|
|
iwl_dealloc_bcast_stations(priv);
|
2010-05-07 16:49:15 +08:00
|
|
|
iwl_clear_driver_stations(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-08-23 22:56:59 +08:00
|
|
|
/* reset BT coex data */
|
2010-08-23 22:57:13 +08:00
|
|
|
priv->bt_status = 0;
|
2011-07-08 23:46:23 +08:00
|
|
|
priv->cur_rssi_ctx = NULL;
|
|
|
|
priv->bt_is_sco = 0;
|
2010-10-06 23:10:00 +08:00
|
|
|
if (priv->cfg->bt_params)
|
|
|
|
priv->bt_traffic_load =
|
|
|
|
priv->cfg->bt_params->bt_init_traffic_load;
|
|
|
|
else
|
|
|
|
priv->bt_traffic_load = 0;
|
2010-08-23 22:57:04 +08:00
|
|
|
priv->bt_full_concurrent = false;
|
|
|
|
priv->bt_ci_compliance = 0;
|
2010-08-23 22:56:59 +08:00
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/* Wipe out the EXIT_PENDING status bit if we are not actually
|
|
|
|
* exiting the module */
|
|
|
|
if (!exit_pending)
|
2011-08-26 14:10:42 +08:00
|
|
|
clear_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
|
|
|
if (priv->mac80211_registered)
|
|
|
|
ieee80211_stop_queues(priv->hw);
|
|
|
|
|
2011-04-13 18:14:44 +08:00
|
|
|
/* Clear out all status bits but a few that are stable across reset */
|
2011-08-26 14:10:42 +08:00
|
|
|
priv->shrd->status &=
|
|
|
|
test_bit(STATUS_RF_KILL_HW, &priv->shrd->status) <<
|
2007-09-26 08:54:57 +08:00
|
|
|
STATUS_RF_KILL_HW |
|
2011-08-26 14:10:42 +08:00
|
|
|
test_bit(STATUS_GEO_CONFIGURED, &priv->shrd->status) <<
|
2008-02-07 03:20:38 +08:00
|
|
|
STATUS_GEO_CONFIGURED |
|
2011-08-26 14:10:42 +08:00
|
|
|
test_bit(STATUS_FW_ERROR, &priv->shrd->status) <<
|
2008-06-30 17:23:15 +08:00
|
|
|
STATUS_FW_ERROR |
|
2011-08-26 14:10:42 +08:00
|
|
|
test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) <<
|
2008-06-30 17:23:15 +08:00
|
|
|
STATUS_EXIT_PENDING;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
trans_stop_device(&priv->trans);
|
iwlwifi: turn off device when not used.
In some cases (e.g. when mac80211 calls iwl_mac_stop() for suspend or user
no longer wants device active), device has not been going into low power state
via __iwl_down(). apm_ops.reset() does not put device into low power state;
instead it resets the device, then puts it into a powered-up state ready to be
re-loaded with uCode and re-started. This has needlessly warmed up user's
laptops and drained batteries.
With current architecture in which mac80211 controls device up/down (including
resetting device after firmware errors), there is no need for apm_ops.reset()
any more; apm_ops.reset() is basically a combination of apm_ops.stop() and
apm_ops.init().
Instead, __iwl_down() now unconditionally places the device into a low-power
state via apm_ops.stop(). Device may be re-started via __iwl_up() calling
apm_ops.init() as soon as it may be needed (e.g. quickly for firmware errors),
but in the meantime, device will stop wasting energy.
Note that, even in this low power state, if driver re-enables interrupts,
the device retains the ability to sense the hardware RF-KILL switch, and
(except for 3945) interrupt the host when it changes.
Signed-off-by: Ben Cahill <ben.m.cahill@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-10-10 04:20:20 +08:00
|
|
|
|
2010-10-04 20:50:36 +08:00
|
|
|
dev_kfree_skb(priv->beacon_skb);
|
2010-10-04 20:50:06 +08:00
|
|
|
priv->beacon_skb = NULL;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
static void iwl_down(struct iwl_priv *priv)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-10-30 05:05:46 +08:00
|
|
|
__iwl_down(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
2007-12-19 13:59:52 +08:00
|
|
|
|
2008-06-12 09:46:53 +08:00
|
|
|
iwl_cancel_deferred_work(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define MAX_HW_RESTARTS 5
|
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
static int __iwl_up(struct iwl_priv *priv)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2010-08-27 23:53:46 +08:00
|
|
|
struct iwl_rxon_context *ctx;
|
2008-04-15 12:16:03 +08:00
|
|
|
int ret;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-04-23 01:15:23 +08:00
|
|
|
lockdep_assert_held(&priv->mutex);
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) {
|
2008-12-19 10:37:32 +08:00
|
|
|
IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2010-08-27 23:53:46 +08:00
|
|
|
for_each_context(priv, ctx) {
|
2010-09-23 00:02:01 +08:00
|
|
|
ret = iwlagn_alloc_bcast_station(priv, ctx);
|
2010-08-27 23:53:46 +08:00
|
|
|
if (ret) {
|
|
|
|
iwl_dealloc_bcast_stations(priv);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
iwlwifi: rework broadcast station management
Currently, the broadcast station is managed along
with the interface type, rather than always being
present. That leads to a bug with injection -- it
is currently not possible to inject frames when
the only virtual interface is a monitor, because
in that the required broadcast station is missing.
Additionally, allocating and deallocating the
broadcast station's LQ all the time is wasteful,
and the code to support this is fairly complex.
So this changes completely the way we manage the
broadcast station. Rather than manage it along
with any interface, we now allocate it when we
bring the device up, and remove it again when we
bring the device down. When we bring the device
up, we don't immediately program the broadcast
station into it, instead we just mark it active
and rely on the next restore cycle to upload it
to the device. This works because an unassociated
RXON is always required at least once to set up
device parameters, which implies a reprogramming
of stations into the device.
As we now manage all stations properly, there no
longer is a need for forcing a clearing of them
via iwl_clear_ucode_stations(), which can become
a lot simpler.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-04-29 15:53:29 +08:00
|
|
|
|
2011-04-23 01:15:23 +08:00
|
|
|
ret = iwlagn_run_init_ucode(priv);
|
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Failed to run INIT ucode: %d\n", ret);
|
|
|
|
goto error;
|
|
|
|
}
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-04-23 01:15:23 +08:00
|
|
|
ret = iwlagn_load_ucode_wait_alive(priv,
|
2011-04-16 23:29:24 +08:00
|
|
|
&priv->ucode_rt,
|
2011-06-07 00:41:15 +08:00
|
|
|
IWL_UCODE_REGULAR);
|
2011-04-23 01:15:23 +08:00
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
|
|
|
|
goto error;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2011-04-23 01:15:23 +08:00
|
|
|
ret = iwl_alive_start(priv);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2011-08-26 14:10:42 +08:00
|
|
|
set_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
|
2008-10-30 05:05:46 +08:00
|
|
|
__iwl_down(priv);
|
2011-08-26 14:10:42 +08:00
|
|
|
clear_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-04-23 01:15:23 +08:00
|
|
|
IWL_ERR(priv, "Unable to initialize device.\n");
|
|
|
|
return ret;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* Workqueue callbacks
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-06-12 09:46:52 +08:00
|
|
|
static void iwl_bg_run_time_calib_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = container_of(work, struct iwl_priv,
|
|
|
|
run_time_calib_work);
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) ||
|
|
|
|
test_bit(STATUS_SCANNING, &priv->shrd->status)) {
|
2008-06-12 09:46:52 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->start_calib) {
|
2011-04-08 23:14:56 +08:00
|
|
|
iwl_chain_noise_calibration(priv);
|
|
|
|
iwl_sensitivity_calibration(priv);
|
2008-06-12 09:46:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2011-04-19 22:45:16 +08:00
|
|
|
static void iwlagn_prepare_restart(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
struct iwl_rxon_context *ctx;
|
|
|
|
bool bt_full_concurrent;
|
|
|
|
u8 bt_ci_compliance;
|
|
|
|
u8 bt_load;
|
|
|
|
u8 bt_status;
|
2011-07-08 23:46:23 +08:00
|
|
|
bool bt_is_sco;
|
2011-04-19 22:45:16 +08:00
|
|
|
|
|
|
|
lockdep_assert_held(&priv->mutex);
|
|
|
|
|
|
|
|
for_each_context(priv, ctx)
|
|
|
|
ctx->vif = NULL;
|
|
|
|
priv->is_open = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* __iwl_down() will clear the BT status variables,
|
|
|
|
* which is correct, but when we restart we really
|
|
|
|
* want to keep them so restore them afterwards.
|
|
|
|
*
|
|
|
|
* The restart process will later pick them up and
|
|
|
|
* re-configure the hw when we reconfigure the BT
|
|
|
|
* command.
|
|
|
|
*/
|
|
|
|
bt_full_concurrent = priv->bt_full_concurrent;
|
|
|
|
bt_ci_compliance = priv->bt_ci_compliance;
|
|
|
|
bt_load = priv->bt_traffic_load;
|
|
|
|
bt_status = priv->bt_status;
|
2011-07-08 23:46:23 +08:00
|
|
|
bt_is_sco = priv->bt_is_sco;
|
2011-04-19 22:45:16 +08:00
|
|
|
|
|
|
|
__iwl_down(priv);
|
|
|
|
|
|
|
|
priv->bt_full_concurrent = bt_full_concurrent;
|
|
|
|
priv->bt_ci_compliance = bt_ci_compliance;
|
|
|
|
priv->bt_traffic_load = bt_load;
|
|
|
|
priv->bt_status = bt_status;
|
2011-07-08 23:46:23 +08:00
|
|
|
priv->bt_is_sco = bt_is_sco;
|
2011-04-19 22:45:16 +08:00
|
|
|
}
|
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
static void iwl_bg_restart(struct work_struct *data)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2008-03-13 07:58:50 +08:00
|
|
|
struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
|
2007-09-26 08:54:57 +08:00
|
|
|
return;
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_and_clear_bit(STATUS_FW_ERROR, &priv->shrd->status)) {
|
2009-05-09 04:44:36 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
2011-04-19 22:45:16 +08:00
|
|
|
iwlagn_prepare_restart(priv);
|
2009-05-09 04:44:36 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
2010-08-23 22:56:59 +08:00
|
|
|
iwl_cancel_deferred_work(priv);
|
2009-05-09 04:44:36 +08:00
|
|
|
ieee80211_restart_hw(priv->hw);
|
|
|
|
} else {
|
2011-04-23 01:15:23 +08:00
|
|
|
WARN_ON(1);
|
2009-05-09 04:44:36 +08:00
|
|
|
}
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* mac80211 entry point functions
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2011-05-27 23:40:30 +08:00
|
|
|
static const struct ieee80211_iface_limit iwlagn_sta_ap_limits[] = {
|
|
|
|
{
|
|
|
|
.max = 1,
|
|
|
|
.types = BIT(NL80211_IFTYPE_STATION),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.max = 1,
|
|
|
|
.types = BIT(NL80211_IFTYPE_AP),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = {
|
|
|
|
{
|
|
|
|
.max = 2,
|
|
|
|
.types = BIT(NL80211_IFTYPE_STATION),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct ieee80211_iface_limit iwlagn_p2p_sta_go_limits[] = {
|
|
|
|
{
|
|
|
|
.max = 1,
|
|
|
|
.types = BIT(NL80211_IFTYPE_STATION),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.max = 1,
|
|
|
|
.types = BIT(NL80211_IFTYPE_P2P_GO) |
|
|
|
|
BIT(NL80211_IFTYPE_AP),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct ieee80211_iface_limit iwlagn_p2p_2sta_limits[] = {
|
|
|
|
{
|
|
|
|
.max = 2,
|
|
|
|
.types = BIT(NL80211_IFTYPE_STATION),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.max = 1,
|
|
|
|
.types = BIT(NL80211_IFTYPE_P2P_CLIENT),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct ieee80211_iface_combination
|
|
|
|
iwlagn_iface_combinations_dualmode[] = {
|
|
|
|
{ .num_different_channels = 1,
|
|
|
|
.max_interfaces = 2,
|
|
|
|
.beacon_int_infra_match = true,
|
|
|
|
.limits = iwlagn_sta_ap_limits,
|
|
|
|
.n_limits = ARRAY_SIZE(iwlagn_sta_ap_limits),
|
|
|
|
},
|
|
|
|
{ .num_different_channels = 1,
|
|
|
|
.max_interfaces = 2,
|
|
|
|
.limits = iwlagn_2sta_limits,
|
|
|
|
.n_limits = ARRAY_SIZE(iwlagn_2sta_limits),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct ieee80211_iface_combination
|
|
|
|
iwlagn_iface_combinations_p2p[] = {
|
|
|
|
{ .num_different_channels = 1,
|
|
|
|
.max_interfaces = 2,
|
|
|
|
.beacon_int_infra_match = true,
|
|
|
|
.limits = iwlagn_p2p_sta_go_limits,
|
|
|
|
.n_limits = ARRAY_SIZE(iwlagn_p2p_sta_go_limits),
|
|
|
|
},
|
|
|
|
{ .num_different_channels = 1,
|
|
|
|
.max_interfaces = 2,
|
|
|
|
.limits = iwlagn_p2p_2sta_limits,
|
|
|
|
.n_limits = ARRAY_SIZE(iwlagn_p2p_2sta_limits),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2009-10-17 05:25:53 +08:00
|
|
|
/*
|
|
|
|
* Not a mac80211 entry point function, but it fits in with all the
|
|
|
|
* other mac80211 functions grouped here.
|
|
|
|
*/
|
2010-04-29 14:33:10 +08:00
|
|
|
static int iwl_mac_setup_register(struct iwl_priv *priv,
|
|
|
|
struct iwlagn_ucode_capabilities *capa)
|
2009-10-17 05:25:53 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ieee80211_hw *hw = priv->hw;
|
2010-08-23 16:46:58 +08:00
|
|
|
struct iwl_rxon_context *ctx;
|
|
|
|
|
2009-10-17 05:25:53 +08:00
|
|
|
hw->rate_control_algorithm = "iwl-agn-rs";
|
|
|
|
|
|
|
|
/* Tell mac80211 our characteristics */
|
|
|
|
hw->flags = IEEE80211_HW_SIGNAL_DBM |
|
|
|
|
IEEE80211_HW_AMPDU_AGGREGATION |
|
2010-08-23 16:46:52 +08:00
|
|
|
IEEE80211_HW_NEED_DTIM_PERIOD |
|
2010-11-17 03:55:02 +08:00
|
|
|
IEEE80211_HW_SPECTRUM_MGMT |
|
|
|
|
IEEE80211_HW_REPORTS_TX_ACK_STATUS;
|
2009-10-17 05:25:53 +08:00
|
|
|
|
2011-01-19 18:54:18 +08:00
|
|
|
hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
|
|
|
|
|
2011-04-02 07:29:53 +08:00
|
|
|
hw->flags |= IEEE80211_HW_SUPPORTS_PS |
|
|
|
|
IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
|
2009-10-17 05:25:53 +08:00
|
|
|
|
2011-06-07 03:05:46 +08:00
|
|
|
if (priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE)
|
2009-12-11 06:37:27 +08:00
|
|
|
hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
|
|
|
|
IEEE80211_HW_SUPPORTS_STATIC_SMPS;
|
|
|
|
|
2011-04-06 00:42:02 +08:00
|
|
|
if (capa->flags & IWL_UCODE_TLV_FLAGS_MFP)
|
|
|
|
hw->flags |= IEEE80211_HW_MFP_CAPABLE;
|
|
|
|
|
2009-10-17 05:25:55 +08:00
|
|
|
hw->sta_data_size = sizeof(struct iwl_station_priv);
|
2010-05-01 02:30:43 +08:00
|
|
|
hw->vif_data_size = sizeof(struct iwl_vif_priv);
|
|
|
|
|
2010-08-23 16:46:58 +08:00
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
hw->wiphy->interface_modes |= ctx->interface_modes;
|
|
|
|
hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
|
|
|
|
}
|
2009-10-17 05:25:53 +08:00
|
|
|
|
2011-05-27 23:40:30 +08:00
|
|
|
BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
|
|
|
|
|
2011-06-03 01:38:43 +08:00
|
|
|
if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) {
|
2011-05-27 23:40:30 +08:00
|
|
|
hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p;
|
|
|
|
hw->wiphy->n_iface_combinations =
|
|
|
|
ARRAY_SIZE(iwlagn_iface_combinations_p2p);
|
2011-06-03 01:38:43 +08:00
|
|
|
} else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
|
2011-05-27 23:40:30 +08:00
|
|
|
hw->wiphy->iface_combinations = iwlagn_iface_combinations_dualmode;
|
|
|
|
hw->wiphy->n_iface_combinations =
|
|
|
|
ARRAY_SIZE(iwlagn_iface_combinations_dualmode);
|
|
|
|
}
|
|
|
|
|
2011-01-07 00:07:10 +08:00
|
|
|
hw->wiphy->max_remain_on_channel_duration = 1000;
|
|
|
|
|
2010-03-13 03:13:26 +08:00
|
|
|
hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
|
2011-01-18 20:44:03 +08:00
|
|
|
WIPHY_FLAG_DISABLE_BEACON_HINTS |
|
|
|
|
WIPHY_FLAG_IBSS_RSN;
|
2009-10-17 05:25:53 +08:00
|
|
|
|
2011-07-16 04:23:45 +08:00
|
|
|
if (priv->ucode_wowlan.code.len && device_can_wakeup(priv->bus->dev)) {
|
|
|
|
hw->wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
|
|
|
|
WIPHY_WOWLAN_DISCONNECT |
|
|
|
|
WIPHY_WOWLAN_EAP_IDENTITY_REQ |
|
|
|
|
WIPHY_WOWLAN_RFKILL_RELEASE;
|
|
|
|
if (!iwlagn_mod_params.sw_crypto)
|
|
|
|
hw->wiphy->wowlan.flags |=
|
|
|
|
WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
|
|
|
|
WIPHY_WOWLAN_GTK_REKEY_FAILURE;
|
|
|
|
|
|
|
|
hw->wiphy->wowlan.n_patterns = IWLAGN_WOWLAN_MAX_PATTERNS;
|
|
|
|
hw->wiphy->wowlan.pattern_min_len =
|
|
|
|
IWLAGN_WOWLAN_MIN_PATTERN_LEN;
|
|
|
|
hw->wiphy->wowlan.pattern_max_len =
|
|
|
|
IWLAGN_WOWLAN_MAX_PATTERN_LEN;
|
|
|
|
}
|
|
|
|
|
2011-06-12 01:00:05 +08:00
|
|
|
if (iwlagn_mod_params.power_save)
|
|
|
|
hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
|
|
|
|
else
|
|
|
|
hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
|
2009-10-17 05:25:53 +08:00
|
|
|
|
2010-02-26 02:02:19 +08:00
|
|
|
hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
|
2009-10-17 05:25:53 +08:00
|
|
|
/* we create the 802.11 header and a zero-length SSID element */
|
2010-04-29 14:33:10 +08:00
|
|
|
hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 2;
|
2009-10-17 05:25:53 +08:00
|
|
|
|
|
|
|
/* Default value; 4 EDCA QOS priorities */
|
|
|
|
hw->queues = 4;
|
|
|
|
|
|
|
|
hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
|
|
|
|
|
|
|
|
if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
|
|
|
|
priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
|
|
|
|
&priv->bands[IEEE80211_BAND_2GHZ];
|
|
|
|
if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
|
|
|
|
priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
|
|
|
|
&priv->bands[IEEE80211_BAND_5GHZ];
|
|
|
|
|
2011-01-22 07:26:39 +08:00
|
|
|
iwl_leds_init(priv);
|
|
|
|
|
2009-10-17 05:25:53 +08:00
|
|
|
ret = ieee80211_register_hw(priv->hw);
|
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
priv->mac80211_registered = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static int iwlagn_mac_start(struct ieee80211_hw *hw)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2008-03-13 07:58:50 +08:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2008-01-15 09:46:18 +08:00
|
|
|
int ret;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
|
|
|
|
/* we should be verifying the device is ready to be opened */
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-10-30 05:05:46 +08:00
|
|
|
ret = __iwl_up(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
2008-01-24 18:19:38 +08:00
|
|
|
if (ret)
|
2009-01-19 20:10:07 +08:00
|
|
|
return ret;
|
2008-01-24 18:19:38 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "Start UP work done.\n");
|
2008-01-24 18:19:38 +08:00
|
|
|
|
2011-04-23 01:15:23 +08:00
|
|
|
/* Now we should be done, and the READY bit should be set. */
|
2011-08-26 14:10:42 +08:00
|
|
|
if (WARN_ON(!test_bit(STATUS_READY, &priv->shrd->status)))
|
2011-04-23 01:15:23 +08:00
|
|
|
ret = -EIO;
|
2008-06-30 17:23:26 +08:00
|
|
|
|
2011-01-22 07:26:39 +08:00
|
|
|
iwlagn_led_enable(priv);
|
2009-10-03 04:44:03 +08:00
|
|
|
|
2008-06-30 17:23:26 +08:00
|
|
|
priv->is_open = 1;
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static void iwlagn_mac_stop(struct ieee80211_hw *hw)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2008-03-13 07:58:50 +08:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-10-25 17:15:45 +08:00
|
|
|
|
2009-05-09 04:44:36 +08:00
|
|
|
if (!priv->is_open)
|
2008-01-24 18:19:38 +08:00
|
|
|
return;
|
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
priv->is_open = 0;
|
2008-01-15 09:46:18 +08:00
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
iwl_down(priv);
|
2008-01-15 09:46:18 +08:00
|
|
|
|
2011-08-26 14:10:41 +08:00
|
|
|
flush_workqueue(priv->shrd->workqueue);
|
2009-01-19 20:10:07 +08:00
|
|
|
|
2010-12-23 19:38:21 +08:00
|
|
|
/* User space software may expect getting rfkill changes
|
|
|
|
* even if interface is down */
|
2009-01-19 20:10:07 +08:00
|
|
|
iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
|
2010-12-23 19:38:21 +08:00
|
|
|
iwl_enable_rfkill_int(priv);
|
2007-10-25 17:15:45 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2011-07-25 04:09:32 +08:00
|
|
|
#ifdef CONFIG_PM
|
2011-07-16 04:23:45 +08:00
|
|
|
static int iwlagn_send_patterns(struct iwl_priv *priv,
|
|
|
|
struct cfg80211_wowlan *wowlan)
|
|
|
|
{
|
|
|
|
struct iwlagn_wowlan_patterns_cmd *pattern_cmd;
|
|
|
|
struct iwl_host_cmd cmd = {
|
|
|
|
.id = REPLY_WOWLAN_PATTERNS,
|
|
|
|
.dataflags[0] = IWL_HCMD_DFL_NOCOPY,
|
|
|
|
.flags = CMD_SYNC,
|
|
|
|
};
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
if (!wowlan->n_patterns)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cmd.len[0] = sizeof(*pattern_cmd) +
|
|
|
|
wowlan->n_patterns * sizeof(struct iwlagn_wowlan_pattern);
|
|
|
|
|
|
|
|
pattern_cmd = kmalloc(cmd.len[0], GFP_KERNEL);
|
|
|
|
if (!pattern_cmd)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
pattern_cmd->n_patterns = cpu_to_le32(wowlan->n_patterns);
|
|
|
|
|
|
|
|
for (i = 0; i < wowlan->n_patterns; i++) {
|
|
|
|
int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);
|
|
|
|
|
|
|
|
memcpy(&pattern_cmd->patterns[i].mask,
|
|
|
|
wowlan->patterns[i].mask, mask_len);
|
|
|
|
memcpy(&pattern_cmd->patterns[i].pattern,
|
|
|
|
wowlan->patterns[i].pattern,
|
|
|
|
wowlan->patterns[i].pattern_len);
|
|
|
|
pattern_cmd->patterns[i].mask_size = mask_len;
|
|
|
|
pattern_cmd->patterns[i].pattern_size =
|
|
|
|
wowlan->patterns[i].pattern_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmd.data[0] = pattern_cmd;
|
|
|
|
err = trans_send_cmd(&priv->trans, &cmd);
|
|
|
|
kfree(pattern_cmd);
|
|
|
|
return err;
|
|
|
|
}
|
2011-07-25 04:09:32 +08:00
|
|
|
#endif
|
2011-07-16 04:23:45 +08:00
|
|
|
|
|
|
|
static void iwlagn_mac_set_rekey_data(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct cfg80211_gtk_rekey_data *data)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
|
|
|
|
if (iwlagn_mod_params.sw_crypto)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
|
|
|
if (priv->contexts[IWL_RXON_CTX_BSS].vif != vif)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
memcpy(priv->kek, data->kek, NL80211_KEK_LEN);
|
|
|
|
memcpy(priv->kck, data->kck, NL80211_KCK_LEN);
|
|
|
|
priv->replay_ctr = cpu_to_le64(be64_to_cpup((__be64 *)&data->replay_ctr));
|
|
|
|
priv->have_rekey_data = true;
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct wowlan_key_data {
|
|
|
|
struct iwl_rxon_context *ctx;
|
|
|
|
struct iwlagn_wowlan_rsc_tsc_params_cmd *rsc_tsc;
|
|
|
|
struct iwlagn_wowlan_tkip_params_cmd *tkip;
|
|
|
|
const u8 *bssid;
|
|
|
|
bool error, use_rsc_tsc, use_tkip;
|
|
|
|
};
|
|
|
|
|
2011-07-25 04:09:32 +08:00
|
|
|
#ifdef CONFIG_PM
|
2011-07-16 04:23:45 +08:00
|
|
|
static void iwlagn_convert_p1k(u16 *p1k, __le16 *out)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < IWLAGN_P1K_SIZE; i++)
|
|
|
|
out[i] = cpu_to_le16(p1k[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void iwlagn_wowlan_program_keys(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_sta *sta,
|
|
|
|
struct ieee80211_key_conf *key,
|
|
|
|
void *_data)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
struct wowlan_key_data *data = _data;
|
|
|
|
struct iwl_rxon_context *ctx = data->ctx;
|
|
|
|
struct aes_sc *aes_sc, *aes_tx_sc = NULL;
|
|
|
|
struct tkip_sc *tkip_sc, *tkip_tx_sc = NULL;
|
|
|
|
struct iwlagn_p1k_cache *rx_p1ks;
|
|
|
|
u8 *rx_mic_key;
|
|
|
|
struct ieee80211_key_seq seq;
|
|
|
|
u32 cur_rx_iv32 = 0;
|
|
|
|
u16 p1k[IWLAGN_P1K_SIZE];
|
|
|
|
int ret, i;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
|
|
|
if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
|
|
|
|
key->cipher == WLAN_CIPHER_SUITE_WEP104) &&
|
|
|
|
!sta && !ctx->key_mapping_keys)
|
|
|
|
ret = iwl_set_default_wep_key(priv, ctx, key);
|
|
|
|
else
|
|
|
|
ret = iwl_set_dynamic_key(priv, ctx, key, sta);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Error setting key during suspend!\n");
|
|
|
|
data->error = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (key->cipher) {
|
|
|
|
case WLAN_CIPHER_SUITE_TKIP:
|
|
|
|
if (sta) {
|
|
|
|
tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.unicast_rsc;
|
|
|
|
tkip_tx_sc = &data->rsc_tsc->all_tsc_rsc.tkip.tsc;
|
|
|
|
|
|
|
|
rx_p1ks = data->tkip->rx_uni;
|
|
|
|
|
|
|
|
ieee80211_get_key_tx_seq(key, &seq);
|
|
|
|
tkip_tx_sc->iv16 = cpu_to_le16(seq.tkip.iv16);
|
|
|
|
tkip_tx_sc->iv32 = cpu_to_le32(seq.tkip.iv32);
|
|
|
|
|
|
|
|
ieee80211_get_tkip_p1k_iv(key, seq.tkip.iv32, p1k);
|
|
|
|
iwlagn_convert_p1k(p1k, data->tkip->tx.p1k);
|
|
|
|
|
|
|
|
memcpy(data->tkip->mic_keys.tx,
|
|
|
|
&key->key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
|
|
|
|
IWLAGN_MIC_KEY_SIZE);
|
|
|
|
|
|
|
|
rx_mic_key = data->tkip->mic_keys.rx_unicast;
|
|
|
|
} else {
|
|
|
|
tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.multicast_rsc;
|
|
|
|
rx_p1ks = data->tkip->rx_multi;
|
|
|
|
rx_mic_key = data->tkip->mic_keys.rx_mcast;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For non-QoS this relies on the fact that both the uCode and
|
|
|
|
* mac80211 use TID 0 (as they need to to avoid replay attacks)
|
|
|
|
* for checking the IV in the frames.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < IWLAGN_NUM_RSC; i++) {
|
|
|
|
ieee80211_get_key_rx_seq(key, i, &seq);
|
|
|
|
tkip_sc[i].iv16 = cpu_to_le16(seq.tkip.iv16);
|
|
|
|
tkip_sc[i].iv32 = cpu_to_le32(seq.tkip.iv32);
|
|
|
|
/* wrapping isn't allowed, AP must rekey */
|
|
|
|
if (seq.tkip.iv32 > cur_rx_iv32)
|
|
|
|
cur_rx_iv32 = seq.tkip.iv32;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_get_tkip_rx_p1k(key, data->bssid, cur_rx_iv32, p1k);
|
|
|
|
iwlagn_convert_p1k(p1k, rx_p1ks[0].p1k);
|
|
|
|
ieee80211_get_tkip_rx_p1k(key, data->bssid,
|
|
|
|
cur_rx_iv32 + 1, p1k);
|
|
|
|
iwlagn_convert_p1k(p1k, rx_p1ks[1].p1k);
|
|
|
|
|
|
|
|
memcpy(rx_mic_key,
|
|
|
|
&key->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
|
|
|
|
IWLAGN_MIC_KEY_SIZE);
|
|
|
|
|
|
|
|
data->use_tkip = true;
|
|
|
|
data->use_rsc_tsc = true;
|
|
|
|
break;
|
|
|
|
case WLAN_CIPHER_SUITE_CCMP:
|
|
|
|
if (sta) {
|
|
|
|
u8 *pn = seq.ccmp.pn;
|
|
|
|
|
|
|
|
aes_sc = data->rsc_tsc->all_tsc_rsc.aes.unicast_rsc;
|
|
|
|
aes_tx_sc = &data->rsc_tsc->all_tsc_rsc.aes.tsc;
|
|
|
|
|
|
|
|
ieee80211_get_key_tx_seq(key, &seq);
|
|
|
|
aes_tx_sc->pn = cpu_to_le64(
|
|
|
|
(u64)pn[5] |
|
|
|
|
((u64)pn[4] << 8) |
|
|
|
|
((u64)pn[3] << 16) |
|
|
|
|
((u64)pn[2] << 24) |
|
|
|
|
((u64)pn[1] << 32) |
|
|
|
|
((u64)pn[0] << 40));
|
|
|
|
} else
|
|
|
|
aes_sc = data->rsc_tsc->all_tsc_rsc.aes.multicast_rsc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For non-QoS this relies on the fact that both the uCode and
|
|
|
|
* mac80211 use TID 0 for checking the IV in the frames.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < IWLAGN_NUM_RSC; i++) {
|
|
|
|
u8 *pn = seq.ccmp.pn;
|
|
|
|
|
|
|
|
ieee80211_get_key_rx_seq(key, i, &seq);
|
|
|
|
aes_sc->pn = cpu_to_le64(
|
|
|
|
(u64)pn[5] |
|
|
|
|
((u64)pn[4] << 8) |
|
|
|
|
((u64)pn[3] << 16) |
|
|
|
|
((u64)pn[2] << 24) |
|
|
|
|
((u64)pn[1] << 32) |
|
|
|
|
((u64)pn[0] << 40));
|
|
|
|
}
|
|
|
|
data->use_rsc_tsc = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iwlagn_mac_suspend(struct ieee80211_hw *hw,
|
|
|
|
struct cfg80211_wowlan *wowlan)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
struct iwlagn_wowlan_wakeup_filter_cmd wakeup_filter_cmd;
|
|
|
|
struct iwl_rxon_cmd rxon;
|
|
|
|
struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
|
|
|
|
struct iwlagn_wowlan_kek_kck_material_cmd kek_kck_cmd;
|
|
|
|
struct iwlagn_wowlan_tkip_params_cmd tkip_cmd = {};
|
|
|
|
struct wowlan_key_data key_data = {
|
|
|
|
.ctx = ctx,
|
|
|
|
.bssid = ctx->active.bssid_addr,
|
|
|
|
.use_rsc_tsc = false,
|
|
|
|
.tkip = &tkip_cmd,
|
|
|
|
.use_tkip = false,
|
|
|
|
};
|
|
|
|
int ret, i;
|
|
|
|
u16 seq;
|
|
|
|
|
|
|
|
if (WARN_ON(!wowlan))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
|
|
|
/* Don't attempt WoWLAN when not associated, tear down instead. */
|
|
|
|
if (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION ||
|
|
|
|
!iwl_is_associated_ctx(ctx)) {
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
key_data.rsc_tsc = kzalloc(sizeof(*key_data.rsc_tsc), GFP_KERNEL);
|
|
|
|
if (!key_data.rsc_tsc) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&wakeup_filter_cmd, 0, sizeof(wakeup_filter_cmd));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We know the last used seqno, and the uCode expects to know that
|
|
|
|
* one, it will increment before TX.
|
|
|
|
*/
|
|
|
|
seq = le16_to_cpu(priv->last_seq_ctl) & IEEE80211_SCTL_SEQ;
|
|
|
|
wakeup_filter_cmd.non_qos_seq = cpu_to_le16(seq);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For QoS counters, we store the one to use next, so subtract 0x10
|
|
|
|
* since the uCode will add 0x10 before using the value.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
seq = priv->stations[IWL_AP_ID].tid[i].seq_number;
|
|
|
|
seq -= 0x10;
|
|
|
|
wakeup_filter_cmd.qos_seq[i] = cpu_to_le16(seq);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wowlan->disconnect)
|
|
|
|
wakeup_filter_cmd.enabled |=
|
|
|
|
cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_BEACON_MISS |
|
|
|
|
IWLAGN_WOWLAN_WAKEUP_LINK_CHANGE);
|
|
|
|
if (wowlan->magic_pkt)
|
|
|
|
wakeup_filter_cmd.enabled |=
|
|
|
|
cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_MAGIC_PACKET);
|
|
|
|
if (wowlan->gtk_rekey_failure)
|
|
|
|
wakeup_filter_cmd.enabled |=
|
|
|
|
cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_GTK_REKEY_FAIL);
|
|
|
|
if (wowlan->eap_identity_req)
|
|
|
|
wakeup_filter_cmd.enabled |=
|
|
|
|
cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_EAP_IDENT_REQ);
|
|
|
|
if (wowlan->four_way_handshake)
|
|
|
|
wakeup_filter_cmd.enabled |=
|
|
|
|
cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_4WAY_HANDSHAKE);
|
|
|
|
if (wowlan->rfkill_release)
|
|
|
|
wakeup_filter_cmd.enabled |=
|
|
|
|
cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_RFKILL);
|
|
|
|
if (wowlan->n_patterns)
|
|
|
|
wakeup_filter_cmd.enabled |=
|
|
|
|
cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_PATTERN_MATCH);
|
|
|
|
|
|
|
|
iwl_scan_cancel_timeout(priv, 200);
|
|
|
|
|
|
|
|
memcpy(&rxon, &ctx->active, sizeof(rxon));
|
|
|
|
|
|
|
|
trans_stop_device(&priv->trans);
|
|
|
|
|
|
|
|
priv->wowlan = true;
|
|
|
|
|
|
|
|
ret = iwlagn_load_ucode_wait_alive(priv, &priv->ucode_wowlan,
|
|
|
|
IWL_UCODE_WOWLAN);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* now configure WoWLAN ucode */
|
|
|
|
ret = iwl_alive_start(priv);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
memcpy(&ctx->staging, &rxon, sizeof(rxon));
|
|
|
|
ret = iwlagn_commit_rxon(priv, ctx);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
ret = iwl_power_update_mode(priv, true);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (!iwlagn_mod_params.sw_crypto) {
|
|
|
|
/* mark all keys clear */
|
|
|
|
priv->ucode_key_table = 0;
|
|
|
|
ctx->key_mapping_keys = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This needs to be unlocked due to lock ordering
|
|
|
|
* constraints. Since we're in the suspend path
|
|
|
|
* that isn't really a problem though.
|
|
|
|
*/
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
ieee80211_iter_keys(priv->hw, ctx->vif,
|
|
|
|
iwlagn_wowlan_program_keys,
|
|
|
|
&key_data);
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
if (key_data.error) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (key_data.use_rsc_tsc) {
|
|
|
|
struct iwl_host_cmd rsc_tsc_cmd = {
|
|
|
|
.id = REPLY_WOWLAN_TSC_RSC_PARAMS,
|
|
|
|
.flags = CMD_SYNC,
|
|
|
|
.data[0] = key_data.rsc_tsc,
|
|
|
|
.dataflags[0] = IWL_HCMD_DFL_NOCOPY,
|
|
|
|
.len[0] = sizeof(*key_data.rsc_tsc),
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = trans_send_cmd(&priv->trans, &rsc_tsc_cmd);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (key_data.use_tkip) {
|
|
|
|
ret = trans_send_cmd_pdu(&priv->trans,
|
|
|
|
REPLY_WOWLAN_TKIP_PARAMS,
|
|
|
|
CMD_SYNC, sizeof(tkip_cmd),
|
|
|
|
&tkip_cmd);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->have_rekey_data) {
|
|
|
|
memset(&kek_kck_cmd, 0, sizeof(kek_kck_cmd));
|
|
|
|
memcpy(kek_kck_cmd.kck, priv->kck, NL80211_KCK_LEN);
|
|
|
|
kek_kck_cmd.kck_len = cpu_to_le16(NL80211_KCK_LEN);
|
|
|
|
memcpy(kek_kck_cmd.kek, priv->kek, NL80211_KEK_LEN);
|
|
|
|
kek_kck_cmd.kek_len = cpu_to_le16(NL80211_KEK_LEN);
|
|
|
|
kek_kck_cmd.replay_ctr = priv->replay_ctr;
|
|
|
|
|
|
|
|
ret = trans_send_cmd_pdu(&priv->trans,
|
|
|
|
REPLY_WOWLAN_KEK_KCK_MATERIAL,
|
|
|
|
CMD_SYNC, sizeof(kek_kck_cmd),
|
|
|
|
&kek_kck_cmd);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = trans_send_cmd_pdu(&priv->trans, REPLY_WOWLAN_WAKEUP_FILTER,
|
|
|
|
CMD_SYNC, sizeof(wakeup_filter_cmd),
|
|
|
|
&wakeup_filter_cmd);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
ret = iwlagn_send_patterns(priv, wowlan);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
device_set_wakeup_enable(priv->bus->dev, true);
|
|
|
|
|
|
|
|
/* Now let the ucode operate on its own */
|
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
|
|
|
|
CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
error:
|
|
|
|
priv->wowlan = false;
|
|
|
|
iwlagn_prepare_restart(priv);
|
|
|
|
ieee80211_restart_hw(priv->hw);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
kfree(key_data.rsc_tsc);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iwlagn_mac_resume(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
|
|
|
|
struct ieee80211_vif *vif;
|
|
|
|
unsigned long flags;
|
|
|
|
u32 base, status = 0xffffffff;
|
|
|
|
int ret = -EIO;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
|
|
|
|
CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
|
|
|
|
|
|
|
|
base = priv->device_pointers.error_event_table;
|
|
|
|
if (iwlagn_hw_valid_rtc_data_addr(base)) {
|
|
|
|
spin_lock_irqsave(&priv->reg_lock, flags);
|
|
|
|
ret = iwl_grab_nic_access_silent(priv);
|
|
|
|
if (ret == 0) {
|
|
|
|
iwl_write32(priv, HBUS_TARG_MEM_RADDR, base);
|
|
|
|
status = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
|
|
|
|
iwl_release_nic_access(priv);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->reg_lock, flags);
|
|
|
|
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUGFS
|
|
|
|
if (ret == 0) {
|
|
|
|
if (!priv->wowlan_sram)
|
|
|
|
priv->wowlan_sram =
|
|
|
|
kzalloc(priv->ucode_wowlan.data.len,
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
|
|
|
if (priv->wowlan_sram)
|
|
|
|
_iwl_read_targ_mem_words(
|
|
|
|
priv, 0x800000, priv->wowlan_sram,
|
|
|
|
priv->ucode_wowlan.data.len / 4);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we'll clear ctx->vif during iwlagn_prepare_restart() */
|
|
|
|
vif = ctx->vif;
|
|
|
|
|
|
|
|
priv->wowlan = false;
|
|
|
|
|
|
|
|
device_set_wakeup_enable(priv->bus->dev, false);
|
|
|
|
|
|
|
|
iwlagn_prepare_restart(priv);
|
|
|
|
|
|
|
|
memset((void *)&ctx->active, 0, sizeof(ctx->active));
|
|
|
|
iwl_connection_init_rx_config(priv, ctx);
|
|
|
|
iwlagn_set_rxon_chain(priv, ctx);
|
|
|
|
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
ieee80211_resume_disconnect(vif);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2011-07-25 04:09:32 +08:00
|
|
|
#endif
|
2011-07-16 04:23:45 +08:00
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static void iwlagn_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2008-03-13 07:58:50 +08:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MACDUMP(priv, "enter\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
|
2008-05-15 18:55:29 +08:00
|
|
|
ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-03-18 04:34:34 +08:00
|
|
|
if (iwlagn_tx_skb(priv, skb))
|
2007-09-26 08:54:57 +08:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MACDUMP(priv, "leave\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_key_conf *keyconf,
|
|
|
|
struct ieee80211_sta *sta,
|
|
|
|
u32 iv32, u16 *phase1key)
|
2008-03-20 21:06:43 +08:00
|
|
|
{
|
2008-11-13 05:14:05 +08:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2008-03-20 21:06:43 +08:00
|
|
|
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
iwl_update_tkip_key(priv, vif, keyconf, sta, iv32, phase1key);
|
2008-03-20 21:06:43 +08:00
|
|
|
}
|
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static int iwlagn_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_sta *sta,
|
|
|
|
struct ieee80211_key_conf *key)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2008-03-13 07:58:50 +08:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2010-08-27 23:53:46 +08:00
|
|
|
struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
|
2010-08-23 16:46:43 +08:00
|
|
|
struct iwl_rxon_context *ctx = vif_priv->ctx;
|
2009-01-20 07:30:22 +08:00
|
|
|
int ret;
|
|
|
|
bool is_default_wep_key = false;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-04-21 06:23:57 +08:00
|
|
|
if (iwlagn_mod_params.sw_crypto) {
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
2011-01-18 20:44:03 +08:00
|
|
|
/*
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
* We could program these keys into the hardware as well, but we
|
|
|
|
* don't expect much multicast traffic in IBSS and having keys
|
|
|
|
* for more stations is probably more useful.
|
|
|
|
*
|
|
|
|
* Mark key TX-only and return 0.
|
2011-01-18 20:44:03 +08:00
|
|
|
*/
|
|
|
|
if (vif->type == NL80211_IFTYPE_ADHOC &&
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
|
|
|
|
key->hw_key_idx = WEP_INVALID_OFFSET;
|
|
|
|
return 0;
|
|
|
|
}
|
2011-01-18 20:44:03 +08:00
|
|
|
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
/* If they key was TX-only, accept deletion */
|
|
|
|
if (cmd == DISABLE_KEY && key->hw_key_idx == WEP_INVALID_OFFSET)
|
|
|
|
return 0;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-04-15 12:16:06 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
2008-06-12 09:47:10 +08:00
|
|
|
iwl_scan_cancel_timeout(priv, 100);
|
2008-04-15 12:16:06 +08:00
|
|
|
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
BUILD_BUG_ON(WEP_INVALID_OFFSET == IWLAGN_HW_KEY_DEFAULT);
|
|
|
|
|
2010-03-30 17:44:16 +08:00
|
|
|
/*
|
|
|
|
* If we are getting WEP group key and we didn't receive any key mapping
|
2008-04-15 12:16:06 +08:00
|
|
|
* so far, we are in legacy wep mode (group key only), otherwise we are
|
|
|
|
* in 1X mode.
|
2010-03-30 17:44:16 +08:00
|
|
|
* In legacy wep mode, we use another host command to the uCode.
|
|
|
|
*/
|
2010-08-10 15:46:38 +08:00
|
|
|
if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
|
2008-04-15 12:16:06 +08:00
|
|
|
if (cmd == SET_KEY)
|
2010-08-23 16:46:43 +08:00
|
|
|
is_default_wep_key = !ctx->key_mapping_keys;
|
2008-04-15 12:16:06 +08:00
|
|
|
else
|
2008-05-15 13:54:09 +08:00
|
|
|
is_default_wep_key =
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
key->hw_key_idx == IWLAGN_HW_KEY_DEFAULT;
|
2008-04-15 12:16:06 +08:00
|
|
|
}
|
2007-10-25 17:15:43 +08:00
|
|
|
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
switch (cmd) {
|
2008-03-20 07:41:41 +08:00
|
|
|
case SET_KEY:
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
if (is_default_wep_key) {
|
2010-08-23 16:46:42 +08:00
|
|
|
ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
ret = iwl_set_dynamic_key(priv, vif_priv->ctx, key, sta);
|
|
|
|
if (ret) {
|
|
|
|
/*
|
|
|
|
* can't add key for RX, but we don't need it
|
|
|
|
* in the device for TX so still return 0
|
|
|
|
*/
|
|
|
|
ret = 0;
|
|
|
|
key->hw_key_idx = WEP_INVALID_OFFSET;
|
|
|
|
}
|
2008-03-20 07:41:41 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
break;
|
|
|
|
case DISABLE_KEY:
|
2008-04-15 12:16:06 +08:00
|
|
|
if (is_default_wep_key)
|
2010-08-23 16:46:43 +08:00
|
|
|
ret = iwl_remove_default_wep_key(priv, ctx, key);
|
2008-03-20 07:41:41 +08:00
|
|
|
else
|
iwlagn: rewrite HW crypto
As I just discovered while doing WoWLAN, HW crypto
is done wrong for GTKs: they should be programmed
for the AP station ID (in the managed mode case)
and the HW can actually deal with multiple group
keys per station as well (which is useful in IBSS
RSN but that I've chosen not to use this).
To fix all this, modify the way keys are sent to
the device and key offsets are allocated. After
these changes, key offsets are stored into the
hw_key_idx which we can then track for the key
lifetime, not relying on our sta_cmd array. WEP
default keys get special treatment, of course.
Additionally, since I had the API for it, we can
now pre-fill TKIP phase 1 keys for RX now that we
can obtain the P1K from mac80211, a capability I
had added for WoWLAN initially.
Finally, some keys simply don't need to be added
into the device's key cache -- a key that won't
be used for RX is only needed in the TX header,
so "pretend" to have accepted any key without
adding it into the device -- no need to use up
key space there for it.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-07-16 04:03:12 +08:00
|
|
|
ret = iwl_remove_dynamic_key(priv, ctx, key, sta);
|
2008-03-20 07:41:41 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
break;
|
|
|
|
default:
|
2008-03-20 07:41:41 +08:00
|
|
|
ret = -EINVAL;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2010-02-20 03:42:32 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-03-20 07:41:41 +08:00
|
|
|
return ret;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
enum ieee80211_ampdu_mlme_action action,
|
|
|
|
struct ieee80211_sta *sta, u16 tid, u16 *ssn,
|
|
|
|
u8 buf_size)
|
2008-07-18 13:53:02 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
2010-06-16 18:30:27 +08:00
|
|
|
int ret = -EINVAL;
|
2011-01-19 18:53:54 +08:00
|
|
|
struct iwl_station_priv *sta_priv = (void *) sta->drv_priv;
|
2008-07-18 13:53:02 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
|
2008-10-28 06:59:26 +08:00
|
|
|
sta->addr, tid);
|
2008-07-18 13:53:02 +08:00
|
|
|
|
2011-06-07 03:05:46 +08:00
|
|
|
if (!(priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE))
|
2008-07-18 13:53:02 +08:00
|
|
|
return -EACCES;
|
|
|
|
|
2010-06-16 18:30:27 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2008-07-18 13:53:02 +08:00
|
|
|
switch (action) {
|
|
|
|
case IEEE80211_AMPDU_RX_START:
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "start Rx\n");
|
2010-06-16 18:30:27 +08:00
|
|
|
ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
|
|
|
|
break;
|
2008-07-18 13:53:02 +08:00
|
|
|
case IEEE80211_AMPDU_RX_STOP:
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "stop Rx\n");
|
2010-05-01 02:30:46 +08:00
|
|
|
ret = iwl_sta_rx_agg_stop(priv, sta, tid);
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
|
2010-06-16 18:30:27 +08:00
|
|
|
ret = 0;
|
|
|
|
break;
|
2008-07-18 13:53:02 +08:00
|
|
|
case IEEE80211_AMPDU_TX_START:
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "start Tx\n");
|
2010-05-01 02:30:46 +08:00
|
|
|
ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
|
2010-03-05 05:38:59 +08:00
|
|
|
if (ret == 0) {
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->agg_tids_count++;
|
|
|
|
IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
|
|
|
|
priv->agg_tids_count);
|
2010-03-05 05:38:59 +08:00
|
|
|
}
|
2010-06-16 18:30:27 +08:00
|
|
|
break;
|
2008-07-18 13:53:02 +08:00
|
|
|
case IEEE80211_AMPDU_TX_STOP:
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "stop Tx\n");
|
2010-05-01 02:30:46 +08:00
|
|
|
ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
|
2011-07-13 23:38:57 +08:00
|
|
|
if ((ret == 0) && (priv->agg_tids_count > 0)) {
|
|
|
|
priv->agg_tids_count--;
|
|
|
|
IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
|
|
|
|
priv->agg_tids_count);
|
2010-03-05 05:38:59 +08:00
|
|
|
}
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
|
2010-06-16 18:30:27 +08:00
|
|
|
ret = 0;
|
2010-10-06 23:10:00 +08:00
|
|
|
if (priv->cfg->ht_params &&
|
|
|
|
priv->cfg->ht_params->use_rts_for_aggregation) {
|
iwlagn: fix rts cts protection
Currently the driver will try to protect all frames,
which leads to a lot of odd things like sending an
RTS with a zeroed RA before multicast frames, which
is clearly bogus.
In order to fix all of this, we need to take a step
back and see what we need to achieve:
* we need RTS/CTS protection if requested by
the AP for the BSS, mac80211 tells us this
* in that case, CTS-to-self should only be
enabled when mac80211 tells us
* additionally, as a hardware workaround, on
some devices we have to protect aggregated
frames with RTS
To achieve the first two items, set up the RXON
accordingly and set the protection required flag
in the transmit command when mac80211 requests
protection for the frame.
To achieve the last item, set the rate-control
RTS-requested flag for all stations that we have
aggregation sessions with, and set the protection
required flag when sending aggregated frames (on
those devices where this is required).
Since otherwise bugs can occur, do not allow the
user to override the RTS-for-aggregation setting
from sysfs any more.
Finally, also clean up the way all these flags get
set in the driver and move everything into the
device-specific functions.
Cc: stable@kernel.org [2.6.35]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-08-10 01:57:02 +08:00
|
|
|
/*
|
|
|
|
* switch off RTS/CTS if it was previously enabled
|
|
|
|
*/
|
|
|
|
sta_priv->lq_sta.lq.general_params.flags &=
|
|
|
|
~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
|
2010-08-23 16:46:46 +08:00
|
|
|
iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
|
|
|
|
&sta_priv->lq_sta.lq, CMD_ASYNC, false);
|
iwlagn: fix rts cts protection
Currently the driver will try to protect all frames,
which leads to a lot of odd things like sending an
RTS with a zeroed RA before multicast frames, which
is clearly bogus.
In order to fix all of this, we need to take a step
back and see what we need to achieve:
* we need RTS/CTS protection if requested by
the AP for the BSS, mac80211 tells us this
* in that case, CTS-to-self should only be
enabled when mac80211 tells us
* additionally, as a hardware workaround, on
some devices we have to protect aggregated
frames with RTS
To achieve the first two items, set up the RXON
accordingly and set the protection required flag
in the transmit command when mac80211 requests
protection for the frame.
To achieve the last item, set the rate-control
RTS-requested flag for all stations that we have
aggregation sessions with, and set the protection
required flag when sending aggregated frames (on
those devices where this is required).
Since otherwise bugs can occur, do not allow the
user to override the RTS-for-aggregation setting
from sysfs any more.
Finally, also clean up the way all these flags get
set in the driver and move everything into the
device-specific functions.
Cc: stable@kernel.org [2.6.35]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-08-10 01:57:02 +08:00
|
|
|
}
|
2010-06-16 18:30:27 +08:00
|
|
|
break;
|
2010-01-09 02:04:41 +08:00
|
|
|
case IEEE80211_AMPDU_TX_OPERATIONAL:
|
2011-03-16 02:33:03 +08:00
|
|
|
buf_size = min_t(int, buf_size, LINK_QUAL_AGG_FRAME_LIMIT_DEF);
|
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
trans_txq_agg_setup(&priv->trans, iwl_sta_id(sta), tid,
|
|
|
|
buf_size);
|
2011-03-16 02:33:03 +08:00
|
|
|
|
2011-01-19 18:53:54 +08:00
|
|
|
/*
|
|
|
|
* If the limit is 0, then it wasn't initialised yet,
|
|
|
|
* use the default. We can do that since we take the
|
|
|
|
* minimum below, and we don't want to go above our
|
|
|
|
* default due to hardware restrictions.
|
|
|
|
*/
|
|
|
|
if (sta_priv->max_agg_bufsize == 0)
|
|
|
|
sta_priv->max_agg_bufsize =
|
|
|
|
LINK_QUAL_AGG_FRAME_LIMIT_DEF;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Even though in theory the peer could have different
|
|
|
|
* aggregation reorder buffer sizes for different sessions,
|
|
|
|
* our ucode doesn't allow for that and has a global limit
|
|
|
|
* for each station. Therefore, use the minimum of all the
|
|
|
|
* aggregation sessions and our default value.
|
|
|
|
*/
|
|
|
|
sta_priv->max_agg_bufsize =
|
|
|
|
min(sta_priv->max_agg_bufsize, buf_size);
|
|
|
|
|
2010-10-06 23:10:00 +08:00
|
|
|
if (priv->cfg->ht_params &&
|
|
|
|
priv->cfg->ht_params->use_rts_for_aggregation) {
|
2010-06-19 02:33:15 +08:00
|
|
|
/*
|
|
|
|
* switch to RTS/CTS if it is the prefer protection
|
|
|
|
* method for HT traffic
|
|
|
|
*/
|
iwlagn: fix rts cts protection
Currently the driver will try to protect all frames,
which leads to a lot of odd things like sending an
RTS with a zeroed RA before multicast frames, which
is clearly bogus.
In order to fix all of this, we need to take a step
back and see what we need to achieve:
* we need RTS/CTS protection if requested by
the AP for the BSS, mac80211 tells us this
* in that case, CTS-to-self should only be
enabled when mac80211 tells us
* additionally, as a hardware workaround, on
some devices we have to protect aggregated
frames with RTS
To achieve the first two items, set up the RXON
accordingly and set the protection required flag
in the transmit command when mac80211 requests
protection for the frame.
To achieve the last item, set the rate-control
RTS-requested flag for all stations that we have
aggregation sessions with, and set the protection
required flag when sending aggregated frames (on
those devices where this is required).
Since otherwise bugs can occur, do not allow the
user to override the RTS-for-aggregation setting
from sysfs any more.
Finally, also clean up the way all these flags get
set in the driver and move everything into the
device-specific functions.
Cc: stable@kernel.org [2.6.35]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-08-10 01:57:02 +08:00
|
|
|
|
|
|
|
sta_priv->lq_sta.lq.general_params.flags |=
|
|
|
|
LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
|
2010-06-19 02:33:15 +08:00
|
|
|
}
|
2011-01-19 18:53:54 +08:00
|
|
|
|
|
|
|
sta_priv->lq_sta.lq.agg_params.agg_frame_cnt_limit =
|
|
|
|
sta_priv->max_agg_bufsize;
|
|
|
|
|
|
|
|
iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
|
|
|
|
&sta_priv->lq_sta.lq, CMD_ASYNC, false);
|
2011-05-27 23:40:32 +08:00
|
|
|
|
|
|
|
IWL_INFO(priv, "Tx aggregation enabled on ra = %pM tid = %d\n",
|
|
|
|
sta->addr, tid);
|
2010-06-19 02:33:15 +08:00
|
|
|
ret = 0;
|
2008-07-18 13:53:02 +08:00
|
|
|
break;
|
|
|
|
}
|
2010-06-16 18:30:27 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
return ret;
|
2008-07-18 13:53:02 +08:00
|
|
|
}
|
2008-11-13 05:14:05 +08:00
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_sta *sta)
|
2010-02-23 08:24:47 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
|
2010-08-27 23:53:46 +08:00
|
|
|
struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
|
2010-04-29 19:43:04 +08:00
|
|
|
bool is_ap = vif->type == NL80211_IFTYPE_STATION;
|
2010-02-23 08:24:47 +08:00
|
|
|
int ret;
|
|
|
|
u8 sta_id;
|
|
|
|
|
|
|
|
IWL_DEBUG_INFO(priv, "received request to add station %pM\n",
|
|
|
|
sta->addr);
|
2010-05-29 00:28:39 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
IWL_DEBUG_INFO(priv, "proceeding to add station %pM\n",
|
|
|
|
sta->addr);
|
|
|
|
sta_priv->common.sta_id = IWL_INVALID_STATION;
|
2010-02-23 08:24:47 +08:00
|
|
|
|
|
|
|
atomic_set(&sta_priv->pending_frames, 0);
|
|
|
|
if (vif->type == NL80211_IFTYPE_AP)
|
|
|
|
sta_priv->client = true;
|
|
|
|
|
2010-08-27 23:53:46 +08:00
|
|
|
ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
|
2010-08-23 16:46:45 +08:00
|
|
|
is_ap, sta, &sta_id);
|
2010-02-23 08:24:47 +08:00
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Unable to add station %pM (%d)\n",
|
|
|
|
sta->addr, ret);
|
|
|
|
/* Should we return success if return code is EEXIST ? */
|
2010-05-29 00:28:39 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
2010-02-23 08:24:47 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-05-01 02:30:43 +08:00
|
|
|
sta_priv->common.sta_id = sta_id;
|
|
|
|
|
2010-02-23 08:24:47 +08:00
|
|
|
/* Initialize rate scaling */
|
2010-03-25 05:19:58 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "Initializing rate scaling for station %pM\n",
|
2010-02-23 08:24:47 +08:00
|
|
|
sta->addr);
|
|
|
|
iwl_rs_rate_init(priv, sta, sta_id);
|
2010-05-29 00:28:39 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
2010-02-23 08:24:47 +08:00
|
|
|
|
2010-05-01 02:30:43 +08:00
|
|
|
return 0;
|
2010-02-23 08:24:47 +08:00
|
|
|
}
|
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_channel_switch *ch_switch)
|
2010-05-06 23:54:11 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
const struct iwl_channel_info *ch_info;
|
|
|
|
struct ieee80211_conf *conf = &hw->conf;
|
2010-07-29 04:40:39 +08:00
|
|
|
struct ieee80211_channel *channel = ch_switch->channel;
|
2010-05-06 23:54:11 +08:00
|
|
|
struct iwl_ht_config *ht_conf = &priv->current_ht_config;
|
2010-08-23 16:46:32 +08:00
|
|
|
/*
|
|
|
|
* MULTI-FIXME
|
|
|
|
* When we add support for multiple interfaces, we need to
|
|
|
|
* revisit this. The channel switch command in the device
|
|
|
|
* only affects the BSS context, but what does that really
|
|
|
|
* mean? And what if we get a CSA on the second interface?
|
|
|
|
* This needs a lot of work.
|
|
|
|
*/
|
|
|
|
struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
|
2010-05-06 23:54:11 +08:00
|
|
|
u16 ch;
|
|
|
|
|
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
|
|
|
|
2011-03-31 23:36:27 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2010-05-06 23:54:11 +08:00
|
|
|
if (iwl_is_rfkill(priv))
|
2011-03-31 23:36:27 +08:00
|
|
|
goto out;
|
2010-05-06 23:54:11 +08:00
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) ||
|
|
|
|
test_bit(STATUS_SCANNING, &priv->shrd->status) ||
|
|
|
|
test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status))
|
2011-03-31 23:36:27 +08:00
|
|
|
goto out;
|
2010-05-06 23:54:11 +08:00
|
|
|
|
2010-08-23 16:46:32 +08:00
|
|
|
if (!iwl_is_associated_ctx(ctx))
|
2011-03-31 23:36:27 +08:00
|
|
|
goto out;
|
2010-05-06 23:54:11 +08:00
|
|
|
|
2011-07-07 23:33:01 +08:00
|
|
|
if (!priv->cfg->lib->set_channel_switch)
|
2011-06-02 22:46:20 +08:00
|
|
|
goto out;
|
2010-05-06 23:54:11 +08:00
|
|
|
|
2011-06-02 22:46:20 +08:00
|
|
|
ch = channel->hw_value;
|
|
|
|
if (le16_to_cpu(ctx->active.channel) == ch)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ch_info = iwl_get_channel_info(priv, channel->band, ch);
|
|
|
|
if (!is_channel_valid(ch_info)) {
|
|
|
|
IWL_DEBUG_MAC80211(priv, "invalid channel\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2010-05-06 23:54:11 +08:00
|
|
|
|
2011-08-26 14:10:43 +08:00
|
|
|
spin_lock_irq(&priv->shrd->lock);
|
2010-05-06 23:54:11 +08:00
|
|
|
|
2011-06-02 22:46:20 +08:00
|
|
|
priv->current_ht_config.smps = conf->smps_mode;
|
2010-05-06 23:54:11 +08:00
|
|
|
|
2011-06-02 22:46:20 +08:00
|
|
|
/* Configure HT40 channels */
|
|
|
|
ctx->ht.enabled = conf_is_ht(conf);
|
|
|
|
if (ctx->ht.enabled) {
|
|
|
|
if (conf_is_ht40_minus(conf)) {
|
|
|
|
ctx->ht.extension_chan_offset =
|
|
|
|
IEEE80211_HT_PARAM_CHA_SEC_BELOW;
|
|
|
|
ctx->ht.is_40mhz = true;
|
|
|
|
} else if (conf_is_ht40_plus(conf)) {
|
|
|
|
ctx->ht.extension_chan_offset =
|
|
|
|
IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
|
|
|
|
ctx->ht.is_40mhz = true;
|
|
|
|
} else {
|
|
|
|
ctx->ht.extension_chan_offset =
|
|
|
|
IEEE80211_HT_PARAM_CHA_SEC_NONE;
|
|
|
|
ctx->ht.is_40mhz = false;
|
2010-05-06 23:54:11 +08:00
|
|
|
}
|
2011-06-02 22:46:20 +08:00
|
|
|
} else
|
|
|
|
ctx->ht.is_40mhz = false;
|
|
|
|
|
|
|
|
if ((le16_to_cpu(ctx->staging.channel) != ch))
|
|
|
|
ctx->staging.flags = 0;
|
|
|
|
|
|
|
|
iwl_set_rxon_channel(priv, channel, ctx);
|
|
|
|
iwl_set_rxon_ht(priv, ht_conf);
|
|
|
|
iwl_set_flags_for_band(priv, ctx, channel->band, ctx->vif);
|
|
|
|
|
2011-08-26 14:10:43 +08:00
|
|
|
spin_unlock_irq(&priv->shrd->lock);
|
2011-06-02 22:46:20 +08:00
|
|
|
|
|
|
|
iwl_set_rate(priv);
|
|
|
|
/*
|
|
|
|
* at this point, staging_rxon has the
|
|
|
|
* configuration for channel switch
|
|
|
|
*/
|
2011-08-26 14:10:42 +08:00
|
|
|
set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status);
|
2011-06-02 22:46:20 +08:00
|
|
|
priv->switch_channel = cpu_to_le16(ch);
|
2011-07-07 23:33:01 +08:00
|
|
|
if (priv->cfg->lib->set_channel_switch(priv, ch_switch)) {
|
2011-08-26 14:10:42 +08:00
|
|
|
clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status);
|
2011-06-02 22:46:20 +08:00
|
|
|
priv->switch_channel = 0;
|
|
|
|
ieee80211_chswitch_done(ctx->vif, false);
|
2010-05-06 23:54:11 +08:00
|
|
|
}
|
2011-06-02 22:46:20 +08:00
|
|
|
|
2010-05-06 23:54:11 +08:00
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
|
|
|
}
|
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static void iwlagn_configure_filter(struct ieee80211_hw *hw,
|
|
|
|
unsigned int changed_flags,
|
|
|
|
unsigned int *total_flags,
|
|
|
|
u64 multicast)
|
2010-08-17 17:24:01 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
__le32 filter_or = 0, filter_nand = 0;
|
2010-08-23 16:46:32 +08:00
|
|
|
struct iwl_rxon_context *ctx;
|
2010-08-17 17:24:01 +08:00
|
|
|
|
|
|
|
#define CHK(test, flag) do { \
|
|
|
|
if (*total_flags & (test)) \
|
|
|
|
filter_or |= (flag); \
|
|
|
|
else \
|
|
|
|
filter_nand |= (flag); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
|
|
|
|
changed_flags, *total_flags);
|
|
|
|
|
|
|
|
CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
|
2010-12-15 22:07:56 +08:00
|
|
|
/* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
|
|
|
|
CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
|
2010-08-17 17:24:01 +08:00
|
|
|
CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
|
|
|
|
|
|
|
|
#undef CHK
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2010-08-23 16:46:32 +08:00
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
ctx->staging.filter_flags &= ~filter_nand;
|
|
|
|
ctx->staging.filter_flags |= filter_or;
|
2010-10-22 23:04:27 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Not committing directly because hardware can perform a scan,
|
|
|
|
* but we'll eventually commit the filter flags change anyway.
|
|
|
|
*/
|
2010-08-23 16:46:32 +08:00
|
|
|
}
|
2010-08-17 17:24:01 +08:00
|
|
|
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Receiving all multicast frames is always enabled by the
|
|
|
|
* default flags setup in iwl_connection_init_rx_config()
|
|
|
|
* since we currently do not support programming multicast
|
|
|
|
* filters into the device.
|
|
|
|
*/
|
|
|
|
*total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
|
|
|
|
FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
|
|
|
|
}
|
|
|
|
|
2011-04-06 00:41:50 +08:00
|
|
|
static void iwlagn_mac_flush(struct ieee80211_hw *hw, bool drop)
|
2010-06-25 04:22:36 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) {
|
2010-06-25 04:22:36 +08:00
|
|
|
IWL_DEBUG_TX(priv, "Aborting flush due to device shutdown\n");
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (iwl_is_rfkill(priv)) {
|
|
|
|
IWL_DEBUG_TX(priv, "Aborting flush due to RF Kill\n");
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* mac80211 will not push any more frames for transmit
|
|
|
|
* until the flush is completed
|
|
|
|
*/
|
|
|
|
if (drop) {
|
|
|
|
IWL_DEBUG_MAC80211(priv, "send flush command\n");
|
2011-06-18 23:03:18 +08:00
|
|
|
if (iwlagn_txfifo_flush(priv, IWL_DROP_ALL)) {
|
2010-06-25 04:22:36 +08:00
|
|
|
IWL_ERR(priv, "flush request fail\n");
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
IWL_DEBUG_MAC80211(priv, "wait transmit/flush all frames\n");
|
|
|
|
iwlagn_wait_tx_queue_empty(priv);
|
|
|
|
done:
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
|
|
|
}
|
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
void iwlagn_disable_roc(struct iwl_priv *priv)
|
2011-01-07 00:07:10 +08:00
|
|
|
{
|
|
|
|
struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
|
|
|
|
|
|
|
|
lockdep_assert_held(&priv->mutex);
|
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
if (!priv->hw_roc_setup)
|
2011-01-07 00:07:10 +08:00
|
|
|
return;
|
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
ctx->staging.dev_type = RXON_DEV_TYPE_P2P;
|
2011-01-07 00:07:10 +08:00
|
|
|
ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->hw_roc_channel = NULL;
|
2011-01-07 00:07:10 +08:00
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
memset(ctx->staging.node_addr, 0, ETH_ALEN);
|
|
|
|
|
2011-06-03 22:54:16 +08:00
|
|
|
iwlagn_commit_rxon(priv, ctx);
|
2011-01-07 00:07:10 +08:00
|
|
|
|
|
|
|
ctx->is_active = false;
|
2011-07-24 01:24:47 +08:00
|
|
|
priv->hw_roc_setup = false;
|
2011-01-07 00:07:10 +08:00
|
|
|
}
|
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
static void iwlagn_disable_roc_work(struct work_struct *work)
|
2011-01-07 00:07:10 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = container_of(work, struct iwl_priv,
|
2011-07-24 01:24:47 +08:00
|
|
|
hw_roc_disable_work.work);
|
2011-01-07 00:07:10 +08:00
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
iwlagn_disable_roc(priv);
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iwl_mac_remain_on_channel(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_channel *channel,
|
|
|
|
enum nl80211_channel_type channel_type,
|
|
|
|
int duration)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
2011-07-24 01:24:47 +08:00
|
|
|
struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
|
2011-01-07 00:07:10 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
if (!(ctx->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)))
|
2011-01-07 00:07:10 +08:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
/*
|
|
|
|
* TODO: Remove this hack! Firmware needs to be updated
|
|
|
|
* to allow longer off-channel periods in scanning for
|
|
|
|
* this use case, based on a flag (and we'll need an API
|
|
|
|
* flag in the firmware when it has that).
|
|
|
|
*/
|
|
|
|
if (iwl_is_associated(priv, IWL_RXON_CTX_BSS) && duration > 80)
|
|
|
|
duration = 80;
|
|
|
|
|
2011-08-26 14:10:42 +08:00
|
|
|
if (test_bit(STATUS_SCAN_HW, &priv->shrd->status)) {
|
2011-01-07 00:07:10 +08:00
|
|
|
err = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->hw_roc_channel = channel;
|
|
|
|
priv->hw_roc_chantype = channel_type;
|
2011-07-24 01:24:47 +08:00
|
|
|
priv->hw_roc_duration = duration;
|
|
|
|
cancel_delayed_work(&priv->hw_roc_disable_work);
|
|
|
|
|
|
|
|
if (!ctx->is_active) {
|
|
|
|
ctx->is_active = true;
|
|
|
|
ctx->staging.dev_type = RXON_DEV_TYPE_P2P;
|
|
|
|
memcpy(ctx->staging.node_addr,
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,
|
|
|
|
ETH_ALEN);
|
|
|
|
memcpy(ctx->staging.bssid_addr,
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,
|
|
|
|
ETH_ALEN);
|
|
|
|
err = iwlagn_commit_rxon(priv, ctx);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK |
|
|
|
|
RXON_FILTER_PROMISC_MSK |
|
|
|
|
RXON_FILTER_CTL2HOST_MSK;
|
|
|
|
|
|
|
|
err = iwlagn_commit_rxon(priv, ctx);
|
|
|
|
if (err) {
|
|
|
|
iwlagn_disable_roc(priv);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
priv->hw_roc_setup = true;
|
|
|
|
}
|
2011-01-07 00:07:10 +08:00
|
|
|
|
2011-07-24 01:24:47 +08:00
|
|
|
err = iwl_scan_initiate(priv, ctx->vif, IWL_SCAN_ROC, channel->band);
|
|
|
|
if (err)
|
|
|
|
iwlagn_disable_roc(priv);
|
2011-01-07 00:07:10 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iwl_mac_cancel_remain_on_channel(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
|
|
|
|
if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2011-07-24 01:24:47 +08:00
|
|
|
iwl_scan_cancel_timeout(priv, priv->hw_roc_duration);
|
2011-01-07 00:07:10 +08:00
|
|
|
iwlagn_disable_roc(priv);
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* driver setup and teardown
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-06-12 09:46:53 +08:00
|
|
|
static void iwl_setup_deferred_work(struct iwl_priv *priv)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2011-08-26 14:10:41 +08:00
|
|
|
priv->shrd->workqueue = create_singlethread_workqueue(DRV_NAME);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
|
|
|
init_waitqueue_head(&priv->wait_command_queue);
|
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
INIT_WORK(&priv->restart, iwl_bg_restart);
|
|
|
|
INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
|
2008-06-12 09:46:52 +08:00
|
|
|
INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
|
2010-06-25 04:18:35 +08:00
|
|
|
INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);
|
2010-08-23 22:57:04 +08:00
|
|
|
INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);
|
2010-08-23 22:57:10 +08:00
|
|
|
INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);
|
2011-07-24 01:24:47 +08:00
|
|
|
INIT_DELAYED_WORK(&priv->hw_roc_disable_work,
|
|
|
|
iwlagn_disable_roc_work);
|
2008-06-12 09:47:10 +08:00
|
|
|
|
|
|
|
iwl_setup_scan_deferred_work(priv);
|
2008-01-28 08:41:47 +08:00
|
|
|
|
2011-07-03 20:45:34 +08:00
|
|
|
if (priv->cfg->lib->bt_setup_deferred_work)
|
|
|
|
priv->cfg->lib->bt_setup_deferred_work(priv);
|
2008-06-12 09:46:53 +08:00
|
|
|
|
|
|
|
init_timer(&priv->statistics_periodic);
|
|
|
|
priv->statistics_periodic.data = (unsigned long)priv;
|
2008-10-30 05:05:46 +08:00
|
|
|
priv->statistics_periodic.function = iwl_bg_statistics_periodic;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-12-11 06:37:26 +08:00
|
|
|
init_timer(&priv->ucode_trace);
|
|
|
|
priv->ucode_trace.data = (unsigned long)priv;
|
|
|
|
priv->ucode_trace.function = iwl_bg_ucode_trace;
|
|
|
|
|
2010-12-03 22:41:48 +08:00
|
|
|
init_timer(&priv->watchdog);
|
|
|
|
priv->watchdog.data = (unsigned long)priv;
|
|
|
|
priv->watchdog.function = iwl_bg_watchdog;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2008-06-12 09:46:53 +08:00
|
|
|
static void iwl_cancel_deferred_work(struct iwl_priv *priv)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2011-07-07 23:33:01 +08:00
|
|
|
if (priv->cfg->lib->cancel_deferred_work)
|
|
|
|
priv->cfg->lib->cancel_deferred_work(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-06-04 01:14:01 +08:00
|
|
|
cancel_work_sync(&priv->run_time_calib_work);
|
2007-09-26 08:54:57 +08:00
|
|
|
cancel_work_sync(&priv->beacon_update);
|
2010-09-13 20:46:41 +08:00
|
|
|
|
|
|
|
iwl_cancel_scan_deferred_work(priv);
|
|
|
|
|
2010-08-23 22:57:04 +08:00
|
|
|
cancel_work_sync(&priv->bt_full_concurrency);
|
2010-08-23 22:57:10 +08:00
|
|
|
cancel_work_sync(&priv->bt_runtime_config);
|
2011-07-24 01:24:47 +08:00
|
|
|
cancel_delayed_work_sync(&priv->hw_roc_disable_work);
|
2010-09-13 20:46:41 +08:00
|
|
|
|
2008-06-12 09:46:53 +08:00
|
|
|
del_timer_sync(&priv->statistics_periodic);
|
2009-12-11 06:37:26 +08:00
|
|
|
del_timer_sync(&priv->ucode_trace);
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2009-10-31 05:36:11 +08:00
|
|
|
static void iwl_init_hw_rates(struct iwl_priv *priv,
|
|
|
|
struct ieee80211_rate *rates)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < IWL_RATE_COUNT_LEGACY; i++) {
|
|
|
|
rates[i].bitrate = iwl_rates[i].ieee * 5;
|
|
|
|
rates[i].hw_value = i; /* Rate scaling will work on indexes */
|
|
|
|
rates[i].hw_value_short = i;
|
|
|
|
rates[i].flags = 0;
|
|
|
|
if ((i >= IWL_FIRST_CCK_RATE) && (i <= IWL_LAST_CCK_RATE)) {
|
|
|
|
/*
|
|
|
|
* If CCK != 1M then set short preamble rate flag.
|
|
|
|
*/
|
|
|
|
rates[i].flags |=
|
|
|
|
(iwl_rates[i].plcp == IWL_RATE_1M_PLCP) ?
|
|
|
|
0 : IEEE80211_RATE_SHORT_PREAMBLE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iwl_init_drv(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock_init(&priv->sta_lock);
|
|
|
|
spin_lock_init(&priv->hcmd_lock);
|
|
|
|
|
|
|
|
mutex_init(&priv->mutex);
|
|
|
|
|
|
|
|
priv->ieee_channels = NULL;
|
|
|
|
priv->ieee_rates = NULL;
|
|
|
|
priv->band = IEEE80211_BAND_2GHZ;
|
|
|
|
|
|
|
|
priv->iw_mode = NL80211_IFTYPE_STATION;
|
2009-12-11 06:37:27 +08:00
|
|
|
priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
|
2010-01-23 06:22:42 +08:00
|
|
|
priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
|
2011-07-13 23:38:57 +08:00
|
|
|
priv->agg_tids_count = 0;
|
2009-10-31 05:36:11 +08:00
|
|
|
|
2010-02-19 14:03:06 +08:00
|
|
|
/* initialize force reset */
|
|
|
|
priv->force_reset[IWL_RF_RESET].reset_duration =
|
|
|
|
IWL_DELAY_NEXT_FORCE_RF_RESET;
|
|
|
|
priv->force_reset[IWL_FW_RESET].reset_duration =
|
|
|
|
IWL_DELAY_NEXT_FORCE_FW_RELOAD;
|
2009-10-31 05:36:11 +08:00
|
|
|
|
2011-03-05 00:51:51 +08:00
|
|
|
priv->rx_statistics_jiffies = jiffies;
|
|
|
|
|
2009-10-31 05:36:11 +08:00
|
|
|
/* Choose which receivers/antennas to use */
|
2011-07-01 22:59:26 +08:00
|
|
|
iwlagn_set_rxon_chain(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
|
2009-10-31 05:36:11 +08:00
|
|
|
|
|
|
|
iwl_init_scan_params(priv);
|
|
|
|
|
2010-08-23 22:57:11 +08:00
|
|
|
/* init bt coex */
|
2010-10-06 23:10:00 +08:00
|
|
|
if (priv->cfg->bt_params &&
|
|
|
|
priv->cfg->bt_params->advanced_bt_coexist) {
|
2010-08-23 22:57:14 +08:00
|
|
|
priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
|
|
|
|
priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
|
|
|
|
priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
|
2010-08-23 22:57:11 +08:00
|
|
|
priv->bt_on_thresh = BT_ON_THRESHOLD_DEF;
|
|
|
|
priv->bt_duration = BT_DURATION_LIMIT_DEF;
|
|
|
|
priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF;
|
|
|
|
}
|
|
|
|
|
2009-10-31 05:36:11 +08:00
|
|
|
ret = iwl_init_channel_map(priv);
|
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2011-08-26 14:10:33 +08:00
|
|
|
ret = iwl_init_geos(priv);
|
2009-10-31 05:36:11 +08:00
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "initializing geos failed: %d\n", ret);
|
|
|
|
goto err_free_channel_map;
|
|
|
|
}
|
|
|
|
iwl_init_hw_rates(priv, priv->ieee_rates);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_free_channel_map:
|
|
|
|
iwl_free_channel_map(priv);
|
|
|
|
err:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void iwl_uninit_drv(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
iwl_calib_free_results(priv);
|
2011-08-26 14:10:33 +08:00
|
|
|
iwl_free_geos(priv);
|
2009-10-31 05:36:11 +08:00
|
|
|
iwl_free_channel_map(priv);
|
2010-04-06 19:12:41 +08:00
|
|
|
kfree(priv->scan_cmd);
|
2011-05-14 02:57:40 +08:00
|
|
|
kfree(priv->beacon_cmd);
|
2011-07-16 04:23:45 +08:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUGFS
|
|
|
|
kfree(priv->wowlan_sram);
|
|
|
|
#endif
|
2009-10-31 05:36:11 +08:00
|
|
|
}
|
|
|
|
|
2011-07-08 23:46:24 +08:00
|
|
|
static void iwl_mac_rssi_callback(struct ieee80211_hw *hw,
|
2011-07-08 23:46:23 +08:00
|
|
|
enum ieee80211_rssi_event rssi_event)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
|
|
|
if (priv->cfg->bt_params &&
|
|
|
|
priv->cfg->bt_params->advanced_bt_coexist) {
|
|
|
|
if (rssi_event == RSSI_EVENT_LOW)
|
|
|
|
priv->bt_enable_pspoll = true;
|
|
|
|
else if (rssi_event == RSSI_EVENT_HIGH)
|
|
|
|
priv->bt_enable_pspoll = false;
|
|
|
|
|
|
|
|
iwlagn_send_advance_bt_config(priv);
|
|
|
|
} else {
|
|
|
|
IWL_DEBUG_MAC80211(priv, "Advanced BT coex disabled,"
|
|
|
|
"ignoring RSSI callback\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2010-10-24 00:15:39 +08:00
|
|
|
struct ieee80211_ops iwlagn_hw_ops = {
|
2010-10-24 00:15:41 +08:00
|
|
|
.tx = iwlagn_mac_tx,
|
|
|
|
.start = iwlagn_mac_start,
|
|
|
|
.stop = iwlagn_mac_stop,
|
2011-07-25 04:09:32 +08:00
|
|
|
#ifdef CONFIG_PM
|
2011-07-16 04:23:45 +08:00
|
|
|
.suspend = iwlagn_mac_suspend,
|
|
|
|
.resume = iwlagn_mac_resume,
|
2011-07-25 04:09:32 +08:00
|
|
|
#endif
|
2008-10-30 05:05:46 +08:00
|
|
|
.add_interface = iwl_mac_add_interface,
|
|
|
|
.remove_interface = iwl_mac_remove_interface,
|
2010-10-24 00:15:43 +08:00
|
|
|
.change_interface = iwl_mac_change_interface,
|
2010-10-24 00:15:41 +08:00
|
|
|
.config = iwlagn_mac_config,
|
2010-08-17 17:24:01 +08:00
|
|
|
.configure_filter = iwlagn_configure_filter,
|
2010-10-24 00:15:41 +08:00
|
|
|
.set_key = iwlagn_mac_set_key,
|
|
|
|
.update_tkip_key = iwlagn_mac_update_tkip_key,
|
2011-07-16 04:23:45 +08:00
|
|
|
.set_rekey_data = iwlagn_mac_set_rekey_data,
|
2008-10-30 05:05:46 +08:00
|
|
|
.conf_tx = iwl_mac_conf_tx,
|
2010-10-24 00:15:41 +08:00
|
|
|
.bss_info_changed = iwlagn_bss_info_changed,
|
|
|
|
.ampdu_action = iwlagn_mac_ampdu_action,
|
2009-11-14 03:56:37 +08:00
|
|
|
.hw_scan = iwl_mac_hw_scan,
|
2010-10-24 00:15:41 +08:00
|
|
|
.sta_notify = iwlagn_mac_sta_notify,
|
2010-02-23 08:24:47 +08:00
|
|
|
.sta_add = iwlagn_mac_sta_add,
|
|
|
|
.sta_remove = iwl_mac_sta_remove,
|
2010-10-24 00:15:41 +08:00
|
|
|
.channel_switch = iwlagn_mac_channel_switch,
|
|
|
|
.flush = iwlagn_mac_flush,
|
2010-07-31 23:34:10 +08:00
|
|
|
.tx_last_beacon = iwl_mac_tx_last_beacon,
|
2011-01-07 00:07:10 +08:00
|
|
|
.remain_on_channel = iwl_mac_remain_on_channel,
|
|
|
|
.cancel_remain_on_channel = iwl_mac_cancel_remain_on_channel,
|
2011-07-08 23:46:23 +08:00
|
|
|
.rssi_callback = iwl_mac_rssi_callback,
|
iwlwifi: support the svtool messages interactions through nl80211 test mode
This patch adds the feature to support the test mode operation through
the generic netlink channel NL80211_CMD_TESTMODE between intel
wireless device iwlwifi and the user space application svtool.
The main purpose is to create a transportation layer between the iwlwifi
device and the user space application so that the interaction between the
user space application svtool and the iwlwifi device in the kernel space is
in a way of generic netlink messaging.
The detail specific functions are:
1. The function iwl_testmode_cmd() is added to digest the svtool test command
from the user space application. The svtool test commands are categorized to
three types : commands to be processed by the device ucode, commands to access
the registers, and commands to be processed at the driver level(such as reload
the ucode). iwl_testmode_cmd() dispatches the commands the corresponding handlers
and reply to user space regarding the command execution status. Extra data is
returned to the user space application if there's any.
2. The function iwl_testmode_ucode_rx_pkt() is added to multicast all the spontaneous
messages from the iwlwifi device to the user space. Regardless the message types,
whenever there is a valid spontaneous message received by the iwlwifi ISR,
iwl_testmode_ucode_rx_pkt() is invoked to multicast the message content to user
space. The message content is not attacked and the message parsing is left to
the user space application.
Implementation guidelines:
1. The generic netlink messaging for iwliwif test mode is through NL80211_CMD_TESTMODE
channel, therefore, the codes need to follow the regulations set by cfg80211.ko
to get the actual device instance ieee80211_ops via cfg80211.ko, so that the iwlwifi
device is indicated with ieee80211_ops and can be actually accessed.
Therefore, a callback iwl_testmode_cmd() is added to the structure
iwlagn_hw_ops in iwl-agn.c.
2. It intends to utilize those low level device access APIs from iwlwifi device driver
(ie. iwlagn.ko) rather than creating it's own set of device access functions.
For example, iwl_send_cmd(), iwl_read32(), iwl_write8(), and iwl_write32() are reused.
3. The main functions are maintained in new files instead of spreading all over the
existing iwlwifi driver files.
The new files added are :
drivers/net/wireless/iwlwifi/iwl-sv-open.c
- to handle the user space test mode application command
and reply the respective command status to the user space application.
- to multicast the spontaneous messages from device to user space.
drivers/net/wireless/iwlwifi/iwl-testmode.h
- the commonly referenced definitions for the TLVs used in
the generic netlink messages
Signed-off-by: Cindy H. Kao <cindy.h.kao@intel.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-05-07 01:40:15 +08:00
|
|
|
CFG80211_TESTMODE_CMD(iwl_testmode_cmd)
|
2011-05-31 23:03:02 +08:00
|
|
|
CFG80211_TESTMODE_DUMP(iwl_testmode_dump)
|
2007-09-26 08:54:57 +08:00
|
|
|
};
|
|
|
|
|
2011-04-06 00:42:08 +08:00
|
|
|
static u32 iwl_hw_detect(struct iwl_priv *priv)
|
2010-07-31 23:34:05 +08:00
|
|
|
{
|
2011-04-06 00:42:12 +08:00
|
|
|
return iwl_read32(priv, CSR_HW_REV);
|
2010-07-31 23:34:05 +08:00
|
|
|
}
|
|
|
|
|
2010-07-31 23:34:08 +08:00
|
|
|
static int iwl_set_hw_params(struct iwl_priv *priv)
|
|
|
|
{
|
2011-08-26 14:10:39 +08:00
|
|
|
hw_params(priv).max_rxq_size = RX_QUEUE_SIZE;
|
|
|
|
hw_params(priv).max_rxq_log = RX_QUEUE_SIZE_LOG;
|
2011-04-21 06:23:57 +08:00
|
|
|
if (iwlagn_mod_params.amsdu_size_8K)
|
2011-08-26 14:10:39 +08:00
|
|
|
hw_params(priv).rx_page_order =
|
|
|
|
get_order(IWL_RX_BUF_SIZE_8K);
|
2010-07-31 23:34:08 +08:00
|
|
|
else
|
2011-08-26 14:10:39 +08:00
|
|
|
hw_params(priv).rx_page_order =
|
|
|
|
get_order(IWL_RX_BUF_SIZE_4K);
|
2010-07-31 23:34:08 +08:00
|
|
|
|
2011-08-26 14:10:39 +08:00
|
|
|
hw_params(priv).max_beacon_itrvl = IWL_MAX_UCODE_BEACON_INTERVAL;
|
2010-07-31 23:34:08 +08:00
|
|
|
|
2011-04-21 06:23:57 +08:00
|
|
|
if (iwlagn_mod_params.disable_11n)
|
2011-06-07 03:05:46 +08:00
|
|
|
priv->cfg->sku &= ~EEPROM_SKU_CAP_11N_ENABLE;
|
2010-07-31 23:34:08 +08:00
|
|
|
|
|
|
|
/* Device-specific setup */
|
2011-07-07 23:33:01 +08:00
|
|
|
return priv->cfg->lib->set_hw_params(priv);
|
2010-07-31 23:34:08 +08:00
|
|
|
}
|
|
|
|
|
2011-04-19 00:34:06 +08:00
|
|
|
/* This function both allocates and initializes hw and priv. */
|
|
|
|
static struct ieee80211_hw *iwl_alloc_all(struct iwl_cfg *cfg)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv;
|
|
|
|
/* mac80211 allocates memory for this device instance, including
|
|
|
|
* space for this driver's private structure */
|
|
|
|
struct ieee80211_hw *hw;
|
|
|
|
|
|
|
|
hw = ieee80211_alloc_hw(sizeof(struct iwl_priv), &iwlagn_hw_ops);
|
|
|
|
if (hw == NULL) {
|
|
|
|
pr_err("%s: Can not allocate network device\n",
|
|
|
|
cfg->name);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv = hw->priv;
|
|
|
|
priv->hw = hw;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return hw;
|
|
|
|
}
|
|
|
|
|
2011-07-11 15:48:51 +08:00
|
|
|
int iwl_probe(struct iwl_bus *bus, struct iwl_cfg *cfg)
|
2011-06-07 23:53:14 +08:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
struct iwl_priv *priv;
|
|
|
|
struct ieee80211_hw *hw;
|
2011-05-31 14:07:00 +08:00
|
|
|
u16 num_mac;
|
2011-06-07 23:53:14 +08:00
|
|
|
u32 hw_rev;
|
|
|
|
|
|
|
|
/************************
|
|
|
|
* 1. Allocating HW data
|
|
|
|
************************/
|
|
|
|
hw = iwl_alloc_all(cfg);
|
|
|
|
if (!hw) {
|
|
|
|
err = -ENOMEM;
|
2011-06-09 17:55:55 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-06-07 23:53:14 +08:00
|
|
|
priv = hw->priv;
|
2011-07-11 15:48:51 +08:00
|
|
|
priv->bus = bus;
|
2011-08-26 14:10:37 +08:00
|
|
|
priv->shrd = &priv->_shrd;
|
|
|
|
priv->shrd->bus = bus;
|
|
|
|
priv->shrd->priv = priv;
|
|
|
|
bus_set_drv_data(priv->bus, priv->shrd);
|
2011-05-31 13:22:30 +08:00
|
|
|
|
2011-06-07 23:53:14 +08:00
|
|
|
/* At this point both hw and priv are allocated. */
|
2010-08-23 16:46:37 +08:00
|
|
|
|
2011-07-11 15:48:51 +08:00
|
|
|
SET_IEEE80211_DEV(hw, priv->bus->dev);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
|
2008-03-05 10:09:30 +08:00
|
|
|
priv->cfg = cfg;
|
2009-05-23 02:01:52 +08:00
|
|
|
priv->inta_mask = CSR_INI_SET_MASK;
|
2008-03-15 01:38:46 +08:00
|
|
|
|
2010-08-23 22:57:04 +08:00
|
|
|
/* is antenna coupling more than 35dB ? */
|
|
|
|
priv->bt_ant_couple_ok =
|
2011-08-26 14:10:36 +08:00
|
|
|
(iwlagn_mod_params.ant_coupling >
|
|
|
|
IWL_BT_ANTENNA_COUPLING_THRESHOLD) ?
|
|
|
|
true : false;
|
2010-08-23 22:57:04 +08:00
|
|
|
|
2010-11-27 05:24:19 +08:00
|
|
|
/* enable/disable bt channel inhibition */
|
2011-08-26 14:10:36 +08:00
|
|
|
priv->bt_ch_announce = iwlagn_mod_params.bt_ch_announce;
|
2010-11-27 05:24:19 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n",
|
|
|
|
(priv->bt_ch_announce) ? "On" : "Off");
|
2010-08-23 22:57:12 +08:00
|
|
|
|
2009-08-08 06:41:39 +08:00
|
|
|
if (iwl_alloc_traffic_mem(priv))
|
|
|
|
IWL_ERR(priv, "Not enough memory to generate traffic log\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2009-12-15 06:12:11 +08:00
|
|
|
/* these spin locks will be used in apm_ops.init and EEPROM access
|
2009-05-23 02:01:47 +08:00
|
|
|
* we should init now
|
|
|
|
*/
|
|
|
|
spin_lock_init(&priv->reg_lock);
|
2011-08-26 14:10:43 +08:00
|
|
|
spin_lock_init(&priv->shrd->lock);
|
2010-02-04 01:38:59 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* stop and reset the on-board processor just in case it is in a
|
|
|
|
* strange state ... like being left stranded by a primary kernel
|
|
|
|
* and this is now the kdump kernel trying to start up
|
|
|
|
*/
|
|
|
|
iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
|
|
|
|
|
2011-05-31 14:07:00 +08:00
|
|
|
/***********************
|
|
|
|
* 3. Read REV register
|
|
|
|
***********************/
|
2011-04-06 00:42:08 +08:00
|
|
|
hw_rev = iwl_hw_detect(priv);
|
2010-03-06 09:05:20 +08:00
|
|
|
IWL_INFO(priv, "Detected %s, REV=0x%X\n",
|
2011-04-06 00:42:08 +08:00
|
|
|
priv->cfg->name, hw_rev);
|
2008-03-15 01:38:46 +08:00
|
|
|
|
2011-07-21 08:51:22 +08:00
|
|
|
err = iwl_trans_register(&priv->trans, priv);
|
|
|
|
if (err)
|
|
|
|
goto out_free_traffic_mem;
|
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
if (trans_prepare_card_hw(&priv->trans)) {
|
2011-06-09 17:55:54 +08:00
|
|
|
err = -EIO;
|
2009-05-23 02:01:54 +08:00
|
|
|
IWL_WARN(priv, "Failed, HW not ready\n");
|
2011-07-21 08:51:22 +08:00
|
|
|
goto out_free_trans;
|
2009-05-23 02:01:54 +08:00
|
|
|
}
|
|
|
|
|
2008-04-24 08:14:53 +08:00
|
|
|
/*****************
|
|
|
|
* 4. Read EEPROM
|
|
|
|
*****************/
|
2008-03-15 01:38:46 +08:00
|
|
|
/* Read the EEPROM */
|
2011-04-06 00:42:08 +08:00
|
|
|
err = iwl_eeprom_init(priv, hw_rev);
|
2008-03-15 01:38:46 +08:00
|
|
|
if (err) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "Unable to init EEPROM\n");
|
2011-07-21 08:51:22 +08:00
|
|
|
goto out_free_trans;
|
2008-03-15 01:38:46 +08:00
|
|
|
}
|
2008-04-24 08:14:55 +08:00
|
|
|
err = iwl_eeprom_check_version(priv);
|
|
|
|
if (err)
|
2009-02-28 08:21:22 +08:00
|
|
|
goto out_free_eeprom;
|
2008-04-24 08:14:55 +08:00
|
|
|
|
2010-11-11 05:32:59 +08:00
|
|
|
err = iwl_eeprom_check_sku(priv);
|
|
|
|
if (err)
|
|
|
|
goto out_free_eeprom;
|
|
|
|
|
2008-05-15 13:53:53 +08:00
|
|
|
/* extract MAC Address */
|
2010-07-15 20:58:30 +08:00
|
|
|
iwl_eeprom_get_mac(priv, priv->addresses[0].addr);
|
|
|
|
IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr);
|
|
|
|
priv->hw->wiphy->addresses = priv->addresses;
|
|
|
|
priv->hw->wiphy->n_addresses = 1;
|
|
|
|
num_mac = iwl_eeprom_query16(priv, EEPROM_NUM_MAC_ADDRESS);
|
|
|
|
if (num_mac > 1) {
|
|
|
|
memcpy(priv->addresses[1].addr, priv->addresses[0].addr,
|
|
|
|
ETH_ALEN);
|
|
|
|
priv->addresses[1].addr[5]++;
|
|
|
|
priv->hw->wiphy->n_addresses++;
|
|
|
|
}
|
2008-03-15 01:38:46 +08:00
|
|
|
|
|
|
|
/************************
|
|
|
|
* 5. Setup HW constants
|
|
|
|
************************/
|
2008-06-30 17:23:20 +08:00
|
|
|
if (iwl_set_hw_params(priv)) {
|
2011-05-31 14:07:00 +08:00
|
|
|
err = -ENOENT;
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "failed to set hw parameters\n");
|
2008-04-22 06:41:52 +08:00
|
|
|
goto out_free_eeprom;
|
2008-03-15 01:38:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*******************
|
2008-05-15 13:54:17 +08:00
|
|
|
* 6. Setup priv
|
2008-03-15 01:38:46 +08:00
|
|
|
*******************/
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-05-15 13:54:17 +08:00
|
|
|
err = iwl_init_drv(priv);
|
2008-03-15 01:38:49 +08:00
|
|
|
if (err)
|
2008-04-24 08:14:56 +08:00
|
|
|
goto out_free_eeprom;
|
2008-03-15 01:38:49 +08:00
|
|
|
/* At this point both hw and priv are initialized. */
|
2008-03-15 01:38:46 +08:00
|
|
|
|
|
|
|
/********************
|
2009-04-21 05:37:03 +08:00
|
|
|
* 7. Setup services
|
2008-03-15 01:38:46 +08:00
|
|
|
********************/
|
2008-06-12 09:46:53 +08:00
|
|
|
iwl_setup_deferred_work(priv);
|
2008-06-30 17:23:11 +08:00
|
|
|
iwl_setup_rx_handlers(priv);
|
iwlwifi: support the svtool messages interactions through nl80211 test mode
This patch adds the feature to support the test mode operation through
the generic netlink channel NL80211_CMD_TESTMODE between intel
wireless device iwlwifi and the user space application svtool.
The main purpose is to create a transportation layer between the iwlwifi
device and the user space application so that the interaction between the
user space application svtool and the iwlwifi device in the kernel space is
in a way of generic netlink messaging.
The detail specific functions are:
1. The function iwl_testmode_cmd() is added to digest the svtool test command
from the user space application. The svtool test commands are categorized to
three types : commands to be processed by the device ucode, commands to access
the registers, and commands to be processed at the driver level(such as reload
the ucode). iwl_testmode_cmd() dispatches the commands the corresponding handlers
and reply to user space regarding the command execution status. Extra data is
returned to the user space application if there's any.
2. The function iwl_testmode_ucode_rx_pkt() is added to multicast all the spontaneous
messages from the iwlwifi device to the user space. Regardless the message types,
whenever there is a valid spontaneous message received by the iwlwifi ISR,
iwl_testmode_ucode_rx_pkt() is invoked to multicast the message content to user
space. The message content is not attacked and the message parsing is left to
the user space application.
Implementation guidelines:
1. The generic netlink messaging for iwliwif test mode is through NL80211_CMD_TESTMODE
channel, therefore, the codes need to follow the regulations set by cfg80211.ko
to get the actual device instance ieee80211_ops via cfg80211.ko, so that the iwlwifi
device is indicated with ieee80211_ops and can be actually accessed.
Therefore, a callback iwl_testmode_cmd() is added to the structure
iwlagn_hw_ops in iwl-agn.c.
2. It intends to utilize those low level device access APIs from iwlwifi device driver
(ie. iwlagn.ko) rather than creating it's own set of device access functions.
For example, iwl_send_cmd(), iwl_read32(), iwl_write8(), and iwl_write32() are reused.
3. The main functions are maintained in new files instead of spreading all over the
existing iwlwifi driver files.
The new files added are :
drivers/net/wireless/iwlwifi/iwl-sv-open.c
- to handle the user space test mode application command
and reply the respective command status to the user space application.
- to multicast the spontaneous messages from device to user space.
drivers/net/wireless/iwlwifi/iwl-testmode.h
- the commonly referenced definitions for the TLVs used in
the generic netlink messages
Signed-off-by: Cindy H. Kao <cindy.h.kao@intel.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
2011-05-07 01:40:15 +08:00
|
|
|
iwl_testmode_init(priv);
|
2008-03-15 01:38:46 +08:00
|
|
|
|
2010-01-23 06:22:53 +08:00
|
|
|
/*********************************************
|
2011-05-31 14:07:00 +08:00
|
|
|
* 8. Enable interrupts
|
2010-01-23 06:22:53 +08:00
|
|
|
*********************************************/
|
2008-05-15 13:54:17 +08:00
|
|
|
|
2010-12-23 19:38:21 +08:00
|
|
|
iwl_enable_rfkill_int(priv);
|
2009-01-19 20:10:07 +08:00
|
|
|
|
|
|
|
/* If platform's RF_KILL switch is NOT set to KILL */
|
|
|
|
if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
|
2011-08-26 14:10:42 +08:00
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->shrd->status);
|
2009-01-19 20:10:07 +08:00
|
|
|
else
|
2011-08-26 14:10:42 +08:00
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->shrd->status);
|
2008-05-15 13:54:17 +08:00
|
|
|
|
2009-06-05 00:26:06 +08:00
|
|
|
wiphy_rfkill_set_hw_state(priv->hw->wiphy,
|
2011-08-26 14:10:42 +08:00
|
|
|
test_bit(STATUS_RF_KILL_HW, &priv->shrd->status));
|
2009-01-19 20:10:07 +08:00
|
|
|
|
2008-06-12 09:47:19 +08:00
|
|
|
iwl_power_initialize(priv);
|
iwlwifi: Thermal Throttling Management - Part 1
Part 1 of Thermal Throttling Management -
Thermal Throttling feature is used to put NIC into low power state when
driver detect the Radio temperature reach pre-defined threshold
Two Thermal Throttling Management Methods; this patch introduce the
Legacy Thermal Management:
IWL_TI_0: normal temperature, system power state
IWL_TI_1: high temperature detect, low power state
IWL_TI_2: higher temperature detected, lower power state
IWL_TI_CT_KILL: critical temperature detected, lowest power state
Once get into CT_KILL state, uCode go into sleep, driver will stop all
the active queues, then move to IWL_TI_CT_KILL state; also set up 5
seconds timer to toggle CSR flag, uCode wake up upon CSR flag change,
then measure the temperature.
If temperature is above CT_KILL exit threshold, uCode go backto sleep;
if temperature is below CT_KILL exit threshold, uCode send Card State
Notification response with appropriate CT_KILL status flag, and uCode
remain awake, Driver receive Card State Notification Response and update
the card temperature to the CT_KILL exit threshold.
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-25 02:13:02 +08:00
|
|
|
iwl_tt_initialize(priv);
|
2010-01-23 06:22:53 +08:00
|
|
|
|
2011-07-13 23:38:57 +08:00
|
|
|
init_completion(&priv->firmware_loading_complete);
|
2010-04-29 22:41:53 +08:00
|
|
|
|
2010-01-30 03:54:56 +08:00
|
|
|
err = iwl_request_firmware(priv, true);
|
2010-01-23 06:22:53 +08:00
|
|
|
if (err)
|
2010-05-23 15:14:08 +08:00
|
|
|
goto out_destroy_workqueue;
|
2010-01-23 06:22:53 +08:00
|
|
|
|
2007-09-26 08:54:57 +08:00
|
|
|
return 0;
|
|
|
|
|
2011-07-04 13:58:19 +08:00
|
|
|
out_destroy_workqueue:
|
2011-08-26 14:10:41 +08:00
|
|
|
destroy_workqueue(priv->shrd->workqueue);
|
|
|
|
priv->shrd->workqueue = NULL;
|
2008-05-15 13:54:17 +08:00
|
|
|
iwl_uninit_drv(priv);
|
2011-07-04 13:58:19 +08:00
|
|
|
out_free_eeprom:
|
2008-04-22 06:41:52 +08:00
|
|
|
iwl_eeprom_free(priv);
|
2011-07-21 08:51:22 +08:00
|
|
|
out_free_trans:
|
|
|
|
trans_free(&priv->trans);
|
2011-07-04 13:58:19 +08:00
|
|
|
out_free_traffic_mem:
|
2009-08-08 06:41:39 +08:00
|
|
|
iwl_free_traffic_mem(priv);
|
2009-10-10 04:20:17 +08:00
|
|
|
ieee80211_free_hw(priv->hw);
|
2011-07-04 13:58:19 +08:00
|
|
|
out:
|
2007-09-26 08:54:57 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-05-31 13:22:30 +08:00
|
|
|
void __devexit iwl_remove(struct iwl_priv * priv)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2008-03-29 07:21:08 +08:00
|
|
|
unsigned long flags;
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-07-13 23:38:57 +08:00
|
|
|
wait_for_completion(&priv->firmware_loading_complete);
|
2010-04-29 22:41:53 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-05-29 16:35:26 +08:00
|
|
|
iwl_dbgfs_unregister(priv);
|
2011-07-11 15:48:51 +08:00
|
|
|
sysfs_remove_group(&priv->bus->dev->kobj,
|
2011-05-31 13:52:10 +08:00
|
|
|
&iwl_attribute_group);
|
2008-05-29 16:35:26 +08:00
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
/* ieee80211_unregister_hw call wil cause iwl_mac_stop to
|
|
|
|
* to be called and iwl_down since we are removing the device
|
2008-09-03 11:18:50 +08:00
|
|
|
* we need to set STATUS_EXIT_PENDING bit.
|
|
|
|
*/
|
2011-08-26 14:10:42 +08:00
|
|
|
set_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
|
2011-01-22 07:26:39 +08:00
|
|
|
|
2011-05-07 01:21:28 +08:00
|
|
|
iwl_testmode_cleanup(priv);
|
2011-01-22 07:26:39 +08:00
|
|
|
iwl_leds_exit(priv);
|
|
|
|
|
2008-03-29 07:21:10 +08:00
|
|
|
if (priv->mac80211_registered) {
|
|
|
|
ieee80211_unregister_hw(priv->hw);
|
|
|
|
priv->mac80211_registered = 0;
|
|
|
|
}
|
|
|
|
|
2011-04-13 18:14:44 +08:00
|
|
|
/* Reset to low power before unloading driver. */
|
2010-09-23 00:02:10 +08:00
|
|
|
iwl_apm_stop(priv);
|
2009-10-24 04:42:35 +08:00
|
|
|
|
iwlwifi: Thermal Throttling Management - Part 1
Part 1 of Thermal Throttling Management -
Thermal Throttling feature is used to put NIC into low power state when
driver detect the Radio temperature reach pre-defined threshold
Two Thermal Throttling Management Methods; this patch introduce the
Legacy Thermal Management:
IWL_TI_0: normal temperature, system power state
IWL_TI_1: high temperature detect, low power state
IWL_TI_2: higher temperature detected, lower power state
IWL_TI_CT_KILL: critical temperature detected, lowest power state
Once get into CT_KILL state, uCode go into sleep, driver will stop all
the active queues, then move to IWL_TI_CT_KILL state; also set up 5
seconds timer to toggle CSR flag, uCode wake up upon CSR flag change,
then measure the temperature.
If temperature is above CT_KILL exit threshold, uCode go backto sleep;
if temperature is below CT_KILL exit threshold, uCode send Card State
Notification response with appropriate CT_KILL status flag, and uCode
remain awake, Driver receive Card State Notification Response and update
the card temperature to the CT_KILL exit threshold.
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-25 02:13:02 +08:00
|
|
|
iwl_tt_exit(priv);
|
|
|
|
|
2008-03-29 07:21:08 +08:00
|
|
|
/* make sure we flush any pending irq or
|
|
|
|
* tasklet for the driver
|
|
|
|
*/
|
2011-08-26 14:10:43 +08:00
|
|
|
spin_lock_irqsave(&priv->shrd->lock, flags);
|
2008-10-30 05:05:46 +08:00
|
|
|
iwl_disable_interrupts(priv);
|
2011-08-26 14:10:43 +08:00
|
|
|
spin_unlock_irqrestore(&priv->shrd->lock, flags);
|
2008-03-29 07:21:08 +08:00
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
trans_sync_irq(&priv->trans);
|
2008-03-29 07:21:08 +08:00
|
|
|
|
2011-05-31 13:52:10 +08:00
|
|
|
iwl_dealloc_ucode(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
trans_rx_free(&priv->trans);
|
|
|
|
trans_tx_free(&priv->trans);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-04-22 06:41:52 +08:00
|
|
|
iwl_eeprom_free(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2007-10-25 17:15:45 +08:00
|
|
|
/*netif_stop_queue(dev); */
|
2011-08-26 14:10:41 +08:00
|
|
|
flush_workqueue(priv->shrd->workqueue);
|
2007-10-25 17:15:45 +08:00
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
/* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
|
2011-08-26 14:10:41 +08:00
|
|
|
* priv->shrd->workqueue... so we can't take down the workqueue
|
2007-09-26 08:54:57 +08:00
|
|
|
* until now... */
|
2011-08-26 14:10:41 +08:00
|
|
|
destroy_workqueue(priv->shrd->workqueue);
|
|
|
|
priv->shrd->workqueue = NULL;
|
2009-08-08 06:41:39 +08:00
|
|
|
iwl_free_traffic_mem(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-07-11 13:51:04 +08:00
|
|
|
trans_free(&priv->trans);
|
2011-07-04 13:58:19 +08:00
|
|
|
|
2011-07-11 15:48:51 +08:00
|
|
|
bus_set_drv_data(priv->bus, NULL);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2008-05-15 13:54:17 +08:00
|
|
|
iwl_uninit_drv(priv);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2010-10-04 20:50:36 +08:00
|
|
|
dev_kfree_skb(priv->beacon_skb);
|
2007-09-26 08:54:57 +08:00
|
|
|
|
|
|
|
ieee80211_free_hw(priv->hw);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* driver and module entry point
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
2008-10-30 05:05:46 +08:00
|
|
|
static int __init iwl_init(void)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
int ret;
|
2010-07-27 05:39:58 +08:00
|
|
|
pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
|
|
|
|
pr_info(DRV_COPYRIGHT "\n");
|
2008-03-29 07:21:09 +08:00
|
|
|
|
2008-07-18 13:53:05 +08:00
|
|
|
ret = iwlagn_rate_control_register();
|
2008-03-29 07:21:09 +08:00
|
|
|
if (ret) {
|
2010-07-27 05:39:58 +08:00
|
|
|
pr_err("Unable to register rate control algorithm: %d\n", ret);
|
2008-03-29 07:21:09 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-05-24 16:39:02 +08:00
|
|
|
ret = iwl_pci_register_driver();
|
2007-09-26 08:54:57 +08:00
|
|
|
|
2011-05-24 16:39:02 +08:00
|
|
|
if (ret)
|
|
|
|
goto error_register;
|
2007-09-26 08:54:57 +08:00
|
|
|
return ret;
|
2008-03-29 07:21:09 +08:00
|
|
|
|
|
|
|
error_register:
|
2008-07-18 13:53:05 +08:00
|
|
|
iwlagn_rate_control_unregister();
|
2008-03-29 07:21:09 +08:00
|
|
|
return ret;
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
static void __exit iwl_exit(void)
|
2007-09-26 08:54:57 +08:00
|
|
|
{
|
2011-05-24 16:39:02 +08:00
|
|
|
iwl_pci_unregister_driver();
|
2008-07-18 13:53:05 +08:00
|
|
|
iwlagn_rate_control_unregister();
|
2007-09-26 08:54:57 +08:00
|
|
|
}
|
|
|
|
|
2008-10-30 05:05:46 +08:00
|
|
|
module_exit(iwl_exit);
|
|
|
|
module_init(iwl_init);
|
2009-07-18 00:30:24 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2011-08-26 14:10:36 +08:00
|
|
|
module_param_named(debug, iwlagn_mod_params.debug_level, uint,
|
|
|
|
S_IRUGO | S_IWUSR);
|
2009-07-18 00:30:24 +08:00
|
|
|
MODULE_PARM_DESC(debug, "debug output mask");
|
|
|
|
#endif
|
|
|
|
|
2010-03-23 00:17:39 +08:00
|
|
|
module_param_named(swcrypto, iwlagn_mod_params.sw_crypto, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
|
|
|
|
module_param_named(queues_num, iwlagn_mod_params.num_of_queues, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(queues_num, "number of hw queues.");
|
|
|
|
module_param_named(11n_disable, iwlagn_mod_params.disable_11n, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
|
|
|
|
module_param_named(amsdu_size_8K, iwlagn_mod_params.amsdu_size_8K,
|
|
|
|
int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size");
|
|
|
|
module_param_named(fw_restart, iwlagn_mod_params.restart_fw, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
|
2010-04-29 14:33:10 +08:00
|
|
|
|
2011-08-26 14:10:36 +08:00
|
|
|
module_param_named(ucode_alternative,
|
|
|
|
iwlagn_mod_params.wanted_ucode_alternative,
|
|
|
|
int, S_IRUGO);
|
2010-04-29 14:33:10 +08:00
|
|
|
MODULE_PARM_DESC(ucode_alternative,
|
|
|
|
"specify ucode alternative to use from ucode file");
|
2010-08-23 22:57:04 +08:00
|
|
|
|
2011-08-26 14:10:36 +08:00
|
|
|
module_param_named(antenna_coupling, iwlagn_mod_params.ant_coupling,
|
|
|
|
int, S_IRUGO);
|
2010-08-23 22:57:04 +08:00
|
|
|
MODULE_PARM_DESC(antenna_coupling,
|
|
|
|
"specify antenna coupling in dB (defualt: 0 dB)");
|
2010-08-23 22:57:12 +08:00
|
|
|
|
2011-08-26 14:10:36 +08:00
|
|
|
module_param_named(bt_ch_inhibition, iwlagn_mod_params.bt_ch_announce,
|
|
|
|
bool, S_IRUGO);
|
2010-11-27 05:24:19 +08:00
|
|
|
MODULE_PARM_DESC(bt_ch_inhibition,
|
|
|
|
"Disable BT channel inhibition (default: enable)");
|
2011-02-28 21:33:15 +08:00
|
|
|
|
|
|
|
module_param_named(plcp_check, iwlagn_mod_params.plcp_check, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(plcp_check, "Check plcp health (default: 1 [enabled])");
|
|
|
|
|
|
|
|
module_param_named(ack_check, iwlagn_mod_params.ack_check, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(ack_check, "Check ack health (default: 0 [disabled])");
|
2011-06-04 04:52:38 +08:00
|
|
|
|
2011-06-26 00:17:41 +08:00
|
|
|
module_param_named(wd_disable, iwlagn_mod_params.wd_disable, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(wd_disable,
|
|
|
|
"Disable stuck queue watchdog timer (default: 0 [enabled])");
|
|
|
|
|
2011-06-04 04:52:38 +08:00
|
|
|
/*
|
|
|
|
* set bt_coex_active to true, uCode will do kill/defer
|
|
|
|
* every time the priority line is asserted (BT is sending signals on the
|
|
|
|
* priority line in the PCIx).
|
|
|
|
* set bt_coex_active to false, uCode will ignore the BT activity and
|
|
|
|
* perform the normal operation
|
|
|
|
*
|
|
|
|
* User might experience transmit issue on some platform due to WiFi/BT
|
|
|
|
* co-exist problem. The possible behaviors are:
|
|
|
|
* Able to scan and finding all the available AP
|
|
|
|
* Not able to associate with any AP
|
|
|
|
* On those platforms, WiFi communication can be restored by set
|
|
|
|
* "bt_coex_active" module parameter to "false"
|
|
|
|
*
|
|
|
|
* default: bt_coex_active = true (BT_COEX_ENABLE)
|
|
|
|
*/
|
|
|
|
module_param_named(bt_coex_active, iwlagn_mod_params.bt_coex_active,
|
|
|
|
bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)");
|
2011-06-04 04:52:39 +08:00
|
|
|
|
|
|
|
module_param_named(led_mode, iwlagn_mod_params.led_mode, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(led_mode, "0=system default, "
|
|
|
|
"1=On(RF On)/Off(RF Off), 2=blinking (default: 0)");
|
2011-06-04 04:52:40 +08:00
|
|
|
|
2011-06-12 01:00:05 +08:00
|
|
|
module_param_named(power_save, iwlagn_mod_params.power_save,
|
|
|
|
bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(power_save,
|
|
|
|
"enable WiFi power management (default: disable)");
|
|
|
|
|
2011-06-12 01:00:06 +08:00
|
|
|
module_param_named(power_level, iwlagn_mod_params.power_level,
|
|
|
|
int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(power_level,
|
|
|
|
"default power save level (range from 1 - 5, default: 1)");
|
|
|
|
|
2011-06-04 04:52:40 +08:00
|
|
|
/*
|
|
|
|
* For now, keep using power level 1 instead of automatically
|
|
|
|
* adjusting ...
|
|
|
|
*/
|
|
|
|
module_param_named(no_sleep_autoadjust, iwlagn_mod_params.no_sleep_autoadjust,
|
|
|
|
bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(no_sleep_autoadjust,
|
|
|
|
"don't automatically adjust sleep level "
|
|
|
|
"according to maximum network latency (default: true)");
|