2008-06-12 09:47:10 +08:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* GPL LICENSE SUMMARY
|
|
|
|
*
|
2011-04-06 00:42:00 +08:00
|
|
|
* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
|
2008-06-12 09:47:10 +08:00
|
|
|
*
|
|
|
|
* 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.GPL.
|
|
|
|
*
|
|
|
|
* Contact Information:
|
2008-12-10 03:28:58 +08:00
|
|
|
* Intel Linux Wireless <ilw@linux.intel.com>
|
2008-06-12 09:47:10 +08:00
|
|
|
* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
|
|
|
|
*****************************************************************************/
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2008-09-25 06:13:14 +08:00
|
|
|
#include <linux/types.h>
|
2008-06-12 09:47:10 +08:00
|
|
|
#include <linux/etherdevice.h>
|
2008-09-25 06:13:14 +08:00
|
|
|
#include <net/mac80211.h>
|
2008-06-12 09:47:10 +08:00
|
|
|
|
|
|
|
#include "iwl-eeprom.h"
|
|
|
|
#include "iwl-dev.h"
|
|
|
|
#include "iwl-core.h"
|
|
|
|
#include "iwl-sta.h"
|
|
|
|
#include "iwl-io.h"
|
|
|
|
#include "iwl-helpers.h"
|
2011-06-03 22:54:15 +08:00
|
|
|
#include "iwl-agn.h"
|
2011-07-08 23:46:16 +08:00
|
|
|
#include "iwl-trans.h"
|
2008-06-12 09:47:10 +08:00
|
|
|
|
|
|
|
/* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
|
|
|
|
* sending probe req. This should be set long enough to hear probe responses
|
|
|
|
* from more than one AP. */
|
2008-07-11 11:53:39 +08:00
|
|
|
#define IWL_ACTIVE_DWELL_TIME_24 (30) /* all times in msec */
|
|
|
|
#define IWL_ACTIVE_DWELL_TIME_52 (20)
|
|
|
|
|
|
|
|
#define IWL_ACTIVE_DWELL_FACTOR_24GHZ (3)
|
|
|
|
#define IWL_ACTIVE_DWELL_FACTOR_52GHZ (2)
|
2008-06-12 09:47:10 +08:00
|
|
|
|
|
|
|
/* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
|
|
|
|
* Must be set longer than active dwell time.
|
|
|
|
* For the most reliable scan, set > AP beacon interval (typically 100msec). */
|
|
|
|
#define IWL_PASSIVE_DWELL_TIME_24 (20) /* all times in msec */
|
|
|
|
#define IWL_PASSIVE_DWELL_TIME_52 (10)
|
|
|
|
#define IWL_PASSIVE_DWELL_BASE (100)
|
|
|
|
#define IWL_CHANNEL_TUNE_TIME 5
|
|
|
|
|
2010-09-13 20:46:36 +08:00
|
|
|
static int iwl_send_scan_abort(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct iwl_rx_packet *pkt;
|
|
|
|
struct iwl_host_cmd cmd = {
|
|
|
|
.id = REPLY_SCAN_ABORT_CMD,
|
2011-07-08 23:46:14 +08:00
|
|
|
.flags = CMD_SYNC | CMD_WANT_SKB,
|
2010-09-13 20:46:36 +08:00
|
|
|
};
|
2008-07-11 11:53:39 +08:00
|
|
|
|
2010-09-13 20:46:36 +08:00
|
|
|
/* Exit instantly with error when device is not ready
|
|
|
|
* to receive scan abort command or it does not perform
|
|
|
|
* hardware scan currently */
|
|
|
|
if (!test_bit(STATUS_READY, &priv->status) ||
|
|
|
|
!test_bit(STATUS_GEO_CONFIGURED, &priv->status) ||
|
|
|
|
!test_bit(STATUS_SCAN_HW, &priv->status) ||
|
|
|
|
test_bit(STATUS_FW_ERROR, &priv->status) ||
|
|
|
|
test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return -EIO;
|
2008-07-11 11:53:39 +08:00
|
|
|
|
2011-07-08 23:46:16 +08:00
|
|
|
ret = trans_send_cmd(priv, &cmd);
|
2010-09-13 20:46:36 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
pkt = (struct iwl_rx_packet *)cmd.reply_page;
|
|
|
|
if (pkt->u.status != CAN_ABORT_STATUS) {
|
|
|
|
/* The scan abort will return 1 for success or
|
|
|
|
* 2 for "failure". A failure condition can be
|
|
|
|
* due to simply not being in an active scan which
|
|
|
|
* can occur if we send the scan abort before we
|
|
|
|
* the microcode has notified us that a scan is
|
|
|
|
* completed. */
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "SCAN_ABORT ret %d.\n", pkt->u.status);
|
2010-09-13 20:46:36 +08:00
|
|
|
ret = -EIO;
|
2008-06-12 09:47:10 +08:00
|
|
|
}
|
|
|
|
|
2010-09-13 20:46:36 +08:00
|
|
|
iwl_free_pages(priv, cmd.reply_page);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2010-09-13 20:46:38 +08:00
|
|
|
static void iwl_complete_scan(struct iwl_priv *priv, bool aborted)
|
|
|
|
{
|
|
|
|
/* check if scan was requested from mac80211 */
|
|
|
|
if (priv->scan_request) {
|
|
|
|
IWL_DEBUG_SCAN(priv, "Complete scan in mac80211\n");
|
|
|
|
ieee80211_scan_completed(priv->hw, aborted);
|
|
|
|
}
|
|
|
|
|
2011-03-11 12:13:26 +08:00
|
|
|
priv->scan_type = IWL_SCAN_NORMAL;
|
2010-09-13 20:46:38 +08:00
|
|
|
priv->scan_vif = NULL;
|
|
|
|
priv->scan_request = NULL;
|
|
|
|
}
|
|
|
|
|
2010-09-13 20:46:41 +08:00
|
|
|
void iwl_force_scan_end(struct iwl_priv *priv)
|
2010-09-13 20:46:39 +08:00
|
|
|
{
|
2010-09-13 20:46:41 +08:00
|
|
|
lockdep_assert_held(&priv->mutex);
|
|
|
|
|
|
|
|
if (!test_bit(STATUS_SCANNING, &priv->status)) {
|
|
|
|
IWL_DEBUG_SCAN(priv, "Forcing scan end while not scanning\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-09-13 20:46:39 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Forcing scan end\n");
|
|
|
|
clear_bit(STATUS_SCANNING, &priv->status);
|
|
|
|
clear_bit(STATUS_SCAN_HW, &priv->status);
|
|
|
|
clear_bit(STATUS_SCAN_ABORTING, &priv->status);
|
|
|
|
iwl_complete_scan(priv, true);
|
|
|
|
}
|
|
|
|
|
2010-09-13 20:46:36 +08:00
|
|
|
static void iwl_do_scan_abort(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int ret;
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2010-09-13 20:46:36 +08:00
|
|
|
lockdep_assert_held(&priv->mutex);
|
|
|
|
|
|
|
|
if (!test_bit(STATUS_SCANNING, &priv->status)) {
|
|
|
|
IWL_DEBUG_SCAN(priv, "Not performing scan to abort\n");
|
|
|
|
return;
|
2008-06-12 09:47:10 +08:00
|
|
|
}
|
|
|
|
|
2010-09-13 20:46:36 +08:00
|
|
|
if (test_and_set_bit(STATUS_SCAN_ABORTING, &priv->status)) {
|
|
|
|
IWL_DEBUG_SCAN(priv, "Scan abort in progress\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = iwl_send_scan_abort(priv);
|
|
|
|
if (ret) {
|
|
|
|
IWL_DEBUG_SCAN(priv, "Send scan abort failed %d\n", ret);
|
2010-09-13 20:46:39 +08:00
|
|
|
iwl_force_scan_end(priv);
|
2010-09-13 20:46:36 +08:00
|
|
|
} else
|
2011-03-31 09:57:33 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Successfully send scan abort\n");
|
2010-09-13 20:46:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_scan_cancel - Cancel any currently executing HW scan
|
|
|
|
*/
|
|
|
|
int iwl_scan_cancel(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
IWL_DEBUG_SCAN(priv, "Queuing abort scan\n");
|
2010-09-13 20:46:37 +08:00
|
|
|
queue_work(priv->workqueue, &priv->abort_scan);
|
2008-06-12 09:47:10 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2010-09-13 20:46:36 +08:00
|
|
|
|
2008-06-12 09:47:10 +08:00
|
|
|
/**
|
|
|
|
* iwl_scan_cancel_timeout - Cancel any currently executing HW scan
|
|
|
|
* @ms: amount of time to wait (in milliseconds) for scan to abort
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int iwl_scan_cancel_timeout(struct iwl_priv *priv, unsigned long ms)
|
|
|
|
{
|
2010-09-13 20:46:37 +08:00
|
|
|
unsigned long timeout = jiffies + msecs_to_jiffies(ms);
|
|
|
|
|
|
|
|
lockdep_assert_held(&priv->mutex);
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2010-09-13 20:46:37 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan cancel timeout\n");
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2010-09-13 20:46:37 +08:00
|
|
|
iwl_do_scan_abort(priv);
|
|
|
|
|
|
|
|
while (time_before_eq(jiffies, timeout)) {
|
|
|
|
if (!test_bit(STATUS_SCAN_HW, &priv->status))
|
|
|
|
break;
|
|
|
|
msleep(20);
|
2008-06-12 09:47:10 +08:00
|
|
|
}
|
|
|
|
|
2010-09-13 20:46:41 +08:00
|
|
|
return test_bit(STATUS_SCAN_HW, &priv->status);
|
2008-06-12 09:47:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Service response to REPLY_SCAN_CMD (0x80) */
|
|
|
|
static void iwl_rx_reply_scan(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-10-09 17:19:45 +08:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-06-12 09:47:10 +08:00
|
|
|
struct iwl_scanreq_notification *notif =
|
|
|
|
(struct iwl_scanreq_notification *)pkt->u.raw;
|
|
|
|
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan request status = 0x%x\n", notif->status);
|
2008-06-12 09:47:10 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Service SCAN_START_NOTIFICATION (0x82) */
|
|
|
|
static void iwl_rx_scan_start_notif(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
|
|
|
{
|
2009-10-09 17:19:45 +08:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-06-12 09:47:10 +08:00
|
|
|
struct iwl_scanstart_notification *notif =
|
|
|
|
(struct iwl_scanstart_notification *)pkt->u.raw;
|
|
|
|
priv->scan_start_tsf = le32_to_cpu(notif->tsf_low);
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan start: "
|
2008-06-12 09:47:10 +08:00
|
|
|
"%d [802.11%s] "
|
|
|
|
"(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
|
|
|
|
notif->channel,
|
|
|
|
notif->band ? "bg" : "a",
|
2008-07-11 11:53:39 +08:00
|
|
|
le32_to_cpu(notif->tsf_high),
|
|
|
|
le32_to_cpu(notif->tsf_low),
|
|
|
|
notif->status, notif->beacon_timer);
|
2008-06-12 09:47:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Service SCAN_RESULTS_NOTIFICATION (0x83) */
|
|
|
|
static void iwl_rx_scan_results_notif(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2009-10-09 17:19:45 +08:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-06-12 09:47:10 +08:00
|
|
|
struct iwl_scanresults_notification *notif =
|
|
|
|
(struct iwl_scanresults_notification *)pkt->u.raw;
|
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan ch.res: "
|
2008-06-12 09:47:10 +08:00
|
|
|
"%d [802.11%s] "
|
|
|
|
"(TSF: 0x%08X:%08X) - %d "
|
2010-01-23 06:22:44 +08:00
|
|
|
"elapsed=%lu usec\n",
|
2008-06-12 09:47:10 +08:00
|
|
|
notif->channel,
|
|
|
|
notif->band ? "bg" : "a",
|
|
|
|
le32_to_cpu(notif->tsf_high),
|
|
|
|
le32_to_cpu(notif->tsf_low),
|
|
|
|
le32_to_cpu(notif->statistics[0]),
|
2010-01-23 06:22:44 +08:00
|
|
|
le32_to_cpu(notif->tsf_low) - priv->scan_start_tsf);
|
2008-06-12 09:47:10 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
|
|
|
|
static void iwl_rx_scan_complete_notif(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
|
|
|
{
|
2009-10-09 17:19:45 +08:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-06-12 09:47:10 +08:00
|
|
|
struct iwl_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
|
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
|
2008-06-12 09:47:10 +08:00
|
|
|
scan_notif->scanned_channels,
|
|
|
|
scan_notif->tsf_low,
|
|
|
|
scan_notif->tsf_high, scan_notif->status);
|
|
|
|
|
|
|
|
/* The HW is no longer scanning */
|
|
|
|
clear_bit(STATUS_SCAN_HW, &priv->status);
|
|
|
|
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan on %sGHz took %dms\n",
|
2010-04-06 19:12:37 +08:00
|
|
|
(priv->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
|
2010-11-12 15:47:07 +08:00
|
|
|
jiffies_to_msecs(jiffies - priv->scan_start));
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2010-09-13 20:46:34 +08:00
|
|
|
queue_work(priv->workqueue, &priv->scan_completed);
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2010-08-23 22:57:15 +08:00
|
|
|
if (priv->iw_mode != NL80211_IFTYPE_ADHOC &&
|
2011-01-28 23:47:47 +08:00
|
|
|
iwl_advanced_bt_coexist(priv) &&
|
2010-09-13 20:46:34 +08:00
|
|
|
priv->bt_status != scan_notif->bt_status) {
|
2010-08-23 22:57:15 +08:00
|
|
|
if (scan_notif->bt_status) {
|
|
|
|
/* BT on */
|
|
|
|
if (!priv->bt_ch_announce)
|
|
|
|
priv->bt_traffic_load =
|
|
|
|
IWL_BT_COEX_TRAFFIC_LOAD_HIGH;
|
|
|
|
/*
|
|
|
|
* otherwise, no traffic load information provided
|
|
|
|
* no changes made
|
|
|
|
*/
|
|
|
|
} else {
|
|
|
|
/* BT off */
|
|
|
|
priv->bt_traffic_load =
|
|
|
|
IWL_BT_COEX_TRAFFIC_LOAD_NONE;
|
|
|
|
}
|
|
|
|
priv->bt_status = scan_notif->bt_status;
|
|
|
|
queue_work(priv->workqueue, &priv->bt_traffic_change_work);
|
|
|
|
}
|
2008-06-12 09:47:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void iwl_setup_rx_scan_handlers(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
/* scan handlers */
|
|
|
|
priv->rx_handlers[REPLY_SCAN_CMD] = iwl_rx_reply_scan;
|
|
|
|
priv->rx_handlers[SCAN_START_NOTIFICATION] = iwl_rx_scan_start_notif;
|
|
|
|
priv->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
|
|
|
|
iwl_rx_scan_results_notif;
|
|
|
|
priv->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
|
|
|
|
iwl_rx_scan_complete_notif;
|
|
|
|
}
|
|
|
|
|
2009-01-24 05:45:12 +08:00
|
|
|
inline u16 iwl_get_active_dwell_time(struct iwl_priv *priv,
|
|
|
|
enum ieee80211_band band,
|
|
|
|
u8 n_probes)
|
2008-06-12 09:47:10 +08:00
|
|
|
{
|
|
|
|
if (band == IEEE80211_BAND_5GHZ)
|
2008-07-11 11:53:39 +08:00
|
|
|
return IWL_ACTIVE_DWELL_TIME_52 +
|
|
|
|
IWL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
|
2008-06-12 09:47:10 +08:00
|
|
|
else
|
2008-07-11 11:53:39 +08:00
|
|
|
return IWL_ACTIVE_DWELL_TIME_24 +
|
|
|
|
IWL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
|
2008-06-12 09:47:10 +08:00
|
|
|
}
|
|
|
|
|
2009-01-24 05:45:12 +08:00
|
|
|
u16 iwl_get_passive_dwell_time(struct iwl_priv *priv,
|
2010-04-29 19:43:06 +08:00
|
|
|
enum ieee80211_band band,
|
|
|
|
struct ieee80211_vif *vif)
|
2008-06-12 09:47:10 +08:00
|
|
|
{
|
2010-08-23 16:46:41 +08:00
|
|
|
struct iwl_rxon_context *ctx;
|
2008-07-11 11:53:39 +08:00
|
|
|
u16 passive = (band == IEEE80211_BAND_2GHZ) ?
|
2008-06-12 09:47:10 +08:00
|
|
|
IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_24 :
|
|
|
|
IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_52;
|
|
|
|
|
2010-08-23 16:46:32 +08:00
|
|
|
if (iwl_is_any_associated(priv)) {
|
2010-08-23 16:46:41 +08:00
|
|
|
/*
|
|
|
|
* If we're associated, we clamp the maximum passive
|
|
|
|
* dwell time to be 98% of the smallest beacon interval
|
|
|
|
* (minus 2 * channel tune time)
|
|
|
|
*/
|
|
|
|
for_each_context(priv, ctx) {
|
|
|
|
u16 value;
|
|
|
|
|
|
|
|
if (!iwl_is_associated_ctx(ctx))
|
|
|
|
continue;
|
|
|
|
value = ctx->vif ? ctx->vif->bss_conf.beacon_int : 0;
|
|
|
|
if ((value > IWL_PASSIVE_DWELL_BASE) || !value)
|
|
|
|
value = IWL_PASSIVE_DWELL_BASE;
|
|
|
|
value = (value * 98) / 100 - IWL_CHANNEL_TUNE_TIME * 2;
|
|
|
|
passive = min(value, passive);
|
|
|
|
}
|
2008-06-12 09:47:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return passive;
|
|
|
|
}
|
|
|
|
|
2008-06-12 09:47:12 +08:00
|
|
|
void iwl_init_scan_params(struct iwl_priv *priv)
|
|
|
|
{
|
2008-10-15 03:32:45 +08:00
|
|
|
u8 ant_idx = fls(priv->hw_params.valid_tx_ant) - 1;
|
2008-06-12 09:47:12 +08:00
|
|
|
if (!priv->scan_tx_ant[IEEE80211_BAND_5GHZ])
|
2008-10-15 03:32:45 +08:00
|
|
|
priv->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
|
2008-06-12 09:47:12 +08:00
|
|
|
if (!priv->scan_tx_ant[IEEE80211_BAND_2GHZ])
|
2008-10-15 03:32:45 +08:00
|
|
|
priv->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
|
2008-06-12 09:47:12 +08:00
|
|
|
}
|
|
|
|
|
2011-03-11 12:13:26 +08:00
|
|
|
int __must_check iwl_scan_initiate(struct iwl_priv *priv,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
enum iwl_scan_type scan_type,
|
|
|
|
enum ieee80211_band band)
|
2008-06-12 09:47:10 +08:00
|
|
|
{
|
2010-09-13 20:46:33 +08:00
|
|
|
int ret;
|
|
|
|
|
2010-08-06 22:17:53 +08:00
|
|
|
lockdep_assert_held(&priv->mutex);
|
2010-04-07 15:21:36 +08:00
|
|
|
|
2010-09-13 20:46:33 +08:00
|
|
|
cancel_delayed_work(&priv->scan_check);
|
|
|
|
|
2010-09-13 20:46:43 +08:00
|
|
|
if (!iwl_is_ready_rf(priv)) {
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_WARN(priv, "Request scan called when driver not ready.\n");
|
2010-09-13 20:46:33 +08:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (test_bit(STATUS_SCAN_HW, &priv->status)) {
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv,
|
2010-09-13 20:46:33 +08:00
|
|
|
"Multiple concurrent scan requests in parallel.\n");
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan request while abort pending.\n");
|
2010-09-13 20:46:33 +08:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Starting %sscan...\n",
|
2011-03-11 12:13:26 +08:00
|
|
|
scan_type == IWL_SCAN_NORMAL ? "" :
|
|
|
|
scan_type == IWL_SCAN_OFFCH_TX ? "offchan TX " :
|
|
|
|
"internal short ");
|
2010-09-13 20:46:33 +08:00
|
|
|
|
2008-06-12 09:47:10 +08:00
|
|
|
set_bit(STATUS_SCANNING, &priv->status);
|
2011-03-11 12:13:26 +08:00
|
|
|
priv->scan_type = scan_type;
|
2008-06-12 09:47:10 +08:00
|
|
|
priv->scan_start = jiffies;
|
2010-09-13 20:46:33 +08:00
|
|
|
priv->scan_band = band;
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2011-07-08 23:46:29 +08:00
|
|
|
ret = iwlagn_request_scan(priv, vif);
|
2010-09-13 20:46:33 +08:00
|
|
|
if (ret) {
|
|
|
|
clear_bit(STATUS_SCANNING, &priv->status);
|
2011-03-11 12:13:26 +08:00
|
|
|
priv->scan_type = IWL_SCAN_NORMAL;
|
2010-09-13 20:46:33 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2010-04-06 19:12:42 +08:00
|
|
|
|
2010-09-13 20:46:33 +08:00
|
|
|
queue_delayed_work(priv->workqueue, &priv->scan_check,
|
|
|
|
IWL_SCAN_CHECK_WATCHDOG);
|
2008-06-12 09:47:10 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-19 07:54:27 +08:00
|
|
|
int iwl_mac_hw_scan(struct ieee80211_hw *hw,
|
2010-04-27 17:59:34 +08:00
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct cfg80211_scan_request *req)
|
2009-02-19 07:54:27 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
2010-04-06 19:12:37 +08:00
|
|
|
int ret;
|
2009-02-19 07:54:27 +08:00
|
|
|
|
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
|
|
|
|
2010-04-06 19:12:37 +08:00
|
|
|
if (req->n_channels == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-02-19 07:54:27 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2010-05-18 17:29:13 +08:00
|
|
|
if (test_bit(STATUS_SCANNING, &priv->status) &&
|
2011-03-11 12:13:26 +08:00
|
|
|
priv->scan_type != IWL_SCAN_NORMAL) {
|
2010-02-03 02:57:12 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan already in progress.\n");
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2010-04-06 19:12:37 +08:00
|
|
|
/* mac80211 will only ask for one band at a time */
|
2009-04-21 05:36:56 +08:00
|
|
|
priv->scan_request = req;
|
2010-05-18 17:29:13 +08:00
|
|
|
priv->scan_vif = vif;
|
2009-02-19 07:54:27 +08:00
|
|
|
|
2010-05-18 17:29:13 +08:00
|
|
|
/*
|
|
|
|
* If an internal scan is in progress, just set
|
|
|
|
* up the scan_request as per above.
|
|
|
|
*/
|
2011-03-11 12:13:26 +08:00
|
|
|
if (priv->scan_type != IWL_SCAN_NORMAL) {
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "SCAN request during internal scan\n");
|
2010-05-18 17:29:13 +08:00
|
|
|
ret = 0;
|
2010-09-13 20:46:44 +08:00
|
|
|
} else
|
2011-03-11 12:13:26 +08:00
|
|
|
ret = iwl_scan_initiate(priv, vif, IWL_SCAN_NORMAL,
|
2010-09-13 20:46:33 +08:00
|
|
|
req->channels[0]->band);
|
2009-02-19 07:54:27 +08:00
|
|
|
|
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-01-23 06:22:43 +08:00
|
|
|
/*
|
|
|
|
* internal short scan, this function should only been called while associated.
|
|
|
|
* It will reset and tune the radio to prevent possible RF related problem
|
|
|
|
*/
|
2010-04-07 15:21:36 +08:00
|
|
|
void iwl_internal_short_hw_scan(struct iwl_priv *priv)
|
2010-01-23 06:22:43 +08:00
|
|
|
{
|
2010-04-07 15:21:36 +08:00
|
|
|
queue_work(priv->workqueue, &priv->start_internal_scan);
|
|
|
|
}
|
|
|
|
|
2010-07-30 22:41:08 +08:00
|
|
|
static void iwl_bg_start_internal_scan(struct work_struct *work)
|
2010-04-07 15:21:36 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, start_internal_scan);
|
|
|
|
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Start internal scan\n");
|
|
|
|
|
2010-04-07 15:21:36 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
2010-01-23 06:22:43 +08:00
|
|
|
|
2011-03-11 12:13:26 +08:00
|
|
|
if (priv->scan_type == IWL_SCAN_RADIO_RESET) {
|
2010-05-14 05:49:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Internal scan already in progress\n");
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
2010-01-23 06:22:43 +08:00
|
|
|
if (test_bit(STATUS_SCANNING, &priv->status)) {
|
|
|
|
IWL_DEBUG_SCAN(priv, "Scan already in progress.\n");
|
2010-04-07 15:21:36 +08:00
|
|
|
goto unlock;
|
2010-01-23 06:22:43 +08:00
|
|
|
}
|
2010-04-07 15:21:36 +08:00
|
|
|
|
2011-03-11 12:13:26 +08:00
|
|
|
if (iwl_scan_initiate(priv, NULL, IWL_SCAN_RADIO_RESET, priv->band))
|
2010-09-13 20:46:33 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "failed to start internal short scan\n");
|
2010-04-07 15:21:36 +08:00
|
|
|
unlock:
|
|
|
|
mutex_unlock(&priv->mutex);
|
2010-01-23 06:22:43 +08:00
|
|
|
}
|
|
|
|
|
2010-07-30 22:41:08 +08:00
|
|
|
static void iwl_bg_scan_check(struct work_struct *data)
|
2008-06-12 09:47:10 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(data, struct iwl_priv, scan_check.work);
|
|
|
|
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan check work\n");
|
|
|
|
|
2010-09-13 20:46:41 +08:00
|
|
|
/* Since we are here firmware does not finish scan and
|
|
|
|
* most likely is in bad shape, so we don't bother to
|
|
|
|
* send abort command, just force scan complete to mac80211 */
|
2008-06-12 09:47:10 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
2010-09-13 20:46:41 +08:00
|
|
|
iwl_force_scan_end(priv);
|
2008-06-12 09:47:10 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
2009-01-24 05:45:12 +08:00
|
|
|
|
2008-06-12 09:47:10 +08:00
|
|
|
/**
|
|
|
|
* iwl_fill_probe_req - fill in all required fields and IE for probe request
|
|
|
|
*/
|
2008-06-12 09:47:12 +08:00
|
|
|
|
2009-04-21 05:36:56 +08:00
|
|
|
u16 iwl_fill_probe_req(struct iwl_priv *priv, struct ieee80211_mgmt *frame,
|
2010-05-12 18:33:12 +08:00
|
|
|
const u8 *ta, const u8 *ies, int ie_len, int left)
|
2008-06-12 09:47:10 +08:00
|
|
|
{
|
|
|
|
int len = 0;
|
|
|
|
u8 *pos = NULL;
|
2008-06-12 09:47:12 +08:00
|
|
|
|
2008-06-12 09:47:10 +08:00
|
|
|
/* Make sure there is enough space for the probe request,
|
|
|
|
* two mandatory IEs and the data */
|
|
|
|
left -= 24;
|
|
|
|
if (left < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
|
|
|
|
memcpy(frame->da, iwl_bcast_addr, ETH_ALEN);
|
2010-05-12 18:33:12 +08:00
|
|
|
memcpy(frame->sa, ta, ETH_ALEN);
|
2008-06-12 09:47:10 +08:00
|
|
|
memcpy(frame->bssid, iwl_bcast_addr, ETH_ALEN);
|
|
|
|
frame->seq_ctrl = 0;
|
|
|
|
|
2008-06-12 09:47:12 +08:00
|
|
|
len += 24;
|
|
|
|
|
2008-06-12 09:47:10 +08:00
|
|
|
/* ...next IE... */
|
2008-06-12 09:47:12 +08:00
|
|
|
pos = &frame->u.probe_req.variable[0];
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2008-06-12 09:47:12 +08:00
|
|
|
/* fill in our indirect SSID IE */
|
2008-06-12 09:47:10 +08:00
|
|
|
left -= 2;
|
|
|
|
if (left < 0)
|
|
|
|
return 0;
|
|
|
|
*pos++ = WLAN_EID_SSID;
|
2010-02-26 02:02:19 +08:00
|
|
|
*pos++ = 0;
|
|
|
|
|
|
|
|
len += 2;
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2009-04-21 05:36:56 +08:00
|
|
|
if (WARN_ON(left < ie_len))
|
|
|
|
return len;
|
2008-06-12 09:47:10 +08:00
|
|
|
|
2010-04-16 21:46:41 +08:00
|
|
|
if (ies && ie_len) {
|
2010-01-23 06:22:43 +08:00
|
|
|
memcpy(pos, ies, ie_len);
|
2010-04-16 21:46:41 +08:00
|
|
|
len += ie_len;
|
|
|
|
}
|
2008-06-12 09:47:12 +08:00
|
|
|
|
2008-06-12 09:47:10 +08:00
|
|
|
return (u16)len;
|
|
|
|
}
|
|
|
|
|
2010-07-30 22:41:08 +08:00
|
|
|
static void iwl_bg_abort_scan(struct work_struct *work)
|
2008-06-12 09:47:10 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = container_of(work, struct iwl_priv, abort_scan);
|
|
|
|
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Abort scan work\n");
|
|
|
|
|
2010-09-13 20:46:41 +08:00
|
|
|
/* We keep scan_check work queued in case when firmware will not
|
|
|
|
* report back scan completed notification */
|
2010-07-29 17:37:41 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
2010-09-13 20:46:40 +08:00
|
|
|
iwl_scan_cancel_timeout(priv, 200);
|
2008-06-12 09:47:10 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2010-07-30 22:41:08 +08:00
|
|
|
static void iwl_bg_scan_completed(struct work_struct *work)
|
2008-10-06 16:05:32 +08:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, scan_completed);
|
2010-09-13 20:46:38 +08:00
|
|
|
bool aborted;
|
2008-10-06 16:05:32 +08:00
|
|
|
|
2011-03-11 12:13:26 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Completed scan.\n");
|
2008-10-06 16:05:32 +08:00
|
|
|
|
2009-05-16 07:13:46 +08:00
|
|
|
cancel_delayed_work(&priv->scan_check);
|
|
|
|
|
2010-05-14 05:49:44 +08:00
|
|
|
mutex_lock(&priv->mutex);
|
2010-09-13 20:46:34 +08:00
|
|
|
|
|
|
|
aborted = test_and_clear_bit(STATUS_SCAN_ABORTING, &priv->status);
|
|
|
|
if (aborted)
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Aborted scan completed.\n");
|
2010-09-13 20:46:34 +08:00
|
|
|
|
2010-09-13 20:46:38 +08:00
|
|
|
if (!test_and_clear_bit(STATUS_SCANNING, &priv->status)) {
|
2010-09-13 20:46:44 +08:00
|
|
|
IWL_DEBUG_SCAN(priv, "Scan already completed.\n");
|
2010-09-13 20:46:45 +08:00
|
|
|
goto out_settings;
|
2010-01-23 06:22:43 +08:00
|
|
|
}
|
2010-05-18 17:29:13 +08:00
|
|
|
|
2011-03-11 12:13:26 +08:00
|
|
|
if (priv->scan_type == IWL_SCAN_OFFCH_TX && priv->_agn.offchan_tx_skb) {
|
|
|
|
ieee80211_tx_status_irqsafe(priv->hw,
|
|
|
|
priv->_agn.offchan_tx_skb);
|
|
|
|
priv->_agn.offchan_tx_skb = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->scan_type != IWL_SCAN_NORMAL && !aborted) {
|
2010-09-13 20:46:38 +08:00
|
|
|
int err;
|
2010-05-18 17:29:13 +08:00
|
|
|
|
2010-09-13 20:46:38 +08:00
|
|
|
/* Check if mac80211 requested scan during our internal scan */
|
|
|
|
if (priv->scan_request == NULL)
|
|
|
|
goto out_complete;
|
2010-09-13 20:46:33 +08:00
|
|
|
|
2010-09-13 20:46:38 +08:00
|
|
|
/* If so request a new scan */
|
2011-03-11 12:13:26 +08:00
|
|
|
err = iwl_scan_initiate(priv, priv->scan_vif, IWL_SCAN_NORMAL,
|
2010-09-13 20:46:38 +08:00
|
|
|
priv->scan_request->channels[0]->band);
|
2010-09-13 20:46:33 +08:00
|
|
|
if (err) {
|
|
|
|
IWL_DEBUG_SCAN(priv,
|
|
|
|
"failed to initiate pending scan: %d\n", err);
|
2010-09-13 20:46:38 +08:00
|
|
|
aborted = true;
|
|
|
|
goto out_complete;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto out;
|
2010-09-13 20:46:33 +08:00
|
|
|
}
|
2010-05-18 17:29:13 +08:00
|
|
|
|
2010-09-13 20:46:38 +08:00
|
|
|
out_complete:
|
|
|
|
iwl_complete_scan(priv, aborted);
|
|
|
|
|
2010-09-13 20:46:45 +08:00
|
|
|
out_settings:
|
2010-09-13 20:46:38 +08:00
|
|
|
/* Can we still talk to firmware ? */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
goto out;
|
|
|
|
|
2011-06-03 22:54:15 +08:00
|
|
|
iwlagn_post_scan(priv);
|
2010-08-28 00:44:50 +08:00
|
|
|
|
2010-10-22 23:04:26 +08:00
|
|
|
out:
|
2010-05-14 05:49:44 +08:00
|
|
|
mutex_unlock(&priv->mutex);
|
2008-10-06 16:05:32 +08:00
|
|
|
}
|
|
|
|
|
2008-06-12 09:47:10 +08:00
|
|
|
void iwl_setup_scan_deferred_work(struct iwl_priv *priv)
|
|
|
|
{
|
2008-10-06 16:05:32 +08:00
|
|
|
INIT_WORK(&priv->scan_completed, iwl_bg_scan_completed);
|
2008-06-12 09:47:10 +08:00
|
|
|
INIT_WORK(&priv->abort_scan, iwl_bg_abort_scan);
|
2010-04-07 15:21:36 +08:00
|
|
|
INIT_WORK(&priv->start_internal_scan, iwl_bg_start_internal_scan);
|
2008-06-12 09:47:10 +08:00
|
|
|
INIT_DELAYED_WORK(&priv->scan_check, iwl_bg_scan_check);
|
|
|
|
}
|
|
|
|
|
2010-09-13 20:46:41 +08:00
|
|
|
void iwl_cancel_scan_deferred_work(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
cancel_work_sync(&priv->start_internal_scan);
|
|
|
|
cancel_work_sync(&priv->abort_scan);
|
|
|
|
cancel_work_sync(&priv->scan_completed);
|
|
|
|
|
|
|
|
if (cancel_delayed_work_sync(&priv->scan_check)) {
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
iwl_force_scan_end(priv);
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
}
|