2007-09-26 00:54:57 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
2010-01-15 21:43:41 +00:00
|
|
|
* Copyright(c) 2003 - 2010 Intel Corporation. All rights reserved.
|
2007-09-26 00:54:57 +00: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-09 19:28:58 +00:00
|
|
|
* Intel Linux Wireless <ilw@linux.intel.com>
|
2007-09-26 00:54:57 +00:00
|
|
|
* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2010-07-26 21:39:58 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/pci.h>
|
2010-08-05 18:39:31 +00:00
|
|
|
#include <linux/pci-aspm.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 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2007-09-26 00:54:57 +00:00
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/delay.h>
|
2009-10-07 13:09:06 +00:00
|
|
|
#include <linux/sched.h>
|
2007-09-26 00:54:57 +00:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/wireless.h>
|
|
|
|
#include <linux/firmware.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
|
|
|
|
#include <net/mac80211.h>
|
|
|
|
|
|
|
|
#include <asm/div64.h>
|
|
|
|
|
2008-12-19 02:37:09 +00:00
|
|
|
#define DRV_NAME "iwlagn"
|
|
|
|
|
2008-03-11 23:17:18 +00:00
|
|
|
#include "iwl-eeprom.h"
|
2008-04-24 18:55:38 +00:00
|
|
|
#include "iwl-dev.h"
|
2008-04-03 23:05:21 +00:00
|
|
|
#include "iwl-core.h"
|
2008-03-25 23:33:37 +00:00
|
|
|
#include "iwl-io.h"
|
2007-09-26 00:54:57 +00:00
|
|
|
#include "iwl-helpers.h"
|
2008-04-15 04:16:06 +00:00
|
|
|
#include "iwl-sta.h"
|
2008-04-16 23:34:47 +00:00
|
|
|
#include "iwl-calib.h"
|
2010-01-21 14:21:10 +00:00
|
|
|
#include "iwl-agn.h"
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-10-25 09:15:49 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* module boiler plate
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* module name, copyright, version, etc.
|
|
|
|
*/
|
2008-07-18 05:53:02 +00:00
|
|
|
#define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2007-09-26 00:54:57 +00:00
|
|
|
#define VD "d"
|
|
|
|
#else
|
|
|
|
#define VD
|
|
|
|
#endif
|
|
|
|
|
2010-01-22 22:22:57 +00:00
|
|
|
#define DRV_VERSION IWLWIFI_VERSION VD
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION(DRV_DESCRIPTION);
|
|
|
|
MODULE_VERSION(DRV_VERSION);
|
2008-12-11 18:33:41 +00:00
|
|
|
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
|
2007-09-26 00:54:57 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
2008-07-21 15:54:42 +00:00
|
|
|
MODULE_ALIAS("iwl4965");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 14:57:04 +00:00
|
|
|
static int iwlagn_ant_coupling;
|
2010-08-23 14:57:12 +00:00
|
|
|
static bool iwlagn_bt_ch_announce = 1;
|
2010-08-23 14:57:04 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_commit_rxon - commit staging_rxon to hardware
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
2007-10-25 09:15:22 +00:00
|
|
|
* The RXON command in staging_rxon is committed to the hardware and
|
2007-09-26 00:54:57 +00:00
|
|
|
* the active_rxon structure is updated with the new data. This
|
|
|
|
* function correctly transitions out of the RXON_ASSOC_MSK state if
|
|
|
|
* a HW tune is required based on the RXON structure changes.
|
|
|
|
*/
|
2010-08-23 08:46:32 +00:00
|
|
|
int iwl_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
/* cast away the const for active_rxon in this function */
|
2010-08-23 08:46:32 +00:00
|
|
|
struct iwl_rxon_cmd *active_rxon = (void *)&ctx->active;
|
2008-06-30 09:23:06 +00:00
|
|
|
int ret;
|
|
|
|
bool new_assoc =
|
2010-08-23 08:46:32 +00:00
|
|
|
!!(ctx->staging.filter_flags & RXON_FILTER_ASSOC_MSK);
|
2010-08-23 08:46:56 +00:00
|
|
|
bool old_assoc = !!(ctx->active.filter_flags & RXON_FILTER_ASSOC_MSK);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_alive(priv))
|
2008-06-30 09:23:06 +00:00
|
|
|
return -EBUSY;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-09-03 13:32:21 +00:00
|
|
|
if (!ctx->is_active)
|
|
|
|
return 0;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* always get timestamp with Rx frame */
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags |= RXON_FLG_TSF2HOST_MSK;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
ret = iwl_check_rxon_cmd(priv, ctx);
|
2008-06-30 09:23:06 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Invalid RXON configuration. Not committing.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-11-06 22:52:54 +00:00
|
|
|
/*
|
|
|
|
* receive commit_rxon request
|
|
|
|
* abort any previous channel switch if still in process
|
|
|
|
*/
|
|
|
|
if (priv->switch_rxon.switch_in_progress &&
|
2010-08-23 08:46:32 +00:00
|
|
|
(priv->switch_rxon.channel != ctx->staging.channel)) {
|
2009-11-06 22:52:54 +00:00
|
|
|
IWL_DEBUG_11H(priv, "abort channel switch on %d\n",
|
|
|
|
le16_to_cpu(priv->switch_rxon.channel));
|
2010-05-06 15:54:11 +00:00
|
|
|
iwl_chswitch_done(priv, false);
|
2009-11-06 22:52:54 +00:00
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* If we don't need to send a full RXON, we can use
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_rxon_assoc_cmd which is used to reconfigure filter
|
2007-09-26 00:54:57 +00:00
|
|
|
* and other flags for the current radio configuration. */
|
2010-08-23 08:46:32 +00:00
|
|
|
if (!iwl_full_rxon_required(priv, ctx)) {
|
|
|
|
ret = iwl_send_rxon_assoc(priv, ctx);
|
2008-06-30 09:23:06 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error setting RXON_ASSOC (%d)\n", ret);
|
2008-06-30 09:23:06 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
memcpy(active_rxon, &ctx->staging, sizeof(*active_rxon));
|
|
|
|
iwl_print_rx_config_cmd(priv, ctx);
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we are currently associated and the new config requires
|
|
|
|
* an RXON_ASSOC and the new config wants the associated mask enabled,
|
|
|
|
* we must clear the associated from the active configuration
|
|
|
|
* before we apply the new config */
|
2010-08-23 08:46:32 +00:00
|
|
|
if (iwl_is_associated_ctx(ctx) && new_assoc) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Toggling associated bit on current RXON\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
|
2010-08-23 08:46:37 +00:00
|
|
|
ret = iwl_send_cmd_pdu(priv, ctx->rxon_cmd,
|
2010-08-23 08:46:32 +00:00
|
|
|
sizeof(struct iwl_rxon_cmd),
|
|
|
|
active_rxon);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* If the mask clearing failed then we set
|
|
|
|
* active_rxon back to what it was previously */
|
2008-06-30 09:23:06 +00:00
|
|
|
if (ret) {
|
2007-09-26 00:54:57 +00:00
|
|
|
active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error clearing ASSOC_MSK (%d)\n", ret);
|
2008-06-30 09:23:06 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2010-08-27 15:55:52 +00:00
|
|
|
iwl_clear_ucode_stations(priv, ctx);
|
|
|
|
iwl_restore_stations(priv, ctx);
|
2010-08-23 08:46:43 +00:00
|
|
|
ret = iwl_restore_default_wep_keys(priv, ctx);
|
2010-03-30 17:11:46 +00:00
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Failed to restore WEP keys (%d)\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Sending RXON\n"
|
2007-09-26 00:54:57 +00:00
|
|
|
"* with%s RXON_FILTER_ASSOC_MSK\n"
|
|
|
|
"* channel = %d\n"
|
2008-10-27 22:59:26 +00:00
|
|
|
"* bssid = %pM\n",
|
2008-06-30 09:23:06 +00:00
|
|
|
(new_assoc ? "" : "out"),
|
2010-08-23 08:46:32 +00:00
|
|
|
le16_to_cpu(ctx->staging.channel),
|
|
|
|
ctx->staging.bssid_addr);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
iwl_set_rxon_hwcrypto(priv, ctx, !priv->cfg->mod_params->sw_crypto);
|
2008-06-30 09:23:06 +00:00
|
|
|
|
2010-08-23 08:46:56 +00:00
|
|
|
if (!old_assoc) {
|
2010-08-23 08:46:52 +00:00
|
|
|
/*
|
|
|
|
* First of all, before setting associated, we need to
|
|
|
|
* send RXON timing so the device knows about the DTIM
|
|
|
|
* period and other timing values
|
|
|
|
*/
|
2010-08-23 08:46:55 +00:00
|
|
|
ret = iwl_send_rxon_timing(priv, ctx);
|
2010-08-23 08:46:52 +00:00
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Error setting RXON timing!\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-27 16:44:50 +00:00
|
|
|
if (priv->cfg->ops->hcmd->set_pan_params) {
|
|
|
|
ret = priv->cfg->ops->hcmd->set_pan_params(priv);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-06-30 09:23:06 +00:00
|
|
|
/* Apply the new configuration
|
2010-02-19 06:58:32 +00:00
|
|
|
* RXON unassoc clears the station table in uCode so restoration of
|
|
|
|
* stations is needed after it (the RXON command) completes
|
2008-06-30 09:23:06 +00:00
|
|
|
*/
|
|
|
|
if (!new_assoc) {
|
2010-08-23 08:46:37 +00:00
|
|
|
ret = iwl_send_cmd_pdu(priv, ctx->rxon_cmd,
|
2010-08-23 08:46:32 +00:00
|
|
|
sizeof(struct iwl_rxon_cmd), &ctx->staging);
|
2008-06-30 09:23:06 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error setting new RXON (%d)\n", ret);
|
2008-06-30 09:23:06 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2010-03-24 21:19:58 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Return from !new_assoc RXON.\n");
|
2010-08-23 08:46:32 +00:00
|
|
|
memcpy(active_rxon, &ctx->staging, sizeof(*active_rxon));
|
2010-08-27 15:55:52 +00:00
|
|
|
iwl_clear_ucode_stations(priv, ctx);
|
|
|
|
iwl_restore_stations(priv, ctx);
|
2010-08-23 08:46:43 +00:00
|
|
|
ret = iwl_restore_default_wep_keys(priv, ctx);
|
2010-03-30 17:11:46 +00:00
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Failed to restore WEP keys (%d)\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-05-08 20:44:36 +00:00
|
|
|
priv->start_calib = 0;
|
2008-06-30 09:23:14 +00:00
|
|
|
if (new_assoc) {
|
2008-06-30 09:23:06 +00:00
|
|
|
/* Apply the new configuration
|
|
|
|
* RXON assoc doesn't clear the station table in uCode,
|
|
|
|
*/
|
2010-08-23 08:46:37 +00:00
|
|
|
ret = iwl_send_cmd_pdu(priv, ctx->rxon_cmd,
|
2010-08-23 08:46:32 +00:00
|
|
|
sizeof(struct iwl_rxon_cmd), &ctx->staging);
|
2008-06-30 09:23:06 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error setting new RXON (%d)\n", ret);
|
2008-06-30 09:23:06 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2010-08-23 08:46:32 +00:00
|
|
|
memcpy(active_rxon, &ctx->staging, sizeof(*active_rxon));
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2010-08-23 08:46:32 +00:00
|
|
|
iwl_print_rx_config_cmd(priv, ctx);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-07-11 03:53:40 +00:00
|
|
|
iwl_init_sensitivity(priv);
|
|
|
|
|
|
|
|
/* If we issue a new RXON command which required a tune then we must
|
|
|
|
* send a new TXPOWER command or we won't be able to Tx any frames */
|
|
|
|
ret = iwl_set_tx_power(priv, priv->tx_power_user_lmt, true);
|
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error sending TX power (%d)\n", ret);
|
2008-07-11 03:53:40 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
void iwl_update_chain_flags(struct iwl_priv *priv)
|
2008-04-21 22:41:51 +00:00
|
|
|
{
|
2010-08-23 08:46:32 +00:00
|
|
|
struct iwl_rxon_context *ctx;
|
2008-04-21 22:41:51 +00:00
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
if (priv->cfg->ops->hcmd->set_rxon_chain) {
|
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
|
|
|
|
iwlcore_commit_rxon(priv, ctx);
|
|
|
|
}
|
|
|
|
}
|
2008-04-21 22:41:51 +00:00
|
|
|
}
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
static void iwl_clear_free_frames(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
struct list_head *element;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "%d frames on pre-allocated heap on clear.\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->frames_count);
|
|
|
|
|
|
|
|
while (!list_empty(&priv->free_frames)) {
|
|
|
|
element = priv->free_frames.next;
|
|
|
|
list_del(element);
|
2008-05-15 05:54:01 +00:00
|
|
|
kfree(list_entry(element, struct iwl_frame, list));
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->frames_count--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->frames_count) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "%d frames still in use. Did we lose one?\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->frames_count);
|
|
|
|
priv->frames_count = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
static struct iwl_frame *iwl_get_free_frame(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-15 05:54:01 +00:00
|
|
|
struct iwl_frame *frame;
|
2007-09-26 00:54:57 +00:00
|
|
|
struct list_head *element;
|
|
|
|
if (list_empty(&priv->free_frames)) {
|
|
|
|
frame = kzalloc(sizeof(*frame), GFP_KERNEL);
|
|
|
|
if (!frame) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Could not allocate frame!\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->frames_count++;
|
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
element = priv->free_frames.next;
|
|
|
|
list_del(element);
|
2008-05-15 05:54:01 +00:00
|
|
|
return list_entry(element, struct iwl_frame, list);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
static void iwl_free_frame(struct iwl_priv *priv, struct iwl_frame *frame)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
memset(frame, 0, sizeof(*frame));
|
|
|
|
list_add(&frame->list, &priv->free_frames);
|
|
|
|
}
|
|
|
|
|
2009-11-13 19:56:33 +00:00
|
|
|
static u32 iwl_fill_beacon_frame(struct iwl_priv *priv,
|
2008-07-18 05:53:03 +00:00
|
|
|
struct ieee80211_hdr *hdr,
|
2008-12-16 07:37:07 +00:00
|
|
|
int left)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-07-15 12:59:07 +00:00
|
|
|
if (!priv->ibss_beacon)
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (priv->ibss_beacon->len > left)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
memcpy(hdr, priv->ibss_beacon->data, priv->ibss_beacon->len);
|
|
|
|
|
|
|
|
return priv->ibss_beacon->len;
|
|
|
|
}
|
|
|
|
|
2009-11-13 19:56:33 +00: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,
|
|
|
|
struct iwl_tx_beacon_cmd *tx_beacon_cmd,
|
|
|
|
u8 *beacon, u32 frame_size)
|
|
|
|
{
|
|
|
|
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");
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static unsigned int iwl_hw_get_beacon_cmd(struct iwl_priv *priv,
|
2009-11-13 19:56:33 +00:00
|
|
|
struct iwl_frame *frame)
|
2008-07-18 05:53:03 +00:00
|
|
|
{
|
|
|
|
struct iwl_tx_beacon_cmd *tx_beacon_cmd;
|
2009-11-13 19:56:33 +00:00
|
|
|
u32 frame_size;
|
|
|
|
u32 rate_flags;
|
|
|
|
u32 rate;
|
|
|
|
/*
|
|
|
|
* We have to set up the TX command, the TX Beacon command, and the
|
|
|
|
* beacon contents.
|
|
|
|
*/
|
2008-07-18 05:53:03 +00:00
|
|
|
|
2010-08-23 08:46:47 +00:00
|
|
|
lockdep_assert_held(&priv->mutex);
|
|
|
|
|
|
|
|
if (!priv->beacon_ctx) {
|
|
|
|
IWL_ERR(priv, "trying to build beacon w/o beacon context!\n");
|
2010-09-05 19:00:26 +00:00
|
|
|
return 0;
|
2010-08-23 08:46:47 +00:00
|
|
|
}
|
|
|
|
|
2009-11-13 19:56:33 +00:00
|
|
|
/* Initialize memory */
|
2008-07-18 05:53:03 +00:00
|
|
|
tx_beacon_cmd = &frame->u.beacon;
|
|
|
|
memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
|
|
|
|
|
2009-11-13 19:56:33 +00:00
|
|
|
/* Set up TX beacon contents */
|
2008-07-18 05:53:03 +00:00
|
|
|
frame_size = iwl_fill_beacon_frame(priv, tx_beacon_cmd->frame,
|
|
|
|
sizeof(frame->u) - sizeof(*tx_beacon_cmd));
|
2009-11-13 19:56:33 +00:00
|
|
|
if (WARN_ON_ONCE(frame_size > MAX_MPDU_SIZE))
|
|
|
|
return 0;
|
2008-07-18 05:53:03 +00:00
|
|
|
|
2009-11-13 19:56:33 +00:00
|
|
|
/* Set up TX command fields */
|
2008-07-18 05:53:03 +00:00
|
|
|
tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
|
2010-08-23 08:46:47 +00:00
|
|
|
tx_beacon_cmd->tx.sta_id = priv->beacon_ctx->bcast_sta_id;
|
2009-11-13 19:56:33 +00: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 05:53:03 +00:00
|
|
|
|
2009-11-13 19:56:33 +00:00
|
|
|
/* Set up TX beacon command fields */
|
|
|
|
iwl_set_beacon_tim(priv, tx_beacon_cmd, (u8 *)tx_beacon_cmd->frame,
|
|
|
|
frame_size);
|
2008-07-18 05:53:03 +00:00
|
|
|
|
2009-11-13 19:56:33 +00:00
|
|
|
/* Set up packet rate and flags */
|
2010-08-23 08:46:47 +00:00
|
|
|
rate = iwl_rate_get_lowest_plcp(priv, priv->beacon_ctx);
|
2010-05-18 09:48:36 +00:00
|
|
|
priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
|
|
|
|
priv->hw_params.valid_tx_ant);
|
2009-11-13 19:56:33 +00:00
|
|
|
rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
|
|
|
|
if ((rate >= IWL_FIRST_CCK_RATE) && (rate <= IWL_LAST_CCK_RATE))
|
|
|
|
rate_flags |= RATE_MCS_CCK_MSK;
|
|
|
|
tx_beacon_cmd->tx.rate_n_flags = iwl_hw_set_rate_n_flags(rate,
|
|
|
|
rate_flags);
|
2008-07-18 05:53:03 +00:00
|
|
|
|
|
|
|
return sizeof(*tx_beacon_cmd) + frame_size;
|
|
|
|
}
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_send_beacon_cmd(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-15 05:54:01 +00:00
|
|
|
struct iwl_frame *frame;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned int frame_size;
|
|
|
|
int rc;
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
frame = iwl_get_free_frame(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
if (!frame) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
|
2007-09-26 00:54:57 +00:00
|
|
|
"command.\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-11-13 19:56:33 +00:00
|
|
|
frame_size = iwl_hw_get_beacon_cmd(priv, frame);
|
|
|
|
if (!frame_size) {
|
|
|
|
IWL_ERR(priv, "Error configuring the beacon command\n");
|
|
|
|
iwl_free_frame(priv, frame);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-21 20:53:44 +00:00
|
|
|
rc = iwl_send_cmd_pdu(priv, REPLY_TX_BEACON, frame_size,
|
2007-09-26 00:54:57 +00:00
|
|
|
&frame->u.cmd[0]);
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
iwl_free_frame(priv, frame);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2009-01-19 23:30:26 +00:00
|
|
|
static inline dma_addr_t iwl_tfd_tb_get_addr(struct iwl_tfd *tfd, u8 idx)
|
|
|
|
{
|
|
|
|
struct iwl_tfd_tb *tb = &tfd->tbs[idx];
|
|
|
|
|
|
|
|
dma_addr_t addr = get_unaligned_le32(&tb->lo);
|
|
|
|
if (sizeof(dma_addr_t) > sizeof(u32))
|
|
|
|
addr |=
|
|
|
|
((dma_addr_t)(le16_to_cpu(tb->hi_n_len) & 0xF) << 16) << 16;
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u16 iwl_tfd_tb_get_len(struct iwl_tfd *tfd, u8 idx)
|
|
|
|
{
|
|
|
|
struct iwl_tfd_tb *tb = &tfd->tbs[idx];
|
|
|
|
|
|
|
|
return le16_to_cpu(tb->hi_n_len) >> 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void iwl_tfd_set_tb(struct iwl_tfd *tfd, u8 idx,
|
|
|
|
dma_addr_t addr, u16 len)
|
|
|
|
{
|
|
|
|
struct iwl_tfd_tb *tb = &tfd->tbs[idx];
|
|
|
|
u16 hi_n_len = len << 4;
|
|
|
|
|
|
|
|
put_unaligned_le32(addr, &tb->lo);
|
|
|
|
if (sizeof(dma_addr_t) > sizeof(u32))
|
|
|
|
hi_n_len |= ((addr >> 16) >> 16) & 0xF;
|
|
|
|
|
|
|
|
tb->hi_n_len = cpu_to_le16(hi_n_len);
|
|
|
|
|
|
|
|
tfd->num_tbs = idx + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u8 iwl_tfd_get_num_tbs(struct iwl_tfd *tfd)
|
|
|
|
{
|
|
|
|
return tfd->num_tbs & 0x1f;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_hw_txq_free_tfd - Free all chunks referenced by TFD [txq->q.read_ptr]
|
|
|
|
* @priv - driver private data
|
|
|
|
* @txq - tx queue
|
|
|
|
*
|
|
|
|
* Does NOT advance any TFD circular buffer read/write indexes
|
|
|
|
* Does NOT free the TFD itself (which is within circular buffer)
|
|
|
|
*/
|
|
|
|
void iwl_hw_txq_free_tfd(struct iwl_priv *priv, struct iwl_tx_queue *txq)
|
|
|
|
{
|
2009-01-23 21:45:13 +00:00
|
|
|
struct iwl_tfd *tfd_tmp = (struct iwl_tfd *)txq->tfds;
|
2009-01-19 23:30:26 +00:00
|
|
|
struct iwl_tfd *tfd;
|
|
|
|
struct pci_dev *dev = priv->pci_dev;
|
|
|
|
int index = txq->q.read_ptr;
|
|
|
|
int i;
|
|
|
|
int num_tbs;
|
|
|
|
|
|
|
|
tfd = &tfd_tmp[index];
|
|
|
|
|
|
|
|
/* Sanity check on number of chunks */
|
|
|
|
num_tbs = iwl_tfd_get_num_tbs(tfd);
|
|
|
|
|
|
|
|
if (num_tbs >= IWL_NUM_OF_TBS) {
|
|
|
|
IWL_ERR(priv, "Too many chunks: %i\n", num_tbs);
|
|
|
|
/* @todo issue fatal error, it is quite serious situation */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unmap tx_cmd */
|
|
|
|
if (num_tbs)
|
|
|
|
pci_unmap_single(dev,
|
2010-06-03 05:19:20 +00:00
|
|
|
dma_unmap_addr(&txq->meta[index], mapping),
|
|
|
|
dma_unmap_len(&txq->meta[index], len),
|
2009-02-18 23:54:33 +00:00
|
|
|
PCI_DMA_BIDIRECTIONAL);
|
2009-01-19 23:30:26 +00:00
|
|
|
|
|
|
|
/* Unmap chunks, if any. */
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
for (i = 1; i < num_tbs; i++)
|
2009-01-19 23:30:26 +00:00
|
|
|
pci_unmap_single(dev, iwl_tfd_tb_get_addr(tfd, i),
|
|
|
|
iwl_tfd_tb_get_len(tfd, i), PCI_DMA_TODEVICE);
|
|
|
|
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
/* free SKB */
|
|
|
|
if (txq->txb) {
|
|
|
|
struct sk_buff *skb;
|
2010-05-17 09:37:32 +00:00
|
|
|
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
skb = txq->txb[txq->q.read_ptr].skb;
|
2010-05-17 09:37:32 +00:00
|
|
|
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
/* can be called from irqs-disabled context */
|
|
|
|
if (skb) {
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
txq->txb[txq->q.read_ptr].skb = NULL;
|
2009-01-19 23:30:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int iwl_hw_txq_attach_buf_to_tfd(struct iwl_priv *priv,
|
|
|
|
struct iwl_tx_queue *txq,
|
|
|
|
dma_addr_t addr, u16 len,
|
|
|
|
u8 reset, u8 pad)
|
|
|
|
{
|
|
|
|
struct iwl_queue *q;
|
2009-01-23 21:45:13 +00:00
|
|
|
struct iwl_tfd *tfd, *tfd_tmp;
|
2009-01-19 23:30:26 +00:00
|
|
|
u32 num_tbs;
|
|
|
|
|
|
|
|
q = &txq->q;
|
2009-01-23 21:45:13 +00:00
|
|
|
tfd_tmp = (struct iwl_tfd *)txq->tfds;
|
|
|
|
tfd = &tfd_tmp[q->write_ptr];
|
2009-01-19 23:30:26 +00:00
|
|
|
|
|
|
|
if (reset)
|
|
|
|
memset(tfd, 0, sizeof(*tfd));
|
|
|
|
|
|
|
|
num_tbs = iwl_tfd_get_num_tbs(tfd);
|
|
|
|
|
|
|
|
/* Each TFD can point to a maximum 20 Tx buffers */
|
|
|
|
if (num_tbs >= IWL_NUM_OF_TBS) {
|
|
|
|
IWL_ERR(priv, "Error can not send more than %d chunks\n",
|
|
|
|
IWL_NUM_OF_TBS);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(addr & ~DMA_BIT_MASK(36));
|
|
|
|
if (unlikely(addr & ~IWL_TX_DMA_MASK))
|
|
|
|
IWL_ERR(priv, "Unaligned address = %llx\n",
|
|
|
|
(unsigned long long)addr);
|
|
|
|
|
|
|
|
iwl_tfd_set_tb(tfd, num_tbs, addr, len);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-23 21:45:14 +00:00
|
|
|
/*
|
|
|
|
* Tell nic where to find circular buffer of Tx Frame Descriptors for
|
|
|
|
* given Tx queue, and enable the DMA channel used for that queue.
|
|
|
|
*
|
|
|
|
* 4965 supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
|
|
|
|
* channels supported in hardware.
|
|
|
|
*/
|
|
|
|
int iwl_hw_tx_queue_init(struct iwl_priv *priv,
|
|
|
|
struct iwl_tx_queue *txq)
|
|
|
|
{
|
|
|
|
int txq_id = txq->q.id;
|
|
|
|
|
|
|
|
/* Circular buffer (TFD queue in DRAM) physical base address */
|
|
|
|
iwl_write_direct32(priv, FH_MEM_CBBC_QUEUE(txq_id),
|
|
|
|
txq->q.dma_addr >> 8);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* Generic RX handler implementations
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
2008-05-29 08:34:55 +00:00
|
|
|
static void iwl_rx_reply_alive(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-10-09 09:19:45 +00:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-05-29 08:34:55 +00:00
|
|
|
struct iwl_alive_resp *palive;
|
2007-09-26 00:54:57 +00:00
|
|
|
struct delayed_work *pwork;
|
|
|
|
|
|
|
|
palive = &pkt->u.alive_frame;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Alive ucode status 0x%08X revision "
|
2007-09-26 00:54:57 +00:00
|
|
|
"0x%01X 0x%01X\n",
|
|
|
|
palive->is_valid, palive->ver_type,
|
|
|
|
palive->ver_subtype);
|
|
|
|
|
|
|
|
if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(&priv->card_alive_init,
|
|
|
|
&pkt->u.alive_frame,
|
2008-05-29 08:34:55 +00:00
|
|
|
sizeof(struct iwl_init_alive_resp));
|
2007-09-26 00:54:57 +00:00
|
|
|
pwork = &priv->init_alive_start;
|
|
|
|
} else {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(&priv->card_alive, &pkt->u.alive_frame,
|
2008-05-29 08:34:55 +00:00
|
|
|
sizeof(struct iwl_alive_resp));
|
2007-09-26 00:54:57 +00:00
|
|
|
pwork = &priv->alive_start;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We delay the ALIVE response by 5ms to
|
|
|
|
* give the HW RF Kill time to activate... */
|
|
|
|
if (palive->is_valid == UCODE_VALID_OK)
|
|
|
|
queue_delayed_work(priv->workqueue, pwork,
|
|
|
|
msecs_to_jiffies(5));
|
|
|
|
else
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "uCode did not respond OK.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bg_beacon_update(struct work_struct *work)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, beacon_update);
|
2007-09-26 00:54:57 +00:00
|
|
|
struct sk_buff *beacon;
|
|
|
|
|
2010-08-23 08:46:47 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
if (!priv->beacon_ctx) {
|
|
|
|
IWL_ERR(priv, "updating beacon w/o beacon context!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 08:46:50 +00: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 08:46:47 +00: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 00:54:57 +00:00
|
|
|
if (!beacon) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "update beacon failed\n");
|
2010-08-23 08:46:47 +00:00
|
|
|
goto out;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* new beacon skb is allocated every time; dispose previous.*/
|
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
|
|
|
|
priv->ibss_beacon = beacon;
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_send_beacon_cmd(priv);
|
2010-08-23 08:46:47 +00:00
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-08-23 14:57:10 +00: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);
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* dont send host command if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return;
|
|
|
|
priv->cfg->ops->hcmd->send_bt_config(priv);
|
|
|
|
}
|
|
|
|
|
2010-08-23 14:57:04 +00: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 08:46:32 +00:00
|
|
|
struct iwl_rxon_context *ctx;
|
2010-08-23 14:57:04 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* dont send host command if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return;
|
|
|
|
|
|
|
|
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 08:46:32 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
if (priv->cfg->ops->hcmd->set_rxon_chain)
|
|
|
|
priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
|
|
|
|
iwlcore_commit_rxon(priv, ctx);
|
|
|
|
}
|
|
|
|
mutex_unlock(&priv->mutex);
|
2010-08-23 14:57:04 +00:00
|
|
|
|
|
|
|
priv->cfg->ops->hcmd->send_bt_config(priv);
|
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
/**
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_bg_statistics_periodic - Timer callback to queue statistics
|
2008-06-12 01:46:53 +00: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-29 21:05:46 +00:00
|
|
|
static void iwl_bg_statistics_periodic(unsigned long data)
|
2008-06-12 01:46:53 +00:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)data;
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
2008-10-29 21:05:49 +00:00
|
|
|
/* dont send host command if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return;
|
|
|
|
|
2009-11-13 19:56:28 +00:00
|
|
|
iwl_send_statistics_request(priv, CMD_ASYNC, false);
|
2008-06-12 01:46:53 +00:00
|
|
|
}
|
|
|
|
|
2009-12-10 22:37:26 +00: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 */
|
|
|
|
_iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, ptr);
|
|
|
|
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++) {
|
|
|
|
ev = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
|
|
|
|
time = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
|
|
|
|
if (mode == 0) {
|
|
|
|
trace_iwlwifi_dev_ucode_cont_event(priv,
|
|
|
|
0, time, ev);
|
|
|
|
} else {
|
|
|
|
data = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
|
|
|
|
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-22 22:22:55 +00:00
|
|
|
static void iwl_continuous_event_trace(struct iwl_priv *priv)
|
2009-12-10 22:37:26 +00: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 */
|
|
|
|
|
|
|
|
if (priv->ucode_type == UCODE_INIT)
|
|
|
|
base = le32_to_cpu(priv->card_alive_init.error_event_table_ptr);
|
|
|
|
else
|
|
|
|
base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
|
|
|
|
if (priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_rx_beacon_notif(struct iwl_priv *priv,
|
2008-05-05 02:22:28 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-10-09 09:19:45 +00:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-12-11 18:33:40 +00:00
|
|
|
struct iwl4965_beacon_notif *beacon =
|
|
|
|
(struct iwl4965_beacon_notif *)pkt->u.raw;
|
2010-07-31 15:34:10 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2008-06-12 01:47:11 +00:00
|
|
|
u8 rate = iwl_hw_get_rate(beacon->beacon_notify_hdr.rate_n_flags);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
|
2007-09-26 00:54:57 +00:00
|
|
|
"tsf %d %d rate %d\n",
|
2008-06-12 01:47:07 +00:00
|
|
|
le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
|
2007-09-26 00:54:57 +00:00
|
|
|
beacon->beacon_notify_hdr.failure_frame,
|
|
|
|
le32_to_cpu(beacon->ibss_mgr_status),
|
|
|
|
le32_to_cpu(beacon->high_tsf),
|
|
|
|
le32_to_cpu(beacon->low_tsf), rate);
|
|
|
|
#endif
|
|
|
|
|
2010-07-31 15:34:10 +00:00
|
|
|
priv->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
|
|
|
|
|
2010-08-23 08:46:50 +00:00
|
|
|
if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
|
2007-09-26 00:54:57 +00:00
|
|
|
queue_work(priv->workqueue, &priv->beacon_update);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle notification from uCode that card's power state is changing
|
|
|
|
* due to software, hardware, or critical temperature RFKILL */
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_rx_card_state_notif(struct iwl_priv *priv,
|
2008-05-05 02:22:28 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-10-09 09:19:45 +00:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2007-09-26 00:54:57 +00:00
|
|
|
u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
|
|
|
|
unsigned long status = priv->status;
|
|
|
|
|
2009-12-10 22:37:24 +00:00
|
|
|
IWL_DEBUG_RF_KILL(priv, "Card state received: HW:%s SW:%s CT:%s\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
(flags & HW_CARD_DISABLED) ? "Kill" : "On",
|
2009-12-10 22:37:24 +00:00
|
|
|
(flags & SW_CARD_DISABLED) ? "Kill" : "On",
|
|
|
|
(flags & CT_CARD_DISABLED) ?
|
|
|
|
"Reached" : "Not reached");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED |
|
2009-12-10 22:37:24 +00:00
|
|
|
CT_CARD_DISABLED)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
|
|
|
|
|
2009-05-22 18:01:47 +00:00
|
|
|
iwl_write_direct32(priv, HBUS_TARG_MBX_C,
|
|
|
|
HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (!(flags & RXON_CARD_DISABLED)) {
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
|
2009-05-22 18:01:47 +00:00
|
|
|
iwl_write_direct32(priv, HBUS_TARG_MBX_C,
|
2007-09-26 00:54:57 +00:00
|
|
|
HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
|
|
|
|
}
|
2009-12-10 22:37:24 +00:00
|
|
|
if (flags & CT_CARD_DISABLED)
|
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-24 18:13:02 +00:00
|
|
|
iwl_tt_enter_ct_kill(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2009-12-10 22:37:24 +00:00
|
|
|
if (!(flags & CT_CARD_DISABLED))
|
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-24 18:13:02 +00:00
|
|
|
iwl_tt_exit_ct_kill(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (flags & HW_CARD_DISABLED)
|
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
else
|
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
|
|
|
|
|
|
|
|
if (!(flags & RXON_CARD_DISABLED))
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if ((test_bit(STATUS_RF_KILL_HW, &status) !=
|
2009-06-04 16:26:06 +00:00
|
|
|
test_bit(STATUS_RF_KILL_HW, &priv->status)))
|
|
|
|
wiphy_rfkill_set_hw_state(priv->hw->wiphy,
|
|
|
|
test_bit(STATUS_RF_KILL_HW, &priv->status));
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
|
|
|
wake_up_interruptible(&priv->wait_command_queue);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
int iwl_set_pwr_src(struct iwl_priv *priv, enum iwl_pwr_src src)
|
2008-07-18 05:53:04 +00:00
|
|
|
{
|
|
|
|
if (src == IWL_PWR_SRC_VAUX) {
|
2009-02-10 23:19:02 +00:00
|
|
|
if (pci_pme_capable(priv->pci_dev, PCI_D3cold))
|
2008-07-18 05:53:04 +00:00
|
|
|
iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
|
|
|
|
APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
|
|
|
|
~APMG_PS_CTRL_MSK_PWR_SRC);
|
|
|
|
} else {
|
|
|
|
iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
|
|
|
|
APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
|
|
|
|
~APMG_PS_CTRL_MSK_PWR_SRC);
|
|
|
|
}
|
|
|
|
|
2009-05-22 18:01:47 +00:00
|
|
|
return 0;
|
2008-07-18 05:53:04 +00:00
|
|
|
}
|
|
|
|
|
2010-06-24 20:18:35 +00:00
|
|
|
static void iwl_bg_tx_flush(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, tx_flush);
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* do nothing if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (priv->cfg->ops->lib->txfifo_flush) {
|
|
|
|
IWL_DEBUG_INFO(priv, "device request: flush all tx frames\n");
|
|
|
|
iwlagn_dev_txfifo_flush(priv, IWL_DROP_ALL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_setup_rx_handlers - Initialize Rx handler callbacks
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Setup the RX handlers for each of the reply types sent from the uCode
|
|
|
|
* to the host.
|
|
|
|
*
|
|
|
|
* This function chains into the hardware specific files for them to setup
|
|
|
|
* any hardware specific handlers as well.
|
|
|
|
*/
|
2008-06-30 09:23:11 +00:00
|
|
|
static void iwl_setup_rx_handlers(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-29 08:34:55 +00:00
|
|
|
priv->rx_handlers[REPLY_ALIVE] = iwl_rx_reply_alive;
|
2008-10-29 21:05:46 +00:00
|
|
|
priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
|
|
|
|
priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
|
2010-01-22 22:22:57 +00:00
|
|
|
priv->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =
|
|
|
|
iwl_rx_spectrum_measure_notif;
|
2008-10-29 21:05:46 +00:00
|
|
|
priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_rx_pm_debug_statistics_notif;
|
|
|
|
priv->rx_handlers[BEACON_NOTIFICATION] = iwl_rx_beacon_notif;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/*
|
|
|
|
* The same handler is used for both the REPLY to a discrete
|
|
|
|
* statistics request from the host as well as for the periodic
|
|
|
|
* statistics notifications (after received beacons) from the uCode.
|
2007-09-26 00:54:57 +00:00
|
|
|
*/
|
2009-11-13 19:56:28 +00:00
|
|
|
priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl_reply_statistics;
|
2008-06-30 09:23:07 +00:00
|
|
|
priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl_rx_statistics;
|
2008-06-12 01:47:10 +00:00
|
|
|
|
|
|
|
iwl_setup_rx_scan_handlers(priv);
|
|
|
|
|
2008-05-29 08:35:18 +00:00
|
|
|
/* status change handler */
|
2008-10-29 21:05:46 +00:00
|
|
|
priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl_rx_card_state_notif;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-29 08:35:04 +00:00
|
|
|
priv->rx_handlers[MISSED_BEACONS_NOTIFICATION] =
|
|
|
|
iwl_rx_missed_beacon_notif;
|
2008-05-29 08:35:18 +00:00
|
|
|
/* Rx handlers */
|
2010-03-17 20:34:36 +00:00
|
|
|
priv->rx_handlers[REPLY_RX_PHY_CMD] = iwlagn_rx_reply_rx_phy;
|
|
|
|
priv->rx_handlers[REPLY_RX_MPDU_CMD] = iwlagn_rx_reply_rx;
|
2008-06-30 09:23:11 +00:00
|
|
|
/* block ack */
|
2010-03-17 20:34:34 +00:00
|
|
|
priv->rx_handlers[REPLY_COMPRESSED_BA] = iwlagn_rx_reply_compressed_ba;
|
2007-11-29 03:09:47 +00:00
|
|
|
/* Set up hardware specific Rx handlers */
|
2008-04-24 18:55:20 +00:00
|
|
|
priv->cfg->ops->lib->rx_handler_setup(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-05-05 02:22:28 +00:00
|
|
|
* iwl_rx_handle - Main entry function for receiving responses from uCode
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Uses the priv->rx_handlers callback function array to invoke
|
|
|
|
* the appropriate handlers, including command responses,
|
|
|
|
* frame-received notifications, and other notifications.
|
|
|
|
*/
|
2008-05-05 02:22:28 +00:00
|
|
|
void iwl_rx_handle(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-05 02:22:28 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb;
|
2008-05-05 02:22:33 +00:00
|
|
|
struct iwl_rx_packet *pkt;
|
2008-05-05 02:22:28 +00:00
|
|
|
struct iwl_rx_queue *rxq = &priv->rxq;
|
2007-09-26 00:54:57 +00:00
|
|
|
u32 r, i;
|
|
|
|
int reclaim;
|
|
|
|
unsigned long flags;
|
2007-11-29 03:10:14 +00:00
|
|
|
u8 fill_rx = 0;
|
2008-02-07 21:16:33 +00:00
|
|
|
u32 count = 8;
|
2009-05-22 18:01:51 +00:00
|
|
|
int total_empty;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:09:55 +00:00
|
|
|
/* uCode's read index (stored in shared DRAM) indicates the last Rx
|
|
|
|
* buffer that the driver may process (last buffer filled by ucode). */
|
2008-11-07 17:58:39 +00:00
|
|
|
r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
|
2007-09-26 00:54:57 +00:00
|
|
|
i = rxq->read;
|
|
|
|
|
|
|
|
/* Rx interrupt, but nothing sent from uCode */
|
|
|
|
if (i == r)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv, "r = %d, i = %d\n", r, i);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-05-22 18:01:51 +00:00
|
|
|
/* calculate total frames need to be restock after handling RX */
|
2009-10-23 20:42:32 +00:00
|
|
|
total_empty = r - rxq->write_actual;
|
2009-05-22 18:01:51 +00:00
|
|
|
if (total_empty < 0)
|
|
|
|
total_empty += RX_QUEUE_SIZE;
|
|
|
|
|
|
|
|
if (total_empty > (RX_QUEUE_SIZE / 2))
|
2007-11-29 03:10:14 +00:00
|
|
|
fill_rx = 1;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
while (i != r) {
|
2010-05-28 11:08:30 +00:00
|
|
|
int len;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
rxb = rxq->queue[i];
|
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/* If an RXB doesn't have a Rx queue slot associated with it,
|
2007-09-26 00:54:57 +00:00
|
|
|
* then a bug has been introduced in the queue refilling
|
|
|
|
* routines -- catch it here */
|
|
|
|
BUG_ON(rxb == NULL);
|
|
|
|
|
|
|
|
rxq->queue[i] = NULL;
|
|
|
|
|
2009-10-09 09:19:45 +00:00
|
|
|
pci_unmap_page(priv->pci_dev, rxb->page_dma,
|
|
|
|
PAGE_SIZE << priv->hw_params.rx_page_order,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
|
|
|
pkt = rxb_addr(rxb);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-05-28 11:08:30 +00:00
|
|
|
len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
|
|
|
|
len += sizeof(u32); /* account for status word */
|
|
|
|
trace_iwlwifi_dev_rx(priv, pkt, len);
|
2009-10-02 20:44:02 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Reclaim a command buffer only if this packet is a response
|
|
|
|
* to a (driver-originated) command.
|
|
|
|
* If the packet (e.g. Rx frame) originated from uCode,
|
|
|
|
* there is no command buffer to reclaim.
|
|
|
|
* Ucode should set SEQ_RX_FRAME bit if ucode-originated,
|
|
|
|
* but apparently a few don't get set; catch them here. */
|
|
|
|
reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
|
|
|
|
(pkt->hdr.cmd != REPLY_RX_PHY_CMD) &&
|
2008-03-21 20:53:44 +00:00
|
|
|
(pkt->hdr.cmd != REPLY_RX) &&
|
2008-10-24 06:48:58 +00:00
|
|
|
(pkt->hdr.cmd != REPLY_RX_MPDU_CMD) &&
|
2007-09-27 03:27:31 +00:00
|
|
|
(pkt->hdr.cmd != REPLY_COMPRESSED_BA) &&
|
2007-09-26 00:54:57 +00:00
|
|
|
(pkt->hdr.cmd != STATISTICS_NOTIFICATION) &&
|
|
|
|
(pkt->hdr.cmd != REPLY_TX);
|
|
|
|
|
|
|
|
/* Based on type of command response or notification,
|
|
|
|
* handle those that need handling via function in
|
2008-10-29 21:05:46 +00:00
|
|
|
* rx_handlers table. See iwl_setup_rx_handlers() */
|
2007-09-26 00:54:57 +00:00
|
|
|
if (priv->rx_handlers[pkt->hdr.cmd]) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv, "r = %d, i = %d, %s, 0x%02x\n", r,
|
2008-05-06 03:05:12 +00:00
|
|
|
i, get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.rx_handlers[pkt->hdr.cmd]++;
|
2009-10-23 20:42:25 +00:00
|
|
|
priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
|
2007-09-26 00:54:57 +00:00
|
|
|
} else {
|
|
|
|
/* No handling needed */
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv,
|
2007-09-26 00:54:57 +00:00
|
|
|
"r %d i %d No handler needed for %s, 0x%02x\n",
|
|
|
|
r, i, get_cmd_string(pkt->hdr.cmd),
|
|
|
|
pkt->hdr.cmd);
|
|
|
|
}
|
|
|
|
|
2009-10-23 20:42:25 +00:00
|
|
|
/*
|
|
|
|
* XXX: After here, we should always check rxb->page
|
|
|
|
* against NULL before touching it or its virtual
|
|
|
|
* memory (pkt). Because some rx_handler might have
|
|
|
|
* already taken or freed the pages.
|
|
|
|
*/
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
if (reclaim) {
|
2009-10-09 09:19:45 +00:00
|
|
|
/* Invoke any callbacks, transfer the buffer to caller,
|
|
|
|
* and fire off the (possibly) blocking iwl_send_cmd()
|
2007-09-26 00:54:57 +00:00
|
|
|
* as we reclaim the driver command queue */
|
2009-10-23 20:42:25 +00:00
|
|
|
if (rxb->page)
|
2008-05-29 08:35:12 +00:00
|
|
|
iwl_tx_cmd_complete(priv, rxb);
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Claim null rxb?\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-10-23 20:42:32 +00:00
|
|
|
/* Reuse the page if possible. For notification packets and
|
|
|
|
* SKBs that fail to Rx correctly, add them back into the
|
|
|
|
* rx_free list for reuse later. */
|
|
|
|
spin_lock_irqsave(&rxq->lock, flags);
|
2009-10-09 09:19:45 +00:00
|
|
|
if (rxb->page != NULL) {
|
2009-10-23 20:42:32 +00:00
|
|
|
rxb->page_dma = pci_map_page(priv->pci_dev, rxb->page,
|
|
|
|
0, PAGE_SIZE << priv->hw_params.rx_page_order,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
|
|
|
list_add_tail(&rxb->list, &rxq->rx_free);
|
|
|
|
rxq->free_count++;
|
|
|
|
} else
|
|
|
|
list_add_tail(&rxb->list, &rxq->rx_used);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&rxq->lock, flags);
|
2009-10-23 20:42:32 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
i = (i + 1) & RX_QUEUE_MASK;
|
2007-11-29 03:10:14 +00:00
|
|
|
/* If there are a lot of unused frames,
|
|
|
|
* restock the Rx queue so ucode wont assert. */
|
|
|
|
if (fill_rx) {
|
|
|
|
count++;
|
|
|
|
if (count >= 8) {
|
2009-10-23 20:42:32 +00:00
|
|
|
rxq->read = i;
|
2010-03-17 20:34:35 +00:00
|
|
|
iwlagn_rx_replenish_now(priv);
|
2007-11-29 03:10:14 +00:00
|
|
|
count = 0;
|
|
|
|
}
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Backtrack one entry */
|
2009-10-23 20:42:32 +00:00
|
|
|
rxq->read = i;
|
2009-05-22 18:01:51 +00:00
|
|
|
if (fill_rx)
|
2010-03-17 20:34:35 +00:00
|
|
|
iwlagn_rx_replenish_now(priv);
|
2009-05-22 18:01:51 +00:00
|
|
|
else
|
2010-03-17 20:34:35 +00:00
|
|
|
iwlagn_rx_queue_restock(priv);
|
2008-05-05 02:22:28 +00:00
|
|
|
}
|
|
|
|
|
2008-03-28 23:21:08 +00:00
|
|
|
/* call this function to flush any scheduled tasklet */
|
|
|
|
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
|
|
|
|
{
|
2008-10-24 06:48:56 +00:00
|
|
|
/* wait to make sure we flush pending tasklet*/
|
2008-03-28 23:21:08 +00:00
|
|
|
synchronize_irq(priv->pci_dev->irq);
|
|
|
|
tasklet_kill(&priv->irq_tasklet);
|
|
|
|
}
|
|
|
|
|
2009-05-22 18:01:50 +00:00
|
|
|
static void iwl_irq_tasklet_legacy(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
u32 inta, handled = 0;
|
|
|
|
u32 inta_fh;
|
|
|
|
unsigned long flags;
|
2009-10-30 21:36:09 +00:00
|
|
|
u32 i;
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2007-09-26 00:54:57 +00:00
|
|
|
u32 inta_mask;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* Ack/clear/reset pending uCode interrupts.
|
|
|
|
* Note: Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
|
|
|
|
* and will clear only when CSR_FH_INT_STATUS gets cleared. */
|
2008-03-25 23:33:37 +00:00
|
|
|
inta = iwl_read32(priv, CSR_INT);
|
|
|
|
iwl_write32(priv, CSR_INT, inta);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Ack/clear/reset pending flow-handler (DMA) interrupts.
|
|
|
|
* Any new interrupts that happen after this, either while we're
|
|
|
|
* in this tasklet, or later, will show up in next ISR/tasklet. */
|
2008-03-25 23:33:37 +00:00
|
|
|
inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
|
|
|
|
iwl_write32(priv, CSR_FH_INT_STATUS, inta_fh);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-08-07 22:41:37 +00:00
|
|
|
if (iwl_get_debug_level(priv) & IWL_DL_ISR) {
|
2007-11-29 03:09:47 +00:00
|
|
|
/* just for debug */
|
2008-03-25 23:33:37 +00:00
|
|
|
inta_mask = iwl_read32(priv, CSR_INT_MASK);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
inta, inta_mask, inta_fh);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-10-09 09:19:45 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
|
|
|
|
* atomic, make sure that inta covers all the interrupts that
|
|
|
|
* we've discovered, even if FH interrupt came in just after
|
|
|
|
* reading CSR_INT. */
|
2008-03-05 02:09:28 +00:00
|
|
|
if (inta_fh & CSR49_FH_INT_RX_MASK)
|
2007-09-26 00:54:57 +00:00
|
|
|
inta |= CSR_INT_BIT_FH_RX;
|
2008-03-05 02:09:28 +00:00
|
|
|
if (inta_fh & CSR49_FH_INT_TX_MASK)
|
2007-09-26 00:54:57 +00:00
|
|
|
inta |= CSR_INT_BIT_FH_TX;
|
|
|
|
|
|
|
|
/* Now service all interrupt bits discovered above. */
|
|
|
|
if (inta & CSR_INT_BIT_HW_ERR) {
|
2009-07-17 16:30:25 +00:00
|
|
|
IWL_ERR(priv, "Hardware error detected. Restarting.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Tell the device to stop sending interrupts */
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_disable_interrupts(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.hw++;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_irq_handle_error(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
handled |= CSR_INT_BIT_HW_ERR;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-08-07 22:41:37 +00:00
|
|
|
if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
/* NIC fires this, but we don't use it, redundant with WAKEUP */
|
2009-04-08 18:39:32 +00:00
|
|
|
if (inta & CSR_INT_BIT_SCD) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
|
2008-01-23 18:15:20 +00:00
|
|
|
"the frame/frames.\n");
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.sch++;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Alive notification via Rx interrupt will do the real work */
|
2009-04-08 18:39:32 +00:00
|
|
|
if (inta & CSR_INT_BIT_ALIVE) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "Alive interrupt\n");
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.alive++;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Safely ignore these bits for debug checks below */
|
2008-01-23 18:15:20 +00:00
|
|
|
inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/* HW RF KILL switch toggled */
|
2007-09-26 00:54:57 +00:00
|
|
|
if (inta & CSR_INT_BIT_RF_KILL) {
|
|
|
|
int hw_rf_kill = 0;
|
2008-03-25 23:33:37 +00:00
|
|
|
if (!(iwl_read32(priv, CSR_GP_CNTRL) &
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
|
|
|
|
hw_rf_kill = 1;
|
|
|
|
|
2009-07-17 16:30:26 +00:00
|
|
|
IWL_WARN(priv, "RF_KILL bit toggled to %s.\n",
|
2008-11-12 21:14:08 +00:00
|
|
|
hw_rf_kill ? "disable radio" : "enable radio");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.rfkill++;
|
|
|
|
|
2008-06-30 09:23:25 +00:00
|
|
|
/* driver only loads ucode once setting the interface up.
|
2009-01-19 12:10:07 +00:00
|
|
|
* the driver allows loading the ucode even if the radio
|
|
|
|
* is killed. Hence update the killswitch state here. The
|
|
|
|
* rfkill handler will care about restarting if needed.
|
2008-06-30 09:23:25 +00:00
|
|
|
*/
|
2009-01-19 12:10:07 +00:00
|
|
|
if (!test_bit(STATUS_ALIVE, &priv->status)) {
|
|
|
|
if (hw_rf_kill)
|
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
else
|
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
2009-06-04 16:26:06 +00:00
|
|
|
wiphy_rfkill_set_hw_state(priv->hw->wiphy, hw_rf_kill);
|
2008-12-11 18:33:37 +00:00
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
handled |= CSR_INT_BIT_RF_KILL;
|
|
|
|
}
|
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/* Chip got too hot and stopped itself */
|
2007-09-26 00:54:57 +00:00
|
|
|
if (inta & CSR_INT_BIT_CT_KILL) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Microcode CT kill error detected.\n");
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.ctkill++;
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= CSR_INT_BIT_CT_KILL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Error detected by uCode */
|
|
|
|
if (inta & CSR_INT_BIT_SW_ERR) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Microcode SW error detected. "
|
|
|
|
" Restarting 0x%X.\n", inta);
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.sw++;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_irq_handle_error(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= CSR_INT_BIT_SW_ERR;
|
|
|
|
}
|
|
|
|
|
2009-10-30 21:36:09 +00:00
|
|
|
/*
|
|
|
|
* uCode wakes up after power-down sleep.
|
|
|
|
* Tell device about any new tx or host commands enqueued,
|
|
|
|
* and about any Rx buffers made available while asleep.
|
|
|
|
*/
|
2007-09-26 00:54:57 +00:00
|
|
|
if (inta & CSR_INT_BIT_WAKEUP) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
|
2008-05-05 02:22:28 +00:00
|
|
|
iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
|
2009-10-30 21:36:09 +00:00
|
|
|
for (i = 0; i < priv->hw_params.max_txq_num; i++)
|
|
|
|
iwl_txq_update_write_ptr(priv, &priv->txq[i]);
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.wakeup++;
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= CSR_INT_BIT_WAKEUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* All uCode command responses, including Tx command responses,
|
|
|
|
* Rx "responses" (frame-received notification), and other
|
|
|
|
* notifications from uCode come through here*/
|
|
|
|
if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
|
2008-05-05 02:22:28 +00:00
|
|
|
iwl_rx_handle(priv);
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.rx++;
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
|
|
|
|
}
|
|
|
|
|
2009-10-30 21:36:08 +00:00
|
|
|
/* This "Tx" DMA channel is used only for loading uCode */
|
2007-09-26 00:54:57 +00:00
|
|
|
if (inta & CSR_INT_BIT_FH_TX) {
|
2009-10-30 21:36:08 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "uCode load interrupt\n");
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.tx++;
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= CSR_INT_BIT_FH_TX;
|
2009-10-30 21:36:08 +00:00
|
|
|
/* Wake up uCode load routine, now that load is complete */
|
2008-05-15 05:54:12 +00:00
|
|
|
priv->ucode_write_complete = 1;
|
|
|
|
wake_up_interruptible(&priv->wait_command_queue);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-04-08 18:39:32 +00:00
|
|
|
if (inta & ~handled) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
|
2009-04-08 18:39:32 +00:00
|
|
|
priv->isr_stats.unhandled++;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-05-22 18:01:52 +00:00
|
|
|
if (inta & ~(priv->inta_mask)) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
|
2009-05-22 18:01:52 +00:00
|
|
|
inta & ~priv->inta_mask);
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, " with FH_INT = 0x%08x\n", inta_fh);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Re-enable all interrupts */
|
2008-03-28 23:21:08 +00:00
|
|
|
/* only Re-enable if diabled by irq */
|
|
|
|
if (test_bit(STATUS_INT_ENABLED, &priv->status))
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_enable_interrupts(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-08-07 22:41:37 +00:00
|
|
|
if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
|
2008-03-25 23:33:37 +00:00
|
|
|
inta = iwl_read32(priv, CSR_INT);
|
|
|
|
inta_mask = iwl_read32(priv, CSR_INT_MASK);
|
|
|
|
inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
|
2007-09-26 00:54:57 +00:00
|
|
|
"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2009-05-22 18:01:50 +00:00
|
|
|
/* tasklet for iwlagn interrupt */
|
|
|
|
static void iwl_irq_tasklet(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
u32 inta = 0;
|
|
|
|
u32 handled = 0;
|
|
|
|
unsigned long flags;
|
2009-11-06 22:53:01 +00:00
|
|
|
u32 i;
|
2009-05-22 18:01:50 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
|
|
|
u32 inta_mask;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* Ack/clear/reset pending uCode interrupts.
|
|
|
|
* Note: Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
|
|
|
|
*/
|
2010-03-16 17:22:26 +00:00
|
|
|
/* There is a hardware bug in the interrupt mask function that some
|
|
|
|
* interrupts (i.e. CSR_INT_BIT_SCD) can still be generated even if
|
|
|
|
* they are disabled in the CSR_INT_MASK register. Furthermore the
|
|
|
|
* ICT interrupt handling mechanism has another bug that might cause
|
|
|
|
* these unmasked interrupts fail to be detected. We workaround the
|
|
|
|
* hardware bugs here by ACKing all the possible interrupts so that
|
|
|
|
* interrupt coalescing can still be achieved.
|
|
|
|
*/
|
2010-04-07 06:53:30 +00:00
|
|
|
iwl_write32(priv, CSR_INT, priv->_agn.inta | ~priv->inta_mask);
|
2009-05-22 18:01:50 +00:00
|
|
|
|
2010-01-21 14:25:54 +00:00
|
|
|
inta = priv->_agn.inta;
|
2009-05-22 18:01:50 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-08-07 22:41:37 +00:00
|
|
|
if (iwl_get_debug_level(priv) & IWL_DL_ISR) {
|
2009-05-22 18:01:50 +00:00
|
|
|
/* just for debug */
|
|
|
|
inta_mask = iwl_read32(priv, CSR_INT_MASK);
|
|
|
|
IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x\n ",
|
|
|
|
inta, inta_mask);
|
|
|
|
}
|
|
|
|
#endif
|
2009-10-09 09:19:45 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2010-01-21 14:25:54 +00:00
|
|
|
/* saved interrupt in inta variable now we can reset priv->_agn.inta */
|
|
|
|
priv->_agn.inta = 0;
|
2009-05-22 18:01:50 +00:00
|
|
|
|
|
|
|
/* Now service all interrupt bits discovered above. */
|
|
|
|
if (inta & CSR_INT_BIT_HW_ERR) {
|
2009-07-17 16:30:25 +00:00
|
|
|
IWL_ERR(priv, "Hardware error detected. Restarting.\n");
|
2009-05-22 18:01:50 +00:00
|
|
|
|
|
|
|
/* Tell the device to stop sending interrupts */
|
|
|
|
iwl_disable_interrupts(priv);
|
|
|
|
|
|
|
|
priv->isr_stats.hw++;
|
|
|
|
iwl_irq_handle_error(priv);
|
|
|
|
|
|
|
|
handled |= CSR_INT_BIT_HW_ERR;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-08-07 22:41:37 +00:00
|
|
|
if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
|
2009-05-22 18:01:50 +00:00
|
|
|
/* NIC fires this, but we don't use it, redundant with WAKEUP */
|
|
|
|
if (inta & CSR_INT_BIT_SCD) {
|
|
|
|
IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
|
|
|
|
"the frame/frames.\n");
|
|
|
|
priv->isr_stats.sch++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Alive notification via Rx interrupt will do the real work */
|
|
|
|
if (inta & CSR_INT_BIT_ALIVE) {
|
|
|
|
IWL_DEBUG_ISR(priv, "Alive interrupt\n");
|
|
|
|
priv->isr_stats.alive++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Safely ignore these bits for debug checks below */
|
|
|
|
inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
|
|
|
|
|
|
|
|
/* HW RF KILL switch toggled */
|
|
|
|
if (inta & CSR_INT_BIT_RF_KILL) {
|
|
|
|
int hw_rf_kill = 0;
|
|
|
|
if (!(iwl_read32(priv, CSR_GP_CNTRL) &
|
|
|
|
CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
|
|
|
|
hw_rf_kill = 1;
|
|
|
|
|
2009-07-17 16:30:26 +00:00
|
|
|
IWL_WARN(priv, "RF_KILL bit toggled to %s.\n",
|
2009-05-22 18:01:50 +00:00
|
|
|
hw_rf_kill ? "disable radio" : "enable radio");
|
|
|
|
|
|
|
|
priv->isr_stats.rfkill++;
|
|
|
|
|
|
|
|
/* driver only loads ucode once setting the interface up.
|
|
|
|
* the driver allows loading the ucode even if the radio
|
|
|
|
* is killed. Hence update the killswitch state here. The
|
|
|
|
* rfkill handler will care about restarting if needed.
|
|
|
|
*/
|
|
|
|
if (!test_bit(STATUS_ALIVE, &priv->status)) {
|
|
|
|
if (hw_rf_kill)
|
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
else
|
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
2009-06-04 16:26:06 +00:00
|
|
|
wiphy_rfkill_set_hw_state(priv->hw->wiphy, hw_rf_kill);
|
2009-05-22 18:01:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
handled |= CSR_INT_BIT_RF_KILL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Chip got too hot and stopped itself */
|
|
|
|
if (inta & CSR_INT_BIT_CT_KILL) {
|
|
|
|
IWL_ERR(priv, "Microcode CT kill error detected.\n");
|
|
|
|
priv->isr_stats.ctkill++;
|
|
|
|
handled |= CSR_INT_BIT_CT_KILL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Error detected by uCode */
|
|
|
|
if (inta & CSR_INT_BIT_SW_ERR) {
|
|
|
|
IWL_ERR(priv, "Microcode SW error detected. "
|
|
|
|
" Restarting 0x%X.\n", inta);
|
|
|
|
priv->isr_stats.sw++;
|
|
|
|
iwl_irq_handle_error(priv);
|
|
|
|
handled |= CSR_INT_BIT_SW_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* uCode wakes up after power-down sleep */
|
|
|
|
if (inta & CSR_INT_BIT_WAKEUP) {
|
|
|
|
IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
|
|
|
|
iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
|
2009-11-06 22:53:01 +00:00
|
|
|
for (i = 0; i < priv->hw_params.max_txq_num; i++)
|
|
|
|
iwl_txq_update_write_ptr(priv, &priv->txq[i]);
|
2009-05-22 18:01:50 +00:00
|
|
|
|
|
|
|
priv->isr_stats.wakeup++;
|
|
|
|
|
|
|
|
handled |= CSR_INT_BIT_WAKEUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* All uCode command responses, including Tx command responses,
|
|
|
|
* Rx "responses" (frame-received notification), and other
|
|
|
|
* notifications from uCode come through here*/
|
2009-05-22 18:01:52 +00:00
|
|
|
if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX |
|
|
|
|
CSR_INT_BIT_RX_PERIODIC)) {
|
2009-05-22 18:01:50 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "Rx interrupt\n");
|
2009-05-22 18:01:52 +00:00
|
|
|
if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
|
|
|
|
handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
|
|
|
|
iwl_write32(priv, CSR_FH_INT_STATUS,
|
|
|
|
CSR49_FH_INT_RX_MASK);
|
|
|
|
}
|
|
|
|
if (inta & CSR_INT_BIT_RX_PERIODIC) {
|
|
|
|
handled |= CSR_INT_BIT_RX_PERIODIC;
|
|
|
|
iwl_write32(priv, CSR_INT, CSR_INT_BIT_RX_PERIODIC);
|
|
|
|
}
|
|
|
|
/* Sending RX interrupt require many steps to be done in the
|
|
|
|
* the device:
|
|
|
|
* 1- write interrupt to current index in ICT table.
|
|
|
|
* 2- dma RX frame.
|
|
|
|
* 3- update RX shared data to indicate last write index.
|
|
|
|
* 4- send interrupt.
|
|
|
|
* This could lead to RX race, driver could receive RX interrupt
|
iwlagn: Use iwl_write8() for CSR_INT_COALESCING register
CSR_INT_COALESCING previously had only one, but now has two single-byte fields.
With only one single-byte field (lowest order byte) it was okay to write via
iwl_write32(), but now with two, an iwl_write32() to the lower order field
clobbers the other field (odd-address CSR_INT_PERIODIC_REG, offset 0x5), and an
iwl_write32() to CSR_INT_PERIODIC_REG could clobber the lowest byte of the
next-higher register (CSR_INT, offset 0x8).
Fortunately, no bad side effects have been produced by the iwl_write32()
usage, due to order of execution (low order byte was always written before
higher order byte), and the fact that writing "0" to the low byte of the
next higher register has no effect (only action is when writing "1"s).
Nonetheless, this cleans up the accesses so no bad side effects might occur
in the future, if execution order changes, or more bit fields get added to
CSR_INT_COALESCING.
Add some comments regarding periodic interrupt usage.
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-11-20 20:04:53 +00:00
|
|
|
* but the shared data changes does not reflect this;
|
|
|
|
* periodic interrupt will detect any dangling Rx activity.
|
2009-05-22 18:01:52 +00:00
|
|
|
*/
|
iwlagn: Use iwl_write8() for CSR_INT_COALESCING register
CSR_INT_COALESCING previously had only one, but now has two single-byte fields.
With only one single-byte field (lowest order byte) it was okay to write via
iwl_write32(), but now with two, an iwl_write32() to the lower order field
clobbers the other field (odd-address CSR_INT_PERIODIC_REG, offset 0x5), and an
iwl_write32() to CSR_INT_PERIODIC_REG could clobber the lowest byte of the
next-higher register (CSR_INT, offset 0x8).
Fortunately, no bad side effects have been produced by the iwl_write32()
usage, due to order of execution (low order byte was always written before
higher order byte), and the fact that writing "0" to the low byte of the
next higher register has no effect (only action is when writing "1"s).
Nonetheless, this cleans up the accesses so no bad side effects might occur
in the future, if execution order changes, or more bit fields get added to
CSR_INT_COALESCING.
Add some comments regarding periodic interrupt usage.
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-11-20 20:04:53 +00:00
|
|
|
|
|
|
|
/* Disable periodic interrupt; we use it as just a one-shot. */
|
|
|
|
iwl_write8(priv, CSR_INT_PERIODIC_REG,
|
2009-05-22 18:01:52 +00:00
|
|
|
CSR_INT_PERIODIC_DIS);
|
2009-05-22 18:01:50 +00:00
|
|
|
iwl_rx_handle(priv);
|
iwlagn: Use iwl_write8() for CSR_INT_COALESCING register
CSR_INT_COALESCING previously had only one, but now has two single-byte fields.
With only one single-byte field (lowest order byte) it was okay to write via
iwl_write32(), but now with two, an iwl_write32() to the lower order field
clobbers the other field (odd-address CSR_INT_PERIODIC_REG, offset 0x5), and an
iwl_write32() to CSR_INT_PERIODIC_REG could clobber the lowest byte of the
next-higher register (CSR_INT, offset 0x8).
Fortunately, no bad side effects have been produced by the iwl_write32()
usage, due to order of execution (low order byte was always written before
higher order byte), and the fact that writing "0" to the low byte of the
next higher register has no effect (only action is when writing "1"s).
Nonetheless, this cleans up the accesses so no bad side effects might occur
in the future, if execution order changes, or more bit fields get added to
CSR_INT_COALESCING.
Add some comments regarding periodic interrupt usage.
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-11-20 20:04:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Enable periodic interrupt in 8 msec only if we received
|
|
|
|
* real RX interrupt (instead of just periodic int), to catch
|
|
|
|
* any dangling Rx interrupt. If it was just the periodic
|
|
|
|
* interrupt, there was no dangling Rx activity, and no need
|
|
|
|
* to extend the periodic interrupt; one-shot is enough.
|
|
|
|
*/
|
2009-05-22 18:01:52 +00:00
|
|
|
if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX))
|
iwlagn: Use iwl_write8() for CSR_INT_COALESCING register
CSR_INT_COALESCING previously had only one, but now has two single-byte fields.
With only one single-byte field (lowest order byte) it was okay to write via
iwl_write32(), but now with two, an iwl_write32() to the lower order field
clobbers the other field (odd-address CSR_INT_PERIODIC_REG, offset 0x5), and an
iwl_write32() to CSR_INT_PERIODIC_REG could clobber the lowest byte of the
next-higher register (CSR_INT, offset 0x8).
Fortunately, no bad side effects have been produced by the iwl_write32()
usage, due to order of execution (low order byte was always written before
higher order byte), and the fact that writing "0" to the low byte of the
next higher register has no effect (only action is when writing "1"s).
Nonetheless, this cleans up the accesses so no bad side effects might occur
in the future, if execution order changes, or more bit fields get added to
CSR_INT_COALESCING.
Add some comments regarding periodic interrupt usage.
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-11-20 20:04:53 +00:00
|
|
|
iwl_write8(priv, CSR_INT_PERIODIC_REG,
|
2009-05-22 18:01:52 +00:00
|
|
|
CSR_INT_PERIODIC_ENA);
|
|
|
|
|
2009-05-22 18:01:50 +00:00
|
|
|
priv->isr_stats.rx++;
|
|
|
|
}
|
|
|
|
|
2009-10-30 21:36:08 +00:00
|
|
|
/* This "Tx" DMA channel is used only for loading uCode */
|
2009-05-22 18:01:50 +00:00
|
|
|
if (inta & CSR_INT_BIT_FH_TX) {
|
|
|
|
iwl_write32(priv, CSR_FH_INT_STATUS, CSR49_FH_INT_TX_MASK);
|
2009-10-30 21:36:08 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "uCode load interrupt\n");
|
2009-05-22 18:01:50 +00:00
|
|
|
priv->isr_stats.tx++;
|
|
|
|
handled |= CSR_INT_BIT_FH_TX;
|
2009-10-30 21:36:08 +00:00
|
|
|
/* Wake up uCode load routine, now that load is complete */
|
2009-05-22 18:01:50 +00:00
|
|
|
priv->ucode_write_complete = 1;
|
|
|
|
wake_up_interruptible(&priv->wait_command_queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inta & ~handled) {
|
|
|
|
IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
|
|
|
|
priv->isr_stats.unhandled++;
|
|
|
|
}
|
|
|
|
|
2009-05-22 18:01:52 +00:00
|
|
|
if (inta & ~(priv->inta_mask)) {
|
2009-05-22 18:01:50 +00:00
|
|
|
IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
|
2009-05-22 18:01:52 +00:00
|
|
|
inta & ~priv->inta_mask);
|
2009-05-22 18:01:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Re-enable all interrupts */
|
|
|
|
/* only Re-enable if diabled by irq */
|
|
|
|
if (test_bit(STATUS_INT_ENABLED, &priv->status))
|
|
|
|
iwl_enable_interrupts(priv);
|
|
|
|
}
|
|
|
|
|
2010-03-16 17:46:31 +00:00
|
|
|
/* the threshold ratio of actual_ack_cnt to expected_ack_cnt in percent */
|
|
|
|
#define ACK_CNT_RATIO (50)
|
|
|
|
#define BA_TIMEOUT_CNT (5)
|
|
|
|
#define BA_TIMEOUT_MAX (16)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_good_ack_health - checks for ACK count ratios, BA timeout retries.
|
|
|
|
*
|
|
|
|
* When the ACK count ratio is 0 and aggregated BA timeout retries exceeding
|
|
|
|
* the BA_TIMEOUT_MAX, reload firmware and bring system back to normal
|
|
|
|
* operation state.
|
|
|
|
*/
|
|
|
|
bool iwl_good_ack_health(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_packet *pkt)
|
|
|
|
{
|
|
|
|
bool rc = true;
|
|
|
|
int actual_ack_cnt_delta, expected_ack_cnt_delta;
|
|
|
|
int ba_timeout_delta;
|
|
|
|
|
|
|
|
actual_ack_cnt_delta =
|
|
|
|
le32_to_cpu(pkt->u.stats.tx.actual_ack_cnt) -
|
2010-06-15 00:09:54 +00:00
|
|
|
le32_to_cpu(priv->_agn.statistics.tx.actual_ack_cnt);
|
2010-03-16 17:46:31 +00:00
|
|
|
expected_ack_cnt_delta =
|
|
|
|
le32_to_cpu(pkt->u.stats.tx.expected_ack_cnt) -
|
2010-06-15 00:09:54 +00:00
|
|
|
le32_to_cpu(priv->_agn.statistics.tx.expected_ack_cnt);
|
2010-03-16 17:46:31 +00:00
|
|
|
ba_timeout_delta =
|
|
|
|
le32_to_cpu(pkt->u.stats.tx.agg.ba_timeout) -
|
2010-06-15 00:09:54 +00:00
|
|
|
le32_to_cpu(priv->_agn.statistics.tx.agg.ba_timeout);
|
2010-03-16 17:46:31 +00:00
|
|
|
if ((priv->_agn.agg_tids_count > 0) &&
|
|
|
|
(expected_ack_cnt_delta > 0) &&
|
|
|
|
(((actual_ack_cnt_delta * 100) / expected_ack_cnt_delta)
|
|
|
|
< ACK_CNT_RATIO) &&
|
|
|
|
(ba_timeout_delta > BA_TIMEOUT_CNT)) {
|
|
|
|
IWL_DEBUG_RADIO(priv, "actual_ack_cnt delta = %d,"
|
|
|
|
" expected_ack_cnt = %d\n",
|
|
|
|
actual_ack_cnt_delta, expected_ack_cnt_delta);
|
|
|
|
|
2010-05-06 19:18:41 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUGFS
|
|
|
|
/*
|
|
|
|
* This is ifdef'ed on DEBUGFS because otherwise the
|
|
|
|
* statistics aren't available. If DEBUGFS is set but
|
|
|
|
* DEBUG is not, these will just compile out.
|
|
|
|
*/
|
2010-03-16 17:46:31 +00:00
|
|
|
IWL_DEBUG_RADIO(priv, "rx_detected_cnt delta = %d\n",
|
2010-06-15 00:09:54 +00:00
|
|
|
priv->_agn.delta_statistics.tx.rx_detected_cnt);
|
2010-03-16 17:46:31 +00:00
|
|
|
IWL_DEBUG_RADIO(priv,
|
|
|
|
"ack_or_ba_timeout_collision delta = %d\n",
|
2010-06-15 00:09:54 +00:00
|
|
|
priv->_agn.delta_statistics.tx.
|
2010-03-16 17:46:31 +00:00
|
|
|
ack_or_ba_timeout_collision);
|
|
|
|
#endif
|
|
|
|
IWL_DEBUG_RADIO(priv, "agg ba_timeout delta = %d\n",
|
|
|
|
ba_timeout_delta);
|
|
|
|
if (!actual_ack_cnt_delta &&
|
|
|
|
(ba_timeout_delta >= BA_TIMEOUT_MAX))
|
|
|
|
rc = false;
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2009-04-08 18:39:32 +00:00
|
|
|
|
2010-05-23 07:14:08 +00: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)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = dev_get_drvdata(d);
|
|
|
|
return sprintf(buf, "0x%08X\n", iwl_get_debug_level(priv));
|
|
|
|
}
|
|
|
|
static ssize_t store_debug_level(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, 0, &val);
|
|
|
|
if (ret)
|
|
|
|
IWL_ERR(priv, "%s is not in hex or decimal form.\n", buf);
|
|
|
|
else {
|
|
|
|
priv->debug_level = val;
|
|
|
|
if (iwl_alloc_traffic_mem(priv))
|
|
|
|
IWL_ERR(priv,
|
|
|
|
"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)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = dev_get_drvdata(d);
|
|
|
|
|
|
|
|
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 00:54:57 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* uCode download functions
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_dealloc_ucode_pci(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_code);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init_data);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_boot);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_nic_start(struct iwl_priv *priv)
|
2008-05-15 05:53:55 +00:00
|
|
|
{
|
|
|
|
/* Remove all resets to allow NIC to operate */
|
|
|
|
iwl_write32(priv, CSR_RESET, 0);
|
|
|
|
}
|
|
|
|
|
2010-04-29 06:33:10 +00:00
|
|
|
struct iwlagn_ucode_capabilities {
|
|
|
|
u32 max_probe_length;
|
2010-07-14 00:13:15 +00:00
|
|
|
u32 standard_phy_calibration_size;
|
2010-08-23 08:46:49 +00:00
|
|
|
bool pan;
|
2010-04-29 06:33:10 +00:00
|
|
|
};
|
2008-05-15 05:53:55 +00:00
|
|
|
|
2010-01-29 19:54:56 +00:00
|
|
|
static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
|
2010-04-29 06:33:10 +00:00
|
|
|
static int iwl_mac_setup_register(struct iwl_priv *priv,
|
|
|
|
struct iwlagn_ucode_capabilities *capa);
|
2010-01-29 19:54:56 +00:00
|
|
|
|
2010-08-12 17:24:07 +00:00
|
|
|
#define UCODE_EXPERIMENTAL_INDEX 100
|
|
|
|
#define UCODE_EXPERIMENTAL_TAG "exp"
|
|
|
|
|
2010-01-29 19:54:56 +00: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-12 17:24:07 +00:00
|
|
|
char tag[8];
|
2010-01-29 19:54:56 +00:00
|
|
|
|
2010-08-12 17:24:07 +00: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-29 19:54:56 +00:00
|
|
|
priv->fw_index = priv->cfg->ucode_api_max;
|
2010-08-12 17:24:07 +00:00
|
|
|
sprintf(tag, "%d", priv->fw_index);
|
|
|
|
} else {
|
2010-01-29 19:54:56 +00:00
|
|
|
priv->fw_index--;
|
2010-08-12 17:24:07 +00:00
|
|
|
sprintf(tag, "%d", priv->fw_index);
|
|
|
|
}
|
2010-01-29 19:54:56 +00:00
|
|
|
|
|
|
|
if (priv->fw_index < priv->cfg->ucode_api_min) {
|
|
|
|
IWL_ERR(priv, "no suitable firmware found!\n");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2010-08-12 17:24:07 +00:00
|
|
|
sprintf(priv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
|
2010-01-29 19:54:56 +00:00
|
|
|
|
2010-08-12 17:24:07 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "attempting to load firmware %s'%s'\n",
|
|
|
|
(priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
|
|
|
|
? "EXPERIMENTAL " : "",
|
2010-01-29 19:54:56 +00:00
|
|
|
priv->firmware_name);
|
|
|
|
|
|
|
|
return request_firmware_nowait(THIS_MODULE, 1, priv->firmware_name,
|
|
|
|
&priv->pci_dev->dev, GFP_KERNEL, priv,
|
|
|
|
iwl_ucode_callback);
|
|
|
|
}
|
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
struct iwlagn_firmware_pieces {
|
|
|
|
const void *inst, *data, *init, *init_data, *boot;
|
|
|
|
size_t inst_size, data_size, init_size, init_data_size, boot_size;
|
|
|
|
|
|
|
|
u32 build;
|
2010-05-06 06:24:54 +00:00
|
|
|
|
|
|
|
u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
|
|
|
|
u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
|
2010-04-28 19:09:16 +00: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:
|
|
|
|
/*
|
|
|
|
* 4965 doesn't revision the firmware file format
|
|
|
|
* along with the API version, it always uses v1
|
|
|
|
* file format.
|
|
|
|
*/
|
|
|
|
if ((priv->hw_rev & CSR_HW_REV_TYPE_MSK) !=
|
|
|
|
CSR_HW_REV_TYPE_4965) {
|
|
|
|
hdr_size = 28;
|
|
|
|
if (ucode_raw->size < hdr_size) {
|
|
|
|
IWL_ERR(priv, "File size too small!\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
pieces->boot_size = le32_to_cpu(ucode->u.v2.boot_size);
|
|
|
|
src = ucode->u.v2.data;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall through for 4965 */
|
|
|
|
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);
|
|
|
|
pieces->boot_size = le32_to_cpu(ucode->u.v1.boot_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 +
|
|
|
|
pieces->init_data_size + pieces->boot_size) {
|
|
|
|
|
|
|
|
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;
|
|
|
|
pieces->boot = src;
|
|
|
|
src += pieces->boot_size;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-29 06:33:10 +00:00
|
|
|
static int iwlagn_wanted_ucode_alternative = 1;
|
|
|
|
|
|
|
|
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;
|
|
|
|
int wanted_alternative = iwlagn_wanted_ucode_alternative, tmp;
|
|
|
|
u64 alternatives;
|
2010-06-22 21:31:45 +00:00
|
|
|
u32 tlv_len;
|
|
|
|
enum iwl_ucode_tlv_type tlv_type;
|
|
|
|
const u8 *tlv_data;
|
2010-04-29 06:33:10 +00:00
|
|
|
|
2010-06-22 21:31:45 +00:00
|
|
|
if (len < sizeof(*ucode)) {
|
|
|
|
IWL_ERR(priv, "uCode has invalid length: %zd\n", len);
|
2010-04-29 06:33:10 +00:00
|
|
|
return -EINVAL;
|
2010-06-22 21:31:45 +00:00
|
|
|
}
|
2010-04-29 06:33:10 +00:00
|
|
|
|
2010-06-22 21:31:45 +00: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 06:33:10 +00:00
|
|
|
return -EINVAL;
|
2010-06-22 21:31:45 +00:00
|
|
|
}
|
2010-04-29 06:33:10 +00: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-14 16:34:50 +00:00
|
|
|
while (len >= sizeof(*tlv)) {
|
2010-04-29 06:33:10 +00: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-22 21:31:45 +00:00
|
|
|
if (len < tlv_len) {
|
|
|
|
IWL_ERR(priv, "invalid TLV len: %zd/%u\n",
|
|
|
|
len, tlv_len);
|
2010-04-29 06:33:10 +00:00
|
|
|
return -EINVAL;
|
2010-06-22 21:31:45 +00:00
|
|
|
}
|
2010-04-29 06:33:10 +00: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:
|
|
|
|
pieces->boot = tlv_data;
|
|
|
|
pieces->boot_size = tlv_len;
|
|
|
|
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-14 16:34:50 +00:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
capa->max_probe_length =
|
2010-06-22 21:31:45 +00:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-04-29 06:33:10 +00:00
|
|
|
break;
|
2010-08-23 08:46:49 +00:00
|
|
|
case IWL_UCODE_TLV_PAN:
|
|
|
|
if (tlv_len)
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
capa->pan = true;
|
|
|
|
break;
|
2010-05-06 06:24:54 +00: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-14 16:34:50 +00:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->init_evtlog_ptr =
|
2010-06-22 21:31:45 +00:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 06:24:54 +00: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-14 16:34:50 +00:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->init_evtlog_size =
|
2010-06-22 21:31:45 +00:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 06:24:54 +00: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-14 16:34:50 +00:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->init_errlog_ptr =
|
2010-06-22 21:31:45 +00:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 06:24:54 +00: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-14 16:34:50 +00:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->inst_evtlog_ptr =
|
2010-06-22 21:31:45 +00:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 06:24:54 +00: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-14 16:34:50 +00:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->inst_evtlog_size =
|
2010-06-22 21:31:45 +00:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 06:24:54 +00: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-14 16:34:50 +00:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
pieces->inst_errlog_ptr =
|
2010-06-22 21:31:45 +00:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
2010-05-06 06:24:54 +00:00
|
|
|
break;
|
2010-06-28 20:05:17 +00: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-14 16:34:50 +00:00
|
|
|
goto invalid_tlv_len;
|
|
|
|
priv->enhance_sensitivity_table = true;
|
2010-06-28 20:05:17 +00:00
|
|
|
break;
|
2010-07-14 00:13:15 +00: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-14 16:34:50 +00:00
|
|
|
if (tlv_len != sizeof(u32))
|
|
|
|
goto invalid_tlv_len;
|
|
|
|
capa->standard_phy_calibration_size =
|
2010-07-14 00:13:15 +00:00
|
|
|
le32_to_cpup((__le32 *)tlv_data);
|
|
|
|
break;
|
2010-04-29 06:33:10 +00:00
|
|
|
default:
|
2010-06-22 21:31:45 +00:00
|
|
|
IWL_WARN(priv, "unknown TLV: %d\n", tlv_type);
|
2010-04-29 06:33:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-22 21:31:45 +00: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-14 16:34:50 +00:00
|
|
|
return -EINVAL;
|
2010-06-22 21:31:45 +00:00
|
|
|
}
|
2010-04-29 06:33:10 +00: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-14 16:34:50 +00: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 06:33:10 +00:00
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
2010-01-29 19:54:56 +00:00
|
|
|
* iwl_ucode_callback - callback when firmware was loaded
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
2010-01-29 19:54:56 +00:00
|
|
|
* If loaded successfully, copies the firmware into buffers
|
|
|
|
* for the card to fetch (via DMA).
|
2007-09-26 00:54:57 +00:00
|
|
|
*/
|
2010-01-29 19:54:56 +00:00
|
|
|
static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-01-29 19:54:56 +00:00
|
|
|
struct iwl_priv *priv = context;
|
2009-07-17 16:30:16 +00:00
|
|
|
struct iwl_ucode_header *ucode;
|
2010-04-28 19:09:16 +00:00
|
|
|
int err;
|
|
|
|
struct iwlagn_firmware_pieces pieces;
|
2008-12-02 20:14:06 +00:00
|
|
|
const unsigned int api_max = priv->cfg->ucode_api_max;
|
|
|
|
const unsigned int api_min = priv->cfg->ucode_api_min;
|
2010-04-28 19:09:16 +00:00
|
|
|
u32 api_ver;
|
2010-04-28 19:09:12 +00:00
|
|
|
char buildstr[25];
|
2010-04-28 19:09:16 +00:00
|
|
|
u32 build;
|
2010-04-29 06:33:10 +00:00
|
|
|
struct iwlagn_ucode_capabilities ucode_capa = {
|
|
|
|
.max_probe_length = 200,
|
2010-07-14 00:13:15 +00:00
|
|
|
.standard_phy_calibration_size =
|
|
|
|
IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE,
|
2010-04-29 06:33:10 +00:00
|
|
|
};
|
2010-04-28 19:09:16 +00:00
|
|
|
|
|
|
|
memset(&pieces, 0, sizeof(pieces));
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-01-29 19:54:56 +00:00
|
|
|
if (!ucode_raw) {
|
2010-08-12 17:24:07 +00:00
|
|
|
if (priv->fw_index <= priv->cfg->ucode_api_max)
|
|
|
|
IWL_ERR(priv,
|
|
|
|
"request for firmware file '%s' failed.\n",
|
|
|
|
priv->firmware_name);
|
2010-01-29 19:54:56 +00:00
|
|
|
goto try_again;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-01-29 19:54:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Loaded firmware file '%s' (%zd bytes).\n",
|
|
|
|
priv->firmware_name, ucode_raw->size);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-04-28 19:09:14 +00:00
|
|
|
/* Make sure that we got at least the API version number */
|
|
|
|
if (ucode_raw->size < 4) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "File size way too small!\n");
|
2010-01-29 19:54:56 +00:00
|
|
|
goto try_again;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Data from ucode file: header followed by uCode images */
|
2009-07-17 16:30:16 +00:00
|
|
|
ucode = (struct iwl_ucode_header *)ucode_raw->data;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
if (ucode->ver)
|
|
|
|
err = iwlagn_load_legacy_firmware(priv, ucode_raw, &pieces);
|
|
|
|
else
|
2010-04-29 06:33:10 +00:00
|
|
|
err = iwlagn_load_firmware(priv, ucode_raw, &pieces,
|
|
|
|
&ucode_capa);
|
2010-04-28 19:09:14 +00:00
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
if (err)
|
|
|
|
goto try_again;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-12-02 20:14:06 +00:00
|
|
|
api_ver = IWL_UCODE_API(priv->ucode_ver);
|
2010-04-28 19:09:16 +00:00
|
|
|
build = pieces.build;
|
2008-12-02 20:14:06 +00:00
|
|
|
|
2010-04-28 19:09:16 +00: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
|
|
|
|
*/
|
2008-12-02 20:14:06 +00:00
|
|
|
if (api_ver < api_min || api_ver > api_max) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Driver unable to support your firmware API. "
|
2008-12-02 20:14:06 +00:00
|
|
|
"Driver supports v%u, firmware is v%u.\n",
|
|
|
|
api_max, api_ver);
|
2010-01-29 19:54:56 +00:00
|
|
|
goto try_again;
|
2008-12-02 20:14:06 +00:00
|
|
|
}
|
2010-01-29 19:54:56 +00:00
|
|
|
|
2008-12-02 20:14:06 +00:00
|
|
|
if (api_ver != api_max)
|
2008-12-19 02:37:31 +00:00
|
|
|
IWL_ERR(priv, "Firmware has old API version. Expected v%u, "
|
2008-12-02 20:14:06 +00:00
|
|
|
"got v%u. New firmware can be obtained "
|
|
|
|
"from http://www.intellinuxwireless.org.\n",
|
|
|
|
api_max, api_ver);
|
|
|
|
|
2010-04-28 19:09:12 +00:00
|
|
|
if (build)
|
2010-08-12 17:24:07 +00:00
|
|
|
sprintf(buildstr, " build %u%s", build,
|
|
|
|
(priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
|
|
|
|
? " (EXP)" : "");
|
2010-04-28 19:09:12 +00: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-02 20:14:06 +00:00
|
|
|
|
2009-10-30 21:36:04 +00:00
|
|
|
snprintf(priv->hw->wiphy->fw_version,
|
|
|
|
sizeof(priv->hw->wiphy->fw_version),
|
2010-04-28 19:09:12 +00:00
|
|
|
"%u.%u.%u.%u%s",
|
2009-10-30 21:36:04 +00:00
|
|
|
IWL_UCODE_MAJOR(priv->ucode_ver),
|
|
|
|
IWL_UCODE_MINOR(priv->ucode_ver),
|
|
|
|
IWL_UCODE_API(priv->ucode_ver),
|
2010-04-28 19:09:12 +00:00
|
|
|
IWL_UCODE_SERIAL(priv->ucode_ver),
|
|
|
|
buildstr);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-01-29 19:54:56 +00: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-28 19:09:16 +00: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);
|
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr boot inst size = %Zd\n",
|
|
|
|
pieces.boot_size);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Verify that uCode images will fit in card's SRAM */
|
2010-04-28 19:09:16 +00:00
|
|
|
if (pieces.inst_size > priv->hw_params.max_inst_size) {
|
|
|
|
IWL_ERR(priv, "uCode instr len %Zd too large to fit in\n",
|
|
|
|
pieces.inst_size);
|
2010-01-29 19:54:56 +00:00
|
|
|
goto try_again;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
if (pieces.data_size > priv->hw_params.max_data_size) {
|
|
|
|
IWL_ERR(priv, "uCode data len %Zd too large to fit in\n",
|
|
|
|
pieces.data_size);
|
2010-01-29 19:54:56 +00:00
|
|
|
goto try_again;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2010-04-28 19:09:16 +00:00
|
|
|
|
|
|
|
if (pieces.init_size > priv->hw_params.max_inst_size) {
|
|
|
|
IWL_ERR(priv, "uCode init instr len %Zd too large to fit in\n",
|
|
|
|
pieces.init_size);
|
2010-01-29 19:54:56 +00:00
|
|
|
goto try_again;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2010-04-28 19:09:16 +00:00
|
|
|
|
|
|
|
if (pieces.init_data_size > priv->hw_params.max_data_size) {
|
|
|
|
IWL_ERR(priv, "uCode init data len %Zd too large to fit in\n",
|
|
|
|
pieces.init_data_size);
|
2010-01-29 19:54:56 +00:00
|
|
|
goto try_again;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2010-04-28 19:09:16 +00:00
|
|
|
|
|
|
|
if (pieces.boot_size > priv->hw_params.max_bsm_size) {
|
|
|
|
IWL_ERR(priv, "uCode boot instr len %Zd too large to fit in\n",
|
|
|
|
pieces.boot_size);
|
2010-01-29 19:54:56 +00:00
|
|
|
goto try_again;
|
2007-09-26 00:54:57 +00: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 */
|
2010-04-28 19:09:16 +00:00
|
|
|
priv->ucode_code.len = pieces.inst_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
priv->ucode_data.len = pieces.data_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
priv->ucode_data_backup.len = pieces.data_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-23 21:45:22 +00:00
|
|
|
if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
|
|
|
|
!priv->ucode_data_backup.v_addr)
|
|
|
|
goto err_pci_alloc;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Initialization instructions and data */
|
2010-04-28 19:09:16 +00:00
|
|
|
if (pieces.init_size && pieces.init_data_size) {
|
|
|
|
priv->ucode_init.len = pieces.init_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
|
2007-11-29 03:09:41 +00:00
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
priv->ucode_init_data.len = pieces.init_data_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
|
2007-11-29 03:09:41 +00:00
|
|
|
|
|
|
|
if (!priv->ucode_init.v_addr || !priv->ucode_init_data.v_addr)
|
|
|
|
goto err_pci_alloc;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Bootstrap (instructions only, no data) */
|
2010-04-28 19:09:16 +00:00
|
|
|
if (pieces.boot_size) {
|
|
|
|
priv->ucode_boot.len = pieces.boot_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:09:41 +00:00
|
|
|
if (!priv->ucode_boot.v_addr)
|
|
|
|
goto err_pci_alloc;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-05-06 06:24:54 +00: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.
|
|
|
|
*/
|
|
|
|
priv->_agn.init_evtlog_ptr = pieces.init_evtlog_ptr;
|
|
|
|
if (pieces.init_evtlog_size)
|
|
|
|
priv->_agn.init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
|
|
|
|
else
|
|
|
|
priv->_agn.init_evtlog_size = priv->cfg->max_event_log_size;
|
|
|
|
priv->_agn.init_errlog_ptr = pieces.init_errlog_ptr;
|
|
|
|
priv->_agn.inst_evtlog_ptr = pieces.inst_evtlog_ptr;
|
|
|
|
if (pieces.inst_evtlog_size)
|
|
|
|
priv->_agn.inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
|
|
|
|
else
|
|
|
|
priv->_agn.inst_evtlog_size = priv->cfg->max_event_log_size;
|
|
|
|
priv->_agn.inst_errlog_ptr = pieces.inst_errlog_ptr;
|
|
|
|
|
2010-08-23 08:46:49 +00:00
|
|
|
if (ucode_capa.pan) {
|
|
|
|
priv->valid_contexts |= BIT(IWL_RXON_CTX_PAN);
|
2010-08-23 08:46:43 +00:00
|
|
|
priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
|
2010-08-23 08:46:49 +00:00
|
|
|
} else
|
|
|
|
priv->sta_key_max_num = STA_KEY_MAX_NUM;
|
2010-08-23 08:46:43 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Copy images into buffers for card's bus-master reads ... */
|
|
|
|
|
|
|
|
/* Runtime instructions (first block of data in file) */
|
2010-04-28 19:09:16 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) uCode instr len %Zd\n",
|
|
|
|
pieces.inst_size);
|
|
|
|
memcpy(priv->ucode_code.v_addr, pieces.inst, pieces.inst_size);
|
2009-07-17 16:30:16 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);
|
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
/*
|
|
|
|
* Runtime data
|
|
|
|
* NOTE: Copy into backup buffer will be done in iwl_up()
|
|
|
|
*/
|
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) uCode data len %Zd\n",
|
|
|
|
pieces.data_size);
|
|
|
|
memcpy(priv->ucode_data.v_addr, pieces.data, pieces.data_size);
|
|
|
|
memcpy(priv->ucode_data_backup.v_addr, pieces.data, pieces.data_size);
|
|
|
|
|
|
|
|
/* Initialization instructions */
|
|
|
|
if (pieces.init_size) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) init instr len %Zd\n",
|
2010-04-28 19:09:16 +00:00
|
|
|
pieces.init_size);
|
|
|
|
memcpy(priv->ucode_init.v_addr, pieces.init, pieces.init_size);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
/* Initialization data */
|
|
|
|
if (pieces.init_data_size) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) init data len %Zd\n",
|
2010-04-28 19:09:16 +00:00
|
|
|
pieces.init_data_size);
|
|
|
|
memcpy(priv->ucode_init_data.v_addr, pieces.init_data,
|
|
|
|
pieces.init_data_size);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-04-28 19:09:16 +00:00
|
|
|
/* Bootstrap instructions */
|
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) boot instr len %Zd\n",
|
|
|
|
pieces.boot_size);
|
|
|
|
memcpy(priv->ucode_boot.v_addr, pieces.boot, pieces.boot_size);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-07-14 00:13:15 +00: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;
|
|
|
|
|
|
|
|
priv->_agn.phy_calib_chain_noise_reset_cmd =
|
|
|
|
ucode_capa.standard_phy_calibration_size;
|
|
|
|
priv->_agn.phy_calib_chain_noise_gain_cmd =
|
|
|
|
ucode_capa.standard_phy_calibration_size + 1;
|
|
|
|
|
2010-01-29 19:54:56 +00:00
|
|
|
/**************************************************
|
|
|
|
* This is still part of probe() in a sense...
|
|
|
|
*
|
|
|
|
* 9. Setup and register with mac80211 and debugfs
|
|
|
|
**************************************************/
|
2010-04-29 06:33:10 +00:00
|
|
|
err = iwl_mac_setup_register(priv, &ucode_capa);
|
2010-01-29 19:54:56 +00: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);
|
|
|
|
|
2010-05-23 07:14:08 +00:00
|
|
|
err = sysfs_create_group(&priv->pci_dev->dev.kobj,
|
|
|
|
&iwl_attribute_group);
|
|
|
|
if (err) {
|
|
|
|
IWL_ERR(priv, "failed to create sysfs device attributes\n");
|
|
|
|
goto out_unbind;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* We have our copies now, allow OS release its copies */
|
|
|
|
release_firmware(ucode_raw);
|
2010-05-10 22:08:11 +00:00
|
|
|
complete(&priv->_agn.firmware_loading_complete);
|
2010-01-29 19:54:56 +00: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 00:54:57 +00:00
|
|
|
|
|
|
|
err_pci_alloc:
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "failed to allocate pci memory\n");
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_dealloc_ucode_pci(priv);
|
2010-01-29 19:54:56 +00:00
|
|
|
out_unbind:
|
2010-05-10 22:08:11 +00:00
|
|
|
complete(&priv->_agn.firmware_loading_complete);
|
2010-01-29 19:54:56 +00:00
|
|
|
device_release_driver(&priv->pci_dev->dev);
|
2007-09-26 00:54:57 +00:00
|
|
|
release_firmware(ucode_raw);
|
|
|
|
}
|
|
|
|
|
2009-09-25 21:24:23 +00:00
|
|
|
static const char *desc_lookup_text[] = {
|
|
|
|
"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",
|
|
|
|
"NMI_INTERRUPT_BREAK_POINT"
|
|
|
|
"DEBUG_0",
|
|
|
|
"DEBUG_1",
|
|
|
|
"DEBUG_2",
|
|
|
|
"DEBUG_3",
|
|
|
|
};
|
|
|
|
|
2010-07-02 22:49:10 +00: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-25 21:24:23 +00:00
|
|
|
{
|
2010-07-02 22:49:10 +00:00
|
|
|
int i;
|
|
|
|
int max = ARRAY_SIZE(desc_lookup_text);
|
2009-09-25 21:24:23 +00:00
|
|
|
|
2010-07-02 22:49:10 +00:00
|
|
|
if (num < max)
|
|
|
|
return desc_lookup_text[num];
|
2009-09-25 21:24:23 +00:00
|
|
|
|
2010-07-02 22:49:10 +00:00
|
|
|
max = ARRAY_SIZE(advanced_lookup) - 1;
|
|
|
|
for (i = 0; i < max; i++) {
|
|
|
|
if (advanced_lookup[i].num == num)
|
|
|
|
break;;
|
|
|
|
}
|
|
|
|
return advanced_lookup[i].name;
|
2009-09-25 21:24:23 +00: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)
|
|
|
|
{
|
|
|
|
u32 data2, line;
|
|
|
|
u32 desc, time, count, base, data1;
|
|
|
|
u32 blink1, blink2, ilink1, ilink2;
|
2010-03-31 00:57:53 +00:00
|
|
|
u32 pc, hcmd;
|
2009-09-25 21:24:23 +00:00
|
|
|
|
2010-05-06 06:24:54 +00:00
|
|
|
if (priv->ucode_type == UCODE_INIT) {
|
2009-09-25 21:24:23 +00:00
|
|
|
base = le32_to_cpu(priv->card_alive_init.error_event_table_ptr);
|
2010-05-06 06:24:54 +00:00
|
|
|
if (!base)
|
|
|
|
base = priv->_agn.init_errlog_ptr;
|
|
|
|
} else {
|
2009-09-25 21:24:23 +00:00
|
|
|
base = le32_to_cpu(priv->card_alive.error_event_table_ptr);
|
2010-05-06 06:24:54 +00:00
|
|
|
if (!base)
|
|
|
|
base = priv->_agn.inst_errlog_ptr;
|
|
|
|
}
|
2009-09-25 21:24:23 +00:00
|
|
|
|
|
|
|
if (!priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
|
2009-12-02 20:53:00 +00:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"Not valid error log pointer 0x%08X for %s uCode\n",
|
|
|
|
base, (priv->ucode_type == UCODE_INIT) ? "Init" : "RT");
|
2009-09-25 21:24:23 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = iwl_read_targ_mem(priv, base);
|
|
|
|
|
|
|
|
if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
|
|
|
|
IWL_ERR(priv, "Start IWL Error Log Dump:\n");
|
|
|
|
IWL_ERR(priv, "Status: 0x%08lX, count: %d\n",
|
|
|
|
priv->status, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
desc = iwl_read_targ_mem(priv, base + 1 * sizeof(u32));
|
2010-08-27 17:41:37 +00:00
|
|
|
priv->isr_stats.err_code = desc;
|
2010-03-31 00:57:53 +00:00
|
|
|
pc = iwl_read_targ_mem(priv, base + 2 * sizeof(u32));
|
2009-09-25 21:24:23 +00:00
|
|
|
blink1 = iwl_read_targ_mem(priv, base + 3 * sizeof(u32));
|
|
|
|
blink2 = iwl_read_targ_mem(priv, base + 4 * sizeof(u32));
|
|
|
|
ilink1 = iwl_read_targ_mem(priv, base + 5 * sizeof(u32));
|
|
|
|
ilink2 = iwl_read_targ_mem(priv, base + 6 * sizeof(u32));
|
|
|
|
data1 = iwl_read_targ_mem(priv, base + 7 * sizeof(u32));
|
|
|
|
data2 = iwl_read_targ_mem(priv, base + 8 * sizeof(u32));
|
|
|
|
line = iwl_read_targ_mem(priv, base + 9 * sizeof(u32));
|
|
|
|
time = iwl_read_targ_mem(priv, base + 11 * sizeof(u32));
|
2010-03-31 00:57:53 +00:00
|
|
|
hcmd = iwl_read_targ_mem(priv, base + 22 * sizeof(u32));
|
2009-09-25 21:24:23 +00:00
|
|
|
|
2009-10-02 20:44:02 +00:00
|
|
|
trace_iwlwifi_dev_ucode_error(priv, desc, time, data1, data2, line,
|
|
|
|
blink1, blink2, ilink1, ilink2);
|
|
|
|
|
2010-06-14 21:40:40 +00:00
|
|
|
IWL_ERR(priv, "Desc Time "
|
2009-09-25 21:24:23 +00:00
|
|
|
"data1 data2 line\n");
|
2010-06-14 21:40:40 +00:00
|
|
|
IWL_ERR(priv, "%-28s (0x%04X) %010u 0x%08X 0x%08X %u\n",
|
2009-09-25 21:24:23 +00:00
|
|
|
desc_lookup(desc), desc, time, data1, data2, line);
|
2010-03-31 00:57:53 +00:00
|
|
|
IWL_ERR(priv, "pc blink1 blink2 ilink1 ilink2 hcmd\n");
|
|
|
|
IWL_ERR(priv, "0x%05X 0x%05X 0x%05X 0x%05X 0x%05X 0x%05X\n",
|
|
|
|
pc, blink1, blink2, ilink1, ilink2, hcmd);
|
2009-09-25 21:24:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define EVENT_START_OFFSET (4 * sizeof(u32))
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_print_event_log - Dump error event log to syslog
|
|
|
|
*
|
|
|
|
*/
|
2009-12-14 22:12:20 +00: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-25 21:24:23 +00: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-06 22:52:58 +00:00
|
|
|
unsigned long reg_flags;
|
2009-09-25 21:24:23 +00:00
|
|
|
|
|
|
|
if (num_events == 0)
|
2009-12-14 22:12:20 +00:00
|
|
|
return pos;
|
2010-05-06 06:24:54 +00:00
|
|
|
|
|
|
|
if (priv->ucode_type == UCODE_INIT) {
|
2009-09-25 21:24:23 +00:00
|
|
|
base = le32_to_cpu(priv->card_alive_init.log_event_table_ptr);
|
2010-05-06 06:24:54 +00:00
|
|
|
if (!base)
|
|
|
|
base = priv->_agn.init_evtlog_ptr;
|
|
|
|
} else {
|
2009-09-25 21:24:23 +00:00
|
|
|
base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
|
2010-05-06 06:24:54 +00:00
|
|
|
if (!base)
|
|
|
|
base = priv->_agn.inst_evtlog_ptr;
|
|
|
|
}
|
2009-09-25 21:24:23 +00: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-06 22:52:58 +00: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 */
|
|
|
|
_iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, ptr);
|
|
|
|
rmb();
|
|
|
|
|
2009-09-25 21:24:23 +00: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++) {
|
2009-11-06 22:52:58 +00:00
|
|
|
ev = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
|
|
|
|
time = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
|
2009-09-25 21:24:23 +00:00
|
|
|
if (mode == 0) {
|
|
|
|
/* data, ev */
|
2009-12-14 22:12:20 +00: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-25 21:24:23 +00:00
|
|
|
} else {
|
2009-11-06 22:52:58 +00:00
|
|
|
data = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
|
2009-12-14 22:12:20 +00: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-25 21:24:23 +00:00
|
|
|
time, data, ev);
|
2009-12-14 22:12:20 +00:00
|
|
|
trace_iwlwifi_dev_ucode_event(priv, time,
|
|
|
|
data, ev);
|
|
|
|
}
|
2009-09-25 21:24:23 +00:00
|
|
|
}
|
|
|
|
}
|
2009-11-06 22:52:58 +00:00
|
|
|
|
|
|
|
/* Allow device to power down */
|
|
|
|
iwl_release_nic_access(priv);
|
|
|
|
spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
|
2009-12-14 22:12:20 +00:00
|
|
|
return pos;
|
2009-09-25 21:24:23 +00:00
|
|
|
}
|
|
|
|
|
2009-11-20 20:05:07 +00:00
|
|
|
/**
|
|
|
|
* iwl_print_last_event_logs - Dump the newest # of event log to syslog
|
|
|
|
*/
|
2009-12-14 22:12:20 +00: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-20 20:05:07 +00: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-14 22:12:20 +00: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-20 20:05:07 +00:00
|
|
|
} else
|
2009-12-14 22:12:20 +00:00
|
|
|
pos = iwl_print_event_log(priv, next_entry - size,
|
|
|
|
size, mode, pos, buf, bufsz);
|
2009-11-20 20:05:07 +00:00
|
|
|
} else {
|
2009-12-14 22:12:20 +00: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-20 20:05:07 +00:00
|
|
|
}
|
2009-12-14 22:12:20 +00:00
|
|
|
return pos;
|
2009-11-20 20:05:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define DEFAULT_DUMP_EVENT_LOG_ENTRIES (20)
|
|
|
|
|
2009-12-14 22:12:20 +00:00
|
|
|
int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
|
|
|
|
char **buf, bool display)
|
2009-09-25 21:24:23 +00: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 06:24:54 +00:00
|
|
|
u32 logsize;
|
2009-12-14 22:12:20 +00:00
|
|
|
int pos = 0;
|
|
|
|
size_t bufsz = 0;
|
2009-09-25 21:24:23 +00:00
|
|
|
|
2010-05-06 06:24:54 +00:00
|
|
|
if (priv->ucode_type == UCODE_INIT) {
|
2009-09-25 21:24:23 +00:00
|
|
|
base = le32_to_cpu(priv->card_alive_init.log_event_table_ptr);
|
2010-05-06 06:24:54 +00:00
|
|
|
logsize = priv->_agn.init_evtlog_size;
|
|
|
|
if (!base)
|
|
|
|
base = priv->_agn.init_evtlog_ptr;
|
|
|
|
} else {
|
2009-09-25 21:24:23 +00:00
|
|
|
base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
|
2010-05-06 06:24:54 +00:00
|
|
|
logsize = priv->_agn.inst_evtlog_size;
|
|
|
|
if (!base)
|
|
|
|
base = priv->_agn.inst_evtlog_ptr;
|
|
|
|
}
|
2009-09-25 21:24:23 +00:00
|
|
|
|
|
|
|
if (!priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
|
2009-12-02 20:53:00 +00:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"Invalid event log pointer 0x%08X for %s uCode\n",
|
|
|
|
base, (priv->ucode_type == UCODE_INIT) ? "Init" : "RT");
|
2010-01-15 21:43:36 +00:00
|
|
|
return -EINVAL;
|
2009-09-25 21:24:23 +00: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 06:24:54 +00:00
|
|
|
if (capacity > logsize) {
|
2009-11-06 22:52:57 +00:00
|
|
|
IWL_ERR(priv, "Log capacity %d is bogus, limit to %d entries\n",
|
2010-05-06 06:24:54 +00:00
|
|
|
capacity, logsize);
|
|
|
|
capacity = logsize;
|
2009-11-06 22:52:57 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 06:24:54 +00:00
|
|
|
if (next_entry > logsize) {
|
2009-11-06 22:52:57 +00:00
|
|
|
IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
|
2010-05-06 06:24:54 +00:00
|
|
|
next_entry, logsize);
|
|
|
|
next_entry = logsize;
|
2009-11-06 22:52:57 +00:00
|
|
|
}
|
|
|
|
|
2009-09-25 21:24:23 +00: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-14 22:12:20 +00:00
|
|
|
return pos;
|
2009-09-25 21:24:23 +00:00
|
|
|
}
|
|
|
|
|
2010-08-23 14:57:12 +00:00
|
|
|
/* enable/disable bt channel announcement */
|
|
|
|
priv->bt_ch_announce = iwlagn_bt_ch_announce;
|
|
|
|
|
2009-11-20 20:05:07 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-12-10 22:37:23 +00:00
|
|
|
if (!(iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) && !full_log)
|
2009-11-20 20:05:07 +00: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-25 21:24:23 +00:00
|
|
|
|
2009-11-20 20:05:07 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-12-14 22:12:20 +00:00
|
|
|
if (display) {
|
|
|
|
if (full_log)
|
|
|
|
bufsz = capacity * 48;
|
|
|
|
else
|
|
|
|
bufsz = size * 48;
|
|
|
|
*buf = kmalloc(bufsz, GFP_KERNEL);
|
|
|
|
if (!*buf)
|
2010-01-15 21:43:36 +00:00
|
|
|
return -ENOMEM;
|
2009-12-14 22:12:20 +00:00
|
|
|
}
|
2009-11-20 20:05:07 +00:00
|
|
|
if ((iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) || full_log) {
|
|
|
|
/*
|
|
|
|
* 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-14 22:12:20 +00:00
|
|
|
pos = iwl_print_event_log(priv, next_entry,
|
|
|
|
capacity - next_entry, mode,
|
|
|
|
pos, buf, bufsz);
|
2009-11-20 20:05:07 +00:00
|
|
|
/* (then/else) start at top of log */
|
2009-12-14 22:12:20 +00:00
|
|
|
pos = iwl_print_event_log(priv, 0,
|
|
|
|
next_entry, mode, pos, buf, bufsz);
|
2009-11-20 20:05:07 +00:00
|
|
|
} else
|
2009-12-14 22:12:20 +00:00
|
|
|
pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
|
|
|
|
next_entry, size, mode,
|
|
|
|
pos, buf, bufsz);
|
2009-11-20 20:05:07 +00:00
|
|
|
#else
|
2009-12-14 22:12:20 +00:00
|
|
|
pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
|
|
|
|
next_entry, size, mode,
|
|
|
|
pos, buf, bufsz);
|
2009-09-25 21:24:23 +00:00
|
|
|
#endif
|
2009-12-14 22:12:20 +00:00
|
|
|
return pos;
|
2009-11-20 20:05:07 +00:00
|
|
|
}
|
2009-09-25 21:24:23 +00:00
|
|
|
|
2010-07-31 15:34:07 +00: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;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
|
|
|
|
CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
priv->thermal_throttle.ct_kill_toggle = false;
|
|
|
|
|
|
|
|
if (priv->cfg->support_ct_kill_exit) {
|
|
|
|
adv_cmd.critical_temperature_enter =
|
|
|
|
cpu_to_le32(priv->hw_params.ct_kill_threshold);
|
|
|
|
adv_cmd.critical_temperature_exit =
|
|
|
|
cpu_to_le32(priv->hw_params.ct_kill_exit_threshold);
|
|
|
|
|
|
|
|
ret = iwl_send_cmd_pdu(priv, REPLY_CT_KILL_CONFIG_CMD,
|
|
|
|
sizeof(adv_cmd), &adv_cmd);
|
|
|
|
if (ret)
|
|
|
|
IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
|
|
|
|
else
|
|
|
|
IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
|
|
|
|
"succeeded, "
|
|
|
|
"critical temperature enter is %d,"
|
|
|
|
"exit is %d\n",
|
|
|
|
priv->hw_params.ct_kill_threshold,
|
|
|
|
priv->hw_params.ct_kill_exit_threshold);
|
|
|
|
} else {
|
|
|
|
cmd.critical_temperature_R =
|
|
|
|
cpu_to_le32(priv->hw_params.ct_kill_threshold);
|
|
|
|
|
|
|
|
ret = iwl_send_cmd_pdu(priv, REPLY_CT_KILL_CONFIG_CMD,
|
|
|
|
sizeof(cmd), &cmd);
|
|
|
|
if (ret)
|
|
|
|
IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
|
|
|
|
else
|
|
|
|
IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
|
|
|
|
"succeeded, "
|
|
|
|
"critical temperature is %d\n",
|
|
|
|
priv->hw_params.ct_kill_threshold);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
2008-05-29 08:34:54 +00:00
|
|
|
* iwl_alive_start - called after REPLY_ALIVE notification received
|
2007-09-26 00:54:57 +00:00
|
|
|
* from protocol/runtime uCode (initialization uCode's
|
2008-05-29 08:34:54 +00:00
|
|
|
* Alive gets handled by iwl_init_alive_start()).
|
2007-09-26 00:54:57 +00:00
|
|
|
*/
|
2008-05-29 08:34:54 +00:00
|
|
|
static void iwl_alive_start(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-04-15 04:16:03 +00:00
|
|
|
int ret = 0;
|
2010-08-23 08:46:32 +00:00
|
|
|
struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->card_alive.is_valid != UCODE_VALID_OK) {
|
|
|
|
/* We had an error bringing up the hardware, so take it
|
|
|
|
* all the way back down so we can try again */
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Alive failed.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize uCode has loaded Runtime uCode ... verify inst image.
|
|
|
|
* This is a paranoid check, because we would not have gotten the
|
|
|
|
* "runtime" alive if code weren't properly loaded. */
|
2008-04-24 18:55:18 +00:00
|
|
|
if (iwl_verify_ucode(priv)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Runtime instruction load was bad;
|
|
|
|
* take it all the way back down so we can try again */
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
2008-04-15 04:16:03 +00:00
|
|
|
ret = priv->cfg->ops->lib->alive_notify(priv);
|
|
|
|
if (ret) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv,
|
|
|
|
"Could not complete ALIVE transition [ntf]: %d\n", ret);
|
2007-09-26 00:54:57 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
/* After the ALIVE response, we can send host commands to the uCode */
|
2007-09-26 00:54:57 +00:00
|
|
|
set_bit(STATUS_ALIVE, &priv->status);
|
|
|
|
|
2010-03-02 01:23:50 +00:00
|
|
|
if (priv->cfg->ops->lib->recover_from_tx_stall) {
|
|
|
|
/* Enable timer to monitor the driver queues */
|
|
|
|
mod_timer(&priv->monitor_recover,
|
|
|
|
jiffies +
|
|
|
|
msecs_to_jiffies(priv->cfg->monitor_recover_period));
|
|
|
|
}
|
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (iwl_is_rfkill(priv))
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
|
2010-08-23 22:24:49 +00:00
|
|
|
if (priv->cfg->advanced_bt_coexist) {
|
|
|
|
/* Configure Bluetooth device coexistence support */
|
|
|
|
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;
|
|
|
|
priv->cfg->ops->hcmd->send_bt_config(priv);
|
|
|
|
priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS;
|
|
|
|
if (bt_coex_active && priv->iw_mode != NL80211_IFTYPE_ADHOC)
|
|
|
|
iwlagn_send_prio_tbl(priv);
|
|
|
|
|
|
|
|
/* FIXME: w/a to force change uCode BT state machine */
|
|
|
|
iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
|
|
|
|
BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
|
|
|
|
iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_CLOSE,
|
|
|
|
BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
|
|
|
|
}
|
2008-05-15 10:55:26 +00:00
|
|
|
ieee80211_wake_queues(priv->hw);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-01-21 19:23:30 +00:00
|
|
|
priv->active_rate = IWL_RATES_MASK;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-09-17 17:43:51 +00:00
|
|
|
/* Configure Tx antenna selection based on H/W config */
|
|
|
|
if (priv->cfg->ops->hcmd->set_tx_ant)
|
|
|
|
priv->cfg->ops->hcmd->set_tx_ant(priv, priv->cfg->valid_tx_ant);
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
if (iwl_is_associated_ctx(ctx)) {
|
2008-05-15 05:53:59 +00:00
|
|
|
struct iwl_rxon_cmd *active_rxon =
|
2010-08-23 08:46:32 +00:00
|
|
|
(struct iwl_rxon_cmd *)&ctx->active;
|
2009-03-18 04:59:18 +00:00
|
|
|
/* apply any changes in staging */
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
|
2007-09-26 00:54:57 +00:00
|
|
|
active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
} else {
|
2010-08-23 08:46:58 +00:00
|
|
|
struct iwl_rxon_context *tmp;
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Initialize our rx_config data */
|
2010-08-23 08:46:58 +00:00
|
|
|
for_each_context(priv, tmp)
|
|
|
|
iwl_connection_init_rx_config(priv, tmp);
|
2009-04-08 18:26:44 +00:00
|
|
|
|
|
|
|
if (priv->cfg->ops->hcmd->set_rxon_chain)
|
2010-08-23 08:46:32 +00:00
|
|
|
priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-08-23 14:57:05 +00:00
|
|
|
if (!priv->cfg->advanced_bt_coexist) {
|
|
|
|
/* Configure Bluetooth device coexistence support */
|
|
|
|
priv->cfg->ops->hcmd->send_bt_config(priv);
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-29 08:34:54 +00:00
|
|
|
iwl_reset_run_time_calib(priv);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Configure the adapter for unassociated operation */
|
2010-08-23 08:46:32 +00:00
|
|
|
iwlcore_commit_rxon(priv, ctx);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* At this point, the NIC is initialized and operational */
|
2008-06-12 01:47:13 +00:00
|
|
|
iwl_rf_kill_ct_config(priv);
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2009-10-02 20:44:03 +00:00
|
|
|
iwl_leds_init(priv);
|
2008-04-03 23:05:23 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
|
2008-03-18 21:57:49 +00:00
|
|
|
set_bit(STATUS_READY, &priv->status);
|
2008-01-15 01:46:18 +00:00
|
|
|
wake_up_interruptible(&priv->wait_command_queue);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-08-07 22:41:51 +00:00
|
|
|
iwl_power_update_mode(priv, true);
|
2010-02-19 06:58:32 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Updated power mode\n");
|
|
|
|
|
2008-06-12 01:47:05 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
restart:
|
|
|
|
queue_work(priv->workqueue, &priv->restart);
|
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
static void iwl_cancel_deferred_work(struct iwl_priv *priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void __iwl_down(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (!exit_pending)
|
|
|
|
set_bit(STATUS_EXIT_PENDING, &priv->status);
|
|
|
|
|
2010-08-20 13:23:47 +00:00
|
|
|
/* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set
|
|
|
|
* to prevent rearm timer */
|
|
|
|
if (priv->cfg->ops->lib->recover_from_tx_stall)
|
|
|
|
del_timer_sync(&priv->monitor_recover);
|
|
|
|
|
2010-08-27 15:55:52 +00:00
|
|
|
iwl_clear_ucode_stations(priv, NULL);
|
2010-08-27 15:53:46 +00:00
|
|
|
iwl_dealloc_bcast_stations(priv);
|
2010-05-07 08:49:15 +00:00
|
|
|
iwl_clear_driver_stations(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 14:56:59 +00:00
|
|
|
/* reset BT coex data */
|
2010-08-23 14:57:13 +00:00
|
|
|
priv->bt_status = 0;
|
2010-08-23 14:57:08 +00:00
|
|
|
priv->bt_traffic_load = priv->cfg->bt_init_traffic_load;
|
2010-08-23 14:56:59 +00:00
|
|
|
priv->bt_sco_active = false;
|
2010-08-23 14:57:04 +00:00
|
|
|
priv->bt_full_concurrent = false;
|
|
|
|
priv->bt_ci_compliance = 0;
|
2010-08-23 14:56:59 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Unblock any waiting calls */
|
|
|
|
wake_up_interruptible_all(&priv->wait_command_queue);
|
|
|
|
|
|
|
|
/* Wipe out the EXIT_PENDING status bit if we are not actually
|
|
|
|
* exiting the module */
|
|
|
|
if (!exit_pending)
|
|
|
|
clear_bit(STATUS_EXIT_PENDING, &priv->status);
|
|
|
|
|
|
|
|
/* stop and reset the on-board processor */
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* tell the device to stop sending interrupts */
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_disable_interrupts(priv);
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
iwl_synchronize_irq(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->mac80211_registered)
|
|
|
|
ieee80211_stop_queues(priv->hw);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
/* If we have not previously called iwl_init() then
|
2009-06-04 16:26:06 +00:00
|
|
|
* clear all bits but the RF Kill bit and return */
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_init(priv)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
|
|
|
|
STATUS_RF_KILL_HW |
|
2008-02-06 19:20:38 +00:00
|
|
|
test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
|
|
|
|
STATUS_GEO_CONFIGURED |
|
2008-06-30 09:23:15 +00:00
|
|
|
test_bit(STATUS_EXIT_PENDING, &priv->status) <<
|
|
|
|
STATUS_EXIT_PENDING;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2009-03-26 17:14:08 +00:00
|
|
|
/* ...otherwise clear out all the status bits but the RF Kill
|
2009-06-04 16:26:06 +00:00
|
|
|
* bit and continue taking the NIC down. */
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
|
|
|
|
STATUS_RF_KILL_HW |
|
2008-02-06 19:20:38 +00:00
|
|
|
test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
|
|
|
|
STATUS_GEO_CONFIGURED |
|
2007-09-26 00:54:57 +00:00
|
|
|
test_bit(STATUS_FW_ERROR, &priv->status) <<
|
2008-06-30 09:23:15 +00:00
|
|
|
STATUS_FW_ERROR |
|
|
|
|
test_bit(STATUS_EXIT_PENDING, &priv->status) <<
|
|
|
|
STATUS_EXIT_PENDING;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-05-22 18:01:50 +00:00
|
|
|
/* device going down, Stop using ICT table */
|
|
|
|
iwl_disable_ict(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-03-17 20:34:34 +00:00
|
|
|
iwlagn_txq_ctx_stop(priv);
|
2010-03-17 20:34:35 +00:00
|
|
|
iwlagn_rxq_stop(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-11-06 22:53:03 +00:00
|
|
|
/* Power-down device's busmaster DMA clocks */
|
|
|
|
iwl_write_prph(priv, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
|
2007-09-26 00:54:57 +00:00
|
|
|
udelay(5);
|
|
|
|
|
2009-11-06 22:53:03 +00:00
|
|
|
/* Make sure (redundant) we've released our request to stay awake */
|
|
|
|
iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
|
|
|
|
|
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-09 20:20:20 +00:00
|
|
|
/* Stop the device, and put it in low power state */
|
|
|
|
priv->cfg->ops->lib->apm_ops.stop(priv);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
exit:
|
2008-05-29 08:34:55 +00:00
|
|
|
memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
priv->ibss_beacon = NULL;
|
|
|
|
|
|
|
|
/* clear out any free frames */
|
2008-05-15 05:54:01 +00:00
|
|
|
iwl_clear_free_frames(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_down(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-10-29 21:05:46 +00:00
|
|
|
__iwl_down(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2007-12-19 05:59:52 +00:00
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
iwl_cancel_deferred_work(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-05-22 18:01:54 +00:00
|
|
|
#define HW_READY_TIMEOUT (50)
|
|
|
|
|
|
|
|
static int iwl_set_hw_ready(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
|
|
|
|
CSR_HW_IF_CONFIG_REG_BIT_NIC_READY);
|
|
|
|
|
|
|
|
/* See if we got it */
|
|
|
|
ret = iwl_poll_bit(priv, CSR_HW_IF_CONFIG_REG,
|
|
|
|
CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
|
|
|
|
CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
|
|
|
|
HW_READY_TIMEOUT);
|
|
|
|
if (ret != -ETIMEDOUT)
|
|
|
|
priv->hw_ready = true;
|
|
|
|
else
|
|
|
|
priv->hw_ready = false;
|
|
|
|
|
|
|
|
IWL_DEBUG_INFO(priv, "hardware %s\n",
|
|
|
|
(priv->hw_ready == 1) ? "ready" : "not ready");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iwl_prepare_card_hw(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2010-03-24 21:19:58 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "iwl_prepare_card_hw enter\n");
|
2009-05-22 18:01:54 +00:00
|
|
|
|
2009-06-19 20:52:41 +00:00
|
|
|
ret = iwl_set_hw_ready(priv);
|
|
|
|
if (priv->hw_ready)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* If HW is not ready, prepare the conditions to check again */
|
2009-05-22 18:01:54 +00:00
|
|
|
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
|
|
|
|
CSR_HW_IF_CONFIG_REG_PREPARE);
|
|
|
|
|
|
|
|
ret = iwl_poll_bit(priv, CSR_HW_IF_CONFIG_REG,
|
|
|
|
~CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE,
|
|
|
|
CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE, 150000);
|
|
|
|
|
2009-06-19 20:52:41 +00:00
|
|
|
/* HW should be ready by now, check again. */
|
2009-05-22 18:01:54 +00:00
|
|
|
if (ret != -ETIMEDOUT)
|
|
|
|
iwl_set_hw_ready(priv);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
#define MAX_HW_RESTARTS 5
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int __iwl_up(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-08-27 15:53:46 +00:00
|
|
|
struct iwl_rxon_context *ctx;
|
2008-04-15 04:16:03 +00:00
|
|
|
int i;
|
|
|
|
int ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2008-01-31 06:05:15 +00:00
|
|
|
if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "ucode not available for device bringup\n");
|
2008-01-31 06:05:15 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2010-08-27 15:53:46 +00:00
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
ret = iwl_alloc_bcast_station(priv, ctx, true);
|
|
|
|
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 07:53:29 +00:00
|
|
|
|
2009-05-22 18:01:54 +00:00
|
|
|
iwl_prepare_card_hw(priv);
|
|
|
|
|
|
|
|
if (!priv->hw_ready) {
|
|
|
|
IWL_WARN(priv, "Exit HW not ready\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2008-01-24 10:19:38 +00:00
|
|
|
/* If platform's RF_KILL switch is NOT set to KILL */
|
2008-08-04 08:00:43 +00:00
|
|
|
if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
|
2008-01-24 10:19:38 +00:00
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
2008-06-30 09:23:19 +00:00
|
|
|
else
|
2008-01-24 10:19:38 +00:00
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
2008-06-30 09:23:19 +00:00
|
|
|
|
2008-08-04 08:00:43 +00:00
|
|
|
if (iwl_is_rfkill(priv)) {
|
2009-06-04 16:26:06 +00:00
|
|
|
wiphy_rfkill_set_hw_state(priv->hw->wiphy, true);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_enable_interrupts(priv);
|
2009-06-04 16:26:06 +00:00
|
|
|
IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
|
2008-08-04 08:00:43 +00:00
|
|
|
return 0;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 08:46:33 +00:00
|
|
|
/* must be initialised before iwl_hw_nic_init */
|
2010-08-23 08:46:34 +00:00
|
|
|
if (priv->valid_contexts != BIT(IWL_RXON_CTX_BSS))
|
|
|
|
priv->cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
|
|
|
|
else
|
|
|
|
priv->cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
|
2010-08-23 08:46:33 +00:00
|
|
|
|
2010-03-17 20:34:34 +00:00
|
|
|
ret = iwlagn_hw_nic_init(priv);
|
2008-04-15 04:16:03 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to init nic\n");
|
2008-04-15 04:16:03 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure rfkill handshake bits are cleared */
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
|
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
|
|
|
|
|
|
|
|
/* clear (again), then enable host interrupts */
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_enable_interrupts(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* really make sure rfkill handshake bits are cleared */
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
|
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Copy original ucode data image from disk into backup cache.
|
|
|
|
* This will be used to initialize the on-board processor's
|
|
|
|
* data SRAM for a clean start when the runtime program first loads. */
|
|
|
|
memcpy(priv->ucode_data_backup.v_addr, priv->ucode_data.v_addr,
|
2008-01-15 01:46:18 +00:00
|
|
|
priv->ucode_data.len);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
for (i = 0; i < MAX_HW_RESTARTS; i++) {
|
|
|
|
|
|
|
|
/* load bootstrap state machine,
|
|
|
|
* load bootstrap program into processor's memory,
|
|
|
|
* prepare to load the "initialize" uCode */
|
2008-04-15 04:16:03 +00:00
|
|
|
ret = priv->cfg->ops->lib->load_ucode(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-15 04:16:03 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to set up bootstrap uCode: %d\n",
|
|
|
|
ret);
|
2007-09-26 00:54:57 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* start card; "initialize" will load runtime ucode */
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_nic_start(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_bit(STATUS_EXIT_PENDING, &priv->status);
|
2008-10-29 21:05:46 +00:00
|
|
|
__iwl_down(priv);
|
2008-06-12 01:47:03 +00:00
|
|
|
clear_bit(STATUS_EXIT_PENDING, &priv->status);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* tried to restart and config the device for as long as our
|
|
|
|
* patience could withstand */
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* Workqueue callbacks
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-05-29 08:34:54 +00:00
|
|
|
static void iwl_bg_init_alive_start(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(data, struct iwl_priv, init_alive_start.work);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-05-05 02:22:45 +00:00
|
|
|
priv->cfg->ops->lib->init_alive_start(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2008-05-29 08:34:54 +00:00
|
|
|
static void iwl_bg_alive_start(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(data, struct iwl_priv, alive_start.work);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
2009-06-03 18:44:10 +00:00
|
|
|
/* enable dram interrupt */
|
|
|
|
iwl_reset_ict(priv);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
2008-05-29 08:34:54 +00:00
|
|
|
iwl_alive_start(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:52 +00: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);
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
|
|
|
|
test_bit(STATUS_SCANNING, &priv->status)) {
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->start_calib) {
|
2010-07-14 15:08:57 +00:00
|
|
|
if (priv->cfg->bt_statistics) {
|
|
|
|
iwl_chain_noise_calibration(priv,
|
|
|
|
(void *)&priv->_agn.statistics_bt);
|
|
|
|
iwl_sensitivity_calibration(priv,
|
|
|
|
(void *)&priv->_agn.statistics_bt);
|
|
|
|
} else {
|
|
|
|
iwl_chain_noise_calibration(priv,
|
|
|
|
(void *)&priv->_agn.statistics);
|
|
|
|
iwl_sensitivity_calibration(priv,
|
|
|
|
(void *)&priv->_agn.statistics);
|
|
|
|
}
|
2008-06-12 01:46:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bg_restart(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
2009-05-08 20:44:36 +00:00
|
|
|
if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
|
2010-08-23 08:46:40 +00:00
|
|
|
struct iwl_rxon_context *ctx;
|
2010-08-23 14:57:04 +00:00
|
|
|
bool bt_sco, bt_full_concurrent;
|
|
|
|
u8 bt_ci_compliance;
|
2010-08-23 14:57:01 +00:00
|
|
|
u8 bt_load;
|
2010-08-23 14:57:13 +00:00
|
|
|
u8 bt_status;
|
2010-08-23 14:57:01 +00:00
|
|
|
|
2009-05-08 20:44:36 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
2010-08-23 08:46:40 +00:00
|
|
|
for_each_context(priv, ctx)
|
|
|
|
ctx->vif = NULL;
|
2009-05-08 20:44:36 +00:00
|
|
|
priv->is_open = 0;
|
2010-08-23 14:57:01 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* __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_sco = priv->bt_sco_active;
|
2010-08-23 14:57:04 +00:00
|
|
|
bt_full_concurrent = priv->bt_full_concurrent;
|
|
|
|
bt_ci_compliance = priv->bt_ci_compliance;
|
2010-08-23 14:57:01 +00:00
|
|
|
bt_load = priv->bt_traffic_load;
|
2010-08-23 14:57:13 +00:00
|
|
|
bt_status = priv->bt_status;
|
2010-08-23 14:57:01 +00:00
|
|
|
|
2010-08-23 14:56:59 +00:00
|
|
|
__iwl_down(priv);
|
2010-08-23 14:57:01 +00:00
|
|
|
|
|
|
|
priv->bt_sco_active = bt_sco;
|
2010-08-23 14:57:04 +00:00
|
|
|
priv->bt_full_concurrent = bt_full_concurrent;
|
|
|
|
priv->bt_ci_compliance = bt_ci_compliance;
|
2010-08-23 14:57:01 +00:00
|
|
|
priv->bt_traffic_load = bt_load;
|
2010-08-23 14:57:13 +00:00
|
|
|
priv->bt_status = bt_status;
|
2010-08-23 14:57:01 +00:00
|
|
|
|
2009-05-08 20:44:36 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2010-08-23 14:56:59 +00:00
|
|
|
iwl_cancel_deferred_work(priv);
|
2009-05-08 20:44:36 +00:00
|
|
|
ieee80211_restart_hw(priv->hw);
|
|
|
|
} else {
|
|
|
|
iwl_down(priv);
|
2010-01-21 14:07:17 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
__iwl_up(priv);
|
|
|
|
mutex_unlock(&priv->mutex);
|
2009-05-08 20:44:36 +00:00
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bg_rx_replenish(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(data, struct iwl_priv, rx_replenish);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2010-03-17 20:34:35 +00:00
|
|
|
iwlagn_rx_replenish(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2007-11-29 03:10:13 +00:00
|
|
|
#define IWL_DELAY_NEXT_SCAN (HZ*2)
|
|
|
|
|
2010-04-29 11:43:06 +00:00
|
|
|
void iwl_post_associate(struct iwl_priv *priv, struct ieee80211_vif *vif)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-08-23 08:46:32 +00:00
|
|
|
struct iwl_rxon_context *ctx;
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_conf *conf = NULL;
|
2008-03-21 20:53:44 +00:00
|
|
|
int ret = 0;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-04-29 11:43:06 +00:00
|
|
|
if (!vif || !priv->is_open)
|
|
|
|
return;
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx = iwl_rxon_ctx_from_vif(vif);
|
|
|
|
|
2010-04-29 11:43:06 +00:00
|
|
|
if (vif->type == NL80211_IFTYPE_AP) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 200);
|
2007-10-25 09:15:43 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
conf = ieee80211_get_hw_conf(priv->hw);
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
iwlcore_commit_rxon(priv, ctx);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 08:46:55 +00:00
|
|
|
ret = iwl_send_rxon_timing(priv, ctx);
|
2008-03-21 20:53:44 +00:00
|
|
|
if (ret)
|
2010-08-23 08:46:37 +00:00
|
|
|
IWL_WARN(priv, "RXON timing - "
|
2007-09-26 00:54:57 +00:00
|
|
|
"Attempting to continue.\n");
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-09-17 02:10:05 +00:00
|
|
|
iwl_set_rxon_ht(priv, &priv->current_ht_config);
|
2008-06-09 19:54:35 +00:00
|
|
|
|
2009-04-08 18:26:44 +00:00
|
|
|
if (priv->cfg->ops->hcmd->set_rxon_chain)
|
2010-08-23 08:46:32 +00:00
|
|
|
priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
|
2009-04-08 18:26:44 +00:00
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.assoc_id = cpu_to_le16(vif->bss_conf.aid);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
|
2010-04-29 11:43:06 +00:00
|
|
|
vif->bss_conf.aid, vif->bss_conf.beacon_int);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-05-06 19:21:40 +00:00
|
|
|
if (vif->bss_conf.use_short_preamble)
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
if (ctx->staging.flags & RXON_FLG_BAND_24G_MSK) {
|
2010-05-06 19:21:40 +00:00
|
|
|
if (vif->bss_conf.use_short_slot)
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
iwlcore_commit_rxon(priv, ctx);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-02-23 00:24:47 +00:00
|
|
|
IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
|
2010-08-23 08:46:32 +00:00
|
|
|
vif->bss_conf.aid, ctx->active.bssid_addr);
|
2010-02-23 00:24:47 +00:00
|
|
|
|
2010-04-29 11:43:06 +00:00
|
|
|
switch (vif->type) {
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_STATION:
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_send_beacon_cmd(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
default:
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "%s Should not be called in %d mode\n",
|
2010-04-29 11:43:06 +00:00
|
|
|
__func__, vif->type);
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-09-03 03:26:53 +00:00
|
|
|
/* the chain noise calibration will enabled PM upon completion
|
|
|
|
* If chain noise has already been run, then we need to enable
|
|
|
|
* power management here */
|
|
|
|
if (priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE)
|
2009-08-07 22:41:51 +00:00
|
|
|
iwl_power_update_mode(priv, false);
|
2008-09-03 03:26:50 +00:00
|
|
|
|
|
|
|
/* Enable Rx differential gain and sensitivity calibrations */
|
|
|
|
iwl_chain_noise_reset(priv);
|
|
|
|
priv->start_calib = 1;
|
|
|
|
|
2008-04-15 04:16:13 +00:00
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* mac80211 entry point functions
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-06-30 09:23:24 +00:00
|
|
|
#define UCODE_READY_TIMEOUT (4 * HZ)
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2009-10-16 21:25:53 +00:00
|
|
|
/*
|
|
|
|
* Not a mac80211 entry point function, but it fits in with all the
|
|
|
|
* other mac80211 functions grouped here.
|
|
|
|
*/
|
2010-04-29 06:33:10 +00:00
|
|
|
static int iwl_mac_setup_register(struct iwl_priv *priv,
|
|
|
|
struct iwlagn_ucode_capabilities *capa)
|
2009-10-16 21:25:53 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ieee80211_hw *hw = priv->hw;
|
2010-08-23 08:46:58 +00:00
|
|
|
struct iwl_rxon_context *ctx;
|
|
|
|
|
2009-10-16 21:25:53 +00: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 08:46:52 +00:00
|
|
|
IEEE80211_HW_NEED_DTIM_PERIOD |
|
2009-10-16 21:25:53 +00:00
|
|
|
IEEE80211_HW_SPECTRUM_MGMT;
|
|
|
|
|
|
|
|
if (!priv->cfg->broken_powersave)
|
|
|
|
hw->flags |= IEEE80211_HW_SUPPORTS_PS |
|
|
|
|
IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
|
|
|
|
|
2009-12-10 22:37:27 +00:00
|
|
|
if (priv->cfg->sku & IWL_SKU_N)
|
|
|
|
hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
|
|
|
|
IEEE80211_HW_SUPPORTS_STATIC_SMPS;
|
|
|
|
|
2009-10-16 21:25:55 +00:00
|
|
|
hw->sta_data_size = sizeof(struct iwl_station_priv);
|
2010-04-30 18:30:43 +00:00
|
|
|
hw->vif_data_size = sizeof(struct iwl_vif_priv);
|
|
|
|
|
2010-08-23 08:46:58 +00:00
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
hw->wiphy->interface_modes |= ctx->interface_modes;
|
|
|
|
hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
|
|
|
|
}
|
2009-10-16 21:25:53 +00:00
|
|
|
|
2010-03-12 19:13:26 +00:00
|
|
|
hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
|
2009-11-18 23:56:28 +00:00
|
|
|
WIPHY_FLAG_DISABLE_BEACON_HINTS;
|
2009-10-16 21:25:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For now, disable PS by default because it affects
|
|
|
|
* RX performance significantly.
|
|
|
|
*/
|
2009-11-18 23:56:28 +00:00
|
|
|
hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
|
2009-10-16 21:25:53 +00:00
|
|
|
|
2010-02-25 18:02:19 +00:00
|
|
|
hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
|
2009-10-16 21:25:53 +00:00
|
|
|
/* we create the 802.11 header and a zero-length SSID element */
|
2010-04-29 06:33:10 +00:00
|
|
|
hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 2;
|
2009-10-16 21:25:53 +00: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];
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_start(struct ieee80211_hw *hw)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2008-01-15 01:46:18 +00:00
|
|
|
int ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* we should be verifying the device is ready to be opened */
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-10-29 21:05:46 +00:00
|
|
|
ret = __iwl_up(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2008-01-24 10:19:38 +00:00
|
|
|
if (ret)
|
2009-01-19 12:10:07 +00:00
|
|
|
return ret;
|
2008-01-24 10:19:38 +00:00
|
|
|
|
2008-08-04 08:00:43 +00:00
|
|
|
if (iwl_is_rfkill(priv))
|
|
|
|
goto out;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Start UP work done.\n");
|
2008-01-24 10:19:38 +00:00
|
|
|
|
2008-05-29 08:35:06 +00:00
|
|
|
/* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
|
2008-01-15 01:46:18 +00:00
|
|
|
* mac80211 will not be run successfully. */
|
2008-06-30 09:23:24 +00:00
|
|
|
ret = wait_event_interruptible_timeout(priv->wait_command_queue,
|
|
|
|
test_bit(STATUS_READY, &priv->status),
|
|
|
|
UCODE_READY_TIMEOUT);
|
|
|
|
if (!ret) {
|
|
|
|
if (!test_bit(STATUS_READY, &priv->status)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "START_ALIVE timeout after %dms.\n",
|
2008-06-30 09:23:24 +00:00
|
|
|
jiffies_to_msecs(UCODE_READY_TIMEOUT));
|
2009-01-19 12:10:07 +00:00
|
|
|
return -ETIMEDOUT;
|
2008-01-15 01:46:18 +00:00
|
|
|
}
|
2008-05-29 08:35:06 +00:00
|
|
|
}
|
2008-06-30 09:23:26 +00:00
|
|
|
|
2009-10-02 20:44:03 +00:00
|
|
|
iwl_led_start(priv);
|
|
|
|
|
2008-08-04 08:00:43 +00:00
|
|
|
out:
|
2008-06-30 09:23:26 +00:00
|
|
|
priv->is_open = 1;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_mac_stop(struct ieee80211_hw *hw)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-10-25 09:15:45 +00:00
|
|
|
|
2009-05-08 20:44:36 +00:00
|
|
|
if (!priv->is_open)
|
2008-01-24 10:19:38 +00:00
|
|
|
return;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->is_open = 0;
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2009-08-21 20:34:25 +00:00
|
|
|
if (iwl_is_ready_rf(priv) || test_bit(STATUS_SCAN_HW, &priv->status)) {
|
2008-01-24 10:19:38 +00:00
|
|
|
/* stop mac, cancel any scan request and clear
|
|
|
|
* RXON_FILTER_ASSOC_MSK BIT
|
|
|
|
*/
|
2008-01-15 01:46:18 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 100);
|
2007-11-29 03:10:15 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_down(priv);
|
2008-01-15 01:46:18 +00:00
|
|
|
|
|
|
|
flush_workqueue(priv->workqueue);
|
2009-01-19 12:10:07 +00:00
|
|
|
|
|
|
|
/* enable interrupts again in order to receive rfkill changes */
|
|
|
|
iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
|
|
|
|
iwl_enable_interrupts(priv);
|
2007-10-25 09:15:45 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MACDUMP(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
|
2008-05-15 10:55:29 +00:00
|
|
|
ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-03-17 20:34:34 +00:00
|
|
|
if (iwlagn_tx_skb(priv, skb))
|
2007-09-26 00:54:57 +00:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MACDUMP(priv, "leave\n");
|
2009-01-19 23:30:32 +00:00
|
|
|
return NETDEV_TX_OK;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-04-29 11:43:06 +00:00
|
|
|
void iwl_config_ap(struct iwl_priv *priv, struct ieee80211_vif *vif)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-08-23 08:46:32 +00:00
|
|
|
struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
|
2008-03-21 20:53:44 +00:00
|
|
|
int ret = 0;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 08:46:47 +00:00
|
|
|
lockdep_assert_held(&priv->mutex);
|
|
|
|
|
2008-01-23 18:15:16 +00:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* The following should be done only at AP bring up */
|
2010-08-23 08:46:32 +00:00
|
|
|
if (!iwl_is_associated_ctx(ctx)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* RXON - unassoc (to set timing command) */
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
iwlcore_commit_rxon(priv, ctx);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* RXON Timing */
|
2010-08-23 08:46:55 +00:00
|
|
|
ret = iwl_send_rxon_timing(priv, ctx);
|
2008-03-21 20:53:44 +00:00
|
|
|
if (ret)
|
2010-08-23 08:46:37 +00:00
|
|
|
IWL_WARN(priv, "RXON timing failed - "
|
2007-09-26 00:54:57 +00:00
|
|
|
"Attempting to continue.\n");
|
|
|
|
|
2009-11-13 19:56:34 +00:00
|
|
|
/* AP has all antennas */
|
|
|
|
priv->chain_noise_data.active_chains =
|
|
|
|
priv->hw_params.valid_rx_ant;
|
|
|
|
iwl_set_rxon_ht(priv, &priv->current_ht_config);
|
2009-04-08 18:26:44 +00:00
|
|
|
if (priv->cfg->ops->hcmd->set_rxon_chain)
|
2010-08-23 08:46:32 +00:00
|
|
|
priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.assoc_id = 0;
|
2010-04-29 11:43:06 +00:00
|
|
|
|
2010-05-06 19:21:40 +00:00
|
|
|
if (vif->bss_conf.use_short_preamble)
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags |=
|
2007-09-26 00:54:57 +00:00
|
|
|
RXON_FLG_SHORT_PREAMBLE_MSK;
|
|
|
|
else
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags &=
|
2007-09-26 00:54:57 +00:00
|
|
|
~RXON_FLG_SHORT_PREAMBLE_MSK;
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
if (ctx->staging.flags & RXON_FLG_BAND_24G_MSK) {
|
2010-05-06 19:21:40 +00:00
|
|
|
if (vif->bss_conf.use_short_slot)
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags |=
|
2007-09-26 00:54:57 +00:00
|
|
|
RXON_FLG_SHORT_SLOT_MSK;
|
|
|
|
else
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.flags &=
|
2007-09-26 00:54:57 +00:00
|
|
|
~RXON_FLG_SHORT_SLOT_MSK;
|
|
|
|
}
|
2010-08-23 08:46:53 +00:00
|
|
|
/* need to send beacon cmd before committing assoc RXON! */
|
|
|
|
iwl_send_beacon_cmd(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
/* restore RXON assoc */
|
2010-08-23 08:46:32 +00:00
|
|
|
ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
|
|
|
|
iwlcore_commit_rxon(priv, ctx);
|
2007-09-27 03:27:32 +00:00
|
|
|
}
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_send_beacon_cmd(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* FIXME - we need to add code here to detect a totally new
|
|
|
|
* configuration, reset the AP, unassoc, rxon timing, assoc,
|
|
|
|
* clear sta table, add BCAST sta... */
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_mac_update_tkip_key(struct ieee80211_hw *hw,
|
2010-01-21 10:40:47 +00:00
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_key_conf *keyconf,
|
|
|
|
struct ieee80211_sta *sta,
|
|
|
|
u32 iv32, u16 *phase1key)
|
2008-03-20 13:06:43 +00:00
|
|
|
{
|
|
|
|
|
2008-11-12 21:14:05 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2010-08-27 15:53:46 +00:00
|
|
|
struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2008-03-20 13:06:43 +00:00
|
|
|
|
2010-08-27 15:53:46 +00:00
|
|
|
iwl_update_tkip_key(priv, vif_priv->ctx, keyconf, sta,
|
2010-01-21 10:40:47 +00:00
|
|
|
iv32, phase1key);
|
2008-03-20 13:06:43 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2008-03-20 13:06:43 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
|
2008-12-29 11:55:09 +00:00
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_sta *sta,
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_key_conf *key)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2010-08-27 15:53:46 +00:00
|
|
|
struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
|
2010-08-23 08:46:43 +00:00
|
|
|
struct iwl_rxon_context *ctx = vif_priv->ctx;
|
2009-01-19 23:30:22 +00:00
|
|
|
int ret;
|
|
|
|
u8 sta_id;
|
|
|
|
bool is_default_wep_key = false;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-06-19 20:52:42 +00:00
|
|
|
if (priv->cfg->mod_params->sw_crypto) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
2010-08-27 15:53:46 +00:00
|
|
|
sta_id = iwl_sta_id_or_broadcast(priv, vif_priv->ctx, sta);
|
2010-04-30 21:08:00 +00:00
|
|
|
if (sta_id == IWL_INVALID_STATION)
|
|
|
|
return -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-15 04:16:06 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 100);
|
2008-04-15 04:16:06 +00:00
|
|
|
|
2010-03-30 09:44:16 +00:00
|
|
|
/*
|
|
|
|
* If we are getting WEP group key and we didn't receive any key mapping
|
2008-04-15 04:16:06 +00:00
|
|
|
* so far, we are in legacy wep mode (group key only), otherwise we are
|
|
|
|
* in 1X mode.
|
2010-03-30 09:44:16 +00:00
|
|
|
* In legacy wep mode, we use another host command to the uCode.
|
|
|
|
*/
|
2010-08-10 07:46:38 +00:00
|
|
|
if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
|
|
|
|
key->cipher == WLAN_CIPHER_SUITE_WEP104) &&
|
2010-08-18 16:35:21 +00:00
|
|
|
!sta) {
|
2008-04-15 04:16:06 +00:00
|
|
|
if (cmd == SET_KEY)
|
2010-08-23 08:46:43 +00:00
|
|
|
is_default_wep_key = !ctx->key_mapping_keys;
|
2008-04-15 04:16:06 +00:00
|
|
|
else
|
2008-05-15 05:54:09 +00:00
|
|
|
is_default_wep_key =
|
|
|
|
(key->hw_key_idx == HW_KEY_DEFAULT);
|
2008-04-15 04:16:06 +00:00
|
|
|
}
|
2007-10-25 09:15:43 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
switch (cmd) {
|
2008-03-19 23:41:41 +00:00
|
|
|
case SET_KEY:
|
2008-04-15 04:16:06 +00:00
|
|
|
if (is_default_wep_key)
|
2010-08-23 08:46:42 +00:00
|
|
|
ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
|
2008-03-19 23:41:41 +00:00
|
|
|
else
|
2010-08-27 15:53:46 +00:00
|
|
|
ret = iwl_set_dynamic_key(priv, vif_priv->ctx,
|
|
|
|
key, sta_id);
|
2008-03-19 23:41:41 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
case DISABLE_KEY:
|
2008-04-15 04:16:06 +00:00
|
|
|
if (is_default_wep_key)
|
2010-08-23 08:46:43 +00:00
|
|
|
ret = iwl_remove_default_wep_key(priv, ctx, key);
|
2008-03-19 23:41:41 +00:00
|
|
|
else
|
2010-08-23 08:46:43 +00:00
|
|
|
ret = iwl_remove_dynamic_key(priv, ctx, key, sta_id);
|
2008-03-19 23:41:41 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
default:
|
2008-03-19 23:41:41 +00:00
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-02-19 19:42:32 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-19 23:41:41 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_ampdu_action(struct ieee80211_hw *hw,
|
2009-11-16 11:00:38 +00:00
|
|
|
struct ieee80211_vif *vif,
|
2010-04-29 11:43:07 +00:00
|
|
|
enum ieee80211_ampdu_mlme_action action,
|
|
|
|
struct ieee80211_sta *sta, u16 tid, u16 *ssn)
|
2008-07-18 05:53:02 +00:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
2010-06-16 10:30:27 +00:00
|
|
|
int ret = -EINVAL;
|
2008-07-18 05:53:02 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
|
2008-10-27 22:59:26 +00:00
|
|
|
sta->addr, tid);
|
2008-07-18 05:53:02 +00:00
|
|
|
|
|
|
|
if (!(priv->cfg->sku & IWL_SKU_N))
|
|
|
|
return -EACCES;
|
|
|
|
|
2010-06-16 10:30:27 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2008-07-18 05:53:02 +00:00
|
|
|
switch (action) {
|
|
|
|
case IEEE80211_AMPDU_RX_START:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "start Rx\n");
|
2010-06-16 10:30:27 +00:00
|
|
|
ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
|
|
|
|
break;
|
2008-07-18 05:53:02 +00:00
|
|
|
case IEEE80211_AMPDU_RX_STOP:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "stop Rx\n");
|
2010-04-30 18:30:46 +00:00
|
|
|
ret = iwl_sta_rx_agg_stop(priv, sta, tid);
|
2009-03-18 04:51:43 +00:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
2010-06-16 10:30:27 +00:00
|
|
|
ret = 0;
|
|
|
|
break;
|
2008-07-18 05:53:02 +00:00
|
|
|
case IEEE80211_AMPDU_TX_START:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "start Tx\n");
|
2010-04-30 18:30:46 +00:00
|
|
|
ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
|
2010-03-04 21:38:59 +00:00
|
|
|
if (ret == 0) {
|
|
|
|
priv->_agn.agg_tids_count++;
|
|
|
|
IWL_DEBUG_HT(priv, "priv->_agn.agg_tids_count = %u\n",
|
|
|
|
priv->_agn.agg_tids_count);
|
|
|
|
}
|
2010-06-16 10:30:27 +00:00
|
|
|
break;
|
2008-07-18 05:53:02 +00:00
|
|
|
case IEEE80211_AMPDU_TX_STOP:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "stop Tx\n");
|
2010-04-30 18:30:46 +00:00
|
|
|
ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
|
2010-03-04 21:38:59 +00:00
|
|
|
if ((ret == 0) && (priv->_agn.agg_tids_count > 0)) {
|
|
|
|
priv->_agn.agg_tids_count--;
|
|
|
|
IWL_DEBUG_HT(priv, "priv->_agn.agg_tids_count = %u\n",
|
|
|
|
priv->_agn.agg_tids_count);
|
|
|
|
}
|
2009-03-18 04:51:43 +00:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
2010-06-16 10:30:27 +00:00
|
|
|
ret = 0;
|
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-09 17:57:02 +00:00
|
|
|
if (priv->cfg->use_rts_for_aggregation) {
|
|
|
|
struct iwl_station_priv *sta_priv =
|
|
|
|
(void *) sta->drv_priv;
|
|
|
|
/*
|
|
|
|
* 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 08:46:46 +00: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-09 17:57:02 +00:00
|
|
|
}
|
2010-06-16 10:30:27 +00:00
|
|
|
break;
|
2010-01-08 18:04:41 +00:00
|
|
|
case IEEE80211_AMPDU_TX_OPERATIONAL:
|
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-09 17:57:02 +00:00
|
|
|
if (priv->cfg->use_rts_for_aggregation) {
|
|
|
|
struct iwl_station_priv *sta_priv =
|
|
|
|
(void *) sta->drv_priv;
|
|
|
|
|
2010-06-18 18:33:15 +00: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-09 17:57:02 +00:00
|
|
|
|
|
|
|
sta_priv->lq_sta.lq.general_params.flags |=
|
|
|
|
LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
|
2010-08-23 08:46:46 +00:00
|
|
|
iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
|
|
|
|
&sta_priv->lq_sta.lq, CMD_ASYNC, false);
|
2010-06-18 18:33:15 +00:00
|
|
|
}
|
|
|
|
ret = 0;
|
2008-07-18 05:53:02 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-06-16 10:30:27 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
return ret;
|
2008-07-18 05:53:02 +00:00
|
|
|
}
|
2008-11-12 21:14:05 +00:00
|
|
|
|
2009-11-13 19:56:37 +00:00
|
|
|
static void iwl_mac_sta_notify(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
enum sta_notify_cmd cmd,
|
|
|
|
struct ieee80211_sta *sta)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
|
|
|
|
int sta_id;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case STA_NOTIFY_SLEEP:
|
|
|
|
WARN_ON(!sta_priv->client);
|
|
|
|
sta_priv->asleep = true;
|
|
|
|
if (atomic_read(&sta_priv->pending_frames) > 0)
|
|
|
|
ieee80211_sta_block_awake(hw, sta, true);
|
|
|
|
break;
|
|
|
|
case STA_NOTIFY_AWAKE:
|
|
|
|
WARN_ON(!sta_priv->client);
|
2010-01-19 18:22:19 +00:00
|
|
|
if (!sta_priv->asleep)
|
|
|
|
break;
|
2009-11-13 19:56:37 +00:00
|
|
|
sta_priv->asleep = false;
|
2010-04-30 18:30:45 +00:00
|
|
|
sta_id = iwl_sta_id(sta);
|
2009-11-13 19:56:37 +00:00
|
|
|
if (sta_id != IWL_INVALID_STATION)
|
|
|
|
iwl_sta_modify_ps_wake(priv, sta_id);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-23 00:24:47 +00:00
|
|
|
static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_sta *sta)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
|
2010-08-27 15:53:46 +00:00
|
|
|
struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
|
2010-04-29 11:43:04 +00:00
|
|
|
bool is_ap = vif->type == NL80211_IFTYPE_STATION;
|
2010-02-23 00:24:47 +00:00
|
|
|
int ret;
|
|
|
|
u8 sta_id;
|
|
|
|
|
|
|
|
IWL_DEBUG_INFO(priv, "received request to add station %pM\n",
|
|
|
|
sta->addr);
|
2010-05-28 16:28:39 +00: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 00:24:47 +00:00
|
|
|
|
|
|
|
atomic_set(&sta_priv->pending_frames, 0);
|
|
|
|
if (vif->type == NL80211_IFTYPE_AP)
|
|
|
|
sta_priv->client = true;
|
|
|
|
|
2010-08-27 15:53:46 +00:00
|
|
|
ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
|
2010-08-23 08:46:45 +00:00
|
|
|
is_ap, sta, &sta_id);
|
2010-02-23 00:24:47 +00: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-28 16:28:39 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2010-02-23 00:24:47 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-04-30 18:30:43 +00:00
|
|
|
sta_priv->common.sta_id = sta_id;
|
|
|
|
|
2010-02-23 00:24:47 +00:00
|
|
|
/* Initialize rate scaling */
|
2010-03-24 21:19:58 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Initializing rate scaling for station %pM\n",
|
2010-02-23 00:24:47 +00:00
|
|
|
sta->addr);
|
|
|
|
iwl_rs_rate_init(priv, sta, sta_id);
|
2010-05-28 16:28:39 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2010-02-23 00:24:47 +00:00
|
|
|
|
2010-04-30 18:30:43 +00:00
|
|
|
return 0;
|
2010-02-23 00:24:47 +00:00
|
|
|
}
|
|
|
|
|
2010-05-06 15:54:11 +00:00
|
|
|
static void iwl_mac_channel_switch(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_channel_switch *ch_switch)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
const struct iwl_channel_info *ch_info;
|
|
|
|
struct ieee80211_conf *conf = &hw->conf;
|
2010-07-28 20:40:39 +00:00
|
|
|
struct ieee80211_channel *channel = ch_switch->channel;
|
2010-05-06 15:54:11 +00:00
|
|
|
struct iwl_ht_config *ht_conf = &priv->current_ht_config;
|
2010-08-23 08:46:32 +00: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 15:54:11 +00:00
|
|
|
u16 ch;
|
|
|
|
unsigned long flags = 0;
|
|
|
|
|
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
|
|
|
|
|
|
|
if (iwl_is_rfkill(priv))
|
|
|
|
goto out_exit;
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
|
|
|
|
test_bit(STATUS_SCANNING, &priv->status))
|
|
|
|
goto out_exit;
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
if (!iwl_is_associated_ctx(ctx))
|
2010-05-06 15:54:11 +00:00
|
|
|
goto out_exit;
|
|
|
|
|
|
|
|
/* channel switch in progress */
|
|
|
|
if (priv->switch_rxon.switch_in_progress == true)
|
|
|
|
goto out_exit;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
if (priv->cfg->ops->lib->set_channel_switch) {
|
|
|
|
|
2010-07-28 20:40:39 +00:00
|
|
|
ch = channel->hw_value;
|
2010-08-23 08:46:32 +00:00
|
|
|
if (le16_to_cpu(ctx->active.channel) != ch) {
|
2010-05-06 15:54:11 +00:00
|
|
|
ch_info = iwl_get_channel_info(priv,
|
2010-07-28 20:40:39 +00:00
|
|
|
channel->band,
|
2010-05-06 15:54:11 +00:00
|
|
|
ch);
|
|
|
|
if (!is_channel_valid(ch_info)) {
|
|
|
|
IWL_DEBUG_MAC80211(priv, "invalid channel\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
priv->current_ht_config.smps = conf->smps_mode;
|
|
|
|
|
|
|
|
/* Configure HT40 channels */
|
2010-08-23 08:46:46 +00:00
|
|
|
ctx->ht.enabled = conf_is_ht(conf);
|
|
|
|
if (ctx->ht.enabled) {
|
2010-05-06 15:54:11 +00:00
|
|
|
if (conf_is_ht40_minus(conf)) {
|
2010-08-23 08:46:46 +00:00
|
|
|
ctx->ht.extension_chan_offset =
|
2010-05-06 15:54:11 +00:00
|
|
|
IEEE80211_HT_PARAM_CHA_SEC_BELOW;
|
2010-08-23 08:46:46 +00:00
|
|
|
ctx->ht.is_40mhz = true;
|
2010-05-06 15:54:11 +00:00
|
|
|
} else if (conf_is_ht40_plus(conf)) {
|
2010-08-23 08:46:46 +00:00
|
|
|
ctx->ht.extension_chan_offset =
|
2010-05-06 15:54:11 +00:00
|
|
|
IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
|
2010-08-23 08:46:46 +00:00
|
|
|
ctx->ht.is_40mhz = true;
|
2010-05-06 15:54:11 +00:00
|
|
|
} else {
|
2010-08-23 08:46:46 +00:00
|
|
|
ctx->ht.extension_chan_offset =
|
2010-05-06 15:54:11 +00:00
|
|
|
IEEE80211_HT_PARAM_CHA_SEC_NONE;
|
2010-08-23 08:46:46 +00:00
|
|
|
ctx->ht.is_40mhz = false;
|
2010-05-06 15:54:11 +00:00
|
|
|
}
|
|
|
|
} else
|
2010-08-23 08:46:46 +00:00
|
|
|
ctx->ht.is_40mhz = false;
|
2010-05-06 15:54:11 +00:00
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
if ((le16_to_cpu(ctx->staging.channel) != ch))
|
|
|
|
ctx->staging.flags = 0;
|
2010-05-06 15:54:11 +00:00
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
iwl_set_rxon_channel(priv, channel, ctx);
|
2010-05-06 15:54:11 +00:00
|
|
|
iwl_set_rxon_ht(priv, ht_conf);
|
2010-08-23 08:46:32 +00:00
|
|
|
iwl_set_flags_for_band(priv, ctx, channel->band,
|
2010-08-23 08:46:40 +00:00
|
|
|
ctx->vif);
|
2010-05-06 15:54:11 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
iwl_set_rate(priv);
|
|
|
|
/*
|
|
|
|
* at this point, staging_rxon has the
|
|
|
|
* configuration for channel switch
|
|
|
|
*/
|
|
|
|
if (priv->cfg->ops->lib->set_channel_switch(priv,
|
|
|
|
ch_switch))
|
|
|
|
priv->switch_rxon.switch_in_progress = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
out_exit:
|
|
|
|
if (!priv->switch_rxon.switch_in_progress)
|
2010-08-23 08:46:40 +00:00
|
|
|
ieee80211_chswitch_done(ctx->vif, false);
|
2010-05-06 15:54:11 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
|
|
|
}
|
|
|
|
|
2010-08-17 09:24:01 +00:00
|
|
|
static void iwlagn_configure_filter(struct ieee80211_hw *hw,
|
|
|
|
unsigned int changed_flags,
|
|
|
|
unsigned int *total_flags,
|
|
|
|
u64 multicast)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
__le32 filter_or = 0, filter_nand = 0;
|
2010-08-23 08:46:32 +00:00
|
|
|
struct iwl_rxon_context *ctx;
|
2010-08-17 09:24:01 +00: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);
|
|
|
|
CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK);
|
|
|
|
CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
|
|
|
|
|
|
|
|
#undef CHK
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
ctx->staging.filter_flags &= ~filter_nand;
|
|
|
|
ctx->staging.filter_flags |= filter_or;
|
|
|
|
iwlcore_commit_rxon(priv, ctx);
|
|
|
|
}
|
2010-08-17 09:24:01 +00: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;
|
|
|
|
}
|
|
|
|
|
2010-06-24 20:22:36 +00:00
|
|
|
static void iwl_mac_flush(struct ieee80211_hw *hw, bool drop)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
|
|
|
|
|
|
|
/* do not support "flush" */
|
|
|
|
if (!priv->cfg->ops->lib->txfifo_flush)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
|
|
|
|
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");
|
|
|
|
if (priv->cfg->ops->lib->txfifo_flush(priv, IWL_DROP_ALL)) {
|
|
|
|
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");
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* driver setup and teardown
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
static void iwl_setup_deferred_work(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-02-13 19:51:18 +00:00
|
|
|
priv->workqueue = create_singlethread_workqueue(DRV_NAME);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
init_waitqueue_head(&priv->wait_command_queue);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
INIT_WORK(&priv->restart, iwl_bg_restart);
|
|
|
|
INIT_WORK(&priv->rx_replenish, iwl_bg_rx_replenish);
|
|
|
|
INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
|
2008-06-12 01:46:52 +00:00
|
|
|
INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
|
2010-06-24 20:18:35 +00:00
|
|
|
INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);
|
2010-08-23 14:57:04 +00:00
|
|
|
INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);
|
2010-08-23 14:57:10 +00:00
|
|
|
INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);
|
2008-05-29 08:34:54 +00:00
|
|
|
INIT_DELAYED_WORK(&priv->init_alive_start, iwl_bg_init_alive_start);
|
|
|
|
INIT_DELAYED_WORK(&priv->alive_start, iwl_bg_alive_start);
|
2008-06-12 01:47:10 +00:00
|
|
|
|
|
|
|
iwl_setup_scan_deferred_work(priv);
|
2008-01-28 00:41:47 +00:00
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
if (priv->cfg->ops->lib->setup_deferred_work)
|
|
|
|
priv->cfg->ops->lib->setup_deferred_work(priv);
|
|
|
|
|
|
|
|
init_timer(&priv->statistics_periodic);
|
|
|
|
priv->statistics_periodic.data = (unsigned long)priv;
|
2008-10-29 21:05:46 +00:00
|
|
|
priv->statistics_periodic.function = iwl_bg_statistics_periodic;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-12-10 22:37:26 +00:00
|
|
|
init_timer(&priv->ucode_trace);
|
|
|
|
priv->ucode_trace.data = (unsigned long)priv;
|
|
|
|
priv->ucode_trace.function = iwl_bg_ucode_trace;
|
|
|
|
|
2010-03-02 01:23:50 +00:00
|
|
|
if (priv->cfg->ops->lib->recover_from_tx_stall) {
|
|
|
|
init_timer(&priv->monitor_recover);
|
|
|
|
priv->monitor_recover.data = (unsigned long)priv;
|
|
|
|
priv->monitor_recover.function =
|
|
|
|
priv->cfg->ops->lib->recover_from_tx_stall;
|
|
|
|
}
|
|
|
|
|
2009-05-22 18:01:50 +00:00
|
|
|
if (!priv->cfg->use_isr_legacy)
|
|
|
|
tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
|
|
|
|
iwl_irq_tasklet, (unsigned long)priv);
|
|
|
|
else
|
|
|
|
tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
|
|
|
|
iwl_irq_tasklet_legacy, (unsigned long)priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
static void iwl_cancel_deferred_work(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-06-12 01:46:53 +00:00
|
|
|
if (priv->cfg->ops->lib->cancel_deferred_work)
|
|
|
|
priv->cfg->ops->lib->cancel_deferred_work(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 01:43:16 +00:00
|
|
|
cancel_delayed_work_sync(&priv->init_alive_start);
|
2007-09-26 00:54:57 +00:00
|
|
|
cancel_delayed_work(&priv->scan_check);
|
2010-04-07 07:21:36 +00:00
|
|
|
cancel_work_sync(&priv->start_internal_scan);
|
2007-09-26 00:54:57 +00:00
|
|
|
cancel_delayed_work(&priv->alive_start);
|
2010-06-03 17:14:01 +00:00
|
|
|
cancel_work_sync(&priv->run_time_calib_work);
|
2007-09-26 00:54:57 +00:00
|
|
|
cancel_work_sync(&priv->beacon_update);
|
2010-08-23 14:57:04 +00:00
|
|
|
cancel_work_sync(&priv->bt_full_concurrency);
|
2010-08-23 14:57:10 +00:00
|
|
|
cancel_work_sync(&priv->bt_runtime_config);
|
2008-06-12 01:46:53 +00:00
|
|
|
del_timer_sync(&priv->statistics_periodic);
|
2009-12-10 22:37:26 +00:00
|
|
|
del_timer_sync(&priv->ucode_trace);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-10-30 21:36:11 +00: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;
|
|
|
|
|
|
|
|
priv->ibss_beacon = NULL;
|
|
|
|
|
|
|
|
spin_lock_init(&priv->sta_lock);
|
|
|
|
spin_lock_init(&priv->hcmd_lock);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&priv->free_frames);
|
|
|
|
|
|
|
|
mutex_init(&priv->mutex);
|
2010-02-19 06:03:04 +00:00
|
|
|
mutex_init(&priv->sync_cmd_mutex);
|
2009-10-30 21:36:11 +00:00
|
|
|
|
|
|
|
priv->ieee_channels = NULL;
|
|
|
|
priv->ieee_rates = NULL;
|
|
|
|
priv->band = IEEE80211_BAND_2GHZ;
|
|
|
|
|
|
|
|
priv->iw_mode = NL80211_IFTYPE_STATION;
|
2009-12-10 22:37:27 +00:00
|
|
|
priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
|
2010-01-22 22:22:42 +00:00
|
|
|
priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
|
2010-03-04 21:38:59 +00:00
|
|
|
priv->_agn.agg_tids_count = 0;
|
2009-10-30 21:36:11 +00:00
|
|
|
|
2010-02-19 06:03:06 +00: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-30 21:36:11 +00:00
|
|
|
|
|
|
|
/* Choose which receivers/antennas to use */
|
|
|
|
if (priv->cfg->ops->hcmd->set_rxon_chain)
|
2010-08-23 08:46:32 +00:00
|
|
|
priv->cfg->ops->hcmd->set_rxon_chain(priv,
|
|
|
|
&priv->contexts[IWL_RXON_CTX_BSS]);
|
2009-10-30 21:36:11 +00:00
|
|
|
|
|
|
|
iwl_init_scan_params(priv);
|
|
|
|
|
2010-08-23 14:57:11 +00:00
|
|
|
/* init bt coex */
|
|
|
|
if (priv->cfg->advanced_bt_coexist) {
|
2010-08-23 14:57:14 +00: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 14:57:11 +00:00
|
|
|
priv->bt_on_thresh = BT_ON_THRESHOLD_DEF;
|
|
|
|
priv->bt_duration = BT_DURATION_LIMIT_DEF;
|
|
|
|
priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF;
|
|
|
|
priv->dynamic_agg_thresh = BT_AGG_THRESHOLD_DEF;
|
|
|
|
}
|
|
|
|
|
2009-10-30 21:36:11 +00:00
|
|
|
/* Set the tx_power_user_lmt to the lowest power level
|
|
|
|
* this value will get overwritten by channel max power avg
|
|
|
|
* from eeprom */
|
2010-03-23 18:37:59 +00:00
|
|
|
priv->tx_power_user_lmt = IWLAGN_TX_POWER_TARGET_POWER_MIN;
|
2009-10-30 21:36:11 +00:00
|
|
|
|
|
|
|
ret = iwl_init_channel_map(priv);
|
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = iwlcore_init_geos(priv);
|
|
|
|
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);
|
|
|
|
iwlcore_free_geos(priv);
|
|
|
|
iwl_free_channel_map(priv);
|
2010-04-06 11:12:41 +00:00
|
|
|
kfree(priv->scan_cmd);
|
2009-10-30 21:36:11 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static struct ieee80211_ops iwl_hw_ops = {
|
|
|
|
.tx = iwl_mac_tx,
|
|
|
|
.start = iwl_mac_start,
|
|
|
|
.stop = iwl_mac_stop,
|
|
|
|
.add_interface = iwl_mac_add_interface,
|
|
|
|
.remove_interface = iwl_mac_remove_interface,
|
|
|
|
.config = iwl_mac_config,
|
2010-08-17 09:24:01 +00:00
|
|
|
.configure_filter = iwlagn_configure_filter,
|
2008-10-29 21:05:46 +00:00
|
|
|
.set_key = iwl_mac_set_key,
|
|
|
|
.update_tkip_key = iwl_mac_update_tkip_key,
|
|
|
|
.conf_tx = iwl_mac_conf_tx,
|
|
|
|
.reset_tsf = iwl_mac_reset_tsf,
|
|
|
|
.bss_info_changed = iwl_bss_info_changed,
|
|
|
|
.ampdu_action = iwl_mac_ampdu_action,
|
2009-11-13 19:56:37 +00:00
|
|
|
.hw_scan = iwl_mac_hw_scan,
|
|
|
|
.sta_notify = iwl_mac_sta_notify,
|
2010-02-23 00:24:47 +00:00
|
|
|
.sta_add = iwlagn_mac_sta_add,
|
|
|
|
.sta_remove = iwl_mac_sta_remove,
|
2010-05-06 15:54:11 +00:00
|
|
|
.channel_switch = iwl_mac_channel_switch,
|
2010-06-24 20:22:36 +00:00
|
|
|
.flush = iwl_mac_flush,
|
2010-07-31 15:34:10 +00:00
|
|
|
.tx_last_beacon = iwl_mac_tx_last_beacon,
|
2007-09-26 00:54:57 +00:00
|
|
|
};
|
|
|
|
|
2010-07-31 15:34:05 +00:00
|
|
|
static void iwl_hw_detect(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
priv->hw_rev = _iwl_read32(priv, CSR_HW_REV);
|
|
|
|
priv->hw_wa_rev = _iwl_read32(priv, CSR_HW_REV_WA_REG);
|
|
|
|
pci_read_config_byte(priv->pci_dev, PCI_REVISION_ID, &priv->rev_id);
|
2010-07-31 15:34:06 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "HW Revision ID = 0x%X\n", priv->rev_id);
|
2010-07-31 15:34:05 +00:00
|
|
|
}
|
|
|
|
|
2010-07-31 15:34:08 +00:00
|
|
|
static int iwl_set_hw_params(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
priv->hw_params.max_rxq_size = RX_QUEUE_SIZE;
|
|
|
|
priv->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
|
|
|
|
if (priv->cfg->mod_params->amsdu_size_8K)
|
|
|
|
priv->hw_params.rx_page_order = get_order(IWL_RX_BUF_SIZE_8K);
|
|
|
|
else
|
|
|
|
priv->hw_params.rx_page_order = get_order(IWL_RX_BUF_SIZE_4K);
|
|
|
|
|
|
|
|
priv->hw_params.max_beacon_itrvl = IWL_MAX_UCODE_BEACON_INTERVAL;
|
|
|
|
|
|
|
|
if (priv->cfg->mod_params->disable_11n)
|
|
|
|
priv->cfg->sku &= ~IWL_SKU_N;
|
|
|
|
|
|
|
|
/* Device-specific setup */
|
|
|
|
return priv->cfg->ops->lib->set_hw_params(priv);
|
|
|
|
}
|
|
|
|
|
2010-08-23 08:46:51 +00:00
|
|
|
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,
|
|
|
|
};
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-08-23 08:46:32 +00:00
|
|
|
int err = 0, i;
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_hw *hw;
|
2008-03-05 02:09:30 +00:00
|
|
|
struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
|
2008-03-28 23:21:08 +00:00
|
|
|
unsigned long flags;
|
2010-07-15 12:58:30 +00:00
|
|
|
u16 pci_cmd, num_mac;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-14 17:38:46 +00:00
|
|
|
/************************
|
|
|
|
* 1. Allocating HW data
|
|
|
|
************************/
|
|
|
|
|
2007-11-29 03:09:55 +00:00
|
|
|
/* Disabling hardware scan means that mac80211 will perform scans
|
|
|
|
* "the hard way", rather than using device's scan. */
|
2008-03-18 21:57:50 +00:00
|
|
|
if (cfg->mod_params->disable_hw_scan) {
|
2009-07-17 16:30:24 +00:00
|
|
|
if (iwl_debug_level & IWL_DL_INFO)
|
2008-05-05 02:22:40 +00:00
|
|
|
dev_printk(KERN_DEBUG, &(pdev->dev),
|
|
|
|
"Disabling hw_scan\n");
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_hw_ops.hw_scan = NULL;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
hw = iwl_alloc_all(cfg, &iwl_hw_ops);
|
2008-03-14 17:38:48 +00:00
|
|
|
if (!hw) {
|
2007-09-26 00:54:57 +00:00
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2008-03-14 17:38:48 +00:00
|
|
|
priv = hw->priv;
|
|
|
|
/* At this point both hw and priv are allocated. */
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
/*
|
|
|
|
* The default context is always valid,
|
|
|
|
* more may be discovered when firmware
|
|
|
|
* is loaded.
|
|
|
|
*/
|
|
|
|
priv->valid_contexts = BIT(IWL_RXON_CTX_BSS);
|
|
|
|
|
|
|
|
for (i = 0; i < NUM_IWL_RXON_CTX; i++)
|
|
|
|
priv->contexts[i].ctxid = i;
|
|
|
|
|
2010-09-03 13:32:21 +00:00
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].always_active = true;
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].is_active = true;
|
2010-08-23 08:46:37 +00:00
|
|
|
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;
|
2010-08-23 08:46:38 +00:00
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].qos_cmd = REPLY_QOS_PARAM;
|
2010-08-23 08:46:42 +00:00
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].ap_sta_id = IWL_AP_ID;
|
2010-08-23 08:46:43 +00:00
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].wep_key_cmd = REPLY_WEPKEY;
|
2010-08-23 08:46:51 +00:00
|
|
|
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;
|
2010-08-23 08:46:58 +00:00
|
|
|
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].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;
|
2010-08-23 08:46:49 +00:00
|
|
|
|
|
|
|
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;
|
2010-08-23 08:46:51 +00:00
|
|
|
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;
|
2010-08-23 08:46:58 +00:00
|
|
|
priv->contexts[IWL_RXON_CTX_PAN].interface_modes =
|
|
|
|
BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP);
|
|
|
|
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;
|
2010-08-23 08:46:49 +00:00
|
|
|
|
|
|
|
BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
|
2010-08-23 08:46:37 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
SET_IEEE80211_DEV(hw, &pdev->dev);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
|
2008-03-05 02:09:30 +00:00
|
|
|
priv->cfg = cfg;
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->pci_dev = pdev;
|
2009-05-22 18:01:52 +00:00
|
|
|
priv->inta_mask = CSR_INI_SET_MASK;
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2010-08-23 14:57:04 +00:00
|
|
|
/* is antenna coupling more than 35dB ? */
|
|
|
|
priv->bt_ant_couple_ok =
|
|
|
|
(iwlagn_ant_coupling > IWL_BT_ANTENNA_COUPLING_THRESHOLD) ?
|
|
|
|
true : false;
|
|
|
|
|
2010-08-23 14:57:12 +00:00
|
|
|
/* enable/disable bt channel announcement */
|
|
|
|
priv->bt_ch_announce = iwlagn_bt_ch_announce;
|
|
|
|
|
2009-08-07 22:41:39 +00:00
|
|
|
if (iwl_alloc_traffic_mem(priv))
|
|
|
|
IWL_ERR(priv, "Not enough memory to generate traffic log\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-14 17:38:46 +00:00
|
|
|
/**************************
|
|
|
|
* 2. Initializing PCI bus
|
|
|
|
**************************/
|
2010-08-05 18:39:31 +00:00
|
|
|
pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
|
|
|
|
PCIE_LINK_STATE_CLKPM);
|
|
|
|
|
2008-03-14 17:38:46 +00:00
|
|
|
if (pci_enable_device(pdev)) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto out_ieee80211_free_hw;
|
|
|
|
}
|
|
|
|
|
|
|
|
pci_set_master(pdev);
|
|
|
|
|
2008-09-26 07:09:34 +00:00
|
|
|
err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
|
2008-03-14 17:38:46 +00:00
|
|
|
if (!err)
|
2008-09-26 07:09:34 +00:00
|
|
|
err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
|
2008-04-21 22:41:59 +00:00
|
|
|
if (err) {
|
2008-09-26 07:09:34 +00:00
|
|
|
err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
|
2008-04-21 22:41:59 +00:00
|
|
|
if (!err)
|
2008-09-26 07:09:34 +00:00
|
|
|
err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
|
2008-04-21 22:41:59 +00:00
|
|
|
/* both attempts failed: */
|
2008-03-14 17:38:46 +00:00
|
|
|
if (err) {
|
2008-12-19 02:37:31 +00:00
|
|
|
IWL_WARN(priv, "No suitable DMA available.\n");
|
2008-03-14 17:38:46 +00:00
|
|
|
goto out_pci_disable_device;
|
2008-04-21 22:41:59 +00:00
|
|
|
}
|
2008-03-14 17:38:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
err = pci_request_regions(pdev, DRV_NAME);
|
|
|
|
if (err)
|
|
|
|
goto out_pci_disable_device;
|
|
|
|
|
|
|
|
pci_set_drvdata(pdev, priv);
|
|
|
|
|
|
|
|
|
|
|
|
/***********************
|
|
|
|
* 3. Read REV register
|
|
|
|
***********************/
|
|
|
|
priv->hw_base = pci_iomap(pdev, 0, 0);
|
|
|
|
if (!priv->hw_base) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto out_pci_release_regions;
|
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
|
2008-03-14 17:38:46 +00:00
|
|
|
(unsigned long long) pci_resource_len(pdev, 0));
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2009-12-14 22:12:11 +00:00
|
|
|
/* these spin locks will be used in apm_ops.init and EEPROM access
|
2009-05-22 18:01:47 +00:00
|
|
|
* we should init now
|
|
|
|
*/
|
|
|
|
spin_lock_init(&priv->reg_lock);
|
2009-12-14 22:12:11 +00:00
|
|
|
spin_lock_init(&priv->lock);
|
2010-02-03 17:38:59 +00: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);
|
|
|
|
|
2008-04-24 00:14:54 +00:00
|
|
|
iwl_hw_detect(priv);
|
2010-03-06 01:05:20 +00:00
|
|
|
IWL_INFO(priv, "Detected %s, REV=0x%X\n",
|
2008-04-24 00:14:54 +00:00
|
|
|
priv->cfg->name, priv->hw_rev);
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2008-09-03 03:26:49 +00:00
|
|
|
/* We disable the RETRY_TIMEOUT register (0x41) to keep
|
|
|
|
* PCI Tx retries from interfering with C3 CPU state */
|
|
|
|
pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
|
|
|
|
|
2009-05-22 18:01:54 +00:00
|
|
|
iwl_prepare_card_hw(priv);
|
|
|
|
if (!priv->hw_ready) {
|
|
|
|
IWL_WARN(priv, "Failed, HW not ready\n");
|
|
|
|
goto out_iounmap;
|
|
|
|
}
|
|
|
|
|
2008-04-24 00:14:53 +00:00
|
|
|
/*****************
|
|
|
|
* 4. Read EEPROM
|
|
|
|
*****************/
|
2008-03-14 17:38:46 +00:00
|
|
|
/* Read the EEPROM */
|
|
|
|
err = iwl_eeprom_init(priv);
|
|
|
|
if (err) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to init EEPROM\n");
|
2008-03-14 17:38:46 +00:00
|
|
|
goto out_iounmap;
|
|
|
|
}
|
2008-04-24 00:14:55 +00:00
|
|
|
err = iwl_eeprom_check_version(priv);
|
|
|
|
if (err)
|
2009-02-28 00:21:22 +00:00
|
|
|
goto out_free_eeprom;
|
2008-04-24 00:14:55 +00:00
|
|
|
|
2008-05-15 05:53:53 +00:00
|
|
|
/* extract MAC Address */
|
2010-07-15 12:58:30 +00: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-14 17:38:46 +00:00
|
|
|
|
|
|
|
/************************
|
|
|
|
* 5. Setup HW constants
|
|
|
|
************************/
|
2008-06-30 09:23:20 +00:00
|
|
|
if (iwl_set_hw_params(priv)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "failed to set hw parameters\n");
|
2008-04-21 22:41:52 +00:00
|
|
|
goto out_free_eeprom;
|
2008-03-14 17:38:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*******************
|
2008-05-15 05:54:17 +00:00
|
|
|
* 6. Setup priv
|
2008-03-14 17:38:46 +00:00
|
|
|
*******************/
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-15 05:54:17 +00:00
|
|
|
err = iwl_init_drv(priv);
|
2008-03-14 17:38:49 +00:00
|
|
|
if (err)
|
2008-04-24 00:14:56 +00:00
|
|
|
goto out_free_eeprom;
|
2008-03-14 17:38:49 +00:00
|
|
|
/* At this point both hw and priv are initialized. */
|
2008-03-14 17:38:46 +00:00
|
|
|
|
|
|
|
/********************
|
2009-04-20 21:37:03 +00:00
|
|
|
* 7. Setup services
|
2008-03-14 17:38:46 +00:00
|
|
|
********************/
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_disable_interrupts(priv);
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2009-01-19 12:10:07 +00:00
|
|
|
pci_enable_msi(priv->pci_dev);
|
|
|
|
|
2009-05-22 18:01:50 +00:00
|
|
|
iwl_alloc_isr_ict(priv);
|
|
|
|
err = request_irq(priv->pci_dev->irq, priv->cfg->ops->lib->isr,
|
|
|
|
IRQF_SHARED, DRV_NAME, priv);
|
2009-01-19 12:10:07 +00:00
|
|
|
if (err) {
|
|
|
|
IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
|
|
|
|
goto out_disable_msi;
|
|
|
|
}
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
iwl_setup_deferred_work(priv);
|
2008-06-30 09:23:11 +00:00
|
|
|
iwl_setup_rx_handlers(priv);
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2010-01-22 22:22:53 +00:00
|
|
|
/*********************************************
|
|
|
|
* 8. Enable interrupts and read RFKILL state
|
|
|
|
*********************************************/
|
2008-05-15 05:54:17 +00:00
|
|
|
|
2009-01-19 12:10:07 +00:00
|
|
|
/* enable interrupts if needed: hw bug w/a */
|
|
|
|
pci_read_config_word(priv->pci_dev, PCI_COMMAND, &pci_cmd);
|
|
|
|
if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
|
|
|
|
pci_cmd &= ~PCI_COMMAND_INTX_DISABLE;
|
|
|
|
pci_write_config_word(priv->pci_dev, PCI_COMMAND, pci_cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
iwl_enable_interrupts(priv);
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
else
|
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
2008-05-15 05:54:17 +00:00
|
|
|
|
2009-06-04 16:26:06 +00:00
|
|
|
wiphy_rfkill_set_hw_state(priv->hw->wiphy,
|
|
|
|
test_bit(STATUS_RF_KILL_HW, &priv->status));
|
2009-01-19 12:10:07 +00:00
|
|
|
|
2008-06-12 01:47:19 +00: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-24 18:13:02 +00:00
|
|
|
iwl_tt_initialize(priv);
|
2010-01-22 22:22:53 +00:00
|
|
|
|
2010-05-10 22:08:11 +00:00
|
|
|
init_completion(&priv->_agn.firmware_loading_complete);
|
2010-04-29 14:41:53 +00:00
|
|
|
|
2010-01-29 19:54:56 +00:00
|
|
|
err = iwl_request_firmware(priv, true);
|
2010-01-22 22:22:53 +00:00
|
|
|
if (err)
|
2010-05-23 07:14:08 +00:00
|
|
|
goto out_destroy_workqueue;
|
2010-01-22 22:22:53 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-05-23 07:14:08 +00:00
|
|
|
out_destroy_workqueue:
|
2009-02-28 00:21:22 +00:00
|
|
|
destroy_workqueue(priv->workqueue);
|
|
|
|
priv->workqueue = NULL;
|
2009-02-12 17:51:03 +00:00
|
|
|
free_irq(priv->pci_dev->irq, priv);
|
2009-05-22 18:01:50 +00:00
|
|
|
iwl_free_isr_ict(priv);
|
2009-01-19 12:10:07 +00:00
|
|
|
out_disable_msi:
|
|
|
|
pci_disable_msi(priv->pci_dev);
|
2008-05-15 05:54:17 +00:00
|
|
|
iwl_uninit_drv(priv);
|
2008-04-21 22:41:52 +00:00
|
|
|
out_free_eeprom:
|
|
|
|
iwl_eeprom_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
out_iounmap:
|
|
|
|
pci_iounmap(pdev, priv->hw_base);
|
|
|
|
out_pci_release_regions:
|
2008-03-14 17:38:46 +00:00
|
|
|
pci_set_drvdata(pdev, NULL);
|
2009-03-03 19:37:04 +00:00
|
|
|
pci_release_regions(pdev);
|
2007-09-26 00:54:57 +00:00
|
|
|
out_pci_disable_device:
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
out_ieee80211_free_hw:
|
2009-08-07 22:41:39 +00:00
|
|
|
iwl_free_traffic_mem(priv);
|
2009-10-09 20:20:17 +00:00
|
|
|
ieee80211_free_hw(priv->hw);
|
2007-09-26 00:54:57 +00:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void __devexit iwl_pci_remove(struct pci_dev *pdev)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = pci_get_drvdata(pdev);
|
2008-03-28 23:21:08 +00:00
|
|
|
unsigned long flags;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (!priv)
|
|
|
|
return;
|
|
|
|
|
2010-05-10 22:08:11 +00:00
|
|
|
wait_for_completion(&priv->_agn.firmware_loading_complete);
|
2010-04-29 14:41:53 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-29 08:35:26 +00:00
|
|
|
iwl_dbgfs_unregister(priv);
|
2008-10-29 21:05:46 +00:00
|
|
|
sysfs_remove_group(&pdev->dev.kobj, &iwl_attribute_group);
|
2008-05-29 08:35:26 +00:00
|
|
|
|
2008-10-29 21:05:46 +00: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 03:18:50 +00:00
|
|
|
* we need to set STATUS_EXIT_PENDING bit.
|
|
|
|
*/
|
|
|
|
set_bit(STATUS_EXIT_PENDING, &priv->status);
|
2008-03-28 23:21:10 +00:00
|
|
|
if (priv->mac80211_registered) {
|
|
|
|
ieee80211_unregister_hw(priv->hw);
|
|
|
|
priv->mac80211_registered = 0;
|
2008-09-03 03:18:50 +00:00
|
|
|
} else {
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_down(priv);
|
2008-03-28 23:21:10 +00:00
|
|
|
}
|
|
|
|
|
2009-10-23 20:42:35 +00:00
|
|
|
/*
|
|
|
|
* Make sure device is reset to low power before unloading driver.
|
|
|
|
* This may be redundant with iwl_down(), but there are paths to
|
|
|
|
* run iwl_down() without calling apm_ops.stop(), and there are
|
|
|
|
* paths to avoid running iwl_down() at all before leaving driver.
|
|
|
|
* This (inexpensive) call *makes sure* device is reset.
|
|
|
|
*/
|
|
|
|
priv->cfg->ops->lib->apm_ops.stop(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-24 18:13:02 +00:00
|
|
|
iwl_tt_exit(priv);
|
|
|
|
|
2008-03-28 23:21:08 +00:00
|
|
|
/* make sure we flush any pending irq or
|
|
|
|
* tasklet for the driver
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_disable_interrupts(priv);
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
iwl_synchronize_irq(priv);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_dealloc_ucode_pci(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->rxq.bd)
|
2010-03-17 20:34:35 +00:00
|
|
|
iwlagn_rx_queue_free(priv, &priv->rxq);
|
2010-03-17 20:34:34 +00:00
|
|
|
iwlagn_hw_txq_ctx_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-21 22:41:52 +00:00
|
|
|
iwl_eeprom_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
2007-10-25 09:15:45 +00:00
|
|
|
/*netif_stop_queue(dev); */
|
|
|
|
flush_workqueue(priv->workqueue);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
/* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
|
2007-09-26 00:54:57 +00:00
|
|
|
* priv->workqueue... so we can't take down the workqueue
|
|
|
|
* until now... */
|
|
|
|
destroy_workqueue(priv->workqueue);
|
|
|
|
priv->workqueue = NULL;
|
2009-08-07 22:41:39 +00:00
|
|
|
iwl_free_traffic_mem(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-19 12:10:07 +00:00
|
|
|
free_irq(priv->pci_dev->irq, priv);
|
|
|
|
pci_disable_msi(priv->pci_dev);
|
2007-09-26 00:54:57 +00:00
|
|
|
pci_iounmap(pdev, priv->hw_base);
|
|
|
|
pci_release_regions(pdev);
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
pci_set_drvdata(pdev, NULL);
|
|
|
|
|
2008-05-15 05:54:17 +00:00
|
|
|
iwl_uninit_drv(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-05-22 18:01:50 +00:00
|
|
|
iwl_free_isr_ict(priv);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
|
|
|
|
ieee80211_free_hw(priv->hw);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* driver and module entry point
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-04-15 23:01:41 +00:00
|
|
|
/* Hardware specific file defines the PCI IDs table for that hardware module */
|
2010-01-07 11:58:11 +00:00
|
|
|
static DEFINE_PCI_DEVICE_TABLE(iwl_hw_card_ids) = {
|
2008-07-21 15:54:42 +00:00
|
|
|
#ifdef CONFIG_IWL4965
|
2008-04-15 23:01:41 +00:00
|
|
|
{IWL_PCI_DEVICE(0x4229, PCI_ANY_ID, iwl4965_agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4230, PCI_ANY_ID, iwl4965_agn_cfg)},
|
2008-07-21 15:54:42 +00:00
|
|
|
#endif /* CONFIG_IWL4965 */
|
2008-04-24 18:55:23 +00:00
|
|
|
#ifdef CONFIG_IWL5000
|
2009-11-20 20:05:03 +00:00
|
|
|
/* 5100 Series WiFi */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1201, iwl5100_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1301, iwl5100_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1204, iwl5100_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1304, iwl5100_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1205, iwl5100_bgn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1305, iwl5100_bgn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1206, iwl5100_abg_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1306, iwl5100_abg_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1221, iwl5100_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1321, iwl5100_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1224, iwl5100_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1324, iwl5100_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1225, iwl5100_bgn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1325, iwl5100_bgn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1226, iwl5100_abg_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1326, iwl5100_abg_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1211, iwl5100_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1311, iwl5100_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1214, iwl5100_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1314, iwl5100_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1215, iwl5100_bgn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1315, iwl5100_bgn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1216, iwl5100_abg_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1316, iwl5100_abg_cfg)}, /* Half Mini Card */
|
|
|
|
|
|
|
|
/* 5300 Series WiFi */
|
|
|
|
{IWL_PCI_DEVICE(0x4235, 0x1021, iwl5300_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4235, 0x1121, iwl5300_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4235, 0x1024, iwl5300_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4235, 0x1124, iwl5300_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4235, 0x1001, iwl5300_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4235, 0x1101, iwl5300_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4235, 0x1004, iwl5300_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4235, 0x1104, iwl5300_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4236, 0x1011, iwl5300_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4236, 0x1111, iwl5300_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4236, 0x1014, iwl5300_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x4236, 0x1114, iwl5300_agn_cfg)}, /* Half Mini Card */
|
|
|
|
|
|
|
|
/* 5350 Series WiFi/WiMax */
|
|
|
|
{IWL_PCI_DEVICE(0x423A, 0x1001, iwl5350_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423A, 0x1021, iwl5350_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423B, 0x1011, iwl5350_agn_cfg)}, /* Mini Card */
|
|
|
|
|
|
|
|
/* 5150 Series Wifi/WiMax */
|
|
|
|
{IWL_PCI_DEVICE(0x423C, 0x1201, iwl5150_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423C, 0x1301, iwl5150_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423C, 0x1206, iwl5150_abg_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423C, 0x1306, iwl5150_abg_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423C, 0x1221, iwl5150_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423C, 0x1321, iwl5150_agn_cfg)}, /* Half Mini Card */
|
|
|
|
|
|
|
|
{IWL_PCI_DEVICE(0x423D, 0x1211, iwl5150_agn_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423D, 0x1311, iwl5150_agn_cfg)}, /* Half Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423D, 0x1216, iwl5150_abg_cfg)}, /* Mini Card */
|
|
|
|
{IWL_PCI_DEVICE(0x423D, 0x1316, iwl5150_abg_cfg)}, /* Half Mini Card */
|
2009-09-17 17:43:53 +00:00
|
|
|
|
|
|
|
/* 6x00 Series */
|
|
|
|
{IWL_PCI_DEVICE(0x422B, 0x1101, iwl6000_3agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x422B, 0x1121, iwl6000_3agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x422C, 0x1301, iwl6000i_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x422C, 0x1306, iwl6000i_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x422C, 0x1307, iwl6000i_2bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x422C, 0x1321, iwl6000i_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x422C, 0x1326, iwl6000i_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4238, 0x1111, iwl6000_3agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4239, 0x1311, iwl6000i_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4239, 0x1316, iwl6000i_2abg_cfg)},
|
2010-04-08 01:06:36 +00:00
|
|
|
|
2010-04-21 18:46:33 +00:00
|
|
|
/* 6x00 Series Gen2a */
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1201, iwl6000g2a_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0085, 0x1211, iwl6000g2a_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1221, iwl6000g2a_2agn_cfg)},
|
2010-05-06 17:15:21 +00:00
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1206, iwl6000g2a_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0085, 0x1216, iwl6000g2a_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1226, iwl6000g2a_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1207, iwl6000g2a_2bg_cfg)},
|
2010-05-11 22:21:54 +00:00
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1301, iwl6000g2a_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1306, iwl6000g2a_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1307, iwl6000g2a_2bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1321, iwl6000g2a_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1326, iwl6000g2a_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0085, 0x1311, iwl6000g2a_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0085, 0x1316, iwl6000g2a_2abg_cfg)},
|
2010-05-06 17:15:21 +00:00
|
|
|
|
|
|
|
/* 6x00 Series Gen2b */
|
|
|
|
{IWL_PCI_DEVICE(0x008F, 0x5105, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0090, 0x5115, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008F, 0x5125, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008F, 0x5107, iwl6000g2b_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008F, 0x5201, iwl6000g2b_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0090, 0x5211, iwl6000g2b_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008F, 0x5221, iwl6000g2b_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008F, 0x5206, iwl6000g2b_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0090, 0x5216, iwl6000g2b_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008F, 0x5226, iwl6000g2b_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008F, 0x5207, iwl6000g2b_2bg_cfg)},
|
2010-05-11 22:21:54 +00:00
|
|
|
{IWL_PCI_DEVICE(0x008A, 0x5301, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008A, 0x5305, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008A, 0x5307, iwl6000g2b_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008A, 0x5321, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008A, 0x5325, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008B, 0x5311, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x008B, 0x5315, iwl6000g2b_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0090, 0x5211, iwl6000g2b_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0090, 0x5215, iwl6000g2b_2bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0090, 0x5216, iwl6000g2b_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0091, 0x5201, iwl6000g2b_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0091, 0x5205, iwl6000g2b_2bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0091, 0x5206, iwl6000g2b_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0091, 0x5207, iwl6000g2b_2bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0091, 0x5221, iwl6000g2b_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0091, 0x5225, iwl6000g2b_2bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0091, 0x5226, iwl6000g2b_2abg_cfg)},
|
2009-09-17 17:43:53 +00:00
|
|
|
|
|
|
|
/* 6x50 WiFi/WiMax Series */
|
|
|
|
{IWL_PCI_DEVICE(0x0087, 0x1301, iwl6050_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0087, 0x1306, iwl6050_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0087, 0x1321, iwl6050_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0087, 0x1326, iwl6050_2abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0089, 0x1311, iwl6050_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0089, 0x1316, iwl6050_2abg_cfg)},
|
|
|
|
|
2010-06-30 00:27:27 +00:00
|
|
|
/* 6x50 WiFi/WiMax Series Gen2 */
|
|
|
|
{IWL_PCI_DEVICE(0x0885, 0x1305, iwl6050g2_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0885, 0x1306, iwl6050g2_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0885, 0x1325, iwl6050g2_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0885, 0x1326, iwl6050g2_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0886, 0x1315, iwl6050g2_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0886, 0x1316, iwl6050g2_bgn_cfg)},
|
|
|
|
|
2009-03-06 21:52:55 +00:00
|
|
|
/* 1000 Series WiFi */
|
2009-09-17 17:43:52 +00:00
|
|
|
{IWL_PCI_DEVICE(0x0083, 0x1205, iwl1000_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0083, 0x1305, iwl1000_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0083, 0x1225, iwl1000_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0083, 0x1325, iwl1000_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0084, 0x1215, iwl1000_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0084, 0x1315, iwl1000_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0083, 0x1206, iwl1000_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0083, 0x1306, iwl1000_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0083, 0x1226, iwl1000_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0083, 0x1326, iwl1000_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0084, 0x1216, iwl1000_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0084, 0x1316, iwl1000_bg_cfg)},
|
2008-04-24 18:55:23 +00:00
|
|
|
#endif /* CONFIG_IWL5000 */
|
2008-12-02 00:32:18 +00:00
|
|
|
|
2008-04-15 23:01:41 +00:00
|
|
|
{0}
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, iwl_hw_card_ids);
|
|
|
|
|
|
|
|
static struct pci_driver iwl_driver = {
|
2007-09-26 00:54:57 +00:00
|
|
|
.name = DRV_NAME,
|
2008-04-15 23:01:41 +00:00
|
|
|
.id_table = iwl_hw_card_ids,
|
2008-10-29 21:05:46 +00:00
|
|
|
.probe = iwl_pci_probe,
|
|
|
|
.remove = __devexit_p(iwl_pci_remove),
|
2007-09-26 00:54:57 +00:00
|
|
|
#ifdef CONFIG_PM
|
2008-10-29 21:05:46 +00:00
|
|
|
.suspend = iwl_pci_suspend,
|
|
|
|
.resume = iwl_pci_resume,
|
2007-09-26 00:54:57 +00:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int __init iwl_init(void)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
int ret;
|
2010-07-26 21:39:58 +00:00
|
|
|
pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
|
|
|
|
pr_info(DRV_COPYRIGHT "\n");
|
2008-03-28 23:21:09 +00:00
|
|
|
|
2008-07-18 05:53:05 +00:00
|
|
|
ret = iwlagn_rate_control_register();
|
2008-03-28 23:21:09 +00:00
|
|
|
if (ret) {
|
2010-07-26 21:39:58 +00:00
|
|
|
pr_err("Unable to register rate control algorithm: %d\n", ret);
|
2008-03-28 23:21:09 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-15 23:01:41 +00:00
|
|
|
ret = pci_register_driver(&iwl_driver);
|
2007-09-26 00:54:57 +00:00
|
|
|
if (ret) {
|
2010-07-26 21:39:58 +00:00
|
|
|
pr_err("Unable to initialize PCI module\n");
|
2008-03-28 23:21:09 +00:00
|
|
|
goto error_register;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2008-03-28 23:21:09 +00:00
|
|
|
|
|
|
|
error_register:
|
2008-07-18 05:53:05 +00:00
|
|
|
iwlagn_rate_control_unregister();
|
2008-03-28 23:21:09 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void __exit iwl_exit(void)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-04-15 23:01:41 +00:00
|
|
|
pci_unregister_driver(&iwl_driver);
|
2008-07-18 05:53:05 +00:00
|
|
|
iwlagn_rate_control_unregister();
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
module_exit(iwl_exit);
|
|
|
|
module_init(iwl_init);
|
2009-07-17 16:30:24 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-09-17 17:43:47 +00:00
|
|
|
module_param_named(debug50, iwl_debug_level, uint, S_IRUGO);
|
2009-07-17 16:30:24 +00:00
|
|
|
MODULE_PARM_DESC(debug50, "50XX debug output mask (deprecated)");
|
2009-09-17 17:43:47 +00:00
|
|
|
module_param_named(debug, iwl_debug_level, uint, S_IRUGO | S_IWUSR);
|
2009-07-17 16:30:24 +00:00
|
|
|
MODULE_PARM_DESC(debug, "debug output mask");
|
|
|
|
#endif
|
|
|
|
|
2010-03-22 16:17:39 +00:00
|
|
|
module_param_named(swcrypto50, iwlagn_mod_params.sw_crypto, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(swcrypto50,
|
|
|
|
"using crypto in software (default 0 [hardware]) (deprecated)");
|
|
|
|
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_num50,
|
|
|
|
iwlagn_mod_params.num_of_queues, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(queues_num50,
|
|
|
|
"number of hw queues in 50xx series (deprecated)");
|
|
|
|
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_disable50, iwlagn_mod_params.disable_11n, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(11n_disable50, "disable 50XX 11n functionality (deprecated)");
|
|
|
|
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_8K50, iwlagn_mod_params.amsdu_size_8K,
|
|
|
|
int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(amsdu_size_8K50,
|
|
|
|
"enable 8K amsdu size in 50XX series (deprecated)");
|
|
|
|
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_restart50, iwlagn_mod_params.restart_fw, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(fw_restart50,
|
|
|
|
"restart firmware in case of error (deprecated)");
|
|
|
|
module_param_named(fw_restart, iwlagn_mod_params.restart_fw, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
|
|
|
|
module_param_named(
|
|
|
|
disable_hw_scan, iwlagn_mod_params.disable_hw_scan, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");
|
2010-04-29 06:33:10 +00:00
|
|
|
|
|
|
|
module_param_named(ucode_alternative, iwlagn_wanted_ucode_alternative, int,
|
|
|
|
S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(ucode_alternative,
|
|
|
|
"specify ucode alternative to use from ucode file");
|
2010-08-23 14:57:04 +00:00
|
|
|
|
|
|
|
module_param_named(antenna_coupling, iwlagn_ant_coupling, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(antenna_coupling,
|
|
|
|
"specify antenna coupling in dB (defualt: 0 dB)");
|
2010-08-23 14:57:12 +00:00
|
|
|
|
|
|
|
module_param_named(bt_ch_announce, iwlagn_bt_ch_announce, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(bt_ch_announce,
|
|
|
|
"Enable BT channel announcement mode (default: enable)");
|